opencode-claude-memory 1.5.1 → 1.6.0

package/src/index.ts

@@ -12,31 +12,180 @@ import {
 } from "./memory.js"
 import { getMemoryDir } from "./paths.js"
 
+// Per-turn derived state — overwritten each time messages.transform fires.
+// This replaces the old process-global session Maps so that compact naturally
+// resets both alreadySurfaced and recentTools (the messages shrink after compact,
+// so the derived state shrinks with them).
+type TurnContext = {
+  query?: string
+  alreadySurfaced: Set<string>
+  recentTools: string[]
+}
+
+const turnContextBySession = new Map<string, TurnContext>()
+
+function shouldIgnoreMemoryContext(query: string | undefined): boolean {
+  if (process.env.OPENCODE_MEMORY_IGNORE === "1") return true
+  if (!query) return false
+
+  const normalized = query.toLowerCase()
+  return (
+    /(ignore|don't use|do not use|without|skip)\s+(the\s+)?memory/.test(normalized) ||
+    /memory\s+(should be|must be)?\s*ignored/.test(normalized)
+  )
+}
+
+function extractUserQuery(message: unknown): string | undefined {
+  if (!message || typeof message !== "object") return undefined
+
+  if ("content" in message) {
+    const content = (message as { content?: unknown }).content
+    if (typeof content === "string") return content
+    if (content !== undefined) return JSON.stringify(content)
+  }
+
+  if ("parts" in message) {
+    const parts = (message as { parts?: unknown }).parts
+    if (Array.isArray(parts)) {
+      const text = parts
+        .map((part) => {
+          if (!part || typeof part !== "object") return ""
+          return typeof (part as { text?: unknown }).text === "string"
+            ? (part as { text: string }).text
+            : ""
+        })
+        .filter(Boolean)
+        .join("\n")
+        .trim()
+      if (text) return text
+    }
+  }
+
+  return undefined
+}
+
+function getLastUserQuery(messages: Array<{ info?: { role?: unknown; sessionID?: unknown }; parts?: unknown }>): {
+  query?: string
+  sessionID?: string
+} {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i]
+    if (message?.info?.role !== "user") continue
+
+    const query = extractUserQuery(message)
+    const sessionID = typeof message.info?.sessionID === "string" ? message.info.sessionID : undefined
+    return { query, sessionID }
+  }
+
+  return {}
+}
+
+function isAutoMemoryPart(part: unknown): boolean {
+  if (!part || typeof part !== "object") return false
+  return typeof (part as { text?: unknown }).text === "string" &&
+    (part as { text: string }).text.includes("# Auto Memory")
+}
+
+// Parses "### <name> (<type>)" headers from the ## Recalled Memories section
+// of system prompts. After compaction old system messages disappear, so
+// the returned set naturally shrinks — no manual reset needed.
+function extractSurfacedMemoryKeys(systemText: string): Set<string> {
+  const keys = new Set<string>()
+  const recalledSection = systemText.indexOf("## Recalled Memories")
+  if (recalledSection === -1) return keys
+
+  const headerPattern = /^### (.+?) \((\w+)\)/gm
+  const section = systemText.slice(recalledSection)
+  for (let match = headerPattern.exec(section); match !== null; match = headerPattern.exec(section)) {
+    keys.add(`${match[1]}|${match[2]}`)
+  }
+  return keys
+}
+
+// Only completed tools — matches Claude Code's collectRecentSuccessfulTools().
+function extractRecentTools(
+  messages: Array<{ info?: { role?: unknown }; parts?: unknown[] }>,
+): string[] {
+  const tools: string[] = []
+  const seen = new Set<string>()
+  for (const message of messages) {
+    if (!message.parts || !Array.isArray(message.parts)) continue
+    for (const part of message.parts) {
+      if (!part || typeof part !== "object") continue
+      const p = part as { type?: string; tool?: string; state?: { status?: string } }
+      if (p.type !== "tool" || !p.tool) continue
+      if (p.state?.status !== "completed") continue
+      if (seen.has(p.tool)) continue
+      seen.add(p.tool)
+      tools.push(p.tool)
+    }
+  }
+  return tools
+}
+
 export const MemoryPlugin: Plugin = async ({ worktree }) => {
   getMemoryDir(worktree)
 
   return {
-    "experimental.chat.system.transform": async (_input, output) => {
-      let query: string | undefined
-      if (_input && typeof _input === "object") {
-        const messages = (_input as { messages?: unknown }).messages
-        if (Array.isArray(messages)) {
-          const lastUserMsg = [...messages]
-            .reverse()
-            .find((message) =>
-              message && typeof message === "object" && "role" in message && (message as { role?: unknown }).role === "user",
-            )
-
-          if (lastUserMsg && typeof lastUserMsg === "object" && "content" in lastUserMsg) {
-            const content = (lastUserMsg as { content?: unknown }).content
-            query = typeof content === "string" ? content : JSON.stringify(content)
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const { query, sessionID } = getLastUserQuery(output.messages)
+
+      if (sessionID) {
+        const alreadySurfaced = new Set<string>()
+        for (const message of output.messages) {
+          const role = String(message.info.role)
+          if (role !== "system") continue
+          for (const part of message.parts) {
+            if (!part || typeof part !== "object") continue
+            const text = (part as { text?: string }).text
+            if (typeof text === "string") {
+              for (const key of extractSurfacedMemoryKeys(text)) {
+                alreadySurfaced.add(key)
+              }
+            }
           }
         }
+
+        const recentTools = extractRecentTools(
+          output.messages as Array<{ info?: { role?: unknown }; parts?: unknown[] }>,
+        )
+
+        turnContextBySession.set(sessionID, { query, alreadySurfaced, recentTools })
       }
 
-      const recalled = recallRelevantMemories(worktree, query)
+      if (shouldIgnoreMemoryContext(query)) {
+        output.messages = output.messages
+          .map((message) => {
+            const role = String(message.info.role)
+            if (role !== "system") return message
+
+            const parts = message.parts.filter((part) => !isAutoMemoryPart(part))
+            return { ...message, parts }
+          })
+          .filter((message) => message.parts.length > 0)
+      }
+    },
+
+    "experimental.chat.system.transform": async (_input, output) => {
+      let sessionID: string | undefined
+      if (_input && typeof _input === "object") {
+        sessionID = (typeof (_input as { sessionID?: unknown }).sessionID === "string"
+          ? (_input as { sessionID?: string }).sessionID
+          : undefined)
+      }
+
+      const ctx = sessionID ? turnContextBySession.get(sessionID) : undefined
+      const query = ctx?.query
+      const alreadySurfaced = ctx?.alreadySurfaced ?? new Set<string>()
+      const recentTools = ctx?.recentTools ?? []
+
+      const ignoreMemoryContext = process.env.OPENCODE_MEMORY_IGNORE === "1" || shouldIgnoreMemoryContext(query)
+      const recalled = ignoreMemoryContext ? [] : recallRelevantMemories(worktree, query, alreadySurfaced, recentTools)
+
       const recalledSection = formatRecalledMemories(recalled)
-      const memoryPrompt = buildMemorySystemPrompt(worktree, recalledSection)
+      const memoryPrompt = buildMemorySystemPrompt(worktree, recalledSection, {
+        includeIndex: !ignoreMemoryContext,
+      })
       output.system.push(memoryPrompt)
     },
 

package/src/memory.ts

@@ -1,4 +1,4 @@
-import { readFileSync, writeFileSync, readdirSync, unlinkSync, existsSync } from "fs"
+import { readFileSync, writeFileSync, readdirSync, unlinkSync } from "fs"
 import { join, basename } from "path"
 import {
   getMemoryDir,
@@ -7,6 +7,8 @@ import {
   validateMemoryFileName,
   MAX_MEMORY_FILES,
   MAX_MEMORY_FILE_BYTES,
+  MAX_ENTRYPOINT_LINES,
+  MAX_ENTRYPOINT_BYTES,
   FRONTMATTER_MAX_LINES,
 } from "./paths.js"
 
@@ -75,7 +77,7 @@ export function listMemories(worktree: string): MemoryEntry[] {
 
   let files: string[]
   try {
-    files = readdirSync(memDir)
+    files = readdirSync(memDir, { encoding: "utf-8" })
       .filter((f) => f.endsWith(".md") && f !== ENTRYPOINT_NAME)
       .sort()
       .slice(0, MAX_MEMORY_FILES)
@@ -214,30 +216,57 @@ function removeFromIndex(worktree: string, fileName: string): void {
   writeFileSync(entrypoint, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8")
 }
 
-export function truncateEntrypoint(raw: string): { content: string; wasTruncated: boolean } {
+function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`
+  return `${(bytes / 1024).toFixed(1)}KB`
+}
+
+export type EntrypointTruncation = {
+  content: string
+  lineCount: number
+  byteCount: number
+  wasLineTruncated: boolean
+  wasByteTruncated: boolean
+}
+
+// Port of Claude Code's truncateEntrypointContent() from memdir.ts.
+// Uses .length (char count, same as Claude Code) for byte measurement.
+export function truncateEntrypoint(raw: string): EntrypointTruncation {
   const trimmed = raw.trim()
-  if (!trimmed) return { content: "", wasTruncated: false }
+  if (!trimmed) return { content: "", lineCount: 0, byteCount: 0, wasLineTruncated: false, wasByteTruncated: false }
 
-  const lines = trimmed.split("\n")
-  const lineCount = lines.length
+  const contentLines = trimmed.split("\n")
+  const lineCount = contentLines.length
   const byteCount = trimmed.length
 
-  const wasLineTruncated = lineCount > 200
-  const wasByteTruncated = byteCount > 25_000
+  const wasLineTruncated = lineCount > MAX_ENTRYPOINT_LINES
+  const wasByteTruncated = byteCount > MAX_ENTRYPOINT_BYTES
 
   if (!wasLineTruncated && !wasByteTruncated) {
-    return { content: trimmed, wasTruncated: false }
+    return { content: trimmed, lineCount, byteCount, wasLineTruncated, wasByteTruncated }
   }
 
-  let truncated = wasLineTruncated ? lines.slice(0, 200).join("\n") : trimmed
+  let truncated = wasLineTruncated
+    ? contentLines.slice(0, MAX_ENTRYPOINT_LINES).join("\n")
+    : trimmed
 
-  if (truncated.length > 25_000) {
-    const cutAt = truncated.lastIndexOf("\n", 25_000)
-    truncated = truncated.slice(0, cutAt > 0 ? cutAt : 25_000)
+  if (truncated.length > MAX_ENTRYPOINT_BYTES) {
+    const cutAt = truncated.lastIndexOf("\n", MAX_ENTRYPOINT_BYTES)
+    truncated = truncated.slice(0, cutAt > 0 ? cutAt : MAX_ENTRYPOINT_BYTES)
   }
 
+  const reason =
+    wasByteTruncated && !wasLineTruncated
+      ? `${formatFileSize(byteCount)} (limit: ${formatFileSize(MAX_ENTRYPOINT_BYTES)}) — index entries are too long`
+      : wasLineTruncated && !wasByteTruncated
+        ? `${lineCount} lines (limit: ${MAX_ENTRYPOINT_LINES})`
+        : `${lineCount} lines and ${formatFileSize(byteCount)}`
+
   return {
-    content: truncated + "\n\n> WARNING: MEMORY.md was truncated. Keep index entries concise.",
-    wasTruncated: true,
+    content: truncated + `\n\n> WARNING: ${ENTRYPOINT_NAME} is ${reason}. Only part of it was loaded. Keep index entries to one line under ~200 chars; move detail into topic files.`,
+    lineCount,
+    byteCount,
+    wasLineTruncated,
+    wasByteTruncated,
   }
 }

package/src/memoryScan.ts

@@ -0,0 +1,130 @@
+import { readdirSync, readFileSync, statSync } from "fs"
+import { basename, join } from "path"
+import {
+  getMemoryDir,
+  ENTRYPOINT_NAME,
+  MAX_MEMORY_FILES,
+  FRONTMATTER_MAX_LINES,
+} from "./paths.js"
+import type { MemoryType } from "./memory.js"
+
+export type MemoryHeader = {
+  filename: string
+  filePath: string
+  mtimeMs: number
+  name: string | null
+  description: string | null
+  type: MemoryType | undefined
+}
+
+const MEMORY_TYPES: readonly string[] = ["user", "feedback", "project", "reference"]
+
+function parseMemoryType(raw: string | undefined): MemoryType | undefined {
+  if (!raw) return undefined
+  return MEMORY_TYPES.includes(raw) ? (raw as MemoryType) : undefined
+}
+
+function readFileHeader(filePath: string, maxLines: number): { content: string; mtimeMs: number } {
+  try {
+    const raw = readFileSync(filePath, "utf-8")
+    const stat = statSync(filePath)
+    const lines = raw.split("\n")
+    const header = lines.slice(0, maxLines).join("\n")
+    return { content: header, mtimeMs: stat.mtimeMs }
+  } catch {
+    return { content: "", mtimeMs: 0 }
+  }
+}
+
+function parseFrontmatterHeader(raw: string): Record<string, string> {
+  const trimmed = raw.trim()
+  if (!trimmed.startsWith("---")) {
+    return {}
+  }
+
+  const lines = trimmed.split("\n")
+  let closingLineIdx = -1
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trimEnd() === "---") {
+      closingLineIdx = i
+      break
+    }
+  }
+  if (closingLineIdx === -1) {
+    return {}
+  }
+
+  const frontmatter: Record<string, string> = {}
+  for (let i = 1; i < closingLineIdx; i++) {
+    const line = lines[i]
+    const colonIdx = line.indexOf(":")
+    if (colonIdx === -1) continue
+    const key = line.slice(0, colonIdx).trim()
+    const value = line.slice(colonIdx + 1).trim()
+    if (key && value) {
+      frontmatter[key] = value
+    }
+  }
+
+  return frontmatter
+}
+
+/**
+ * Recursive scan of memory directory. Reads only frontmatter (first N lines),
+ * returns headers sorted by mtime desc, capped at MAX_MEMORY_FILES.
+ * Port of Claude Code's scanMemoryFiles().
+ */
+export function scanMemoryFiles(memoryDir: string): MemoryHeader[] {
+  try {
+    const entries = readdirSync(memoryDir, { recursive: true, encoding: "utf-8" }) as string[]
+    const mdFiles = entries.filter(
+      (f: string) => f.endsWith(".md") && basename(f) !== ENTRYPOINT_NAME,
+    )
+
+    const headers: MemoryHeader[] = []
+    for (const relativePath of mdFiles) {
+      const filePath = join(memoryDir, relativePath)
+      try {
+        const { content, mtimeMs } = readFileHeader(filePath, FRONTMATTER_MAX_LINES)
+        const frontmatter = parseFrontmatterHeader(content)
+        headers.push({
+          filename: relativePath,
+          filePath,
+          mtimeMs,
+          name: frontmatter.name || null,
+          description: frontmatter.description || null,
+          type: parseMemoryType(frontmatter.type),
+        })
+      } catch {
+        // skip unreadable files
+      }
+    }
+
+    return headers
+      .sort((a, b) => b.mtimeMs - a.mtimeMs)
+      .slice(0, MAX_MEMORY_FILES)
+  } catch {
+    return []
+  }
+}
+
+// Port of Claude Code's formatMemoryManifest():
+// `- [type] filename (ISO timestamp): description` per line
+export function formatMemoryManifest(memories: MemoryHeader[]): string {
+  return memories
+    .map((m) => {
+      const tag = m.type ? `[${m.type}] ` : ""
+      const ts = new Date(m.mtimeMs).toISOString()
+      return m.description
+        ? `- ${tag}${m.filename} (${ts}): ${m.description}`
+        : `- ${tag}${m.filename} (${ts})`
+    })
+    .join("\n")
+}
+
+export function getMemoryManifest(worktree: string): { headers: MemoryHeader[]; manifest: string } {
+  const memoryDir = getMemoryDir(worktree)
+  const headers = scanMemoryFiles(memoryDir)
+  const manifest = formatMemoryManifest(headers)
+  return { headers, manifest }
+}

package/src/paths.ts

@@ -141,10 +141,13 @@ function getClaudeConfigHomeDir(): string {
   return (process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude")).normalize("NFC")
 }
 
-export function getMemoryDir(worktree: string): string {
+export function getProjectDir(worktree: string): string {
   const canonicalRoot = findCanonicalGitRoot(worktree) ?? worktree
-  const projectsDir = join(getClaudeConfigHomeDir(), "projects")
-  const memoryDir = join(projectsDir, sanitizePath(canonicalRoot), "memory")
+  return join(getClaudeConfigHomeDir(), "projects", sanitizePath(canonicalRoot))
+}
+
+export function getMemoryDir(worktree: string): string {
+  const memoryDir = join(getProjectDir(worktree), "memory")
   ensureDir(memoryDir)
   return memoryDir
 }