opencode-claude-memory 1.7.6 → 1.7.8

package/dist/memory.d.ts

@@ -1,25 +0,0 @@
-export declare const MEMORY_TYPES: readonly ["user", "feedback", "project", "reference"];
-export type MemoryType = (typeof MEMORY_TYPES)[number];
-export type MemoryEntry = {
-    filePath: string;
-    fileName: string;
-    name: string;
-    description: string;
-    type: MemoryType;
-    content: string;
-    rawContent: string;
-};
-export declare function listMemories(worktree: string): MemoryEntry[];
-export declare function readMemory(worktree: string, fileName: string): MemoryEntry | null;
-export declare function saveMemory(worktree: string, fileName: string, name: string, description: string, type: MemoryType, content: string): string;
-export declare function deleteMemory(worktree: string, fileName: string): boolean;
-export declare function searchMemories(worktree: string, query: string): MemoryEntry[];
-export declare function readIndex(worktree: string): string;
-export type EntrypointTruncation = {
-    content: string;
-    lineCount: number;
-    byteCount: number;
-    wasLineTruncated: boolean;
-    wasByteTruncated: boolean;
-};
-export declare function truncateEntrypoint(raw: string): EntrypointTruncation;

package/dist/memory.js

@@ -1,203 +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"];
-function parseFrontmatter(raw) {
-    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 = {};
-    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, description, type) {
-    return `---\nname: ${name}\ndescription: ${description}\ntype: ${type}\n---`;
-}
-function parseMemoryType(raw) {
-    if (!raw)
-        return undefined;
-    return MEMORY_TYPES.find((t) => t === raw);
-}
-export function listMemories(worktree) {
-    const memDir = getMemoryDir(worktree);
-    const entries = [];
-    let files;
-    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, fileName) {
-    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, fileName, name, description, type, content) {
-    const safeName = validateMemoryFileName(fileName);
-    if (typeof name !== "string" || !name.trim()) {
-        throw new Error("Memory name is required");
-    }
-    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, fileName) {
-    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, query) {
-    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) {
-    const entrypoint = getMemoryEntrypoint(worktree);
-    try {
-        return readFileSync(entrypoint, "utf-8");
-    }
-    catch {
-        return "";
-    }
-}
-function updateIndex(worktree, fileName, name, description) {
-    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, fileName) {
-    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) {
-    if (bytes < 1024)
-        return `${bytes}B`;
-    return `${(bytes / 1024).toFixed(1)}KB`;
-}
-// Port of Claude Code's truncateEntrypointContent() from memdir.ts.
-// Uses .length (char count, same as Claude Code) for byte measurement.
-export function truncateEntrypoint(raw) {
-    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/dist/memoryScan.d.ts

@@ -1,20 +0,0 @@
-import type { MemoryType } from "./memory.js";
-export type MemoryHeader = {
-    filename: string;
-    filePath: string;
-    mtimeMs: number;
-    name: string | null;
-    description: string | null;
-    type: MemoryType | undefined;
-};
-/**
- * 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 declare function scanMemoryFiles(memoryDir: string): MemoryHeader[];
-export declare function formatMemoryManifest(memories: MemoryHeader[]): string;
-export declare function getMemoryManifest(worktree: string): {
-    headers: MemoryHeader[];
-    manifest: string;
-};

package/dist/memoryScan.js

@@ -1,106 +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";
-const MEMORY_TYPES = ["user", "feedback", "project", "reference"];
-function parseMemoryType(raw) {
-    if (!raw)
-        return undefined;
-    return MEMORY_TYPES.includes(raw) ? raw : undefined;
-}
-function readFileHeader(filePath, maxLines) {
-    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) {
-    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 = {};
-    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) {
-    try {
-        const entries = readdirSync(memoryDir, { recursive: true, encoding: "utf-8" });
-        const mdFiles = entries.filter((f) => f.endsWith(".md") && basename(f) !== ENTRYPOINT_NAME);
-        const headers = [];
-        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) {
-    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) {
-    const memoryDir = getMemoryDir(worktree);
-    const headers = scanMemoryFiles(memoryDir);
-    const manifest = formatMemoryManifest(headers);
-    return { headers, manifest };
-}

package/dist/nativeExtraction.d.ts

@@ -1,2 +0,0 @@
-export declare function getNativeExtractTimeoutMs(raw?: string | undefined): number;
-export declare function logNativeExtractionFailure(client: unknown, directory: string, sessionID: string, error: unknown): void;

package/dist/nativeExtraction.js

@@ -1,38 +0,0 @@
-const DEFAULT_NATIVE_EXTRACT_TIMEOUT_MS = 120_000;
-const MAX_TIMER_DELAY_MS = 2_147_483_647;
-function getErrorMessage(error) {
-    if (error instanceof Error)
-        return error.message;
-    if (error && typeof error === "object") {
-        const message = error.message;
-        if (typeof message === "string")
-            return message;
-    }
-    return String(error);
-}
-export function getNativeExtractTimeoutMs(raw = process.env.OPENCODE_MEMORY_EXTRACT_TIMEOUT_MS) {
-    const timeout = Number(raw);
-    return Number.isSafeInteger(timeout) && timeout > 0 && timeout <= MAX_TIMER_DELAY_MS
-        ? timeout
-        : DEFAULT_NATIVE_EXTRACT_TIMEOUT_MS;
-}
-export function logNativeExtractionFailure(client, directory, sessionID, error) {
-    const c = client;
-    if (!c?.app?.log)
-        return;
-    try {
-        const message = getErrorMessage(error);
-        void c.app.log({
-            body: {
-                service: "opencode-claude-memory",
-                level: "error",
-                message: "Native extraction failed",
-                extra: { error: message, sessionID },
-            },
-            query: { directory },
-        }).catch(() => { });
-    }
-    catch {
-        // Logging must stay best-effort: stderr is rendered into the OpenCode chat UI.
-    }
-}

package/dist/paths.js

@@ -1,141 +0,0 @@
-// Claude Code compatible memory directory path resolution.
-// Directory: ~/.claude/projects/<sanitizePath(canonicalGitRoot)>/memory/
-// Ensures bidirectional memory sharing between Claude Code and OpenCode.
-import { homedir } from "os";
-import { join, dirname, resolve, sep } from "path";
-import { mkdirSync, existsSync, readFileSync, statSync, realpathSync } from "fs";
-export const ENTRYPOINT_NAME = "MEMORY.md";
-export const MAX_ENTRYPOINT_LINES = 200;
-export const MAX_ENTRYPOINT_BYTES = 25_000;
-export const MAX_MEMORY_FILES = 200;
-export const MAX_MEMORY_FILE_BYTES = 40_000;
-export const FRONTMATTER_MAX_LINES = 30;
-export function validateMemoryFileName(fileName) {
-    const base = fileName.endsWith(".md") ? fileName.slice(0, -3) : fileName;
-    if (base.length === 0) {
-        throw new Error("Memory file name cannot be empty");
-    }
-    if (base.includes("/") || base.includes("\\")) {
-        throw new Error(`Memory file name must not contain path separators: ${fileName}`);
-    }
-    if (base.includes("..")) {
-        throw new Error(`Memory file name must not contain path traversal: ${fileName}`);
-    }
-    if (base.includes("\0")) {
-        throw new Error(`Memory file name must not contain null bytes: ${fileName}`);
-    }
-    if (base.startsWith(".")) {
-        throw new Error(`Memory file name must not start with '.': ${fileName}`);
-    }
-    if (base.toUpperCase() === "MEMORY") {
-        throw new Error(`'MEMORY' is a reserved name and cannot be used as a memory file name`);
-    }
-    return `${base}.md`;
-}
-const MAX_SANITIZED_LENGTH = 200;
-// Exact copy of Claude Code's djb2Hash() from utils/hash.ts
-function djb2Hash(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        hash = ((hash << 5) - hash + str.charCodeAt(i)) | 0;
-    }
-    return hash;
-}
-function simpleHash(str) {
-    return Math.abs(djb2Hash(str)).toString(36);
-}
-// Exact copy of Claude Code's sanitizePath() from utils/sessionStoragePortable.ts
-export function sanitizePath(name) {
-    const sanitized = name.replace(/[^a-zA-Z0-9]/g, "-");
-    if (sanitized.length <= MAX_SANITIZED_LENGTH) {
-        return sanitized;
-    }
-    const hash = simpleHash(name);
-    return `${sanitized.slice(0, MAX_SANITIZED_LENGTH)}-${hash}`;
-}
-// Matches Claude Code's findGitRoot() from utils/git.ts
-function findGitRoot(startPath) {
-    let current = resolve(startPath);
-    const root = current.substring(0, current.indexOf(sep) + 1) || sep;
-    while (current !== root) {
-        try {
-            const gitPath = join(current, ".git");
-            const s = statSync(gitPath);
-            if (s.isDirectory() || s.isFile()) {
-                return current.normalize("NFC");
-            }
-        }
-        catch { }
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    try {
-        const gitPath = join(root, ".git");
-        const s = statSync(gitPath);
-        if (s.isDirectory() || s.isFile()) {
-            return root.normalize("NFC");
-        }
-    }
-    catch { }
-    return null;
-}
-// Matches Claude Code's resolveCanonicalRoot() from utils/git.ts
-// Resolves worktrees to the main repo root via .git -> gitdir -> commondir chain
-function resolveCanonicalRoot(gitRoot) {
-    try {
-        const gitContent = readFileSync(join(gitRoot, ".git"), "utf-8").trim();
-        if (!gitContent.startsWith("gitdir:")) {
-            return gitRoot;
-        }
-        const worktreeGitDir = resolve(gitRoot, gitContent.slice("gitdir:".length).trim());
-        const commonDir = resolve(worktreeGitDir, readFileSync(join(worktreeGitDir, "commondir"), "utf-8").trim());
-        // SECURITY: validate worktreeGitDir is a direct child of <commonDir>/worktrees/
-        if (resolve(dirname(worktreeGitDir)) !== join(commonDir, "worktrees")) {
-            return gitRoot;
-        }
-        // SECURITY: validate gitdir back-link points to our .git
-        const backlink = realpathSync(readFileSync(join(worktreeGitDir, "gitdir"), "utf-8").trim());
-        if (backlink !== join(realpathSync(gitRoot), ".git")) {
-            return gitRoot;
-        }
-        if (commonDir.endsWith(`${sep}.git`) || commonDir.endsWith("/.git")) {
-            return dirname(commonDir).normalize("NFC");
-        }
-        return commonDir.normalize("NFC");
-    }
-    catch {
-        return gitRoot;
-    }
-}
-export function findCanonicalGitRoot(startPath) {
-    const root = findGitRoot(startPath);
-    if (!root)
-        return null;
-    return resolveCanonicalRoot(root);
-}
-function getClaudeConfigHomeDir() {
-    return (process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude")).normalize("NFC");
-}
-export function getProjectDir(worktree) {
-    const canonicalRoot = findCanonicalGitRoot(worktree) ?? worktree;
-    return join(getClaudeConfigHomeDir(), "projects", sanitizePath(canonicalRoot));
-}
-export function getMemoryDir(worktree) {
-    const memoryDir = join(getProjectDir(worktree), "memory");
-    ensureDir(memoryDir);
-    return memoryDir;
-}
-export function getMemoryEntrypoint(worktree) {
-    return join(getMemoryDir(worktree), ENTRYPOINT_NAME);
-}
-export function isMemoryPath(absolutePath, worktree) {
-    const memDir = getMemoryDir(worktree);
-    return absolutePath.startsWith(memDir);
-}
-export function ensureDir(dir) {
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-}

package/dist/prompt.d.ts

@@ -1,4 +0,0 @@
-export type BuildMemorySystemPromptOptions = {
-    includeIndex?: boolean;
-};
-export declare function buildMemorySystemPrompt(worktree: string, recalledMemoriesSection?: string, options?: BuildMemorySystemPromptOptions): string;

package/dist/recall.d.ts

@@ -1,12 +0,0 @@
-import type { MemoryHeader } from "./memoryScan.js";
-export type RecalledMemory = {
-    fileName: string;
-    filePath: string;
-    name: string;
-    type: string;
-    description: string;
-    content: string;
-    ageInDays: number;
-};
-export declare function recallSelectedMemories(headers: readonly MemoryHeader[], selectedFilenames: readonly string[], alreadySurfaced?: ReadonlySet<string>): RecalledMemory[];
-export declare function formatRecalledMemories(memories: RecalledMemory[]): string;