@bubblebrain-ai/bubble 0.0.1

package/dist/memory/phase2.js

@@ -0,0 +1,100 @@
+import { randomUUID } from "node:crypto";
+import { MemoryDatabase } from "./db.js";
+import { getMemoryPaths } from "./paths.js";
+import { buildConsolidationMessages, parseJsonObject } from "./prompts.js";
+import { rebuildRawMemories, syncRolloutSummaries, writeConsolidatedMemory } from "./storage.js";
+const DEFAULT_SELECTION_LIMIT = 40;
+export async function runMemoryPhase2(options) {
+    if (!options.model) {
+        return { status: "skipped", reason: "no active model", selected: 0 };
+    }
+    const db = new MemoryDatabase(options.cwd);
+    const paths = getMemoryPaths(options.cwd);
+    const workerId = randomUUID();
+    const claim = db.claimGlobalPhase2Job(workerId, 3600);
+    if (!claim.claimed) {
+        db.close();
+        return { status: "skipped", reason: claim.reason ?? "phase2 unavailable", selected: 0 };
+    }
+    try {
+        const selected = db.listStage1Outputs(options.limit ?? DEFAULT_SELECTION_LIMIT);
+        if (selected.length === 0) {
+            db.finishGlobalPhase2Job(true, Date.now());
+            return { status: "skipped", reason: "no stage-1 outputs", selected: 0 };
+        }
+        const retained = selected.filter((item) => item.selectedForPhase2);
+        const removed = db.listPreviouslySelectedNotIn(selected.map((item) => item.sessionFile));
+        syncRolloutSummaries(options.cwd, selected);
+        const rawMemories = rebuildRawMemories(options.cwd, selected);
+        writeConsolidatedMemory(options.cwd, buildFallbackConsolidatedMemory(selected));
+        const raw = await options.complete(buildConsolidationMessages({
+            memoryRoot: paths.globalRoot,
+            selected,
+            retained,
+            removed,
+            rawMemories,
+        }), {
+            model: options.model,
+            temperature: 0,
+            thinkingLevel: "off",
+        });
+        const parsed = parseJsonObject(raw);
+        const memoryMd = stringField(parsed.memory_md);
+        const memorySummaryMd = stringField(parsed.memory_summary_md);
+        if (!memoryMd || !memorySummaryMd) {
+            throw new Error("consolidation output must include memory_md and memory_summary_md");
+        }
+        writeConsolidatedMemory(options.cwd, { memoryMd, memorySummaryMd });
+        db.markSelectedForPhase2(selected);
+        db.finishGlobalPhase2Job(true, Date.now());
+        return {
+            status: "succeeded",
+            selected: selected.length,
+            memoryPath: paths.globalMemory,
+            summaryPath: paths.globalSummary,
+        };
+    }
+    catch (error) {
+        db.finishGlobalPhase2Job(false, Date.now(), error instanceof Error ? error.message : String(error));
+        return {
+            status: "failed",
+            reason: error instanceof Error ? error.message : String(error),
+            selected: 0,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+function stringField(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function buildFallbackConsolidatedMemory(selected) {
+    const memoryLines = [
+        "# Bubble Memory",
+        "",
+        "This deterministic memory snapshot was generated from completed phase-1 extraction outputs. It may be replaced by a model-consolidated version when phase 2 finishes.",
+        "",
+    ];
+    const summaryLines = [
+        "# Bubble Memory Summary",
+        "",
+        "Model consolidation is in progress or previously failed, so this summary is derived directly from extracted rollout summaries.",
+        "",
+    ];
+    for (const item of selected) {
+        const title = item.rolloutSlug || item.sessionFile.split("/").pop()?.replace(/\.jsonl$/, "") || "rollout";
+        memoryLines.push(`## ${title}`);
+        memoryLines.push(`cwd: ${item.cwd}`);
+        memoryLines.push(`rollout_path: ${item.sessionFile}`);
+        memoryLines.push("");
+        memoryLines.push(item.rawMemory.trim());
+        memoryLines.push("");
+        const summary = item.rolloutSummary.trim();
+        summaryLines.push(`- ${item.cwd}: ${summary}`);
+    }
+    return {
+        memoryMd: memoryLines.join("\n").trim(),
+        memorySummaryMd: summaryLines.join("\n").trim(),
+    };
+}

package/dist/memory/prompts.d.ts

@@ -0,0 +1,19 @@
+import type { Message } from "../types.js";
+import type { Stage1Output } from "./db.js";
+export declare function buildStageOneMessages(input: {
+    cwd: string;
+    sessionFile: string;
+    transcript: string;
+}): Message[];
+export declare function buildConsolidationMessages(input: {
+    memoryRoot: string;
+    selected: Stage1Output[];
+    retained: Stage1Output[];
+    removed: Stage1Output[];
+    rawMemories: string;
+}): Message[];
+export declare function buildReadPathPrompt(input: {
+    memoryRoot: string;
+    memorySummary: string;
+}): string;
+export declare function parseJsonObject(raw: string): Record<string, unknown>;

package/dist/memory/prompts.js

@@ -0,0 +1,99 @@
+export function buildStageOneMessages(input) {
+    return [
+        {
+            role: "system",
+            content: [
+                "You are Bubble's phase-1 memory extractor.",
+                "Extract durable, reusable memory from one coding-agent rollout.",
+                "Return strict JSON only. Do not wrap it in markdown.",
+                "Do not include secrets, credentials, API keys, tokens, private keys, or full large logs.",
+                "Prefer concrete project facts, user preferences, workflows, decisions, and gotchas.",
+                "Skip transient progress updates and one-off chatter.",
+            ].join("\n"),
+        },
+        {
+            role: "user",
+            content: [
+                `rollout_cwd: ${input.cwd}`,
+                `rollout_path: ${input.sessionFile}`,
+                "",
+                "Return this JSON shape:",
+                JSON.stringify({
+                    raw_memory: "detailed markdown memory for this rollout",
+                    rollout_summary: "compact recap with durable lessons and evidence",
+                    rollout_slug: "short-kebab-case-slug",
+                }, null, 2),
+                "",
+                "Rollout transcript:",
+                input.transcript,
+            ].join("\n"),
+        },
+    ];
+}
+export function buildConsolidationMessages(input) {
+    return [
+        {
+            role: "system",
+            content: [
+                "You are Bubble's phase-2 memory consolidation agent.",
+                "Maintain the durable memory workspace automatically.",
+                "Return strict JSON only. Do not wrap it in markdown.",
+                "Do not include secrets, credentials, API keys, tokens, private keys, or full large logs.",
+                "Merge duplicate facts, preserve cwd/project boundaries in the content, and remove stale one-off details.",
+            ].join("\n"),
+        },
+        {
+            role: "user",
+            content: [
+                `memory_root: ${input.memoryRoot}`,
+                "",
+                "Return this JSON shape:",
+                JSON.stringify({
+                    memory_md: "# Bubble Memory\n\n...",
+                    memory_summary_md: "# Bubble Memory Summary\n\n...",
+                }, null, 2),
+                "",
+                `Selected inputs this run: ${input.selected.length}`,
+                `Retained from previous successful Phase 2 selection: ${input.retained.length}`,
+                `Removed from previous successful Phase 2 selection: ${input.removed.length}`,
+                "",
+                "Current selected Phase 1 inputs:",
+                ...input.selected.map((item) => `- session=${item.sessionFile} cwd=${item.cwd} updated_at=${item.sourceUpdatedAt}`),
+                "",
+                "Raw memories:",
+                input.rawMemories,
+            ].join("\n"),
+        },
+    ];
+}
+export function buildReadPathPrompt(input) {
+    return [
+        "## Persistent Memory",
+        "",
+        "You have access to Bubble's persistent memory workspace for continuity across sessions.",
+        "",
+        "Memory retrieval rules:",
+        "- Use memory when the task mentions prior work, this repo, user preferences, or a recurring workflow.",
+        "- Start from the injected memory_summary.md below; use memory_search or memory_read_summary when more detail is needed.",
+        "- Search MEMORY.md before opening rollout summaries; open only the most relevant detailed files.",
+        "- Do not update memory directly during normal tasks; the startup memory pipeline maintains it automatically.",
+        "- When memory materially informs your answer, cite the memory files with an <oai-mem-citation> block at the end.",
+        "",
+        `Memory root: ${input.memoryRoot}`,
+        "",
+        "### memory_summary.md",
+        input.memorySummary,
+    ].join("\n");
+}
+export function parseJsonObject(raw) {
+    const trimmed = raw.trim();
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start < 0 || end <= start)
+        throw new Error("model did not return a JSON object");
+    const parsed = JSON.parse(trimmed.slice(start, end + 1));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("model returned invalid JSON object");
+    }
+    return parsed;
+}

package/dist/memory/reset.d.ts

@@ -0,0 +1 @@
+export declare function resetMemory(cwd: string): string;

package/dist/memory/reset.js

@@ -0,0 +1,13 @@
+import { MemoryDatabase } from "./db.js";
+import { resetMemoryWorkspace } from "./storage.js";
+export function resetMemory(cwd) {
+    const db = new MemoryDatabase(cwd);
+    try {
+        db.resetStageData();
+    }
+    finally {
+        db.close();
+    }
+    resetMemoryWorkspace(cwd);
+    return "Memory reset complete.";
+}

package/dist/memory/start.d.ts

@@ -0,0 +1,24 @@
+import type { Message, ThinkingLevel } from "../types.js";
+import { type Phase1Result } from "./phase1.js";
+import { type Phase2Result } from "./phase2.js";
+export interface MemoryStartupOptions {
+    cwd: string;
+    complete: (messages: Message[], options?: {
+        model?: string;
+        temperature?: number;
+        thinkingLevel?: ThinkingLevel;
+    }) => Promise<string>;
+    model?: string;
+    disabled?: boolean;
+    minEntries?: number;
+}
+export interface MemoryStartupResult {
+    status: "succeeded" | "skipped" | "failed";
+    phase1?: Phase1Result;
+    phase2?: Phase2Result;
+    reason?: string;
+}
+export declare function runMemoryStartupPipeline(options: MemoryStartupOptions): Promise<MemoryStartupResult>;
+export declare function startMemoryStartupTask(options: MemoryStartupOptions): void;
+export declare function formatMemoryStartupResult(result: MemoryStartupResult): string;
+export declare function isMemoryDisabled(): boolean;

package/dist/memory/start.js

@@ -0,0 +1,50 @@
+import { runMemoryPhase1 } from "./phase1.js";
+import { runMemoryPhase2 } from "./phase2.js";
+export async function runMemoryStartupPipeline(options) {
+    if (options.disabled || isMemoryDisabled()) {
+        return { status: "skipped", reason: "disabled by BUBBLE_MEMORY_AUTO" };
+    }
+    if (!options.model) {
+        return { status: "skipped", reason: "no active model" };
+    }
+    const phase1 = await runMemoryPhase1({
+        cwd: options.cwd,
+        complete: options.complete,
+        model: options.model,
+        minEntries: options.minEntries,
+    });
+    const phase2 = await runMemoryPhase2({
+        cwd: options.cwd,
+        complete: options.complete,
+        model: options.model,
+    });
+    return {
+        status: phase2.status === "failed" || phase1.failed > 0 ? "failed" : "succeeded",
+        phase1,
+        phase2,
+        reason: phase2.reason,
+    };
+}
+export function startMemoryStartupTask(options) {
+    if (options.disabled || isMemoryDisabled() || !options.model)
+        return;
+    void runMemoryStartupPipeline(options).catch(() => {
+        // Startup memory is best-effort and must not take down the main session.
+    });
+}
+export function formatMemoryStartupResult(result) {
+    if (result.status === "skipped")
+        return `Memory startup skipped: ${result.reason ?? "not needed"}.`;
+    const lines = [
+        `Memory startup ${result.status}.`,
+        result.phase1 ? `Phase 1: scanned ${result.phase1.scanned}, claimed ${result.phase1.claimed}, succeeded ${result.phase1.succeeded}, empty ${result.phase1.empty}, failed ${result.phase1.failed}, skipped ${result.phase1.skipped}.` : undefined,
+        result.phase2 ? `Phase 2: ${result.phase2.status}, selected ${result.phase2.selected}${result.phase2.reason ? ` (${result.phase2.reason})` : ""}.` : undefined,
+        result.phase2?.memoryPath ? `Memory: ${result.phase2.memoryPath}` : undefined,
+        result.phase2?.summaryPath ? `Summary: ${result.phase2.summaryPath}` : undefined,
+    ].filter(Boolean);
+    return lines.join("\n");
+}
+export function isMemoryDisabled() {
+    const value = process.env.BUBBLE_MEMORY_AUTO?.trim().toLowerCase();
+    return value === "0" || value === "false" || value === "off" || value === "no";
+}

package/dist/memory/storage.d.ts

@@ -0,0 +1,10 @@
+import type { Stage1Output } from "./db.js";
+export declare function ensureMemoryWorkspace(cwd: string): void;
+export declare function rebuildRawMemories(cwd: string, outputs: Stage1Output[], limit?: number): string;
+export declare function syncRolloutSummaries(cwd: string, outputs: Stage1Output[], limit?: number): void;
+export declare function writeConsolidatedMemory(cwd: string, input: {
+    memoryMd: string;
+    memorySummaryMd: string;
+}): void;
+export declare function resetMemoryWorkspace(cwd: string): void;
+export declare function rolloutSummaryFileName(output: Stage1Output): string;

package/dist/memory/storage.js

@@ -0,0 +1,82 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getMemoryPaths } from "./paths.js";
+import { redactSecrets } from "./store.js";
+export function ensureMemoryWorkspace(cwd) {
+    const paths = getMemoryPaths(cwd);
+    mkdirSync(paths.globalRoot, { recursive: true });
+    mkdirSync(paths.globalRolloutSummaries, { recursive: true });
+    mkdirSync(paths.globalSkills, { recursive: true });
+}
+export function rebuildRawMemories(cwd, outputs, limit = 40) {
+    const paths = getMemoryPaths(cwd);
+    ensureMemoryWorkspace(cwd);
+    const retained = outputs.slice(0, limit);
+    const lines = ["# Raw Memories", "", "Merged stage-1 raw memories (latest first):", ""];
+    for (const output of retained) {
+        lines.push(`## Session \`${output.sessionFile}\``);
+        lines.push(`updated_at: ${output.sourceUpdatedAt}`);
+        lines.push(`cwd: ${output.cwd}`);
+        lines.push(`rollout_path: ${output.sessionFile}`);
+        lines.push(`rollout_summary_file: ${rolloutSummaryFileName(output)}`);
+        lines.push("");
+        lines.push(redactSecrets(output.rawMemory).text.trim());
+        lines.push("");
+    }
+    const content = `${lines.join("\n").trim()}\n`;
+    writeFileSync(paths.globalRawMemories, content, "utf-8");
+    return content;
+}
+export function syncRolloutSummaries(cwd, outputs, limit = 40) {
+    const paths = getMemoryPaths(cwd);
+    ensureMemoryWorkspace(cwd);
+    const retained = outputs.slice(0, limit);
+    const keep = new Set(retained.map(rolloutSummaryFileName));
+    if (existsSync(paths.globalRolloutSummaries)) {
+        for (const file of readdirSync(paths.globalRolloutSummaries)) {
+            if (file.endsWith(".md") && !keep.has(file)) {
+                rmSync(join(paths.globalRolloutSummaries, file), { force: true });
+            }
+        }
+    }
+    for (const output of retained) {
+        const lines = [
+            `session: ${output.sessionFile}`,
+            `updated_at: ${output.sourceUpdatedAt}`,
+            `cwd: ${output.cwd}`,
+            "",
+            redactSecrets(output.rolloutSummary).text.trim(),
+            "",
+        ];
+        writeFileSync(join(paths.globalRolloutSummaries, rolloutSummaryFileName(output)), lines.join("\n"), "utf-8");
+    }
+}
+export function writeConsolidatedMemory(cwd, input) {
+    const paths = getMemoryPaths(cwd);
+    ensureMemoryWorkspace(cwd);
+    writeFileSync(paths.globalMemory, normalizeMemoryMarkdown(input.memoryMd), "utf-8");
+    writeFileSync(paths.globalSummary, normalizeSummaryMarkdown(input.memorySummaryMd), "utf-8");
+}
+export function resetMemoryWorkspace(cwd) {
+    const paths = getMemoryPaths(cwd);
+    rmSync(paths.globalRoot, { recursive: true, force: true });
+}
+export function rolloutSummaryFileName(output) {
+    const timestamp = output.sourceUpdatedAt.replace(/[:.]/g, "-");
+    const slug = slugify(output.rolloutSlug || output.sessionFile.split("/").pop()?.replace(/\.jsonl$/, "") || "rollout");
+    return `${timestamp}-${slug}.md`;
+}
+function normalizeMemoryMarkdown(value) {
+    const cleaned = stripCodeFence(redactSecrets(value).text).trim();
+    return `${cleaned.startsWith("#") ? cleaned : `# Bubble Memory\n\n${cleaned}`}\n`;
+}
+function normalizeSummaryMarkdown(value) {
+    const cleaned = stripCodeFence(redactSecrets(value).text).trim();
+    return `${/^#\s+Bubble Memory Summary/m.test(cleaned) ? cleaned : `# Bubble Memory Summary\n\n${cleaned}`}\n`;
+}
+function stripCodeFence(value) {
+    return value.trim().replace(/^```(?:markdown|md)?\s*/i, "").replace(/```$/i, "").trim();
+}
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "rollout";
+}

