@scitrera/memorylayer-opencode-plugin 0.1.22

package/src/shared/observation.ts

@@ -0,0 +1,447 @@
+/**
+ * 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: string): boolean {
+  if (SKIP_TOOLS.has(toolName)) return true;
+  return SKIP_PREFIXES.some(prefix => toolName.startsWith(prefix));
+}
+
+// Observation types
+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 function getObservationType(toolName: string): ObservationType {
+  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: string,
+  toolArgs: Record<string, unknown>
+): { filesRead: string[]; filesModified: string[] } {
+  const filesRead: string[] = [];
+  const filesModified: string[] = [];
+
+  try {
+    const filePath = (toolArgs.file_path || toolArgs.path || toolArgs.file || "") as string;
+
+    if (!filePath) {
+      // Try to extract paths from bash commands
+      if (toolName === "bash") {
+        const command = (toolArgs.command || "") as string;
+        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: string) => 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: string, toolArgs: Record<string, unknown>): string {
+  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 || "") as string;
+        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: string,
+  toolArgs: Record<string, unknown>,
+  toolOutput?: string
+): string[] {
+  const facts: string[] = [];
+
+  try {
+    const filePath = (toolArgs.file_path || toolArgs.path || toolArgs.file || "") as string;
+
+    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 || "") as string;
+        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: string, toolArgs: Record<string, unknown>): string[] {
+  const concepts: Set<string> = new Set();
+
+  try {
+    const filePath = (toolArgs.file_path || toolArgs.path || toolArgs.file || "") as string;
+
+    // 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: Record<string, string> = {
+            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: Record<string, string> = {
+          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 || "") as string;
+      const newStr = (toolArgs.new_string || "") as 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 || "") as string;
+        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: string,
+  toolArgs: Record<string, unknown>,
+  prompt?: string
+): string | null {
+  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: string[]): string {
+  return createHash("sha256")
+    .update(parts.join("|"))
+    .digest("hex")
+    .slice(0, 16);
+}
+
+/**
+ * Truncate string to max length
+ */
+function truncate(str: string, maxLen: number = 500): string {
+  if (str.length <= maxLen) return str;
+  return str.substring(0, maxLen) + "...";
+}
+
+/**
+ * Build observation from tool execution data
+ */
+export function buildObservation(
+  toolName: string,
+  toolArgs: Record<string, unknown>,
+  toolOutput?: string,
+  currentPrompt?: string
+): ObservationData | null {
+  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: string,
+  toolArgs: Record<string, unknown>,
+  _toolOutput: string | undefined,
+  filesRead: string[],
+  filesModified: string[]
+): string {
+  const parts: string[] = [];
+
+  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 || "") as string;
+      parts.push(`Command: ${truncate(cmd, 100)}`);
+    } else if (toolName === "grep" || toolName === "codesearch") {
+      const pattern = (toolArgs.pattern || "") as string;
+      parts.push(`Pattern: ${pattern}`);
+    } else if (toolName === "task") {
+      const desc = (toolArgs.description || "") as string;
+      parts.push(`Task: ${truncate(desc, 100)}`);
+    }
+  } catch {
+    // Ignore
+  }
+
+  return parts.length > 0 ? parts.join("; ") : `Used ${toolName}`;
+}

package/src/shared/state.ts

