opencode-claude-memory 1.6.0 → 1.6.2

package/src/index.ts

@@ -1,291 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin"
-import { tool } from "@opencode-ai/plugin"
-import { buildMemorySystemPrompt } from "./prompt.js"
-import { recallRelevantMemories, formatRecalledMemories } from "./recall.js"
-import {
-  saveMemory,
-  deleteMemory,
-  listMemories,
-  searchMemories,
-  readMemory,
-  MEMORY_TYPES,
-} 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.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 })
-      }
-
-      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, {
-        includeIndex: !ignoreMemoryContext,
-      })
-      output.system.push(memoryPrompt)
-    },
-
-    tool: {
-      memory_save: tool({
-        description:
-          "Save or update a memory for future conversations. " +
-          "Each memory is stored as a markdown file with frontmatter. " +
-          "Use this when the user explicitly asks you to remember something, " +
-          "or when you observe important information worth preserving across sessions " +
-          "(user preferences, feedback, project context, external references). " +
-          "Check existing memories first with memory_list or memory_search to avoid duplicates.",
-        args: {
-          file_name: tool.schema
-            .string()
-            .describe(
-              'File name for the memory (without .md extension). Use snake_case, e.g. "user_role", "feedback_testing_style", "project_auth_rewrite"',
-            ),
-          name: tool.schema.string().describe("Human-readable name for this memory"),
-          description: tool.schema
-            .string()
-            .describe("One-line description — used to decide relevance in future conversations, so be specific"),
-          type: tool.schema
-            .enum(MEMORY_TYPES)
-            .describe(
-              "Memory type: user (about the person), feedback (guidance on approach), project (ongoing work context), reference (pointers to external systems)",
-            ),
-          content: tool.schema
-            .string()
-            .describe(
-              "Memory content. For feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines",
-            ),
-        },
-        async execute(args) {
-          const filePath = saveMemory(worktree, args.file_name, args.name, args.description, args.type, args.content)
-          return `Memory saved to ${filePath}`
-        },
-      }),
-
-      memory_delete: tool({
-        description: "Delete a memory that is outdated, wrong, or no longer relevant. Also removes it from the index.",
-        args: {
-          file_name: tool.schema.string().describe("File name of the memory to delete (with or without .md extension)"),
-        },
-        async execute(args) {
-          const deleted = deleteMemory(worktree, args.file_name)
-          return deleted ? `Memory "${args.file_name}" deleted.` : `Memory "${args.file_name}" not found.`
-        },
-      }),
-
-      memory_list: tool({
-        description:
-          "List all saved memories with their names, types, and descriptions. " +
-          "Use this to check what memories exist before saving a new one (to avoid duplicates) " +
-          "or when you need to recall what's been stored.",
-        args: {},
-        async execute() {
-          const entries = listMemories(worktree)
-          if (entries.length === 0) {
-            return "No memories saved yet."
-          }
-          const lines = entries.map(
-            (e) => `- **${e.name}** (${e.type}) [${e.fileName}]: ${e.description}`,
-          )
-          return `${entries.length} memories found:\n${lines.join("\n")}`
-        },
-      }),
-
-      memory_search: tool({
-        description:
-          "Search memories by keyword. Searches across names, descriptions, and content. " +
-          "Use this to find relevant memories before answering questions or when the user references past conversations.",
-        args: {
-          query: tool.schema.string().describe("Search query — searches across name, description, and content"),
-        },
-        async execute(args) {
-          const results = searchMemories(worktree, args.query)
-          if (results.length === 0) {
-            return `No memories matching "${args.query}".`
-          }
-          const lines = results.map(
-            (e) => `- **${e.name}** (${e.type}) [${e.fileName}]: ${e.description}\n  Content: ${e.content.slice(0, 200)}${e.content.length > 200 ? "..." : ""}`,
-          )
-          return `${results.length} matches for "${args.query}":\n${lines.join("\n")}`
-        },
-      }),
-
-      memory_read: tool({
-        description: "Read the full content of a specific memory file.",
-        args: {
-          file_name: tool.schema.string().describe("File name of the memory to read (with or without .md extension)"),
-        },
-        async execute(args) {
-          const entry = readMemory(worktree, args.file_name)
-          if (!entry) {
-            return `Memory "${args.file_name}" not found.`
-          }
-          return `# ${entry.name}\n**Type:** ${entry.type}\n**Description:** ${entry.description}\n\n${entry.content}`
-        },
-      }),
-    },
-  }
-}