package/dist/memory/store.d.ts

@@ -0,0 +1,43 @@
+import { type BubbleEnvironment } from "../bubble-home.js";
+import { type MemoryJob } from "./db.js";
+import { type MemoryPaths } from "./paths.js";
+export type MemoryScope = "global" | "project";
+export type MemorySearchScope = MemoryScope | "all";
+export interface MemoryStatus {
+    paths: MemoryPaths;
+    bubbleHome: string;
+    environment: BubbleEnvironment;
+    files: Array<{
+        label: string;
+        path: string;
+        exists: boolean;
+        bytes: number;
+    }>;
+    database: {
+        path: string;
+        stage1Outputs: number;
+        disabledThreads: number;
+        jobs: MemoryJob[];
+    };
+}
+export interface MemorySearchResult {
+    scope: MemoryScope;
+    path: string;
+    line: number;
+    text: string;
+}
+export declare function buildMemoryPrompt(cwd: string): string | undefined;
+export declare function getMemoryStatus(cwd: string): MemoryStatus;
+export declare function searchMemory(cwd: string, query: string, options?: {
+    scope?: MemorySearchScope;
+    limit?: number;
+}): MemorySearchResult[];
+export declare function readMemorySummary(cwd: string, scope?: MemorySearchScope): Array<{
+    scope: MemoryScope;
+    path: string;
+    content: string;
+}>;
+export declare function redactSecrets(value: string): {
+    text: string;
+    redacted: boolean;
+};

