@chendpoc/pi-memory 0.2.4 → 0.3.2

package/dist/sidecar/server/vec/store.js

@@ -1,161 +1,34 @@
 import { createRequire } from "node:module";
 import { ensureDirSync, pathDirname } from "../../../utils/fs.js";
-import { readRetrievalConfig } from "../../../config/retrieval.js";
-import { getEmbedder } from "./embedder.js";
-import { cosineSimilarity, distanceToRelevance, mmrSelect } from "./mmr.js";
+import { queryChunks } from "./chunkQuery.js";
+import { reindexChunks } from "./chunkReindex.js";
+import { embeddingMetaMatches, getChunkCount, getIndexGeneration, getStoredEmbeddingMeta, initVecSchema, } from "./schema.js";
 const require = createRequire(import.meta.url);
-function embeddingToBlob(embedding) {
-    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-}
-function blobToEmbedding(blob) {
-    return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
-}
 export class VecStore {
     db;
     constructor(dbPath) {
         ensureDirSync(pathDirname(dbPath));
         const Database = require("better-sqlite3");
         this.db = new Database(dbPath);
-        this.initSchema();
-    }
-    initSchema() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS meta (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS memory_chunks (
-        chunk_id TEXT PRIMARY KEY,
-        content TEXT NOT NULL,
-        source TEXT NOT NULL,
-        timestamp TEXT NOT NULL,
-        embedding BLOB NOT NULL
-      );
-    `);
+        initVecSchema(this.db);
     }
     getStoredEmbeddingMeta() {
-        const read = (key) => this.db.prepare("SELECT value FROM meta WHERE key = ?").pluck().get(key);
-        const model = read("embedding_model");
-        const provider = read("embedding_provider");
-        const dimRaw = read("embedding_dim");
-        if (!model || !provider || !dimRaw)
-            return null;
-        const dim = Number.parseInt(dimRaw, 10);
-        if (!Number.isFinite(dim))
-            return null;
-        return { model, provider, dim };
+        return getStoredEmbeddingMeta(this.db);
     }
     embeddingMetaMatches(embedder) {
-        const stored = this.getStoredEmbeddingMeta();
-        if (!stored)
-            return true;
-        return (stored.model === embedder.model &&
-            stored.provider === embedder.provider &&
-            stored.dim === embedder.dim);
+        return embeddingMetaMatches(this.db, embedder);
     }
     getIndexGeneration() {
-        const raw = this.db.prepare("SELECT value FROM meta WHERE key = 'index_generation'").pluck().get();
-        return Number(raw ?? "0");
+        return getIndexGeneration(this.db);
     }
     getChunkCount() {
-        const row = this.db.prepare("SELECT COUNT(*) AS count FROM memory_chunks").get();
-        return row.count;
-    }
-    clearChunksIfEmbeddingMismatch(embedder) {
-        if (this.embeddingMetaMatches(embedder))
-            return;
-        this.db.prepare("DELETE FROM memory_chunks").run();
-    }
-    bumpIndexGeneration() {
-        const generation = this.getIndexGeneration() + 1;
-        this.db
-            .prepare("INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
-            .run("index_generation", String(generation));
-        return generation;
-    }
-    writeEmbeddingMeta(embedder) {
-        const upsert = this.db.prepare("INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value");
-        upsert.run("embedding_model", embedder.model);
-        upsert.run("embedding_provider", embedder.provider);
-        upsert.run("embedding_dim", String(embedder.dim));
+        return getChunkCount(this.db);
     }
-    async reindex(documents) {
-        const embedder = getEmbedder();
-        this.clearChunksIfEmbeddingMismatch(embedder);
-        if (documents.length === 0) {
-            const indexGeneration = this.getIndexGeneration();
-            this.writeEmbeddingMeta(embedder);
-            return { indexed: 0, indexGeneration };
-        }
-        const embeddings = await embedder.embedBatch(documents.map((doc) => doc.content));
-        const sync = this.db.transaction((docs, vectors) => {
-            const incomingIds = new Set(docs.map((doc) => doc.id));
-            const existing = this.db.prepare("SELECT chunk_id FROM memory_chunks").all();
-            const deleteChunk = this.db.prepare("DELETE FROM memory_chunks WHERE chunk_id = ?");
-            for (const row of existing) {
-                if (!incomingIds.has(row.chunk_id)) {
-                    deleteChunk.run(row.chunk_id);
-                }
-            }
-            const upsert = this.db.prepare(`
-        INSERT INTO memory_chunks(chunk_id, content, source, timestamp, embedding)
-        VALUES (?, ?, ?, ?, ?)
-        ON CONFLICT(chunk_id) DO UPDATE SET
-          content = excluded.content,
-          source = excluded.source,
-          timestamp = excluded.timestamp,
-          embedding = excluded.embedding
-      `);
-            for (let i = 0; i < docs.length; i++) {
-                const doc = docs[i];
-                upsert.run(doc.id, doc.content, doc.source, doc.timestamp, embeddingToBlob(vectors[i]));
-            }
-            const indexGeneration = this.bumpIndexGeneration();
-            this.writeEmbeddingMeta(embedder);
-            return { indexed: docs.length, indexGeneration };
-        });
-        return sync(documents, embeddings);
+    reindex(documents) {
+        return reindexChunks(this.db, documents);
     }
-    async query(queryText, topK) {
-        const retrieval = readRetrievalConfig();
-        const limit = topK ?? retrieval.topK;
-        const embedder = getEmbedder();
-        this.clearChunksIfEmbeddingMismatch(embedder);
-        const queryEmbedding = await embedder.embed(queryText);
-        const rows = this.db
-            .prepare("SELECT chunk_id, content, source, timestamp, embedding FROM memory_chunks")
-            .all();
-        if (rows.length === 0)
-            return [];
-        const candidates = [];
-        for (const row of rows) {
-            const embedding = blobToEmbedding(row.embedding);
-            if (embedding.length !== queryEmbedding.length)
-                continue;
-            const similarity = cosineSimilarity(queryEmbedding, embedding);
-            if (similarity < retrieval.minRelevance)
-                continue;
-            candidates.push({
-                chunkId: row.chunk_id,
-                content: row.content,
-                source: row.source,
-                timestamp: row.timestamp,
-                distance: 1 - similarity,
-                embedding,
-            });
-        }
-        if (candidates.length === 0)
-            return [];
-        candidates.sort((a, b) => a.distance - b.distance);
-        const poolSize = Math.min(limit * retrieval.candidatePoolMultiplier, candidates.length);
-        const pool = candidates.slice(0, poolSize);
-        const selected = mmrSelect(queryEmbedding, pool, limit, retrieval.mmrLambda);
-        return selected.map((item) => ({
-            content: item.content,
-            source: item.source,
-            timestamp: item.timestamp,
-            relevance: distanceToRelevance(item.distance),
-        }));
+    query(queryText, topK) {
+        return queryChunks(this.db, queryText, topK);
     }
     close() {
         this.db.close();

package/dist/sidecar/sidecarManager.js

@@ -1,12 +1,10 @@
-// Agent 侧：connect-or-create、spawn lock、execa 生命周期
-import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+// Agent 侧：connect-or-create、execa 生命周期
 import { execa } from "execa";
-import { SIDECAR_SPAWN_LOCK_FILE } from "../constants/paths.js";
-import { SIDECAR_FORCE_KILL_DELAY_MS, SIDECAR_SPAWN_LOCK_STALE_MS, SIDECAR_START_TIMEOUT_MS, } from "../constants/timing.js";
-import { ensureDirSync, joinPath, pathDirname, pathExists } from "../utils/fs.js";
-import { nowMs } from "../utils/time.js";
+import { SIDECAR_FORCE_KILL_DELAY_MS, SIDECAR_START_TIMEOUT_MS } from "../constants/timing.js";
+import { ensureDirSync, pathDirname } from "../utils/fs.js";
 import { ping } from "./client.js";
 import { resolveSidecarEntry } from "./paths.js";
+import { acquireSpawnLock, releaseSpawnLock } from "./spawnLock.js";
 import { canConnect, waitUntilReady } from "./utils.js";
 export { resolveSidecarEntry } from "./paths.js";
 const START_TIMEOUT_MS = SIDECAR_START_TIMEOUT_MS;
@@ -56,55 +54,3 @@ class SidecarManager {
         this.child = undefined;
     }
 }
-function spawnLockPath(socketPath) {
-    return joinPath(pathDirname(socketPath), SIDECAR_SPAWN_LOCK_FILE);
-}
-function acquireSpawnLock(socketPath) {
-    const lockPath = spawnLockPath(socketPath);
-    for (let i = 0; i < 5; i++) {
-        try {
-            writeFileSync(lockPath, `${process.pid}\n${nowMs()}\n`, { flag: "wx" });
-            return true;
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            if (isLockStale(lockPath)) {
-                try {
-                    unlinkSync(lockPath);
-                }
-                catch { }
-                continue;
-            }
-            return false;
-        }
-    }
-    return false;
-}
-function isLockStale(lockPath) {
-    if (!pathExists(lockPath))
-        return false;
-    try {
-        const [pidLine = "", tsLine = "0"] = readFileSync(lockPath, "utf8").trim().split("\n");
-        const pid = Number.parseInt(pidLine, 10);
-        const ts = Number.parseInt(tsLine, 10);
-        if (Number.isFinite(pid)) {
-            try {
-                process.kill(pid, 0);
-            }
-            catch {
-                return true;
-            }
-        }
-        return !Number.isFinite(ts) || nowMs() - ts > SIDECAR_SPAWN_LOCK_STALE_MS;
-    }
-    catch {
-        return true;
-    }
-}
-function releaseSpawnLock(socketPath) {
-    try {
-        unlinkSync(spawnLockPath(socketPath));
-    }
-    catch { }
-}

package/dist/sidecar/spawnLock.d.ts

@@ -0,0 +1,2 @@
+export declare function acquireSpawnLock(socketPath: string): boolean;
+export declare function releaseSpawnLock(socketPath: string): void;

package/dist/sidecar/spawnLock.js

@@ -0,0 +1,57 @@
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { SIDECAR_SPAWN_LOCK_FILE } from "../constants/paths.js";
+import { SIDECAR_SPAWN_LOCK_STALE_MS } from "../constants/timing.js";
+import { joinPath, pathDirname, pathExists } from "../utils/fs.js";
+import { nowMs } from "../utils/time.js";
+function spawnLockPath(socketPath) {
+    return joinPath(pathDirname(socketPath), SIDECAR_SPAWN_LOCK_FILE);
+}
+export function acquireSpawnLock(socketPath) {
+    const lockPath = spawnLockPath(socketPath);
+    for (let i = 0; i < 5; i++) {
+        try {
+            writeFileSync(lockPath, `${process.pid}\n${nowMs()}\n`, { flag: "wx" });
+            return true;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            if (isLockStale(lockPath)) {
+                try {
+                    unlinkSync(lockPath);
+                }
+                catch { }
+                continue;
+            }
+            return false;
+        }
+    }
+    return false;
+}
+function isLockStale(lockPath) {
+    if (!pathExists(lockPath))
+        return false;
+    try {
+        const [pidLine = "", tsLine = "0"] = readFileSync(lockPath, "utf8").trim().split("\n");
+        const pid = Number.parseInt(pidLine, 10);
+        const ts = Number.parseInt(tsLine, 10);
+        if (Number.isFinite(pid)) {
+            try {
+                process.kill(pid, 0);
+            }
+            catch {
+                return true;
+            }
+        }
+        return !Number.isFinite(ts) || nowMs() - ts > SIDECAR_SPAWN_LOCK_STALE_MS;
+    }
+    catch {
+        return true;
+    }
+}
+export function releaseSpawnLock(socketPath) {
+    try {
+        unlinkSync(spawnLockPath(socketPath));
+    }
+    catch { }
+}

package/dist/sidecar/syncIndex.d.ts

@@ -0,0 +1,3 @@
+import type { ConsolidateStoreAccess } from "../store/consolidatePort.js";
+/** Ensure sidecar is up, reindex from store export, and invalidate query cache. */
+export declare function syncSidecarIndex(agentDir: string, store: Pick<ConsolidateStoreAccess, "exportForIndex">): Promise<number>;

package/dist/sidecar/syncIndex.js

@@ -0,0 +1,12 @@
+import { reindex } from "./client.js";
+import { sidecarQueryCache } from "./queryCache.js";
+import { resolveSidecarPaths } from "./paths.js";
+import { ensureSidecarRunning } from "./sidecarManager.js";
+/** Ensure sidecar is up, reindex from store export, and invalidate query cache. */
+export async function syncSidecarIndex(agentDir, store) {
+    const sidecar = resolveSidecarPaths(agentDir);
+    await ensureSidecarRunning(sidecar);
+    const result = await reindex(sidecar.socketPath, await store.exportForIndex());
+    sidecarQueryCache.onReindexComplete(agentDir, result.index_generation);
+    return result.index_generation;
+}

package/dist/sidecar/warmup.js

@@ -21,7 +21,7 @@ export async function warmSidecar(socketPath, options = {}) {
         const queryStartedAt = nowMs();
         const queryTimeoutMs = options.queryTimeoutMs ?? SIDECAR_WARMUP_QUERY_TIMEOUT_MS;
         try {
-            await query(socketPath, ".", queryTimeoutMs);
+            await query(socketPath, ".", { timeoutMs: queryTimeoutMs });
         }
         catch {
             // warm query is best-effort

package/dist/status/copy.d.ts

@@ -0,0 +1,2 @@
+export declare const MEMORY_STATUS_EXPAND_HINT = " (/memory-status to expand)";
+export declare const MEMORY_STATUS_COLLAPSE_HINT = "  /memory-status to collapse \u00B7 /memory-status hide to dismiss";

package/dist/status/copy.js

@@ -0,0 +1,2 @@
+export const MEMORY_STATUS_EXPAND_HINT = " (/memory-status to expand)";
+export const MEMORY_STATUS_COLLAPSE_HINT = "  /memory-status to collapse · /memory-status hide to dismiss";

package/dist/status/format.d.ts

@@ -0,0 +1,7 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { MemoryStatusReport, StatusPalette } from "./types.js";
+export declare function piStatusPalette(theme: Theme): StatusPalette;
+export declare function formatMemoryStatusSummary(report: MemoryStatusReport, palette: StatusPalette, accent: (text: string) => string): string;
+export declare function formatMemoryStatusLines(report: MemoryStatusReport, palette?: StatusPalette): string[];
+export declare function formatMemoryStatusTuiLines(report: MemoryStatusReport, palette: StatusPalette, theme: Theme): string[];
+export declare function printMemoryStatusRows(report: MemoryStatusReport, palette: StatusPalette, logLine: (label: string, value: string) => void): void;

package/dist/status/format.js

@@ -0,0 +1,133 @@
+const plainPalette = {
+    dim: (text) => text,
+    ok: (text) => text,
+    bad: (text) => text,
+    warn: (text) => text,
+};
+export function piStatusPalette(theme) {
+    return {
+        dim: (text) => theme.fg("dim", text),
+        ok: (text) => theme.fg("success", text),
+        bad: (text) => theme.fg("error", text),
+        warn: (text) => theme.fg("warning", text),
+    };
+}
+function embedderMatchesIndex(report) {
+    const { embeddingProvider, embeddingModel, embeddingDim } = report.vectorIndex;
+    if (!embeddingProvider || !embeddingModel || embeddingDim === undefined)
+        return true;
+    return (embeddingProvider === report.embedder.provider &&
+        embeddingModel === report.embedder.model &&
+        embeddingDim === report.embedder.dim);
+}
+function formatVectorIndexLine(report) {
+    const { generation, chunkCount, readError } = report.vectorIndex;
+    if (readError) {
+        return `(unreadable: ${readError})`;
+    }
+    if (generation === undefined || chunkCount === undefined) {
+        return "(unknown — start sidecar or run pi-memory status again)";
+    }
+    return `gen=${generation} chunks=${chunkCount}`;
+}
+function formatIndexEmbedderLine(report, palette) {
+    const { embeddingProvider, embeddingModel, embeddingDim, chunkCount, readError } = report.vectorIndex;
+    if (readError) {
+        return palette.dim("(unavailable)");
+    }
+    if (!embeddingProvider || !embeddingModel || embeddingDim === undefined) {
+        if (chunkCount === 0) {
+            return palette.dim("(empty — reindex pending)");
+        }
+        return palette.dim("(no embedding meta — run reindex)");
+    }
+    const label = `${embeddingProvider}/${embeddingModel} (${embeddingDim}d)`;
+    if (embedderMatchesIndex(report)) {
+        return label;
+    }
+    return palette.warn(`${label} ≠ configured`);
+}
+function memoryStatusRows(report, palette = plainPalette) {
+    const lastConsolidated = report.memory.lastConsolidatedAt ?? "(never)";
+    const rows = [
+        { label: "agent dir", value: () => report.agentDir },
+        { label: "MEMORY lines", value: () => String(report.memory.lineCount) },
+        { label: "entries", value: () => String(report.memory.entryCount) },
+        { label: "overflow files", value: () => String(report.memory.overflowFileCount) },
+        {
+            label: "last consolidate",
+            value: () => !report.memory.lastConsolidatedAt ? palette.dim(lastConsolidated) : lastConsolidated,
+        },
+        {
+            label: "sidecar",
+            value: () => {
+                const sidecarState = report.sidecar.running ? "running" : "not reachable";
+                const state = report.sidecar.running ? palette.ok(sidecarState) : palette.bad(sidecarState);
+                return `${state} ${palette.dim(`(${report.sidecar.socketPath})`)}`;
+            },
+        },
+    ];
+    if (!report.vectorIndex.exists) {
+        rows.push({
+            label: "vector index",
+            value: () => palette.dim("(missing — write MEMORY or start session)"),
+        });
+    }
+    else {
+        rows.push({
+            label: "vector index",
+            value: () => {
+                const line = formatVectorIndexLine(report);
+                if (report.vectorIndex.readError)
+                    return palette.bad(line);
+                if (report.vectorIndex.generation === undefined || report.vectorIndex.chunkCount === undefined) {
+                    return palette.dim(line);
+                }
+                return line;
+            },
+        });
+        rows.push({
+            label: "index embedder",
+            value: () => formatIndexEmbedderLine(report, palette),
+        });
+    }
+    rows.push({
+        label: "configured embedder",
+        value: () => `${report.embedder.provider}/${report.embedder.model} (${report.embedder.dim}d)`,
+    });
+    return rows;
+}
+export function formatMemoryStatusSummary(report, palette, accent) {
+    const parts = [
+        accent("pi-memory"),
+        palette.dim(`entries=${report.memory.entryCount}`),
+        report.sidecar.running ? palette.ok("sidecar up") : palette.bad("sidecar down"),
+    ];
+    if (!report.vectorIndex.exists) {
+        parts.push(palette.dim("no index"));
+    }
+    else {
+        const vec = formatVectorIndexLine(report);
+        if (report.vectorIndex.readError) {
+            parts.push(palette.bad(vec));
+        }
+        else if (report.vectorIndex.generation === undefined || report.vectorIndex.chunkCount === undefined) {
+            parts.push(palette.dim(vec));
+        }
+        else {
+            parts.push(vec);
+        }
+    }
+    return parts.join(palette.dim(" · "));
+}
+export function formatMemoryStatusLines(report, palette) {
+    return memoryStatusRows(report, palette).map(({ label, value }) => `${label.padEnd(16)} ${value()}`);
+}
+export function formatMemoryStatusTuiLines(report, palette, theme) {
+    return memoryStatusRows(report, palette).map(({ label, value }) => `${theme.fg("muted", label.padEnd(16))} ${value()}`);
+}
+export function printMemoryStatusRows(report, palette, logLine) {
+    for (const { label, value } of memoryStatusRows(report, palette)) {
+        logLine(label, value());
+    }
+}

package/dist/status/gather.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryStatusReport } from "./types.js";
+export declare function gatherMemoryStatus(agentDir: string): Promise<MemoryStatusReport>;

package/dist/status/gather.js

@@ -0,0 +1,88 @@
+import { readPiMemoryEnv, resolveEmbedDim } from "../config/env.js";
+import { DEFAULT_HASH_EMBED_DIM } from "../constants/env.js";
+import { createEmbedder } from "../adapters/embed/factory.js";
+import { fetchIndexStats, ping } from "../sidecar/client.js";
+import { resolveSidecarPaths } from "../sidecar/paths.js";
+import { getVecStore } from "../sidecar/server/vec/store.js";
+import { createMemoryStore } from "../store/index.js";
+import { pathExists } from "../utils/fs.js";
+function applyLocalVecStats(report, dbPath) {
+    const vec = getVecStore(dbPath);
+    report.vectorIndex.generation = vec.getIndexGeneration();
+    report.vectorIndex.chunkCount = vec.getChunkCount();
+    const meta = vec.getStoredEmbeddingMeta();
+    if (meta) {
+        report.vectorIndex.embeddingProvider = meta.provider;
+        report.vectorIndex.embeddingModel = meta.model;
+        report.vectorIndex.embeddingDim = meta.dim;
+    }
+}
+function applySidecarVecStats(report, stats) {
+    report.vectorIndex.fromSidecar = true;
+    report.vectorIndex.generation = stats.index_generation;
+    report.vectorIndex.chunkCount = stats.chunk_count;
+    if (stats.embedding_provider && stats.embedding_model && stats.embedding_dim !== undefined) {
+        report.vectorIndex.embeddingProvider = stats.embedding_provider;
+        report.vectorIndex.embeddingModel = stats.embedding_model;
+        report.vectorIndex.embeddingDim = stats.embedding_dim;
+    }
+}
+function resolveConfiguredEmbedder(env) {
+    try {
+        const embedder = createEmbedder(env);
+        return { provider: embedder.provider, model: embedder.model, dim: embedder.dim };
+    }
+    catch {
+        const embedModel = env.embedder === "openai"
+            ? env.openaiEmbedModel
+            : env.embedder === "ollama"
+                ? env.ollamaEmbedModel
+                : "hash/dev";
+        const dim = env.embedder === "hash"
+            ? (env.embedDimOverride ?? DEFAULT_HASH_EMBED_DIM)
+            : resolveEmbedDim(embedModel, env.embedDimOverride);
+        return { provider: env.embedder, model: embedModel, dim };
+    }
+}
+export async function gatherMemoryStatus(agentDir) {
+    const store = createMemoryStore({ agentDir });
+    await store.ensureInitialized();
+    const sidecar = resolveSidecarPaths(agentDir);
+    const env = readPiMemoryEnv();
+    const sidecarRunning = await ping(sidecar.socketPath);
+    const report = {
+        agentDir,
+        memory: await store.getStats(),
+        sidecar: {
+            socketPath: sidecar.socketPath,
+            running: sidecarRunning,
+        },
+        vectorIndex: {
+            dbPath: sidecar.dbPath,
+            exists: pathExists(sidecar.dbPath),
+        },
+        embedder: resolveConfiguredEmbedder(env),
+    };
+    if (!report.vectorIndex.exists)
+        return report;
+    if (sidecarRunning) {
+        const result = await fetchIndexStats(sidecar.socketPath);
+        if ("stats" in result) {
+            applySidecarVecStats(report, result.stats);
+            return report;
+        }
+        const hint = result.error.includes("unknown frame type")
+            ? "restart sidecar (reload Pi session or pi-memory)"
+            : result.error;
+        report.vectorIndex.readError = hint;
+        return report;
+    }
+    try {
+        applyLocalVecStats(report, sidecar.dbPath);
+    }
+    catch (error) {
+        report.vectorIndex.readError =
+            error instanceof Error ? error.message : "unable to open vector index (start sidecar)";
+    }
+    return report;
+}

package/dist/status/index.d.ts

@@ -0,0 +1,4 @@
+export type { MemoryStatusReport, StatusPalette } from "./types.js";
+export { gatherMemoryStatus } from "./gather.js";
+export { formatMemoryStatusLines, formatMemoryStatusSummary, formatMemoryStatusTuiLines, piStatusPalette, printMemoryStatusRows, } from "./format.js";
+export { MEMORY_STATUS_COLLAPSE_HINT, MEMORY_STATUS_EXPAND_HINT } from "./copy.js";

package/dist/status/index.js

@@ -0,0 +1,3 @@
+export { gatherMemoryStatus } from "./gather.js";
+export { formatMemoryStatusLines, formatMemoryStatusSummary, formatMemoryStatusTuiLines, piStatusPalette, printMemoryStatusRows, } from "./format.js";
+export { MEMORY_STATUS_COLLAPSE_HINT, MEMORY_STATUS_EXPAND_HINT } from "./copy.js";

package/dist/status/types.d.ts

@@ -0,0 +1,33 @@
+import type { MemoryStats } from "../store/types.js";
+export type StatusPalette = {
+    dim: (text: string) => string;
+    ok: (text: string) => string;
+    bad: (text: string) => string;
+    warn: (text: string) => string;
+};
+export type MemoryStatusReport = {
+    agentDir: string;
+    memory: MemoryStats;
+    sidecar: {
+        socketPath: string;
+        running: boolean;
+    };
+    vectorIndex: {
+        dbPath: string;
+        exists: boolean;
+        generation?: number;
+        chunkCount?: number;
+        embeddingProvider?: string;
+        embeddingModel?: string;
+        embeddingDim?: number;
+        /** Set when the index file exists but could not be read locally. */
+        readError?: string;
+        /** Stats came from sidecar RPC rather than opening sqlite in-process. */
+        fromSidecar?: boolean;
+    };
+    embedder: {
+        provider: string;
+        model: string;
+        dim: number;
+    };
+};

package/dist/status/types.js

@@ -0,0 +1 @@
+export {};

package/dist/store/consolidatePort.d.ts

@@ -0,0 +1,11 @@
+import type { IndexDocument } from "../sidecar/protocol.js";
+import type { TimeInput } from "../utils/time.js";
+import type { MemoryStats, ParsedEntry } from "./types.js";
+/** Store capabilities used by consolidate jobs (no merge algorithms). */
+export type ConsolidateStoreAccess = {
+    shouldConsolidate(at?: TimeInput, cronFired?: boolean): Promise<boolean>;
+    getStats(): Promise<MemoryStats>;
+    exportForIndex(): Promise<IndexDocument[]>;
+    isConsolidating(): boolean;
+    rewriteMemoryUnderLock(updateEntries: (entries: ParsedEntry[]) => Promise<ParsedEntry[]>): Promise<void>;
+};

package/dist/store/consolidatePort.js

@@ -0,0 +1 @@
+export {};

package/dist/store/index.d.ts

@@ -1,4 +1,6 @@
+export { initializeMemoryWorkspace, readMemoryTemplateExample, type InitMemoryWorkspaceResult } from "./initWorkspace.js";
 export { MemoryStore, createMemoryStore } from "./memoryStore.js";
+export type { ConsolidateStoreAccess } from "./consolidatePort.js";
 export { MarkdownMemoryBackend } from "./backend.js";
 export { getAgentPaths, resolveAgentDir } from "./paths.js";
 export * from "./types.js";

package/dist/store/index.js

@@ -1,3 +1,4 @@
+export { initializeMemoryWorkspace, readMemoryTemplateExample } from "./initWorkspace.js";
 export { MemoryStore, createMemoryStore } from "./memoryStore.js";
 export { MarkdownMemoryBackend } from "./backend.js";
 export { getAgentPaths, resolveAgentDir } from "./paths.js";