@scitrera/memorylayer-opencode-plugin 0.1.22

package/dist/src/shared/formatters.js

@@ -0,0 +1,187 @@
+/**
+ * Format API responses for injection into OpenCode's context.
+ *
+ * Uses the same types returned by MemoryLayerClient (the MCP adapter),
+ * so hooks and MCP tools share the same data contracts.
+ */
+/**
+ * Format a single memory for display
+ */
+function formatMemory(memory, index) {
+    const lines = [];
+    const typeStr = memory.subtype
+        ? `${memory.type}/${memory.subtype}`
+        : memory.type;
+    const relevanceStr = memory.relevance_score
+        ? ` (relevance: ${(memory.relevance_score * 100).toFixed(0)}%)`
+        : "";
+    lines.push(`${index + 1}. [${typeStr}]${relevanceStr}`);
+    lines.push(`   ${memory.content}`);
+    const tags = memory.tags ?? [];
+    if (tags.length > 0) {
+        lines.push(`   Tags: ${tags.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format recall results for context injection
+ */
+export function formatRecallResult(result, query) {
+    if (result.memories.length === 0) {
+        return `No memories found matching "${query}".`;
+    }
+    const totalCount = result.total_count ?? result.memories.length;
+    const lines = [
+        `Found ${totalCount} memories for "${query}" (showing ${result.memories.length}):`,
+        "",
+    ];
+    for (let i = 0; i < result.memories.length; i++) {
+        lines.push(formatMemory(result.memories[i], i));
+        if (i < result.memories.length - 1) {
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format briefing for context injection.
+ * Accepts the ToolResponse from MemoryLayerClient.getBriefing().
+ */
+export function formatBriefing(briefing) {
+    if (!briefing) {
+        return "=== Workspace Briefing ===\n\nNo workspace data available.";
+    }
+    const totalMemories = briefing.total_memories ?? 0;
+    const activeTopics = briefing.active_topics ?? [];
+    const memoryTypes = briefing.memory_types ?? {};
+    const recentActivity = briefing.recent_activity ?? [];
+    const lines = [
+        "=== Workspace Briefing ===",
+        "",
+        `Total memories: ${totalMemories}`,
+    ];
+    if (activeTopics.length > 0) {
+        lines.push(`Active topics: ${activeTopics.join(", ")}`);
+    }
+    // Memory type breakdown
+    const types = Object.entries(memoryTypes);
+    if (types.length > 0) {
+        lines.push("");
+        lines.push("Memory types:");
+        for (const [type, count] of types) {
+            lines.push(`  - ${type}: ${count}`);
+        }
+    }
+    // Recent activity
+    if (recentActivity.length > 0) {
+        lines.push("");
+        lines.push("Recent activity:");
+        for (const activity of recentActivity.slice(0, 3)) {
+            const date = new Date(activity.timestamp ?? new Date().toISOString()).toLocaleDateString();
+            lines.push(`  - ${date}: ${activity.summary ?? ""} (${activity.memories_created ?? 0} memories)`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format directive memories specially (high importance user instructions)
+ */
+export function formatDirectives(memories) {
+    const directives = memories.filter(m => m.subtype === "directive" || (m.subtype === "preference" && (m.importance ?? 0) >= 0.9));
+    if (directives.length === 0) {
+        return "";
+    }
+    const lines = [
+        "=== User Directives (must follow) ===",
+        "",
+    ];
+    for (const directive of directives) {
+        lines.push(`- ${directive.content}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format sandbox state for context injection (post-compaction recovery)
+ */
+export function formatSandboxState(inspectResult) {
+    const variableCount = inspectResult.variable_count ?? 0;
+    const variables = inspectResult.variables ?? {};
+    const lines = [
+        "=== Existing Sandbox State (server-side) ===",
+        "",
+        `The server-side sandbox has ${variableCount} variable(s) from a prior session or before context compaction.`,
+        "These variables are live and available for memory_context_exec, memory_context_query, and memory_context_rlm.",
+        "",
+    ];
+    for (const [name, info] of Object.entries(variables)) {
+        lines.push(`  ${name} (${info.type}): ${info.preview}`);
+    }
+    lines.push("");
+    lines.push("Use `memory_context_inspect` for detailed variable inspection.");
+    return lines.join("\n");
+}
+/**
+ * Format combined session start output
+ */
+export function formatSessionStart(briefing, directives, topicRecall, topic, sandboxState) {
+    const sections = [];
+    // Briefing first
+    if (briefing) {
+        sections.push(formatBriefing(briefing));
+    }
+    // Directives (high priority)
+    const directiveSection = formatDirectives(directives);
+    if (directiveSection) {
+        sections.push(directiveSection);
+    }
+    // Topic-specific recall
+    if (topicRecall && topicRecall.memories.length > 0 && topic) {
+        sections.push(formatRecallResult(topicRecall, topic));
+    }
+    // Existing sandbox state (post-compaction or resumed session)
+    if (sandboxState) {
+        sections.push(formatSandboxState(sandboxState));
+    }
+    // Add session guidance
+    const guidance = `=== Session Guidance ===
+
+Recalling Memories:
+- Before answering questions about preferences, setup, conventions, or past decisions, call \`memory_recall\` first
+- For broad context gathering, use \`memory_recall\` with relevant keywords
+- Directives (subtype: directive) and preferences (subtype: preference) represent explicit user instructions — prioritize these
+
+Storing Memories:
+- \`memory_remember\`: store to long-term memory with type, subtype, and importance
+- \`memory_session_commit\`: checkpoint working memory mid-session (without ending it)
+
+Importance Guide: directives/preferences -> 0.9 | decisions/architecture -> 0.7-0.8 | fixes/solutions -> 0.7 | patterns -> 0.5-0.6
+Types: semantic (facts), procedural (how-to), episodic (events), working (current context, auto-expires)
+Subtypes: directive, decision, fix, solution, code_pattern, error, workflow, preference, problem
+
+Context Environment (sandbox survives compaction):
+- Load + analyze memories server-side: \`memory_context_load\` -> \`memory_context_query\` or \`memory_context_rlm\`
+- Run computations on loaded data: \`memory_context_exec\` (Python sandbox)
+- After compaction, call \`memory_context_inspect\` to re-orient with existing sandbox variables`;
+    sections.push(guidance);
+    if (sections.length === 1) {
+        // Only guidance, no prior context
+        return "MemoryLayer: No prior context found for this session.\n\n" + guidance;
+    }
+    return sections.join("\n\n");
+}
+/**
+ * Format guidance for storing memories after tool use
+ */
+export function formatStorageGuidance(toolName, isSignificant) {
+    if (!isSignificant) {
+        return "";
+    }
+    const guidance = {
+        task: "Consider storing exploration/research findings with `memory_remember` (subtype: decision/problem/entity).",
+        bash: "If this was a significant git commit, test result, or build output, store with `memory_remember` (subtype: workflow).",
+        edit: "If this edit completes a milestone, store with `memory_remember` (type: working, tags: [active-file]).",
+        write: "If this file represents a significant deliverable, store with `memory_remember` (type: working, tags: [active-file]).",
+    };
+    return guidance[toolName] || "";
+}
+//# sourceMappingURL=formatters.js.map

package/dist/src/shared/formatters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.js","sourceRoot":"","sources":["../../../src/shared/formatters.ts"],"names":[],"mappings":"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"}

package/dist/src/shared/observation.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Observation extraction for auto-capture hooks.
+ * Extracts structured observation data from tool usage.
+ *
+ * Adapted from the CC plugin with OpenCode tool name mappings.
+ * OpenCode uses lowercase tool names: bash, edit, write, read, glob, grep,
+ * task, webfetch, websearch, multiedit, ls, apply_patch, codesearch, etc.
+ */
+export declare function shouldSkipTool(toolName: string): boolean;
+export type ObservationType = "read" | "write" | "execute" | "search" | "other";
+export interface ObservationData {
+    type: ObservationType;
+    title: string;
+    toolName: string;
+    filesRead: string[];
+    filesModified: string[];
+    facts: string[];
+    concepts: string[];
+    intent: string | null;
+    contentHash: string;
+    summary: string;
+}
+/**
+ * Classify tool as read/write/execute/search/other.
+ * Uses OpenCode's lowercase tool names.
+ */
+export declare function getObservationType(toolName: string): ObservationType;
+/**
+ * Extract file paths from tool args, classified as read or modified
+ */
+export declare function extractFilePaths(toolName: string, toolArgs: Record<string, unknown>): {
+    filesRead: string[];
+    filesModified: string[];
+};
+/**
+ * Generate observation title from tool usage
+ */
+export declare function generateTitle(toolName: string, toolArgs: Record<string, unknown>): string;
+/**
+ * Extract facts from tool args/output
+ */
+export declare function extractFacts(toolName: string, toolArgs: Record<string, unknown>, toolOutput?: string): string[];
+/**
+ * Extract concepts/topics from tool usage
+ */
+export declare function extractConcepts(toolName: string, toolArgs: Record<string, unknown>): string[];
+/**
+ * Detect intent from tool usage and user prompt
+ */
+export declare function detectIntent(toolName: string, toolArgs: Record<string, unknown>, prompt?: string): string | null;
+/**
+ * Compute content hash for deduplication
+ */
+export declare function computeContentHash(...parts: string[]): string;
+/**
+ * Build observation from tool execution data
+ */
+export declare function buildObservation(toolName: string, toolArgs: Record<string, unknown>, toolOutput?: string, currentPrompt?: string): ObservationData | null;
+//# sourceMappingURL=observation.d.ts.map

package/dist/src/shared/observation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation.d.ts","sourceRoot":"","sources":["../../../src/shared/observation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAoBH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGxD;AAGD,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEhF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAWpE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC;IAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAE,CAgClD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAiCzF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,EAAE,CAsDV;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,CAwF7F;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CA0Cf;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAK7D;AAUD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,MAAM,GACrB,eAAe,GAAG,IAAI,CAiCxB"}

package/dist/src/shared/observation.js

@@ -0,0 +1,406 @@
+/**
+ * Observation extraction for auto-capture hooks.
+ * Extracts structured observation data from tool usage.
+ *
+ * Adapted from the CC plugin with OpenCode tool name mappings.
+ * OpenCode uses lowercase tool names: bash, edit, write, read, glob, grep,
+ * task, webfetch, websearch, multiedit, ls, apply_patch, codesearch, etc.
+ */
+import { createHash } from "crypto";
+// Tools to skip (internal/noisy/self-referential)
+const SKIP_TOOLS = new Set([
+    "todo",
+    "question",
+    "plan",
+    "skill",
+    "batch",
+]);
+// Also skip any tool matching these prefixes (memory tools)
+const SKIP_PREFIXES = [
+    "memorylayer",
+    "memory_",
+    "mcp__memorylayer",
+];
+export function shouldSkipTool(toolName) {
+    if (SKIP_TOOLS.has(toolName))
+        return true;
+    return SKIP_PREFIXES.some(prefix => toolName.startsWith(prefix));
+}
+/**
+ * Classify tool as read/write/execute/search/other.
+ * Uses OpenCode's lowercase tool names.
+ */
+export function getObservationType(toolName) {
+    const readTools = ["read", "glob", "grep", "ls", "codesearch"];
+    const writeTools = ["write", "edit", "multiedit", "apply_patch"];
+    const executeTools = ["bash", "task"];
+    const searchTools = ["websearch", "webfetch"];
+    if (readTools.includes(toolName))
+        return "read";
+    if (writeTools.includes(toolName))
+        return "write";
+    if (executeTools.includes(toolName))
+        return "execute";
+    if (searchTools.includes(toolName))
+        return "search";
+    return "other";
+}
+/**
+ * Extract file paths from tool args, classified as read or modified
+ */
+export function extractFilePaths(toolName, toolArgs) {
+    const filesRead = [];
+    const filesModified = [];
+    try {
+        const filePath = (toolArgs.file_path || toolArgs.path || toolArgs.file || "");
+        if (!filePath) {
+            // Try to extract paths from bash commands
+            if (toolName === "bash") {
+                const command = (toolArgs.command || "");
+                const pathMatches = command.match(/(?:^|\s)([^\s]+\.(ts|js|py|json|yaml|yml|md|txt|go|rs|java|c|cpp|h))\b/gi);
+                if (pathMatches) {
+                    filesRead.push(...pathMatches.map((p) => p.trim()));
+                }
+            }
+            return { filesRead, filesModified };
+        }
+        const type = getObservationType(toolName);
+        if (type === "write") {
+            filesModified.push(filePath);
+        }
+        else if (type === "read") {
+            filesRead.push(filePath);
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return { filesRead, filesModified };
+}
+/**
+ * Generate observation title from tool usage
+ */
+export function generateTitle(toolName, toolArgs) {
+    try {
+        switch (toolName) {
+            case "read":
+                return `Read ${toolArgs.file_path || toolArgs.path || "file"}`;
+            case "write":
+                return `Write ${toolArgs.file_path || toolArgs.path || "file"}`;
+            case "edit":
+            case "multiedit":
+                return `Edit ${toolArgs.file_path || toolArgs.path || "file"}`;
+            case "apply_patch":
+                return `Patch ${toolArgs.file_path || toolArgs.path || "file"}`;
+            case "bash": {
+                const cmd = (toolArgs.command || "");
+                return `Run: ${cmd.substring(0, 50)}${cmd.length > 50 ? "..." : ""}`;
+            }
+            case "glob":
+                return `Find ${toolArgs.pattern || "files"}`;
+            case "grep":
+            case "codesearch":
+                return `Search "${toolArgs.pattern || ""}"`;
+            case "task":
+                return `Task: ${toolArgs.description || "agent"}`;
+            case "websearch":
+                return `Search: ${toolArgs.query || ""}`;
+            case "webfetch":
+                return `Fetch: ${toolArgs.url || ""}`;
+            default:
+                return toolName;
+        }
+    }
+    catch {
+        return toolName;
+    }
+}
+/**
+ * Extract facts from tool args/output
+ */
+export function extractFacts(toolName, toolArgs, toolOutput) {
+    const facts = [];
+    try {
+        const filePath = (toolArgs.file_path || toolArgs.path || toolArgs.file || "");
+        switch (toolName) {
+            case "read":
+                if (filePath)
+                    facts.push(`File read: ${filePath}`);
+                break;
+            case "write":
+                if (filePath)
+                    facts.push(`File created/updated: ${filePath}`);
+                break;
+            case "edit":
+            case "multiedit":
+            case "apply_patch":
+                if (filePath)
+                    facts.push(`File modified: ${filePath}`);
+                if (toolArgs.old_string) {
+                    facts.push(`Code replaced in ${filePath.split(/[/\\]/).pop() || "file"}`);
+                }
+                break;
+            case "bash": {
+                const cmd = (toolArgs.command || "");
+                facts.push(`Command executed: ${cmd.substring(0, 100)}`);
+                if (toolOutput) {
+                    if (toolOutput.includes("passed") || toolOutput.includes("\u2713"))
+                        facts.push("Tests passed");
+                    if (toolOutput.includes("failed") || toolOutput.includes("\u2717"))
+                        facts.push("Tests failed");
+                    if (toolOutput.includes("error") || toolOutput.includes("Error"))
+                        facts.push("Errors encountered");
+                }
+                break;
+            }
+            case "glob":
+                if (toolArgs.pattern)
+                    facts.push(`Pattern searched: ${toolArgs.pattern}`);
+                break;
+            case "grep":
+            case "codesearch":
+                if (toolArgs.pattern)
+                    facts.push(`Code pattern searched: ${toolArgs.pattern}`);
+                if (toolArgs.path)
+                    facts.push(`Search scope: ${toolArgs.path}`);
+                break;
+            case "websearch":
+                if (toolArgs.query)
+                    facts.push(`Web search: ${toolArgs.query}`);
+                break;
+            case "webfetch":
+                if (toolArgs.url)
+                    facts.push(`URL fetched: ${toolArgs.url}`);
+                break;
+            case "task":
+                if (toolArgs.description)
+                    facts.push(`Sub-task: ${toolArgs.description}`);
+                break;
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return facts;
+}
+/**
+ * Extract concepts/topics from tool usage
+ */
+export function extractConcepts(toolName, toolArgs) {
+    const concepts = new Set();
+    try {
+        const filePath = (toolArgs.file_path || toolArgs.path || toolArgs.file || "");
+        // Extract concepts from file paths
+        if (filePath) {
+            const parts = filePath.split(/[/\\]/);
+            for (const part of parts) {
+                if (["src", "lib", "dist", "node_modules", ".", ".."].includes(part))
+                    continue;
+                if (part.includes(".")) {
+                    const ext = part.split(".").pop();
+                    const extMap = {
+                        ts: "typescript", tsx: "react", js: "javascript", jsx: "react",
+                        py: "python", rs: "rust", go: "golang", css: "styling", scss: "styling",
+                        html: "html", json: "configuration", yaml: "configuration", yml: "configuration",
+                        md: "documentation", test: "testing", spec: "testing", sql: "database",
+                    };
+                    if (ext && extMap[ext])
+                        concepts.add(extMap[ext]);
+                }
+                const dirMap = {
+                    tests: "testing", __tests__: "testing", test: "testing", spec: "testing",
+                    hooks: "hooks", api: "api", auth: "authentication", db: "database",
+                    components: "components", pages: "pages", routes: "routing", utils: "utilities",
+                    services: "services", middleware: "middleware", models: "models", types: "types",
+                    cli: "cli", config: "configuration", migrations: "database", schemas: "schemas",
+                };
+                if (dirMap[part])
+                    concepts.add(dirMap[part]);
+            }
+        }
+        // Extract function/class names from edit tools
+        if (toolName === "edit" || toolName === "multiedit") {
+            const oldStr = (toolArgs.old_string || "");
+            const newStr = (toolArgs.new_string || "");
+            const combined = oldStr + "\n" + newStr;
+            const funcMatches = combined.match(/(?:function|async function|const|let|var)\s+(\w{3,})/g);
+            if (funcMatches) {
+                for (const m of funcMatches.slice(0, 3)) {
+                    const name = m.replace(/(?:function|async function|const|let|var)\s+/, "");
+                    concepts.add(`fn:${name}`);
+                }
+            }
+            const classMatches = combined.match(/class\s+(\w{3,})/g);
+            if (classMatches) {
+                for (const m of classMatches.slice(0, 2)) {
+                    concepts.add(`class:${m.replace("class ", "")}`);
+                }
+            }
+            if (/\bimport\b/.test(combined))
+                concepts.add("pattern:import");
+            if (/\bexport\b/.test(combined))
+                concepts.add("pattern:export");
+            if (/\binterface\b/.test(combined))
+                concepts.add("pattern:interface");
+            if (/\benum\b/.test(combined))
+                concepts.add("pattern:enum");
+            if (/\btry\s*\{/.test(combined))
+                concepts.add("pattern:error-handling");
+            if (/\basync\b/.test(combined))
+                concepts.add("pattern:async");
+        }
+        // Tool-based concepts
+        switch (toolName) {
+            case "bash": {
+                const cmd = (toolArgs.command || "");
+                if (cmd.includes("test") || cmd.includes("vitest") || cmd.includes("jest"))
+                    concepts.add("testing");
+                if (cmd.includes("build") || cmd.includes("tsc"))
+                    concepts.add("build");
+                if (cmd.includes("git"))
+                    concepts.add("version-control");
+                if (cmd.includes("npm") || cmd.includes("yarn") || cmd.includes("pnpm") || cmd.includes("bun"))
+                    concepts.add("package-management");
+                if (cmd.includes("docker"))
+                    concepts.add("containerization");
+                if (cmd.includes("lint") || cmd.includes("eslint") || cmd.includes("biome"))
+                    concepts.add("linting");
+                break;
+            }
+            case "websearch":
+                concepts.add("research");
+                break;
+            case "webfetch":
+                concepts.add("web-content");
+                break;
+            case "task":
+                concepts.add("delegation");
+                break;
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return Array.from(concepts);
+}
+/**
+ * Detect intent from tool usage and user prompt
+ */
+export function detectIntent(toolName, toolArgs, prompt) {
+    const intentPatterns = {
+        bugfix: /fix|bug|error|issue|broken|crash|repair/i,
+        feature: /add|feature|implement|create|new|build/i,
+        refactor: /refactor|clean|rename|reorganize|restructure/i,
+        testing: /test|spec|coverage|verify/i,
+        investigation: /find|search|investigate|debug|analyze|explore/i,
+        documentation: /document|comment|readme|doc|explain/i,
+    };
+    if (prompt) {
+        for (const [intent, pattern] of Object.entries(intentPatterns)) {
+            if (pattern.test(prompt)) {
+                return intent;
+            }
+        }
+    }
+    try {
+        const inputStr = JSON.stringify(toolArgs);
+        for (const [intent, pattern] of Object.entries(intentPatterns)) {
+            if (pattern.test(inputStr)) {
+                return intent;
+            }
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    switch (toolName) {
+        case "read":
+        case "glob":
+        case "grep":
+        case "codesearch":
+            return "investigation";
+        case "write":
+            return "feature";
+        case "edit":
+            return null; // Too ambiguous without context
+        default:
+            return null;
+    }
+}
+/**
+ * Compute content hash for deduplication
+ */
+export function computeContentHash(...parts) {
+    return createHash("sha256")
+        .update(parts.join("|"))
+        .digest("hex")
+        .slice(0, 16);
+}
+/**
+ * Truncate string to max length
+ */
+function truncate(str, maxLen = 500) {
+    if (str.length <= maxLen)
+        return str;
+    return str.substring(0, maxLen) + "...";
+}
+/**
+ * Build observation from tool execution data
+ */
+export function buildObservation(toolName, toolArgs, toolOutput, currentPrompt) {
+    const type = getObservationType(toolName);
+    const title = generateTitle(toolName, toolArgs);
+    const { filesRead, filesModified } = extractFilePaths(toolName, toolArgs);
+    const facts = extractFacts(toolName, toolArgs, toolOutput);
+    const concepts = extractConcepts(toolName, toolArgs);
+    const intent = detectIntent(toolName, toolArgs, currentPrompt);
+    const summary = buildSummary(toolName, toolArgs, toolOutput, filesRead, filesModified);
+    const contentHash = computeContentHash(toolName, JSON.stringify(toolArgs), summary);
+    // Skip if empty observation (no meaningful data extracted)
+    if (filesRead.length === 0 && filesModified.length === 0 && facts.length === 0 && concepts.length === 0) {
+        return null;
+    }
+    return {
+        type,
+        title,
+        toolName,
+        filesRead,
+        filesModified,
+        facts,
+        concepts,
+        intent,
+        contentHash,
+        summary,
+    };
+}
+/**
+ * Build human-readable summary
+ */
+function buildSummary(toolName, toolArgs, _toolOutput, filesRead, filesModified) {
+    const parts = [];
+    if (filesRead.length > 0) {
+        parts.push(`Read: ${filesRead.join(", ")}`);
+    }
+    if (filesModified.length > 0) {
+        parts.push(`Modified: ${filesModified.join(", ")}`);
+    }
+    try {
+        if (toolName === "bash") {
+            const cmd = (toolArgs.command || "");
+            parts.push(`Command: ${truncate(cmd, 100)}`);
+        }
+        else if (toolName === "grep" || toolName === "codesearch") {
+            const pattern = (toolArgs.pattern || "");
+            parts.push(`Pattern: ${pattern}`);
+        }
+        else if (toolName === "task") {
+            const desc = (toolArgs.description || "");
+            parts.push(`Task: ${truncate(desc, 100)}`);
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return parts.length > 0 ? parts.join("; ") : `Used ${toolName}`;
+}
+//# sourceMappingURL=observation.js.map