package/dist/memory/store.js

@@ -0,0 +1,193 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { getBubbleHomeInfo } from "../bubble-home.js";
+import { MemoryDatabase } from "./db.js";
+import { getMemoryPaths } from "./paths.js";
+import { buildReadPathPrompt } from "./prompts.js";
+const MAX_PROMPT_FILE_CHARS = 12_000;
+const MAX_SEARCH_RESULTS = 12;
+export function buildMemoryPrompt(cwd) {
+    const paths = getMemoryPaths(cwd);
+    const sections = [];
+    addFileSection(sections, "Global AGENTS.md", paths.globalAgents);
+    addFileSection(sections, "Project AGENTS.md", paths.projectAgents);
+    addFileSection(sections, "Project .bubble/AGENTS.md", paths.projectLocalAgents);
+    const memorySummary = readOptional(paths.globalSummary)?.trim();
+    if (sections.length === 0 && !memorySummary) {
+        return undefined;
+    }
+    const memoryPrompt = memorySummary
+        ? buildReadPathPrompt({ memoryRoot: paths.globalRoot, memorySummary })
+        : undefined;
+    return [...sections, memoryPrompt].filter(Boolean).join("\n\n");
+}
+export function getMemoryStatus(cwd) {
+    const paths = getMemoryPaths(cwd);
+    const bubbleHome = getBubbleHomeInfo();
+    const files = [
+        { label: "global AGENTS.md", path: paths.globalAgents },
+        { label: "global memory_summary.md", path: paths.globalSummary },
+        { label: "global MEMORY.md", path: paths.globalMemory },
+        { label: "global raw_memories.md", path: paths.globalRawMemories },
+        { label: "global state.sqlite", path: paths.globalDatabase },
+        { label: "project AGENTS.md", path: paths.projectAgents },
+        { label: "project .bubble/AGENTS.md", path: paths.projectLocalAgents },
+    ].map((item) => {
+        const content = readOptional(item.path);
+        return {
+            ...item,
+            exists: content !== undefined,
+            bytes: content?.length ?? 0,
+        };
+    });
+    const db = new MemoryDatabase(cwd);
+    try {
+        const stats = db.stats();
+        return {
+            paths,
+            bubbleHome: bubbleHome.home,
+            environment: bubbleHome.environment,
+            files,
+            database: {
+                path: paths.globalDatabase,
+                ...stats,
+            },
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export function searchMemory(cwd, query, options = {}) {
+    const paths = getMemoryPaths(cwd);
+    const normalized = query.trim().toLowerCase();
+    if (!normalized) {
+        return [];
+    }
+    const scope = options.scope ?? "all";
+    const files = [
+        ...(scope === "global" || scope === "all" ? [
+            { scope: "global", path: paths.globalSummary },
+            { scope: "global", path: paths.globalMemory },
+            { scope: "global", path: paths.globalRawMemories },
+        ] : []),
+        ...(scope === "project" || scope === "all" ? [
+            { scope: "project", path: paths.globalSummary },
+            { scope: "project", path: paths.globalMemory },
+            { scope: "project", path: paths.globalRawMemories },
+        ] : []),
+    ];
+    const seenFiles = new Set();
+    const results = [];
+    const limit = options.limit ?? MAX_SEARCH_RESULTS;
+    for (const file of files) {
+        if (seenFiles.has(file.path))
+            continue;
+        seenFiles.add(file.path);
+        const content = readOptional(file.path);
+        if (!content)
+            continue;
+        const lines = content.split("\n");
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            if (!line.toLowerCase().includes(normalized))
+                continue;
+            results.push({
+                scope: file.scope,
+                path: file.path,
+                line: index + 1,
+                text: collapseWhitespace(line).slice(0, 220),
+            });
+            if (results.length >= limit) {
+                return results;
+            }
+        }
+    }
+    for (const rollout of listRolloutSummaryFiles(paths.globalRolloutSummaries)) {
+        const content = readOptional(rollout);
+        if (!content)
+            continue;
+        const lines = content.split("\n");
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            if (!line.toLowerCase().includes(normalized))
+                continue;
+            results.push({
+                scope: "global",
+                path: rollout,
+                line: index + 1,
+                text: collapseWhitespace(line).slice(0, 220),
+            });
+            if (results.length >= limit)
+                return results;
+        }
+    }
+    return results;
+}
+export function readMemorySummary(cwd, scope = "project") {
+    const paths = getMemoryPaths(cwd);
+    const files = [
+        ...(scope === "global" || scope === "all" ? [{ scope: "global", path: paths.globalSummary }] : []),
+        ...(scope === "project" || scope === "all" ? [{ scope: "project", path: paths.globalSummary }] : []),
+    ];
+    return files
+        .map((file) => ({ ...file, content: readOptional(file.path)?.trim() ?? "" }))
+        .filter((file) => file.content);
+}
+function listRolloutSummaryFiles(dir) {
+    try {
+        if (!existsSync(dir))
+            return [];
+        return readdirSync(dir)
+            .filter((file) => file.endsWith(".md"))
+            .sort()
+            .reverse()
+            .map((file) => join(dir, file));
+    }
+    catch {
+        return [];
+    }
+}
+function addFileSection(sections, label, path) {
+    const content = readOptional(path)?.trim();
+    if (!content)
+        return;
+    sections.push(`### ${label}\nPath: ${path}\n\n${truncate(content, MAX_PROMPT_FILE_CHARS)}`);
+}
+function readOptional(path) {
+    try {
+        if (!existsSync(path))
+            return undefined;
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function truncate(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, maxChars - 80).trimEnd()}\n\n[truncated ${value.length - maxChars + 80} chars]`;
+}
+function collapseWhitespace(value) {
+    return value.trim().replace(/\s+/g, " ");
+}
+export function redactSecrets(value) {
+    const patterns = [
+        /\b(sk-[A-Za-z0-9_-]{12,})\b/g,
+        /\b([A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,})\b/g,
+        /\b((?:api[_-]?key|token|password|secret)\s*[:=]\s*)\S+/gi,
+    ];
+    let text = value;
+    let redacted = false;
+    for (const pattern of patterns) {
+        text = text.replace(pattern, (...args) => {
+            redacted = true;
+            if (args.length > 2 && typeof args[1] === "string" && args[1].match(/[:=]\s*$/)) {
+                return `${args[1]}[REDACTED_SECRET]`;
+            }
+            return "[REDACTED_SECRET]";
+        });
+    }
+    return { text, redacted };
+}

package/dist/memory/usage.d.ts

@@ -0,0 +1 @@
+export declare function recordMemoryCitations(cwd: string, text: string): number;