opencode-claude-memory 1.5.2 → 1.6.1

package/dist/index.js

@@ -0,0 +1,239 @@
+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";
+const turnContextBySession = new Map();
+function shouldIgnoreMemoryContext(query) {
+    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) {
+    if (!message || typeof message !== "object")
+        return undefined;
+    if ("content" in message) {
+        const content = message.content;
+        if (typeof content === "string")
+            return content;
+        if (content !== undefined)
+            return JSON.stringify(content);
+    }
+    if ("parts" in message) {
+        const parts = message.parts;
+        if (Array.isArray(parts)) {
+            const text = parts
+                .map((part) => {
+                if (!part || typeof part !== "object")
+                    return "";
+                return typeof part.text === "string"
+                    ? part.text
+                    : "";
+            })
+                .filter(Boolean)
+                .join("\n")
+                .trim();
+            if (text)
+                return text;
+        }
+    }
+    return undefined;
+}
+function getLastUserQuery(messages) {
+    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) {
+    if (!part || typeof part !== "object")
+        return false;
+    return typeof part.text === "string" &&
+        part.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) {
+    const keys = new Set();
+    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) {
+    const tools = [];
+    const seen = new Set();
+    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;
+            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 = async ({ worktree }) => {
+    getMemoryDir(worktree);
+    return {
+        "experimental.chat.messages.transform": async (_input, output) => {
+            const { query, sessionID } = getLastUserQuery(output.messages);
+            if (sessionID) {
+                const alreadySurfaced = new Set();
+                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.text;
+                        if (typeof text === "string") {
+                            for (const key of extractSurfacedMemoryKeys(text)) {
+                                alreadySurfaced.add(key);
+                            }
+                        }
+                    }
+                }
+                const recentTools = extractRecentTools(output.messages);
+                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;
+            if (_input && typeof _input === "object") {
+                sessionID = (typeof _input.sessionID === "string"
+                    ? _input.sessionID
+                    : undefined);
+            }
+            const ctx = sessionID ? turnContextBySession.get(sessionID) : undefined;
+            const query = ctx?.query;
+            const alreadySurfaced = ctx?.alreadySurfaced ?? new Set();
+            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/dist/memory.d.ts

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

@@ -0,0 +1,200 @@
+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);
+    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

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

@@ -0,0 +1,106 @@
+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/paths.d.ts

@@ -0,0 +1,14 @@
+export declare const ENTRYPOINT_NAME = "MEMORY.md";
+export declare const MAX_ENTRYPOINT_LINES = 200;
+export declare const MAX_ENTRYPOINT_BYTES = 25000;
+export declare const MAX_MEMORY_FILES = 200;
+export declare const MAX_MEMORY_FILE_BYTES = 40000;
+export declare const FRONTMATTER_MAX_LINES = 30;
+export declare function validateMemoryFileName(fileName: string): string;
+export declare function sanitizePath(name: string): string;
+export declare function findCanonicalGitRoot(startPath: string): string | null;
+export declare function getProjectDir(worktree: string): string;
+export declare function getMemoryDir(worktree: string): string;
+export declare function getMemoryEntrypoint(worktree: string): string;
+export declare function isMemoryPath(absolutePath: string, worktree: string): boolean;
+export declare function ensureDir(dir: string): void;