@@ -0,0 +1,159 @@
+/**
+ * Hook state management - persists state between hook invocations.
+ *
+ * Adapted from the CC plugin's state module. Removes CLAUDE_ENV_FILE
+ * logic since OpenCode uses a different environment mechanism.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import type { HookState } from "./types.js";
+
+const STATE_DIR = join(homedir(), ".memorylayer");
+const STATE_FILE = join(STATE_DIR, "hook-state.json");
+
+/** Default empty state */
+const DEFAULT_STATE: HookState = {
+  recallDoneThisTurn: false,
+};
+
+/**
+ * Read current hook state from disk
+ */
+export function readHookState(): HookState {
+  try {
+    if (!existsSync(STATE_FILE)) {
+      return { ...DEFAULT_STATE };
+    }
+    const data = readFileSync(STATE_FILE, "utf-8");
+    return JSON.parse(data) as HookState;
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+
+/**
+ * Write hook state to disk
+ */
+export function writeHookState(state: HookState): void {
+  try {
+    if (!existsSync(STATE_DIR)) {
+      mkdirSync(STATE_DIR, { recursive: true });
+    }
+    writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  } catch (error) {
+    console.error("Failed to write hook state:", error);
+  }
+}
+
+/**
+ * Mark that recall has been done this turn for a specific query
+ */
+export function markRecallDone(query: string): void {
+  const state = readHookState();
+  state.recallDoneThisTurn = true;
+  state.lastRecallAt = new Date().toISOString();
+  state.lastRecallQuery = query;
+  const queries = state.recallQueriesThisTurn || [];
+  queries.push(query);
+  state.recallQueriesThisTurn = queries;
+  writeHookState(state);
+}
+
+/**
+ * Check if recall was already done this turn (any query)
+ */
+export function wasRecallDoneThisTurn(): boolean {
+  const state = readHookState();
+  return state.recallDoneThisTurn;
+}
+
+/**
+ * Check if a specific query (or similar) was already recalled this turn.
+ * Allows different queries to proceed even if a recall was already done.
+ */
+export function wasQueryRecalledThisTurn(query: string): boolean {
+  const state = readHookState();
+  const queries = state.recallQueriesThisTurn || [];
+  const normalized = query.toLowerCase().trim().replace(/\s+/g, " ");
+  return queries.some(q => q.toLowerCase().trim().replace(/\s+/g, " ") === normalized);
+}
+
+/**
+ * Reset recall status for new turn
+ */
+export function resetRecallStatus(): void {
+  const state = readHookState();
+  state.recallDoneThisTurn = false;
+  state.recallQueriesThisTurn = [];
+  writeHookState(state);
+}
+
+/**
+ * Store the user's current topic for cross-hook context
+ */
+export function setCurrentTopic(topic: string): void {
+  const state = readHookState();
+  state.currentTopic = topic;
+  writeHookState(state);
+}
+
+/**
+ * Get the user's current topic (set by chat.message hook)
+ */
+export function getCurrentTopic(): string | undefined {
+  return readHookState().currentTopic;
+}
+
+/**
+ * Store the user's current prompt for cross-hook context
+ */
+export function setCurrentPrompt(prompt: string): void {
+  const state = readHookState();
+  state.currentPrompt = prompt;
+  writeHookState(state);
+}
+
+/**
+ * Get the user's current prompt
+ */
+export function getCurrentPrompt(): string | undefined {
+  return readHookState().currentPrompt;
+}
+
+/**
+ * Update workspace/session info
+ */
+export function updateSessionInfo(workspaceId: string, sessionId?: string): void {
+  const state = readHookState();
+  state.workspaceId = workspaceId;
+  state.sessionId = sessionId;
+  writeHookState(state);
+}
+
+/**
+ * Get current workspace ID from state
+ */
+export function getWorkspaceId(): string | undefined {
+  return readHookState().workspaceId;
+}
+
+/**
+ * Resolve session ID from hook state.
+ *
+ * Unlike the CC plugin which checks CLAUDE_ENV_FILE first, OpenCode
+ * plugins receive session IDs directly via hook input parameters.
+ * This function serves as a fallback for hooks that need the session
+ * ID but don't receive it directly.
+ */
+export function resolveSessionId(_caller: string): string | undefined {
+  // Check environment variable first (may be set via shell.env hook)
+  const envSessionId = process.env.MEMORYLAYER_SESSION_ID;
+  if (envSessionId) {
+    return envSessionId;
+  }
+
+  // Fall back to persisted state
+  return readHookState().sessionId;
+}