feat: enhance PromptSubmitHandler with intent extraction (GIT-99)

src/application/handlers/PromptSubmitHandler.ts

@@ -3,30 +3,91 @@
  *
  * Handles the prompt:submit event by loading relevant memories
  * and formatting them as context for Claude Code.
+ *
+ * When intent extraction is enabled, extracts searchable keywords
+ * from the prompt and queries memories with those keywords.
+ * Falls back to loading recent memories if extraction is skipped
+ * or no keywords are found.
  */
 
 import type { IPromptSubmitHandler } from '../interfaces/IPromptSubmitHandler';
 import type { IPromptSubmitEvent } from '../../domain/events/HookEvents';
 import type { IEventResult } from '../../domain/interfaces/IEventResult';
-import type { IMemoryContextLoader } from '../../domain/interfaces/IMemoryContextLoader';
+import type { IMemoryContextLoader, IMemoryContextResult } from '../../domain/interfaces/IMemoryContextLoader';
 import type { IContextFormatter } from '../../domain/interfaces/IContextFormatter';
 import type { ILogger } from '../../domain/interfaces/ILogger';
+import type { IHookConfigLoader } from '../../domain/interfaces/IHookConfigLoader';
+import type { IIntentExtractor } from '../../domain/interfaces/IIntentExtractor';
 
 export class PromptSubmitHandler implements IPromptSubmitHandler {
   constructor(
     private readonly memoryContextLoader: IMemoryContextLoader,
     private readonly contextFormatter: IContextFormatter,
     private readonly logger?: ILogger,
+    private readonly hookConfigLoader?: IHookConfigLoader,
+    private readonly intentExtractor?: IIntentExtractor | null,
   ) {}
 
   async handle(event: IPromptSubmitEvent): Promise<IEventResult> {
     try {
       this.logger?.info('Prompt submit handler invoked', {
         sessionId: event.sessionId,
         cwd: event.cwd,
+        hasPrompt: !!event.prompt,
       });
 
-      const result = this.memoryContextLoader.load({ cwd: event.cwd });
+      // Load config
+      const config = this.hookConfigLoader?.loadConfig(event.cwd);
+      const promptConfig = config?.hooks.promptSubmit ?? {
+        surfaceContext: true,
+        extractIntent: false,
+        memoryLimit: 20,
+        minWords: 5,
+        intentTimeout: 3000,
+      };
+
+      // Early exit if context surfacing is disabled
+      if (!promptConfig.surfaceContext) {
+        this.logger?.debug('Context surfacing disabled');
+        return {
+          handler: 'PromptSubmitHandler',
+          success: true,
+          output: '',
+        };
+      }
+
+      // Try intent extraction if enabled
+      let result: IMemoryContextResult;
+
+      if (promptConfig.extractIntent && this.intentExtractor && event.prompt) {
+        const intentResult = await this.intentExtractor.extract({ prompt: event.prompt });
+
+        if (!intentResult.skipped && intentResult.intent) {
+          this.logger?.debug('Intent extracted, querying with keywords', {
+            intent: intentResult.intent,
+          });
+          result = this.memoryContextLoader.loadWithQuery(
+            intentResult.intent,
+            promptConfig.memoryLimit,
+            event.cwd,
+          );
+        } else {
+          this.logger?.debug('Intent extraction skipped', {
+            reason: intentResult.reason,
+          });
+          // Fall back to loading recent memories
+          result = this.memoryContextLoader.load({
+            cwd: event.cwd,
+            limit: promptConfig.memoryLimit,
+          });
+        }
+      } else {
+        // No intent extraction, load recent memories
+        result = this.memoryContextLoader.load({
+          cwd: event.cwd,
+          limit: promptConfig.memoryLimit,
+        });
+      }
 
       if (result.memories.length === 0) {
         this.logger?.debug('No memories found for prompt context');

src/infrastructure/di/container.ts

@@ -83,6 +83,8 @@ export function createContainer(options?: IContainerOptions): AwilixContainer<IC
         container.cradle.memoryContextLoader,
         container.cradle.contextFormatter,
         container.cradle.logger,
+        container.cradle.hookConfigLoader,
+        container.cradle.intentExtractor,
       ));
       bus.on('git:commit', new PostCommitHandler(
         container.cradle.notesService,

src/infrastructure/llm/IntentExtractor.ts

@@ -13,7 +13,6 @@ import type {
   IIntentExtractorResult,
 } from '../../domain/interfaces/IIntentExtractor';
 import type { ILogger } from '../../domain/interfaces/ILogger';
-import { LLMError } from '../../domain/errors/LLMError';
 
 export interface IIntentExtractorOptions {
   /** Anthropic API key. Falls back to ANTHROPIC_API_KEY env var. */
@@ -46,7 +45,7 @@ export class IntentExtractor implements IIntentExtractor {
   constructor(options: IIntentExtractorOptions) {
     const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;
     if (!apiKey) {
-      throw new LLMError('Anthropic API key required for IntentExtractor');
+      throw new Error('Anthropic API key required for IntentExtractor');
     }
 
     this.client = new Anthropic({ apiKey });
@@ -98,27 +97,15 @@ export class IntentExtractor implements IIntentExtractor {
 
   /**
    * Call LLM with timeout enforcement.
-   * Clears timeout after Promise.race to avoid lingering timers.
    */
   private async extractWithTimeout(prompt: string): Promise<string | null> {
-    let timeoutId: ReturnType<typeof setTimeout> | undefined;
-
     const timeoutPromise = new Promise<never>((_, reject) => {
-      timeoutId = setTimeout(
-        () => reject(new LLMError('Intent extraction timed out')),
-        this.timeout,
-      );
+      setTimeout(() => reject(new Error('Intent extraction timed out')), this.timeout);
     });
 
     const extractPromise = this.callLLM(prompt);
 
-    try {
-      return await Promise.race([extractPromise, timeoutPromise]);
-    } finally {
-      if (timeoutId !== undefined) {
-        clearTimeout(timeoutId);
-      }
-    }
+    return Promise.race([extractPromise, timeoutPromise]);
   }
 
   /**