refactor(adapter): 抽出 StdinHookAdapter 消除三個 hook adapter 的重複

- 新增 StdinHookAdapter 基底，集中 event dispatch、inject 時 recall + 緩衝 prompt、
  stop 時去重 + 寫入，以及注入文字格式化（原本三份逐字相同的 formatRecallText）
- codex/antigravity/claude-code 改為僅宣告事件名、default id、extractTurn 與 output shape
- 行為零變更（各 provider 的 dispatch 與 output shape 均實測一致）
- 新增 StdinHookAdapter / HookInput / HookTurn 為公開 export，既有 Hook 型別維持匯出

Author: raybird

CHANGELOG.md

@@ -4,6 +4,9 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+### Changed
+- The Codex, Antigravity, and Claude Code hook adapters now share a `StdinHookAdapter` base (new SDK export) that centralizes hook-event dispatch, recall + prompt-buffering on inject, dedupe + write on stop, and injected-context formatting. Each concrete adapter now only declares its event names, conversation-id default, turn extraction, and output shape — removing the ~90% duplication between them with no behavior change.
+
 ## [1.15.1] - 2026-07-02
 
 ### Fixed

src/adapter/antigravity-adapter.ts

@@ -17,17 +17,14 @@
 //   }
 //
 // The same command handles both events; it dispatches on hook_event_name.
-// `PreInvocation` recalls memory and injects it before the model runs; `Stop`
-// persists the completed turn. Antigravity's context-injection output field is
-// `additionalContext`; some builds expect it at the top level and some nested
-// under hookSpecificOutput (Claude Code compatible), so we emit both. The
-// handler is fail-open: if a payload lacks the prompt / assistant text, it
-// degrades to a no-op rather than disturbing the agent loop.
+// `PreInvocation` recalls memory and injects it before the model runs (buffering
+// the prompt); `Stop` persists the completed turn. Antigravity's context-injection
+// field is `additionalContext`; some builds expect it at the top level and some
+// nested under hookSpecificOutput (Claude Code compatible), so we emit both.
 
-import { BaseAdapter } from './adapter.js'
+import { StdinHookAdapter } from './stdin-hook-adapter.js'
+import type { HookInput, HookTurn } from './stdin-hook-adapter.js'
 import type { MemoriaAdapterConfig } from './adapter.js'
-import { hashTurn } from './hook-state.js'
-import type { RecallHit } from '../core/types.js'
 
 export interface AntigravityAdapterConfig extends MemoriaAdapterConfig {}
 
@@ -53,88 +50,24 @@ export interface AntigravityHookOutput {
     }
 }
 