package/src/memory.ts

@@ -1,272 +0,0 @@
-import { readFileSync, writeFileSync, readdirSync, unlinkSync } from "fs"
-import { join, basename } from "path"
-import {
-  getMemoryDir,
-  getMemoryEntrypoint,
-  ENTRYPOINT_NAME,
-  validateMemoryFileName,
-  MAX_MEMORY_FILES,
-  MAX_MEMORY_FILE_BYTES,
-  MAX_ENTRYPOINT_LINES,
-  MAX_ENTRYPOINT_BYTES,
-  FRONTMATTER_MAX_LINES,
-} from "./paths.js"
-
-export const MEMORY_TYPES = ["user", "feedback", "project", "reference"] as const
-export type MemoryType = (typeof MEMORY_TYPES)[number]
-
-export type MemoryEntry = {
-  filePath: string
-  fileName: string
-  name: string
-  description: string
-  type: MemoryType
-  content: string
-  rawContent: string
-}
-
-function parseFrontmatter(raw: string): { frontmatter: Record<string, string>; content: string } {
-  const trimmed = raw.trim()
-  if (!trimmed.startsWith("---")) {
-    return { frontmatter: {}, content: trimmed }
-  }
-
-  const lines = trimmed.split("\n")
-  let closingLineIdx = -1
-  for (let i = 1; i < Math.min(lines.length, FRONTMATTER_MAX_LINES); i++) {
-    if (lines[i].trimEnd() === "---") {
-      closingLineIdx = i
-      break
-    }
-  }
-  if (closingLineIdx === -1) {
-    return { frontmatter: {}, content: trimmed }
-  }
-
-  const endIndex = lines.slice(0, closingLineIdx).join("\n").length + 1
-
-  const frontmatterBlock = trimmed.slice(3, endIndex).trim()
-  const content = trimmed.slice(endIndex + 3).trim()
-
-  const frontmatter: Record<string, string> = {}
-  for (const line of frontmatterBlock.split("\n")) {
-    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, content }
-}
-
-function buildFrontmatter(name: string, description: string, type: MemoryType): string {
-  return `---\nname: ${name}\ndescription: ${description}\ntype: ${type}\n---`
-}
-
-function parseMemoryType(raw: string | undefined): MemoryType | undefined {
-  if (!raw) return undefined
-  return MEMORY_TYPES.find((t) => t === raw)
-}
-
-export function listMemories(worktree: string): MemoryEntry[] {
-  const memDir = getMemoryDir(worktree)
-  const entries: MemoryEntry[] = []
-
-  let files: string[]
-  try {
-    files = readdirSync(memDir, { encoding: "utf-8" })
-      .filter((f) => f.endsWith(".md") && f !== ENTRYPOINT_NAME)
-      .sort()
-      .slice(0, MAX_MEMORY_FILES)
-  } catch {
-    return entries
-  }
-
-  for (const fileName of files) {
-    const filePath = join(memDir, fileName)
-    try {
-      const rawContent = readFileSync(filePath, "utf-8")
-      const { frontmatter, content } = parseFrontmatter(rawContent)
-      entries.push({
-        filePath,
-        fileName,
-        name: frontmatter.name ?? fileName.replace(/\.md$/, ""),
-        description: frontmatter.description ?? "",
-        type: parseMemoryType(frontmatter.type) ?? "user",
-        content,
-        rawContent,
-      })
-    } catch {
-      
-    }
-  }
-
-  return entries
-}
-
-export function readMemory(worktree: string, fileName: string): MemoryEntry | null {
-  const safeName = validateMemoryFileName(fileName)
-  const memDir = getMemoryDir(worktree)
-  const filePath = join(memDir, safeName)
-
-  try {
-    const rawContent = readFileSync(filePath, "utf-8")
-    const { frontmatter, content } = parseFrontmatter(rawContent)
-    return {
-      filePath,
-      fileName: basename(filePath),
-      name: frontmatter.name ?? fileName.replace(/\.md$/, ""),
-      description: frontmatter.description ?? "",
-      type: parseMemoryType(frontmatter.type) ?? "user",
-      content,
-      rawContent,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function saveMemory(
-  worktree: string,
-  fileName: string,
-  name: string,
-  description: string,
-  type: MemoryType,
-  content: string,
-): string {
-  const safeName = validateMemoryFileName(fileName)
-  const memDir = getMemoryDir(worktree)
-  const filePath = join(memDir, safeName)
-
-  const fileContent = `${buildFrontmatter(name, description, type)}\n\n${content.trim()}\n`
-  if (Buffer.byteLength(fileContent, "utf-8") > MAX_MEMORY_FILE_BYTES) {
-    throw new Error(
-      `Memory file content exceeds the ${MAX_MEMORY_FILE_BYTES}-byte limit`,
-    )
-  }
-  writeFileSync(filePath, fileContent, "utf-8")
-
-  updateIndex(worktree, safeName, name, description)
-
-  return filePath
-}
-
-export function deleteMemory(worktree: string, fileName: string): boolean {
-  const safeName = validateMemoryFileName(fileName)
-  const memDir = getMemoryDir(worktree)
-  const filePath = join(memDir, safeName)
-
-  try {
-    unlinkSync(filePath)
-    removeFromIndex(worktree, safeName)
-    return true
-  } catch {
-    return false
-  }
-}
-
-export function searchMemories(worktree: string, query: string): MemoryEntry[] {
-  const all = listMemories(worktree)
-  const lowerQuery = query.toLowerCase()
-
-  return all.filter(
-    (entry) =>
-      entry.name.toLowerCase().includes(lowerQuery) ||
-      entry.description.toLowerCase().includes(lowerQuery) ||
-      entry.content.toLowerCase().includes(lowerQuery),
-  )
-}
-
-export function readIndex(worktree: string): string {
-  const entrypoint = getMemoryEntrypoint(worktree)
-  try {
-    return readFileSync(entrypoint, "utf-8")
-  } catch {
-    return ""
-  }
-}
-
-function updateIndex(worktree: string, fileName: string, name: string, description: string): void {
-  const entrypoint = getMemoryEntrypoint(worktree)
-  const existing = readIndex(worktree)
-  const lines = existing.split("\n").filter((l) => l.trim())
-
-  const pointer = `- [${name}](${fileName}) — ${description}`
-  const existingIdx = lines.findIndex((l) => l.includes(`(${fileName})`))
-
-  if (existingIdx >= 0) {
-    lines[existingIdx] = pointer
-  } else {
-    lines.push(pointer)
-  }
-
-  writeFileSync(entrypoint, lines.join("\n") + "\n", "utf-8")
-}
-
-function removeFromIndex(worktree: string, fileName: string): void {
-  const entrypoint = getMemoryEntrypoint(worktree)
-  const existing = readIndex(worktree)
-  const lines = existing
-    .split("\n")
-    .filter((l) => l.trim() && !l.includes(`(${fileName})`))
-
-  writeFileSync(entrypoint, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8")
-}
-
-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: "", lineCount: 0, byteCount: 0, wasLineTruncated: false, wasByteTruncated: false }
-
-  const contentLines = trimmed.split("\n")
-  const lineCount = contentLines.length
-  const byteCount = trimmed.length
-
-  const wasLineTruncated = lineCount > MAX_ENTRYPOINT_LINES
-  const wasByteTruncated = byteCount > MAX_ENTRYPOINT_BYTES
-
-  if (!wasLineTruncated && !wasByteTruncated) {
-    return { content: trimmed, lineCount, byteCount, wasLineTruncated, wasByteTruncated }
-  }
-
-  let truncated = wasLineTruncated
-    ? contentLines.slice(0, MAX_ENTRYPOINT_LINES).join("\n")
-    : trimmed
-
-  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: ${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

@@ -1,130 +0,0 @@
-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 }
-}