opencode-claude-memory 1.7.7 → 2.0.0

package/dist/memory.d.ts

@@ -1,31 +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 type SaveMemoryResult = {
-    filePath: string;
-    fileName: string;
-    unchanged: boolean;
-};
-export declare function saveMemory(worktree: string, fileName: string, name: string, description: string, type: MemoryType, content: string): string;
-export declare function saveMemoryDetailed(worktree: string, fileName: string, name: string, description: string, type: MemoryType, content: string): SaveMemoryResult;
-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,224 +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) {
-    return saveMemoryDetailed(worktree, fileName, name, description, type, content).filePath;
-}
-// Same as saveMemory() but reports whether anything was actually written. An identical re-save is a
-// no-op: the extraction fork uses that signal to tell the model it is repeating itself (see #35).
-export function saveMemoryDetailed(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`);
-    }
-    if (isMemoryUnchanged(worktree, filePath, fileContent, buildIndexPointer(safeName, name, description))) {
-        return { filePath, fileName: safeName, unchanged: true };
-    }
-    writeFileSync(filePath, fileContent, "utf-8");
-    updateIndex(worktree, safeName, name, description);
-    return { filePath, fileName: safeName, unchanged: false };
-}
-function isMemoryUnchanged(worktree, filePath, fileContent, pointer) {
-    try {
-        if (readFileSync(filePath, "utf-8") !== fileContent)
-            return false;
-    }
-    catch {
-        return false;
-    }
-    return readIndex(worktree).split("\n").some((line) => line.trimEnd() === pointer);
-}
-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 buildIndexPointer(fileName, name, description) {
-    return `- [${name}](${fileName}) — ${description}`;
-}
-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 = buildIndexPointer(fileName, name, 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,9 +0,0 @@
-export declare function getNativeExtractTimeoutMs(raw?: string | undefined): number;
-export declare function getNativeExtractMaxSteps(raw?: string | undefined): number | undefined;
-export type MemorySaveOutcome = {
-    filePath: string;
-    fileName: string;
-    unchanged: boolean;
-};
-export declare function formatMemorySaveResult(outcome: MemorySaveOutcome, savedThisRun?: readonly string[]): string;
-export declare function logNativeExtractionFailure(client: unknown, directory: string, sessionID: string, error: unknown): void;

package/dist/nativeExtraction.js

@@ -1,80 +0,0 @@
-const DEFAULT_NATIVE_EXTRACT_TIMEOUT_MS = 120_000;
-const MAX_TIMER_DELAY_MS = 2_147_483_647;
-// A legitimate extraction is 1 memory_list + a handful of memory_save calls; 30 agentic steps leaves
-// generous headroom while still terminating a model that keeps re-saving the same files (#35).
-const DEFAULT_NATIVE_EXTRACT_MAX_STEPS = 30;
-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;
-}
-// Step cap for the extraction agent (OpenCode `agent.<name>.steps`). Unset/invalid → default;
-// "0" → undefined, i.e. no cap (the wall-clock timeout becomes the only backstop).
-export function getNativeExtractMaxSteps(raw = process.env.OPENCODE_MEMORY_EXTRACT_MAX_STEPS) {
-    const trimmed = raw?.trim();
-    // Only a plain non-negative integer counts; "" / " " must not become Number("") === 0 (no cap).
-    if (!trimmed || !/^\d+$/.test(trimmed))
-        return DEFAULT_NATIVE_EXTRACT_MAX_STEPS;
-    const steps = Number(trimmed);
-    if (!Number.isSafeInteger(steps))
-        return DEFAULT_NATIVE_EXTRACT_MAX_STEPS;
-    return steps === 0 ? undefined : steps;
-}
-// Tool result for memory_save. Inside an extraction fork, `savedThisRun` (file names already saved
-// by this fork, in order) is appended as an explicit done-signal so the model does not lose track on
-// long transcripts and re-save the same memories until the timeout kills it (#35).
-export function formatMemorySaveResult(outcome, savedThisRun) {
-    const inExtractionRun = savedThisRun !== undefined;
-    // The current file is recorded before formatting, so "earlier" means it appeared before this call.
-    const savedEarlierThisRun = inExtractionRun && savedThisRun.indexOf(outcome.fileName) < savedThisRun.length - 1;
-    let head;
-    if (outcome.unchanged) {
-        head = savedEarlierThisRun
-            ? `Skipped: "${outcome.fileName}" was already saved earlier in this extraction run with identical content — nothing written.`
-            : `Skipped: "${outcome.fileName}" already exists with identical content — nothing written (${outcome.filePath}).`;
-    }
-    else if (savedEarlierThisRun) {
-        head = `Updated "${outcome.fileName}" (first saved earlier in this extraction run) at ${outcome.filePath}`;
-    }
-    else {
-        head = `Memory saved to ${outcome.filePath}`;
-    }
-    if (!inExtractionRun)
-        return head;
-    const unique = Array.from(new Set(savedThisRun));
-    return (`${head}\n\n` +
-        `Saved so far in this extraction run (${unique.length}): ${unique.join(", ")}\n` +
-        "These memories are already persisted — do not call memory_save for them again. " +
-        "Once every distinct memory worth keeping is saved, stop calling tools and reply with a one-line summary.");
-}
-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;