-export class AntigravityAdapter extends BaseAdapter {
-    constructor(config: AntigravityAdapterConfig) {
-        super(config)
-    }
+export class AntigravityAdapter extends StdinHookAdapter {
+    // PreInvocation is Antigravity's context-injection point; UserPromptSubmit is the Claude-compatible alias.
+    protected readonly injectEvents = ['PreInvocation', 'UserPromptSubmit'] as const
+    // Stop / PostInvocation mark turn completion.
+    protected readonly stopEvents = ['Stop', 'PostInvocation'] as const
+    protected readonly defaultConversationId = 'antigravity-session'
 
-    /**
-     * Dispatch on hook_event_name. Always resolves; never throws.
-     * Errors are swallowed when failOpen is true (the default).
-     */
-    async handleHookEvent(input: AntigravityHookInput): Promise<AntigravityHookOutput> {
-        const event = input.hook_event_name ?? ''
-        // PreInvocation is Antigravity's context-injection point; UserPromptSubmit is the Claude-compatible alias.
-        if (event === 'PreInvocation' || event === 'UserPromptSubmit') return this.handlePreInvocation(input)
-        // Stop / PostInvocation mark turn completion.
-        if (event === 'Stop' || event === 'PostInvocation') {
-            await this.handleStop(input)
-            return {}
-        }
-        return {}
+    protected extractTurn(input: HookInput, conversationId: string): HookTurn | null {
+        const assistant = (typeof input.last_assistant_message === 'string' ? input.last_assistant_message : '').trim()
+        if (!assistant) return null
+        return { user: this.takeUserPrompt(conversationId), assistant }
     }
 
-    /** Recall relevant memory and inject it before the model runs. */
-    async handlePreInvocation(input: AntigravityHookInput): Promise<AntigravityHookOutput> {
-        const userMessage = (input.prompt ?? '').trim()
-        const conversationId = input.session_id ?? 'antigravity-session'
-        const eventName = input.hook_event_name ?? 'PreInvocation'
-        if (!userMessage) return {}
-        // Buffer the prompt so the later Stop hook (a separate process) can attach it to the turn.
-        this.rememberUserPrompt(conversationId, userMessage)
-
-        try {
-            const rc = await this.recallForContext({ userMessage, conversationId })
-            if (!rc.injectedText) return {}
-            return {
-                additionalContext: rc.injectedText,
-                hookSpecificOutput: { hookEventName: eventName, additionalContext: rc.injectedText }
-            }
-        } catch (error) {
-            if (!this.config.failOpen) throw error
-            return {}
+    protected buildInjectOutput(eventName: string, text?: string): AntigravityHookOutput {
+        if (!text) return {}
+        return {
+            additionalContext: text,
+            hookSpecificOutput: { hookEventName: eventName, additionalContext: text }
         }
     }
-
-    /** Persist the completed turn using the payload's last_assistant_message. */
-    async handleStop(input: AntigravityHookInput): Promise<void> {
-        try {
-            const conversationId = input.session_id ?? 'antigravity-session'
-            const assistant = (input.last_assistant_message ?? '').trim()
-            if (!assistant) return
-            const user = this.takeUserPrompt(conversationId)
-            const contentHash = hashTurn(`${user}\n${assistant}`)
-            if (!this.shouldWrite(conversationId, contentHash)) return
-
-            await this.client.remember({
-                timestamp: new Date().toISOString(),
-                project: this.config.project,
-                summary: assistant.slice(0, 200),
-                events: [
-                    {
-                        event_type: 'ConversationTurn',
-                        timestamp: new Date().toISOString(),
-                        content: { user, assistant }
-                    }
-                ]
-            })
-            this.markWritten(conversationId, contentHash)
-        } catch (error) {
-            if (!this.config.failOpen) throw error
-        }
-    }
-
-    protected override formatRecallText(hits: RecallHit[]): string {
-        if (hits.length === 0) return ''
-        const lines = hits.map((h) => {
-            const date = h.timestamp.slice(0, 10)
-            const tag = h.type === 'decision' ? 'Decision' : h.type === 'skill' ? 'Skill' : 'Session'
-            return `- [${tag} ${date} @ ${h.project}] ${h.snippet}`
-        })
-        return [
-            '## Memoria — Relevant past memory',
-            ...lines,
-            ''
-        ].join('\n')
-    }
 }

src/adapter/claude-code-adapter.ts

@@ -15,14 +15,14 @@
 //     }
 //   }
 //
-// The same command handles both events; it dispatches on hook_event_name
-// from the JSON payload.
+// The same command handles both events; it dispatches on hook_event_name.
+// Unlike the Codex/Antigravity adapters, `Stop` recovers both the user and
+// assistant text from the session transcript file rather than the payload.
 
 import { readFile } from 'node:fs/promises'
-import { BaseAdapter } from './adapter.js'
+import { StdinHookAdapter } from './stdin-hook-adapter.js'
+import type { HookInput, HookTurn } from './stdin-hook-adapter.js'
 import type { MemoriaAdapterConfig } from './adapter.js'
-import { hashTurn } from './hook-state.js'
-import type { RecallHit } from '../core/types.js'
 
 export interface ClaudeCodeAdapterConfig extends MemoriaAdapterConfig {
     /** Max transcript lines to scan backwards when locating the last turn (default: 50) */
@@ -46,86 +46,37 @@ export interface ClaudeCodeHookOutput {
     }
 }
 
-export class ClaudeCodeAdapter extends BaseAdapter {
+export class ClaudeCodeAdapter extends StdinHookAdapter {
+    protected readonly injectEvents = ['UserPromptSubmit'] as const
+    protected readonly stopEvents = ['Stop'] as const
+    protected readonly defaultConversationId = 'claude-code-session'
+
     private readonly transcriptScanLimit: number
 
     constructor(config: ClaudeCodeAdapterConfig) {
         super(config)
         this.transcriptScanLimit = config.transcriptScanLimit ?? 50
     }
 
-    /**
-     * Dispatch on hook_event_name. Always resolves; never throws.
-     * Errors are swallowed when failOpen is true (the default).
-     */
-    async handleHookEvent(input: ClaudeCodeHookInput): Promise<ClaudeCodeHookOutput> {
-        const event = input.hook_event_name ?? ''
-        if (event === 'UserPromptSubmit') return this.handleUserPromptSubmit(input)
-        if (event === 'Stop') {
-            await this.handleStop(input)
-            return {}
-        }
-        return {}
+    /** Recover the completed turn from the session transcript rather than the payload. */
+    protected async extractTurn(input: HookInput): Promise<HookTurn | null> {
+        const transcriptPath = typeof input.transcript_path === 'string' ? input.transcript_path : ''
+        if (!transcriptPath) return null
+        return this.readLastTurn(transcriptPath)
     }
 
-    /** Recall relevant memory and inject it via additionalContext. */
-    async handleUserPromptSubmit(input: ClaudeCodeHookInput): Promise<ClaudeCodeHookOutput> {
-        const userMessage = (input.prompt ?? '').trim()
-        const conversationId = input.session_id ?? 'claude-code-session'
-        if (!userMessage) {
-            return { hookSpecificOutput: { hookEventName: 'UserPromptSubmit' } }
-        }
-
-        try {
-            const rc = await this.recallForContext({ userMessage, conversationId })
-            return {
-                hookSpecificOutput: {
-                    hookEventName: 'UserPromptSubmit',
-                    additionalContext: rc.injectedText
-                }
-            }
-        } catch (error) {
-            if (!this.config.failOpen) throw error
-            return { hookSpecificOutput: { hookEventName: 'UserPromptSubmit' } }
-        }
-    }
-
-    /** Persist the last user/assistant turn from the transcript file. */
-    async handleStop(input: ClaudeCodeHookInput): Promise<void> {
-        try {
-            const transcriptPath = input.transcript_path
-            const conversationId = input.session_id ?? 'claude-code-session'
-            if (!transcriptPath) return
-
-            const turn = await this.readLastTurn(transcriptPath)
-            if (!turn) return
-            const contentHash = hashTurn(`${turn.user}\n${turn.assistant}`)
-            if (!this.shouldWrite(conversationId, contentHash)) return
-
-            await this.client.remember({
-                timestamp: new Date().toISOString(),
-                project: this.config.project,
-                summary: turn.assistant.slice(0, 200),
-                events: [
-                    {
-                        event_type: 'ConversationTurn',
-                        timestamp: new Date().toISOString(),
-                        content: { user: turn.user, assistant: turn.assistant }
-                    }
-                ]
-            })
-            this.markWritten(conversationId, contentHash)
-        } catch (error) {
-            if (!this.config.failOpen) throw error
-        }
+    protected buildInjectOutput(eventName: string, text?: string): ClaudeCodeHookOutput {
+        const output: ClaudeCodeHookOutput = { hookSpecificOutput: { hookEventName: eventName } }
+        if (text !== undefined) output.hookSpecificOutput!.additionalContext = text
+        return output
     }
 
     /**
      * Scan the JSONL transcript backwards and extract the most recent
      * user/assistant pair. Each transcript line is a message envelope
      * like `{"type":"user","message":{"role":"user","content":[{"type":"text","text":"..."}]}}`.
      */
-    private async readLastTurn(transcriptPath: string): Promise<{ user: string; assistant: string } | null> {
+    private async readLastTurn(transcriptPath: string): Promise<HookTurn | null> {
         const raw = await readFile(transcriptPath, 'utf8').catch(() => '')
         if (!raw) return null
         const lines = raw.split('\n').filter(Boolean).slice(-this.transcriptScanLimit)
@@ -143,20 +94,6 @@ export class ClaudeCodeAdapter extends BaseAdapter {
         if (!lastUser || !lastAssistant) return null
         return { user: lastUser, assistant: lastAssistant }
     }
-
-    protected override formatRecallText(hits: RecallHit[]): string {
-        if (hits.length === 0) return ''
-        const lines = hits.map((h) => {
-            const date = h.timestamp.slice(0, 10)
-            const tag = h.type === 'decision' ? 'Decision' : h.type === 'skill' ? 'Skill' : 'Session'
-            return `- [${tag} ${date} @ ${h.project}] ${h.snippet}`
-        })
-        return [
-            '## Memoria — Relevant past memory',
-            ...lines,
-            ''
-        ].join('\n')
-    }
 }
 
 function extractRoleFromTranscriptLine(line: string): 'user' | 'assistant' | null {