@metabob/minibob 0.1.2

package/src/memory-agent.ts

@@ -0,0 +1,316 @@
+/**
+ * SessionMemoryAgent - Automatic context preparation for activity execution
+ * 
+ * Moved from metabob-opencode to minibob as part of library integration.
+ * This version is simplified to work with minibob's minimal dependencies.
+ * 
+ * Design goals:
+ * - Fast analysis (<2s with Claude Haiku)
+ * - Automatic impulse creation based on intent
+ * - Self-contained (no opencode dependencies)
+ */
+
+import type { Impulse } from "./types"
+import { createAnthropicClient } from "./llm"
+import { createImpulse, getImpulseStore } from "./impulse"
+import z from "zod"
+
+export namespace SessionMemoryAgent {
+  /**
+   * User intent classification schema
+   */
+  const IntentSchema = z.object({
+    type: z.enum(["code_fix", "feature_request", "question", "refactor", "exploration", "other"]),
+    confidence: z.number().min(0).max(1),
+    reasoning: z.string(),
+    suggestedImpulses: z.array(
+      z.object({
+        id: z.string(),
+        type: z.enum(["file", "metabobIssue", "history", "memo", "bashOutput"]),
+        description: z.string(),
+        priority: z.enum(["critical", "high", "medium", "low"]),
+        budget: z.number().positive(),
+        pointer: z.union([
+          z.object({
+            type: z.literal("file"),
+            path: z.string(),
+            offset: z.number().optional(),
+            limit: z.number().optional(),
+          }),
+          z.object({
+            type: z.literal("memo"),
+            content: z.string(),
+          }),
+          z.object({
+            type: z.literal("custom"),
+            resolver: z.string(),
+            data: z.record(z.string(), z.unknown()),
+          }),
+        ]),
+      }),
+    ),
+  })
+
+  export type Intent = z.infer<typeof IntentSchema>
+
+  /**
+   * Configuration for session memory agent
+   */
+  export interface Config {
+    enabled: boolean
+    timeout: number // Max time for analysis (ms)
+    model: string // Model to use (e.g., "claude-3-5-haiku-20241022")
+    defaultBudget: number // Default token budget per impulse
+    maxImpulses: number // Max impulses per turn
+  }
+
+  const DEFAULT_CONFIG: Config = {
+    enabled: true,
+    timeout: 3000,
+    model: "claude-3-5-haiku-20241022",
+    defaultBudget: 2000,
+    maxImpulses: 5,
+  }
+
+  /**
+   * Analyze user intent from prompt text
+   * Returns intent classification with suggested impulses
+   */
+  export async function analyzeIntent(input: {
+    promptText: string
+    workingDirectory?: string
+    config?: Partial<Config>
+  }): Promise<Intent> {
+    const cfg = { ...DEFAULT_CONFIG, ...input.config }
+    const start = Date.now()
+
+    try {
+      console.log("[MemoryAgent] Analyzing intent", {
+        promptLength: input.promptText.length,
+        model: cfg.model,
+        timeout: cfg.timeout,
+      })
+
+      if (!process.env.ANTHROPIC_API_KEY) {
+        throw new Error("ANTHROPIC_API_KEY environment variable not set")
+      }
+
+      // Create LLM client
+      const llmClient = createAnthropicClient(process.env.ANTHROPIC_API_KEY)
+
+      // Build system prompt
+      const systemPrompt = `You are the Session Memory Agent - an intent analyzer for conversational coding assistance.
+
+## Your Role
+
+Analyze user messages to understand their intent and recommend context (impulses) to load.
+You DO NOT execute tasks. You ONLY analyze intent and suggest what context might be helpful.
+
+For trivial messages (greetings, acknowledgments), classify as type="other" with empty suggestedImpulses array.
+
+## Intent Types
+
+- **code_fix**: User reports a bug, error, or unexpected behavior
+- **feature_request**: User wants to add/modify functionality
+- **question**: User asks about code, architecture, or how things work
+- **refactor**: User wants to improve existing code structure
+- **exploration**: User is exploring codebase or investigating
+- **other**: Greetings, acknowledgments, or messages that don't need coding context
+
+## Impulse Types
+
+1. **file**: Specific source files
+   - For code_fix: error file, related tests
+   - For feature_request: files to modify, similar features
+   - For question: files being asked about
+   
+2. **memo**: Inline context notes
+   - For important constraints, requirements, or decisions
+   - Short-term memory across turns
+
+3. **custom**: Custom pointer types for specialized resolvers
+
+## Budget Guidelines
+
+- file: 1500-3000 tokens (depends on file size)
+- memo: 200-500 tokens
+- custom: Varies by resolver
+
+## Priority Guidelines
+
+- **critical**: Must-have for understanding request
+- **high**: Very important for request
+- **medium**: Helpful but not essential
+- **low**: Background context
+
+## Output Format
+
+Return JSON with:
+- type: Intent classification
+- confidence: 0-1 (how confident you are)
+- reasoning: Why you classified this way (1 sentence)
+- suggestedImpulses: Array of recommended impulses (0-${cfg.maxImpulses})
+
+## Examples
+
+**Input**: "Fix the TypeError in calculator.ts"
+**Output**:
+{
+  "type": "code_fix",
+  "confidence": 0.95,
+  "reasoning": "User reports specific error with file reference",
+  "suggestedImpulses": [
+    {
+      "id": "errorFile",
+      "type": "file",
+      "description": "File containing the error",
+      "priority": "high",
+      "budget": 2000,
+      "pointer": { "type": "file", "path": "calculator.ts" }
+    }
+  ]
+}
+
+**Input**: "hi"
+**Output**:
+{
+  "type": "other",
+  "confidence": 1.0,
+  "reasoning": "Simple greeting, no coding context needed",
+  "suggestedImpulses": []
+}
+
+Be conservative with impulses. Quality over quantity. Only suggest what's clearly needed.`
+
+      // Call LLM
+      const result = await llmClient.complete({
+        model: cfg.model,
+        messages: [
+          {
+            role: "system",
+            content: systemPrompt + "\n\nIMPORTANT: Return ONLY valid JSON matching this schema. No markdown, no explanations.",
+          },
+          {
+            role: "user",
+            content: `Analyze this user message and suggest context impulses:\n\n"${input.promptText}"\n\nReturn JSON only.`,
+          },
+        ],
+        maxTokens: 2000,
+        temperature: 0.2,
+      })
+
+      // Parse JSON response
+      let intent: Intent
+      try {
+        // Remove markdown code blocks if present
+        let jsonStr = result.content.trim()
+        if (jsonStr.startsWith("```json")) {
+          jsonStr = jsonStr.slice(7)
+        }
+        if (jsonStr.startsWith("```")) {
+          jsonStr = jsonStr.slice(3)
+        }
+        if (jsonStr.endsWith("```")) {
+          jsonStr = jsonStr.slice(0, -3)
+        }
+        
+        const parsed = JSON.parse(jsonStr.trim())
+        intent = IntentSchema.parse(parsed)
+      } catch (parseError) {
+        console.warn("[MemoryAgent] Failed to parse LLM response as JSON", {
+          error: parseError instanceof Error ? parseError.message : String(parseError),
+          response: result.content.slice(0, 200),
+        })
+        throw new Error("Failed to parse intent analysis response")
+      }
+
+      console.log("[MemoryAgent] Analysis complete", {
+        type: intent.type,
+        confidence: intent.confidence,
+        impulseCount: intent.suggestedImpulses.length,
+        elapsed: Date.now() - start,
+      })
+
+      return intent
+    } catch (error) {
+      console.warn("[MemoryAgent] Analysis failed, returning fallback", {
+        error: error instanceof Error ? error.message : String(error),
+        elapsed: Date.now() - start,
+      })
+
+      // Fallback: return "other" with no impulses
+      return {
+        type: "other",
+        confidence: 0,
+        reasoning: "Analysis failed, proceeding without context",
+        suggestedImpulses: [],
+      }
+    }
+  }
+
+  /**
+   * Prepare impulses based on intent analysis
+   * Creates impulses in the impulse store
+   */
+  export async function prepare(input: { intent: Intent }): Promise<{
+    impulsesCreated: number
+    impulseIds: string[]
+  }> {
+    const start = Date.now()
+
+    try {
+      const store = getImpulseStore()
+      let created = 0
+      const impulseIds: string[] = []
+
+      // Create impulses from suggestions
+      for (const suggestion of input.intent.suggestedImpulses) {
+        // Check if impulse already exists
+        const existing = store.get(suggestion.id)
+        if (existing) {
+          console.log("[MemoryAgent] Impulse already exists, skipping", { impulseId: suggestion.id })
+          continue
+        }
+
+        // Create impulse (match Impulse type minus loaded/createdAt)
+        const impulse = createImpulse({
+          id: suggestion.id,
+          pointer: suggestion.pointer as any,
+          budget: suggestion.budget,
+          priority: suggestion.priority,
+          tags: ["memory-agent", `type:${suggestion.type}`],
+        })
+
+        created++
+        impulseIds.push(impulse.id)
+
+        console.log("[MemoryAgent] Impulse created", {
+          impulseId: impulse.id,
+          type: suggestion.type,
+          priority: suggestion.priority,
+          budget: suggestion.budget,
+        })
+      }
+
+      console.log("[MemoryAgent] Preparation complete", {
+        created,
+        elapsed: Date.now() - start,
+      })
+
+      return {
+        impulsesCreated: created,
+        impulseIds,
+      }
+    } catch (error) {
+      console.error("[MemoryAgent] Preparation failed", {
+        error: error instanceof Error ? error.message : String(error),
+        elapsed: Date.now() - start,
+      })
+
+      return {
+        impulsesCreated: 0,
+        impulseIds: [],
+      }
+    }
+  }
+}