opensquid 0.5.395

package/dist/project.test.js

@@ -0,0 +1,287 @@
+import * as crypto from "node:crypto";
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { applyResolution, cardPathForRoot, findProjectCard, loadRegistry, pruneDeleted, resolveProject, saveRegistry, writeProjectCard, } from "./project.js";
+let tmpRoot;
+let tmpHome;
+beforeEach(async () => {
+    const uniq = crypto.randomUUID();
+    tmpRoot = path.join(os.tmpdir(), `oscli-project-cwd-${uniq}`);
+    tmpHome = path.join(os.tmpdir(), `oscli-project-home-${uniq}`);
+    await fs.mkdir(tmpRoot, { recursive: true });
+    await fs.mkdir(tmpHome, { recursive: true });
+});
+afterEach(async () => {
+    await fs.rm(tmpRoot, { recursive: true, force: true });
+    await fs.rm(tmpHome, { recursive: true, force: true });
+});
+// ---------------------------------------------------------------------
+// findProjectCard
+// ---------------------------------------------------------------------
+describe("findProjectCard", () => {
+    it("returns null when no card in any ancestor", async () => {
+        expect(await findProjectCard(tmpRoot)).toBeNull();
+    });
+    it("finds a card at cwd", async () => {
+        const card = {
+            version: 1,
+            id: "x",
+            uuid: "u-1",
+            created_at: "2026-05-15T00:00:00Z",
+        };
+        await writeProjectCard(tmpRoot, card);
+        const found = await findProjectCard(tmpRoot);
+        expect(found?.card.uuid).toBe("u-1");
+    });
+    it("walks up to find a card at an ancestor", async () => {
+        const card = {
+            version: 1,
+            id: "x",
+            uuid: "u-1",
+            created_at: "2026-05-15T00:00:00Z",
+        };
+        await writeProjectCard(tmpRoot, card);
+        const deep = path.join(tmpRoot, "src", "nested", "deep");
+        await fs.mkdir(deep, { recursive: true });
+        const found = await findProjectCard(deep);
+        expect(found?.card.uuid).toBe("u-1");
+        expect(found?.cardPath).toBe(cardPathForRoot(tmpRoot));
+    });
+    it("ignores malformed card files", async () => {
+        await fs.mkdir(path.join(tmpRoot, ".opensquid"), { recursive: true });
+        await fs.writeFile(cardPathForRoot(tmpRoot), "{not valid json", "utf8");
+        expect(await findProjectCard(tmpRoot)).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------
+// writeProjectCard
+// ---------------------------------------------------------------------
+describe("writeProjectCard", () => {
+    it("creates the .opensquid/project.json file", async () => {
+        const card = {
+            version: 1,
+            id: "x",
+            uuid: "u-1",
+            created_at: "now",
+        };
+        const res = await writeProjectCard(tmpRoot, card);
+        expect(res.cardPath).toBe(cardPathForRoot(tmpRoot));
+        const read = await fs.readFile(res.cardPath, "utf8");
+        expect(JSON.parse(read).uuid).toBe("u-1");
+    });
+    it("refuses to overwrite without force", async () => {
+        const card = {
+            version: 1,
+            id: "x",
+            uuid: "u-1",
+            created_at: "now",
+        };
+        await writeProjectCard(tmpRoot, card);
+        await expect(writeProjectCard(tmpRoot, card)).rejects.toThrow(/already exists/);
+    });
+    it("overwrites with force=true", async () => {
+        const v1 = {
+            version: 1,
+            id: "x",
+            uuid: "u-1",
+            created_at: "now",
+        };
+        await writeProjectCard(tmpRoot, v1);
+        const v2 = { ...v1, id: "y" };
+        await writeProjectCard(tmpRoot, v2, { force: true });
+        const found = await findProjectCard(tmpRoot);
+        expect(found?.card.id).toBe("y");
+    });
+});
+// ---------------------------------------------------------------------
+// resolveProject — state machine
+// ---------------------------------------------------------------------
+describe("resolveProject state machine", () => {
+    it("returns 'new' when no card exists", async () => {
+        const r = await resolveProject(tmpRoot, { dataRoot: tmpHome });
+        expect(r.kind).toBe("new");
+        if (r.kind === "new") {
+            expect(r.suggested_id).toBe(path.basename(tmpRoot));
+        }
+    });
+    it("returns 'known' when card exists at path that matches registry", async () => {
+        const card = {
+            version: 1,
+            id: "x",
+            uuid: "u-1",
+            created_at: "now",
+        };
+        await writeProjectCard(tmpRoot, card);
+        // Apply once so registry knows the path.
+        await applyResolution(tmpRoot, await resolveProject(tmpRoot, { dataRoot: tmpHome }), {
+            dataRoot: tmpHome,
+        });
+        const r = await resolveProject(tmpRoot, { dataRoot: tmpHome });
+        expect(r.kind).toBe("known");
+    });
+    it("returns 'moved' when card exists at NEW path but registry has DIFFERENT path", async () => {
+        // Create card at tmpRoot, register it there.
+        const card = {
+            version: 1,
+            id: "x",
+            uuid: "u-1",
+            created_at: "now",
+        };
+        await writeProjectCard(tmpRoot, card);
+        await applyResolution(tmpRoot, await resolveProject(tmpRoot, { dataRoot: tmpHome }), {
+            dataRoot: tmpHome,
+        });
+        // Simulate move: write the same card at a new path, leave registry as-is.
+        const newRoot = path.join(os.tmpdir(), `oscli-moved-${crypto.randomUUID()}`);
+        await fs.mkdir(newRoot, { recursive: true });
+        try {
+            await writeProjectCard(newRoot, card);
+            const r = await resolveProject(newRoot, { dataRoot: tmpHome });
+            expect(r.kind).toBe("moved");
+            if (r.kind === "moved") {
+                expect(r.from_path).toBe(tmpRoot);
+            }
+        }
+        finally {
+            await fs.rm(newRoot, { recursive: true, force: true });
+        }
+    });
+});
+// ---------------------------------------------------------------------
+// applyResolution
+// ---------------------------------------------------------------------
+describe("applyResolution", () => {
+    it("auto-creates card on 'new' when autoCreate=true", async () => {
+        const r = await resolveProject(tmpRoot, { dataRoot: tmpHome });
+        expect(r.kind).toBe("new");
+        const card = await applyResolution(tmpRoot, r, {
+            dataRoot: tmpHome,
+            autoCreate: true,
+        });
+        expect(card).not.toBeNull();
+        expect(card?.id).toBe(path.basename(tmpRoot));
+        // Card persisted on disk.
+        const found = await findProjectCard(tmpRoot);
+        expect(found?.card.uuid).toBe(card?.uuid);
+        // Registry has it.
+        const reg = await loadRegistry(tmpHome);
+        expect(reg.projects[card.uuid].last_seen_path).toBe(tmpRoot);
+    });
+    it("returns null on 'new' when autoCreate=false (default)", async () => {
+        const r = await resolveProject(tmpRoot, { dataRoot: tmpHome });
+        const card = await applyResolution(tmpRoot, r, { dataRoot: tmpHome });
+        expect(card).toBeNull();
+        expect(await findProjectCard(tmpRoot)).toBeNull();
+    });
+    it("custom --id overrides the suggested default on auto-create", async () => {
+        const r = await resolveProject(tmpRoot, { dataRoot: tmpHome });
+        const card = await applyResolution(tmpRoot, r, {
+            dataRoot: tmpHome,
+            autoCreate: true,
+            id: "custom-name",
+        });
+        expect(card?.id).toBe("custom-name");
+    });
+    it("updates registry path on 'moved'", async () => {
+        // Create card + register at tmpRoot.
+        const card = {
+            version: 1,
+            id: "x",
+            uuid: "u-mov",
+            created_at: "now",
+        };
+        await writeProjectCard(tmpRoot, card);
+        await applyResolution(tmpRoot, await resolveProject(tmpRoot, { dataRoot: tmpHome }), {
+            dataRoot: tmpHome,
+        });
+        // Move: same card at a new path.
+        const newRoot = path.join(os.tmpdir(), `oscli-moved-${crypto.randomUUID()}`);
+        await fs.mkdir(newRoot, { recursive: true });
+        try {
+            await writeProjectCard(newRoot, card);
+            const r = await resolveProject(newRoot, { dataRoot: tmpHome });
+            expect(r.kind).toBe("moved");
+            await applyResolution(newRoot, r, { dataRoot: tmpHome });
+            const reg = await loadRegistry(tmpHome);
+            expect(reg.projects["u-mov"].last_seen_path).toBe(newRoot);
+        }
+        finally {
+            await fs.rm(newRoot, { recursive: true, force: true });
+        }
+    });
+    it("preserves created_at across registry updates", async () => {
+        const card = {
+            version: 1,
+            id: "x",
+            uuid: "u-1",
+            created_at: "2020-01-01T00:00:00Z",
+        };
+        await writeProjectCard(tmpRoot, card);
+        await applyResolution(tmpRoot, await resolveProject(tmpRoot, { dataRoot: tmpHome }), {
+            dataRoot: tmpHome,
+        });
+        const reg1 = await loadRegistry(tmpHome);
+        const firstCreatedAt = reg1.projects["u-1"].created_at;
+        // Second invocation shouldn't change created_at even when last_seen_at moves.
+        await applyResolution(tmpRoot, await resolveProject(tmpRoot, { dataRoot: tmpHome }), {
+            dataRoot: tmpHome,
+        });
+        const reg2 = await loadRegistry(tmpHome);
+        expect(reg2.projects["u-1"].created_at).toBe(firstCreatedAt);
+    });
+});
+// ---------------------------------------------------------------------
+// pruneDeleted
+// ---------------------------------------------------------------------
+describe("pruneDeleted", () => {
+    it("flips entries whose last_seen_path no longer exists", async () => {
+        // Set up two entries: one path exists, one doesn't.
+        const goneRoot = path.join(os.tmpdir(), `oscli-gone-${crypto.randomUUID()}`);
+        await fs.mkdir(goneRoot);
+        await saveRegistry({
+            version: 1,
+            projects: {
+                alive: {
+                    id: "alive",
+                    last_seen_path: tmpRoot,
+                    last_seen_at: "2026-05-15T00:00:00Z",
+                    created_at: "2026-05-15T00:00:00Z",
+                    status: "active",
+                },
+                gone: {
+                    id: "gone",
+                    last_seen_path: goneRoot,
+                    last_seen_at: "2026-05-15T00:00:00Z",
+                    created_at: "2026-05-15T00:00:00Z",
+                    status: "active",
+                },
+            },
+        }, tmpHome);
+        // Delete the path for "gone" so it'll be flagged.
+        await fs.rm(goneRoot, { recursive: true, force: true });
+        const res = await pruneDeleted(tmpHome);
+        expect(res.swept).toBe(1);
+        expect(res.removed_ids).toEqual(["gone"]);
+        const reg = await loadRegistry(tmpHome);
+        expect(reg.projects.alive.status).toBe("active");
+        expect(reg.projects.gone.status).toBe("deleted");
+    });
+    it("does not touch already-deleted entries", async () => {
+        await saveRegistry({
+            version: 1,
+            projects: {
+                ghost: {
+                    id: "ghost",
+                    last_seen_path: "/nonexistent/path",
+                    last_seen_at: "2026-05-15T00:00:00Z",
+                    created_at: "2026-05-15T00:00:00Z",
+                    status: "deleted",
+                },
+            },
+        }, tmpHome);
+        const res = await pruneDeleted(tmpHome);
+        expect(res.swept).toBe(0);
+    });
+});

package/dist/rag/backend_factory.d.ts

@@ -0,0 +1,59 @@
+/**
+ * RAG backend factory: maps a `BackendConfig` to a concrete `RagBackend`.
+ *
+ * Phase 1 supports `libsql-qwen3` (hybrid semantic+lexical default) and
+ * `libsql-lexical` (FTS5-only fallback, Task 1.11). Task 1.12 will add
+ * `claude-auto-memory`. Each new backend is one switch arm — the rest
+ * of the runtime stays unchanged.
+ *
+ * `kind` is a string-literal discriminant so future additions don't break
+ * existing config files: an unknown `kind` throws a clear error instead
+ * of silently selecting a default. Pack manifests that depend on a
+ * backend that hasn't shipped yet will fail loudly at load time, which
+ * is what we want.
+ *
+ * Also exports `libsqlQwen3WithLexicalFallback` — a thin wrapper that
+ * starts as qwen3 and swaps to lexical the first time `embed()` returns
+ * `null` (Ollama unreachable). Single-direction transition: once swapped,
+ * stays swapped for the session, so we don't retry a dead embedder on
+ * every call. Replaces the stderr notification with the Task 1.14
+ * notification router once that lands — placeholder for now.
+ *
+ * Imports from: ./backends/libsql_qwen3.js, ./backends/libsql_lexical.js,
+ * ./types.js.
+ * Imported by: src/runtime/ (Phase 1 wiring), tests.
+ */
+import type { RagBackend } from './types.js';
+export type BackendConfig = {
+    kind: 'libsql-qwen3';
+    dbUrl: string;
+    ollamaUrl: string;
+    embedderModel?: string;
+} | {
+    kind: 'libsql-lexical';
+    dbUrl: string;
+} | {
+    kind: 'claude-auto-memory';
+} | {
+    kind: 'libsql-fastembed';
+    dbUrl: string;
+    sourceDir?: string;
+};
+export declare function createBackend(config: BackendConfig): RagBackend;
+export interface QwenWithFallbackOpts {
+    dbUrl: string;
+    ollamaUrl: string;
+    embedderModel?: string;
+}
+/**
+ * Hybrid wrapper: starts as libsql-qwen3, swaps to libsql-lexical on the
+ * first `embed()` that returns `null` (Ollama down). Both backends share
+ * the same dbUrl so the lessons table written by the primary remains
+ * queryable after the swap.
+ *
+ * One-way transition by design — retry on every call would burn worst-case
+ * latency for the rest of the session if Ollama stays down. If the user
+ * restarts Ollama mid-session they can restart the host.
+ */
+export declare function libsqlQwen3WithLexicalFallback(opts: QwenWithFallbackOpts): RagBackend;
+//# sourceMappingURL=backend_factory.d.ts.map

package/dist/rag/backend_factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend_factory.d.ts","sourceRoot":"","sources":["../../src/rag/backend_factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAQH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,MAAM,aAAa,GACrB;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GACD;IACE,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,GACD;IAKE,IAAI,EAAE,oBAAoB,CAAC;CAC5B,GACD;IAIE,IAAI,EAAE,kBAAkB,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IAEd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEN,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU,CAyB/D;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,oBAAoB,GAAG,UAAU,CA0DrF"}

package/dist/rag/backend_factory.js

@@ -0,0 +1,125 @@
+/**
+ * RAG backend factory: maps a `BackendConfig` to a concrete `RagBackend`.
+ *
+ * Phase 1 supports `libsql-qwen3` (hybrid semantic+lexical default) and
+ * `libsql-lexical` (FTS5-only fallback, Task 1.11). Task 1.12 will add
+ * `claude-auto-memory`. Each new backend is one switch arm — the rest
+ * of the runtime stays unchanged.
+ *
+ * `kind` is a string-literal discriminant so future additions don't break
+ * existing config files: an unknown `kind` throws a clear error instead
+ * of silently selecting a default. Pack manifests that depend on a
+ * backend that hasn't shipped yet will fail loudly at load time, which
+ * is what we want.
+ *
+ * Also exports `libsqlQwen3WithLexicalFallback` — a thin wrapper that
+ * starts as qwen3 and swaps to lexical the first time `embed()` returns
+ * `null` (Ollama unreachable). Single-direction transition: once swapped,
+ * stays swapped for the session, so we don't retry a dead embedder on
+ * every call. Replaces the stderr notification with the Task 1.14
+ * notification router once that lands — placeholder for now.
+ *
+ * Imports from: ./backends/libsql_qwen3.js, ./backends/libsql_lexical.js,
+ * ./types.js.
+ * Imported by: src/runtime/ (Phase 1 wiring), tests.
+ */
+import { claudeAutoMemoryBackend } from './backends/claude_auto_memory.js';
+import { libsqlLexicalBackend } from './backends/libsql_lexical.js';
+import { libsqlQwen3Backend } from './backends/libsql_qwen3.js';
+import { libsqlStoreBackend } from './backends/libsql_store.js';
+import { fastembedEmbedder } from './embedders/fastembed.js';
+export function createBackend(config) {
+    switch (config.kind) {
+        case 'libsql-qwen3':
+            return libsqlQwen3Backend({
+                dbUrl: config.dbUrl,
+                ollamaUrl: config.ollamaUrl,
+                ...(config.embedderModel === undefined ? {} : { embedderModel: config.embedderModel }),
+            });
+        case 'libsql-lexical':
+            return libsqlLexicalBackend({ dbUrl: config.dbUrl });
+        case 'claude-auto-memory':
+            return claudeAutoMemoryBackend();
+        case 'libsql-fastembed':
+            return libsqlStoreBackend({
+                dbUrl: config.dbUrl,
+                embedder: fastembedEmbedder(),
+                ...(config.sourceDir === undefined ? {} : { sourceDir: config.sourceDir }),
+            });
+        default: {
+            // Exhaustive check: if `BackendConfig` gains a variant and this arm
+            // isn't updated, TS flags `_exhaustive` as not-`never`.
+            const _exhaustive = config;
+            throw new Error(`Unsupported RAG backend: ${String(_exhaustive.kind)}`);
+        }
+    }
+}
+/**
+ * Hybrid wrapper: starts as libsql-qwen3, swaps to libsql-lexical on the
+ * first `embed()` that returns `null` (Ollama down). Both backends share
+ * the same dbUrl so the lessons table written by the primary remains
+ * queryable after the swap.
+ *
+ * One-way transition by design — retry on every call would burn worst-case
+ * latency for the rest of the session if Ollama stays down. If the user
+ * restarts Ollama mid-session they can restart the host.
+ */
+export function libsqlQwen3WithLexicalFallback(opts) {
+    const primary = libsqlQwen3Backend({
+        dbUrl: opts.dbUrl,
+        ollamaUrl: opts.ollamaUrl,
+        ...(opts.embedderModel === undefined ? {} : { embedderModel: opts.embedderModel }),
+    });
+    const fallback = libsqlLexicalBackend({ dbUrl: opts.dbUrl });
+    let active = primary;
+    let fellBack = false;
+    async function swap() {
+        if (fellBack)
+            return;
+        // Phase 1 placeholder. Task 1.14 (notification router) replaces this
+        // with a real channel-routed alert so users see the swap in their
+        // configured Telegram / chat / log destinations.
+        process.stderr.write('[opensquid rag] Ollama unavailable; falling back to lexical-only backend\n');
+        await fallback.init();
+        active = fallback;
+        fellBack = true;
+    }
+    return {
+        async init() {
+            // Only the primary inits up-front. The fallback's init is deferred
+            // until the swap so a healthy session never pays for it. Both
+            // backends use `CREATE TABLE IF NOT EXISTS`, so a later swap-time
+            // init against the same dbUrl is a no-op against existing tables.
+            await active.init();
+        },
+        async embed(text) {
+            if (fellBack)
+                return active.embed(text);
+            try {
+                const v = await active.embed(text);
+                if (v === null) {
+                    await swap();
+                    return null;
+                }
+                return v;
+            }
+            catch {
+                // Defensive: libsql-qwen3 currently catches its own embedder
+                // errors and returns null, but a future backend variant might
+                // throw. Either signal triggers the same one-way swap.
+                await swap();
+                return null;
+            }
+        },
+        async recall(q, k, scope) {
+            return active.recall(q, k, scope);
+        },
+        async storeLesson(l) {
+            return active.storeLesson(l);
+        },
+        async deleteLesson(id, opts) {
+            return active.deleteLesson(id, opts);
+        },
+    };
+}
+//# sourceMappingURL=backend_factory.js.map

package/dist/rag/backend_factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend_factory.js","sourceRoot":"","sources":["../../src/rag/backend_factory.ts"],"names":[],"mappings":"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"}

package/dist/rag/backends/claude_auto_memory.d.ts

@@ -0,0 +1,46 @@
+/**
+ * claude-auto-memory RAG backend: wraps Claude Code's own auto-memory
+ * directory (`~/.claude/projects/<slug>/memory/`) as a `RagBackend`.
+ *
+ * This is the strategic adapter — opensquid sits on TOP of Claude Code's
+ * auto-memory storage rather than competing with it. Users who already
+ * rely on Claude's per-project memory get opensquid's runtime + workflow
+ * + wedge gate without migrating data. `embed()` is a no-op because the
+ * adapter does not own the embedding pipeline (Claude Code's own
+ * vectorizer, if any, is opaque); `recall()` is naive substring search
+ * over the directory's `.md` files for Phase 1. Phase 2+ may upgrade to
+ * semantic recall if Anthropic exposes the auto-memory vectorizer.
+ *
+ * `MEMORY.md` is treated as an index (Claude Code maintains it) and
+ * excluded from recall hits — including it would surface index-summary
+ * matches as if they were lessons.
+ *
+ * Path containment is enforced on `storeLesson`: a `lesson.id` containing
+ * `..` segments must NOT escape the resolved memory dir. We resolve the
+ * target file, take its `relative` path from the resolved dir, and reject
+ * any result that starts with `..` (or contains a `..` segment). This is
+ * the only write surface the adapter exposes, so this check is the only
+ * traversal gate needed.
+ *
+ * `CLAUDE_PROJECT_DIR` is required at init — there is no sensible default.
+ * Cross-project leak (resolving to another project's memory) is prevented
+ * by failing loudly when the env var is unset, rather than guessing.
+ *
+ * Imports from: node:fs/promises, node:os, node:path, ../types.js.
+ * Imported by: src/rag/backend_factory.ts.
+ */
+import type { RagBackend } from '../types.js';
+/**
+ * Resolve the Claude Code auto-memory dir for the current project.
+ *
+ * Slug convention (matches Claude Code's own scheme observed at
+ * `~/.claude/projects/`): replace every `/` in the absolute project path
+ * with `-`. e.g. `/Users/slee/projects/loop` → `-Users-slee-projects-loop`.
+ *
+ * Throws if `CLAUDE_PROJECT_DIR` is unset — better to fail at init than
+ * silently write into a wrong-project memory dir or the current shell's
+ * cwd.
+ */
+export declare function projectMemoryDir(): string;
+export declare function claudeAutoMemoryBackend(): RagBackend;
+//# sourceMappingURL=claude_auto_memory.d.ts.map

package/dist/rag/backends/claude_auto_memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude_auto_memory.d.ts","sourceRoot":"","sources":["../../../src/rag/backends/claude_auto_memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAQH,OAAO,KAAK,EAAwB,UAAU,EAAa,MAAM,aAAa,CAAC;AAE/E;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAUzC;AAmBD,wBAAgB,uBAAuB,IAAI,UAAU,CAkFpD"}