pi-memory-stone 0.1.0 → 0.1.2

package/README.md

@@ -8,31 +8,37 @@ A global pi extension that preserves and retrieves useful memory across pi sessi
 
 ## Quick Start
 
-Install globally as a pi package:
+Install globally from npm:
 
 ```bash
-pi install git:github.com/nikolasp/pi-memory-stone
+pi install npm:pi-memory-stone
 ```
 
-Or install manually in pi's global extension directory:
+Package page: https://www.npmjs.com/package/pi-memory-stone
+
+Then restart pi or run `/reload`, and verify it is active:
 
 ```bash
-git clone https://github.com/nikolasp/pi-memory-stone ~/.pi/agent/extensions/pi-memory-stone
+/memory-status
 ```
 
-Then restart pi or run `/reload`, and verify it is active:
+Alternative installs:
 
 ```bash
-/memory-status
+# Install directly from GitHub
+pi install git:github.com/nikolasp/pi-memory-stone
+
+# Manual global extension checkout
+git clone https://github.com/nikolasp/pi-memory-stone ~/.pi/agent/extensions/pi-memory-stone
 ```
 
-> Scope note: `pi install -l ...` / `pi install --local ...` writes to the current project's `.pi/settings.json` and only loads there. For all projects, run `pi install git:github.com/nikolasp/pi-memory-stone` without `--local` (user settings) or use `~/.pi/agent/extensions/`.
+> Scope note: `pi install -l ...` / `pi install --local ...` writes to the current project's `.pi/settings.json` and only loads there. For all projects, run `pi install npm:pi-memory-stone` without `--local` (user settings) or use `~/.pi/agent/extensions/`.
 
 ## Architecture
 
 ```
 ~/.pi/agent/memory/memory.db      # SQLite + FTS5 (WAL mode)
-~/.pi/agent/extensions/pi-memory-stone/
+pi-memory-stone package source
 ├── src/
 │   ├── index.ts                  # Entry point: hooks, lifecycle
 │   ├── db/                       # SQLite connection, migrations, CRUD

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "pi-memory-stone",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Global pi extension: preserves and retrieves useful memory across pi sessions",
   "license": "MIT",
+  "keywords": ["pi-package"],
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
   "pi": {
     "extensions": ["./src/index.ts"]
   },

package/test/indexing.test.ts

@@ -1,97 +0,0 @@
-/**
- * Tests for incremental session indexing.
- */
-
-import { describe, it, beforeEach, after } from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, unlinkSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { indexSessionOnAgentEnd } from "../src/indexing/index.js";
-import { closeDb, getDb, getDbPath } from "../src/db/index.js";
-
-const testMemoryDir = mkdtempSync(join(tmpdir(), "pi-memory-stone-indexing-"));
-process.env.PI_MEMORY_STONE_DB_PATH = join(testMemoryDir, "memory.db");
-
-function cleanDb() {
-  const dbPath = getDbPath();
-  closeDb();
-  for (const f of [dbPath, dbPath + "-wal", dbPath + "-shm"]) {
-    try { if (existsSync(f)) unlinkSync(f); } catch {}
-  }
-}
-
-function makeUserEntry(id: string, text: string) {
-  return {
-    type: "message",
-    id,
-    parentId: null,
-    message: {
-      role: "user",
-      content: text,
-      timestamp: Date.now(),
-    },
-  };
-}
-
-function makeAssistantEntry(id: string, text: string) {
-  return {
-    type: "message",
-    id,
-    parentId: null,
-    message: {
-      role: "assistant",
-      content: [{ type: "text", text }],
-      timestamp: Date.now(),
-    },
-  };
-}
-
-function makeContext(sessionFile: string, branch: unknown[]) {
-  return {
-    cwd: testMemoryDir,
-    sessionManager: {
-      getSessionFile: () => sessionFile,
-      getSessionId: () => "session-1",
-      getBranch: () => branch,
-      getLeafId: () => (branch.at(-1) as { id?: string } | undefined)?.id,
-    },
-  } as any;
-}
-
-describe("indexSessionOnAgentEnd", () => {
-  beforeEach(() => cleanDb());
-
-  after(() => {
-    cleanDb();
-    rmSync(testMemoryDir, { recursive: true, force: true });
-  });
-
-  it("indexes only entries after the last indexed entry when timestamps are absent", async () => {
-    const sessionFile = join(testMemoryDir, "session.jsonl");
-    writeFileSync(sessionFile, "");
-
-    const firstBranch = [
-      makeUserEntry("001", "First question"),
-      makeAssistantEntry("002", "First answer"),
-    ];
-    const first = await indexSessionOnAgentEnd(makeContext(sessionFile, firstBranch), {});
-    assert.equal(first.errors.length, 0);
-
-    const fullBranch = [
-      ...firstBranch,
-      makeUserEntry("003", "Second question"),
-      makeAssistantEntry("004", "Second answer"),
-    ];
-    const second = await indexSessionOnAgentEnd(makeContext(sessionFile, fullBranch), {});
-    assert.equal(second.errors.length, 0);
-
-    const rows = getDb()
-      .prepare("SELECT text FROM records WHERE kind = 'turn_summary' ORDER BY created_at")
-      .all() as Array<{ text: string }>;
-
-    assert.equal(rows.length, 2);
-    assert.ok(rows.some((r) => r.text.includes("First question")));
-    assert.ok(rows.some((r) => r.text.includes("Second question")));
-  });
-});

package/test/parser.test.ts

@@ -1,261 +0,0 @@
-/**
- * Tests for the session parser module.
- * Run with: node --experimental-sqlite --test test/parser.test.ts
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { parseEntries, turnsToRecords } from "../src/indexing/parser.js";
-
-// ─── Helpers ────────────────────────────────────────────────────────
-
-function makeUserEntry(id: string, text: string) {
-  return {
-    type: "message",
-    id,
-    parentId: id === "001" ? null : String(Number(id) - 1).padStart(3, "0"),
-    timestamp: new Date().toISOString(),
-    message: {
-      role: "user",
-      content: text,
-      timestamp: Date.now(),
-    },
-  };
-}
-
-function makeAssistantEntry(id: string, text: string, toolCalls: Array<{ id: string; name: string; arguments: Record<string, unknown> }> = []) {
-  const content: Array<Record<string, unknown>> = [];
-  if (text) {
-    content.push({ type: "text", text });
-  }
-  for (const tc of toolCalls) {
-    content.push({ type: "toolCall", ...tc });
-  }
-  return {
-    type: "message",
-    id,
-    parentId: String(Number(id) - 1).padStart(3, "0"),
-    timestamp: new Date().toISOString(),
-    message: {
-      role: "assistant",
-      content,
-      provider: "anthropic",
-      model: "claude-sonnet-4-5",
-      usage: { totalTokens: 100 },
-      stopReason: "stop",
-      timestamp: Date.now(),
-    },
-  };
-}
-
-function makeToolResultEntry(id: string, toolCallId: string, toolName: string, text: string, isError = false) {
-  return {
-    type: "message",
-    id,
-    parentId: String(Number(id) - 1).padStart(3, "0"),
-    timestamp: new Date().toISOString(),
-    message: {
-      role: "toolResult",
-      toolCallId,
-      toolName,
-      content: [{ type: "text", text }],
-      isError,
-      timestamp: Date.now(),
-    },
-  };
-}
-
-// ─── Tests ──────────────────────────────────────────────────────────
-
-describe("parseEntries", () => {
-  it("parses a simple user-assistant turn", () => {
-    const entries = [
-      makeUserEntry("001", "Hello, can you help me?"),
-      makeAssistantEntry("002", "Of course! How can I assist?"),
-    ];
-
-    const { turns } = parseEntries(entries as any);
-    assert.equal(turns.length, 1);
-    assert.equal(turns[0].userEntryId, "001");
-    assert.ok(turns[0].userPrompt.includes("Hello"));
-    assert.ok(turns[0].assistantText.includes("Of course"));
-    assert.equal(turns[0].toolCalls.length, 0);
-    assert.equal(turns[0].errors.length, 0);
-  });
-
-  it("parses a turn with tool calls", () => {
-    const entries = [
-      makeUserEntry("001", "Read package.json"),
-      makeAssistantEntry("002", "Let me read that file.", [
-        { id: "call_1", name: "read", arguments: { path: "package.json" } },
-      ]),
-      makeToolResultEntry("003", "call_1", "read", '{"name": "my-package"}'),
-    ];
-
-    const { turns } = parseEntries(entries as any);
-    assert.equal(turns.length, 1);
-    assert.equal(turns[0].toolCalls.length, 1);
-    assert.equal(turns[0].toolCalls[0].toolName, "read");
-    assert.deepEqual(turns[0].toolCalls[0].args, { path: "package.json" });
-    assert.equal(turns[0].toolCalls[0].resultText, '{"name": "my-package"}');
-  });
-
-  it("preserves assistant tool calls without tool results", () => {
-    const entries = [
-      makeUserEntry("001", "Read package.json"),
-      makeAssistantEntry("002", "Let me read that file.", [
-        { id: "call_1", name: "read", arguments: { path: "package.json" } },
-      ]),
-    ];
-
-    const { turns } = parseEntries(entries as any);
-    assert.equal(turns.length, 1);
-    assert.equal(turns[0].toolCalls.length, 1);
-    assert.equal(turns[0].toolCalls[0].toolCallId, "call_1");
-    assert.equal(turns[0].toolCalls[0].toolName, "read");
-    assert.deepEqual(turns[0].toolCalls[0].args, { path: "package.json" });
-    assert.equal(turns[0].toolCalls[0].resultText, "");
-  });
-
-  it("parses multiple turns", () => {
-    const entries = [
-      makeUserEntry("001", "Question 1"),
-      makeAssistantEntry("002", "Answer 1"),
-      makeUserEntry("003", "Question 2"),
-      makeAssistantEntry("004", "Answer 2"),
-    ];
-
-    const { turns } = parseEntries(entries as any);
-    assert.equal(turns.length, 2);
-    assert.equal(turns[0].userEntryId, "001");
-    assert.equal(turns[1].userEntryId, "003");
-  });
-
-  it("detects errors in tool results", () => {
-    const entries = [
-      makeUserEntry("001", "Run a command"),
-      makeAssistantEntry("002", "Running...", [
-        { id: "call_1", name: "bash", arguments: { command: "invalid" } },
-      ]),
-      makeToolResultEntry("003", "call_1", "bash", "Command not found", true),
-    ];
-
-    const { turns } = parseEntries(entries as any);
-    assert.equal(turns[0].errors.length, 1);
-    assert.equal(turns[0].errors[0].toolName, "bash");
-  });
-
-  it("detects file activities from tool calls", () => {
-    const entries = [
-      makeUserEntry("001", "Check package.json"),
-      makeAssistantEntry("002", "Let me check.", [
-        { id: "call_1", name: "read", arguments: { path: "src/index.ts" } },
-        { id: "call_2", name: "edit", arguments: { path: "src/utils.ts" } },
-      ]),
-      makeToolResultEntry("003", "call_1", "read", "content..."),
-      makeToolResultEntry("004", "call_2", "edit", "edited"),
-    ];
-
-    const { fileActivities } = parseEntries(entries as any);
-
-    const reads = fileActivities.filter((f) => f.action === "read");
-    const edits = fileActivities.filter((f) => f.action === "edit");
-
-    assert.equal(reads.length, 1);
-    assert.equal(edits.length, 1);
-    assert.equal(reads[0].path, "src/index.ts");
-    assert.equal(edits[0].path, "src/utils.ts");
-  });
-
-  it("skips sensitive file paths", () => {
-    const entries = [
-      makeUserEntry("001", "Check env"),
-      makeAssistantEntry("002", "Checking...", [
-        { id: "call_1", name: "read", arguments: { path: ".env" } },
-        { id: "call_2", name: "read", arguments: { path: "src/app.ts" } },
-      ]),
-      makeToolResultEntry("003", "call_1", "read", "SECRET=abc"),
-      makeToolResultEntry("004", "call_2", "read", "code..."),
-    ];
-
-    const { fileActivities } = parseEntries(entries as any);
-    const envActivity = fileActivities.filter((f) => f.path.includes(".env"));
-    const normalActivity = fileActivities.filter((f) => f.path === "src/app.ts");
-
-    assert.equal(envActivity.length, 0, "Should skip .env files");
-    assert.equal(normalActivity.length, 1, "Should keep normal files once");
-  });
-
-  it("handles compactions", () => {
-    const entries = [
-      makeUserEntry("001", "Test"),
-      makeAssistantEntry("002", "Response"),
-      {
-        type: "compaction",
-        id: "003",
-        parentId: "002",
-        timestamp: new Date().toISOString(),
-        summary: "Previous context summarized",
-        firstKeptEntryId: "001",
-        tokensBefore: 5000,
-      },
-    ];
-
-    const { compactions } = parseEntries(entries as any);
-    assert.equal(compactions.length, 1);
-    assert.ok(compactions[0].summary.includes("Previous"));
-  });
-});
-
-describe("turnsToRecords", () => {
-  it("generates turn_summary records", () => {
-    const turns = [
-      {
-        userEntryId: "001",
-        userPrompt: "Fix the authentication bug",
-        assistantEntryIds: ["002"],
-        assistantText: "I found the issue in auth.ts and fixed it.",
-        toolCalls: [
-          {
-            entryId: "003",
-            toolName: "read",
-            args: { path: "src/auth.ts" },
-            resultText: "code...",
-            isError: false,
-          },
-        ],
-        errors: [],
-      },
-    ];
-
-    const records = turnsToRecords(turns, "/home/project", "session-1", "/path/session.jsonl");
-    assert.ok(records.length >= 1);
-    assert.equal(records[0].kind, "turn_summary");
-    assert.ok(records[0].text.includes("Fix the authentication"));
-    assert.ok(records[0].text.includes("auth.ts"));
-  });
-
-  it("generates error_resolution records for errors", () => {
-    const turns = [
-      {
-        userEntryId: "001",
-        userPrompt: "Run deployment",
-        assistantEntryIds: ["002"],
-        assistantText: "Running deploy...",
-        toolCalls: [],
-        errors: [
-          {
-            entryId: "003",
-            toolName: "bash",
-            message: "Permission denied: cannot write to /etc",
-          },
-        ],
-      },
-    ];
-
-    const records = turnsToRecords(turns, "/home/project", "session-1", "/path/session.jsonl");
-    const errorRecords = records.filter((r) => r.kind === "error_resolution");
-    assert.equal(errorRecords.length, 1);
-    assert.ok(errorRecords[0].text.includes("Permission denied"));
-  });
-});

package/test/privacy.test.ts

@@ -1,120 +0,0 @@
-/**
- * Tests for the privacy/redaction module.
- * Run with: node --experimental-sqlite --test test/privacy.test.ts
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { redactSecrets, isSensitivePath, shouldIgnoreFile } from "../src/privacy/index.js";
-
-describe("redactSecrets", () => {
-  it("redacts OpenAI API keys", () => {
-    const input = "My key is sk-proj-abc123def456ghi789jkl012mno345pqr678stu";
-    const result = redactSecrets(input);
-    assert.ok(result.includes("[REDACTED:openai-key]"));
-    assert.ok(!result.includes("sk-proj-"));
-  });
-
-  it("redacts GitHub tokens", () => {
-    const input = "export GITHUB_TOKEN=ghp_abc123def456ghi789jkl012mno345pqr678";
-    const result = redactSecrets(input);
-    assert.ok(result.includes("[REDACTED:github-token]"));
-  });
-
-  it("redacts JWT tokens", () => {
-    const input = "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U";
-    const result = redactSecrets(input);
-    assert.ok(result.includes("[REDACTED:jwt]"));
-  });
-
-  it("redacts passwords in assignments", () => {
-    const input = 'password="superSecret123" and pwd="admin123"';
-    const result = redactSecrets(input);
-    assert.ok(result.includes("[REDACTED:password]"));
-    assert.ok(!result.includes("superSecret123"));
-    assert.ok(!result.includes("admin123"));
-  });
-
-  it("redacts unquoted password, token, and secret assignments", () => {
-    const input = "password=superSecret123 pwd=admin123 TOKEN=abcdef0123456789 SECRET=shhDontKeepMe";
-    const result = redactSecrets(input);
-    assert.ok(result.includes("[REDACTED:password]"));
-    assert.ok(result.includes("[REDACTED:token]"));
-    assert.ok(result.includes("[REDACTED:secret]"));
-    assert.ok(!result.includes("superSecret123"));
-    assert.ok(!result.includes("abcdef0123456789"));
-    assert.ok(!result.includes("shhDontKeepMe"));
-  });
-
-  it("redacts connection strings", () => {
-    const input = "DATABASE_URL=mongodb://user:pass@localhost:27017/db";
-    const result = redactSecrets(input);
-    assert.ok(result.includes("[REDACTED]@"));
-    assert.ok(!result.includes("user:pass@"));
-  });
-
-  it("redacts private keys", () => {
-    const input = `-----BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC...
------END PRIVATE KEY-----`;
-    const result = redactSecrets(input);
-    assert.ok(result.includes("[REDACTED:private-key]"));
-    assert.ok(!result.includes("MIIEvQ"));
-  });
-
-  it("preserves normal text", () => {
-    const input = "Just some normal conversation about code";
-    const result = redactSecrets(input);
-    assert.equal(result, input);
-  });
-});
-
-describe("isSensitivePath", () => {
-  it("flags .env files", () => {
-    assert.ok(isSensitivePath(".env"));
-    assert.ok(isSensitivePath(".env.local"));
-    assert.ok(isSensitivePath("path/to/.env.production"));
-  });
-
-  it("flags key/cert files", () => {
-    assert.ok(isSensitivePath("cert.pem"));
-    assert.ok(isSensitivePath("private.key"));
-    assert.ok(isSensitivePath("path/to/server.crt"));
-  });
-
-  it("flags SSH keys", () => {
-    assert.ok(isSensitivePath("~/.ssh/id_rsa"));
-    assert.ok(isSensitivePath("/home/user/.ssh/id_ed25519"));
-  });
-
-  it("flags AWS credentials", () => {
-    assert.ok(isSensitivePath("~/.aws/credentials"));
-    assert.ok(isSensitivePath("~/.aws/config"));
-  });
-
-  it("flags node_modules", () => {
-    assert.ok(isSensitivePath("node_modules/foo/bar.ts"));
-  });
-
-  it("flags .git directory", () => {
-    assert.ok(isSensitivePath(".git/config"));
-  });
-
-  it("allows normal source files", () => {
-    assert.ok(!isSensitivePath("src/index.ts"));
-    assert.ok(!isSensitivePath("components/Button.tsx"));
-    assert.ok(!isSensitivePath("README.md"));
-  });
-});
-
-describe("shouldIgnoreFile", () => {
-  it("returns true for sensitive files", () => {
-    assert.ok(shouldIgnoreFile(".env"));
-    assert.ok(shouldIgnoreFile("secrets/config.json"));
-  });
-
-  it("returns false for normal files", () => {
-    assert.ok(!shouldIgnoreFile("src/utils.ts"));
-    assert.ok(!shouldIgnoreFile("package.json"));
-  });
-});

package/test/ranking.test.ts

@@ -1,403 +0,0 @@
-/**
- * Tests for the retrieval/ranking module.
- * Run with: NODE_OPTIONS="--experimental-sqlite" tsx --test test/ranking.test.ts
- */
-
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, unlinkSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  buildSearchQuery,
-  rankAndFilter,
-  buildInjectionPacket,
-  formatInjectionForLlm,
-} from "../src/retrieval/index.js";
-import {
-  getDb,
-  closeDb,
-  upsertRecord,
-  getDbPath,
-  softForgetRecord,
-  getRecord,
-  hardDeleteRecord,
-  insertInjection,
-  getLastInjection,
-} from "../src/db/index.js";
-import type { RecordRow } from "../src/db/index.js";
-import type { RecordKind, RecordScope } from "../src/db/schema.js";
-
-// ─── DB cleanup ─────────────────────────────────────────────────────
-
-const testMemoryDir = mkdtempSync(join(tmpdir(), "pi-memory-stone-ranking-"));
-process.env.PI_MEMORY_STONE_DB_PATH = join(testMemoryDir, "memory.db");
-
-function cleanDb() {
-  const dbPath = getDbPath();
-  closeDb();
-  // Small delay to ensure file handles are released
-  const files = [dbPath, dbPath + "-wal", dbPath + "-shm"];
-  for (const f of files) {
-    try { if (existsSync(f)) unlinkSync(f); } catch {}
-  }
-}
-
-// ─── Seed data helper ───────────────────────────────────────────────
-
-function seedTestRecords() {
-  const now = Date.now();
-  const records: Array<{
-    kind: RecordKind;
-    scope: RecordScope;
-    project_id: string | null;
-    text: string;
-    tags?: string;
-    created_at: number;
-  }> = [
-    {
-      kind: "decision",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "Decided to use TypeScript for the frontend. Reasoning: better type safety and tooling support.",
-      tags: "typescript,frontend,decision",
-      created_at: now - 1000,
-    },
-    {
-      kind: "preference",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "User prefers 2-space indentation for all TypeScript files.",
-      tags: "formatting,preference",
-      created_at: now - 2000,
-    },
-    {
-      kind: "error_resolution",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "Tool: bash\nError: Module not found: @earendil-works/pi-coding-agent\nResolution: Run npm install in the extension directory.",
-      tags: "error,resolve",
-      created_at: now - 5000,
-    },
-    {
-      kind: "task",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "TODO: Add unit tests for the authentication module.",
-      tags: "task,todo",
-      created_at: now - 10000,
-    },
-    {
-      kind: "preference",
-      scope: "global",
-      project_id: null,
-      text: "User always wants answers in concise bullet-point format.",
-      tags: "formatting,global",
-      created_at: now - 3000,
-    },
-    {
-      kind: "decision",
-      scope: "project",
-      project_id: "/home/other-project",
-      text: "Decided to use PostgreSQL instead of MySQL for the other project.",
-      tags: "database,decision",
-      created_at: now - 6000,
-    },
-  ];
-
-  for (const r of records) {
-    upsertRecord({
-      kind: r.kind,
-      scope: r.scope,
-      project_id: r.project_id,
-      text: r.text,
-      tags: r.tags,
-    });
-  }
-}
-
-// ─── Tests ──────────────────────────────────────────────────────────
-
-describe("buildSearchQuery", () => {
-  it("uses user prompt text", () => {
-    const query = buildSearchQuery("How should I format TypeScript files?");
-    assert.ok(query.includes("How should I format"));
-    assert.ok(query.includes("TypeScript files"));
-  });
-
-  it("includes recent file basenames", () => {
-    const query = buildSearchQuery("Fix auth bug", [
-      "src/auth/login.ts",
-      "src/auth/signup.ts",
-    ]);
-    assert.ok(query.includes("login.ts"));
-    assert.ok(query.includes("signup.ts"));
-  });
-
-  it("truncates long prompts", () => {
-    const longPrompt = "A".repeat(500);
-    const query = buildSearchQuery(longPrompt);
-    assert.ok(query.length <= 250);
-  });
-});
-
-describe("rankAndFilter", () => {
-  before(() => {
-    cleanDb();
-    seedTestRecords();
-  });
-
-  after(() => {
-    cleanDb();
-    rmSync(testMemoryDir, { recursive: true, force: true });
-  });
-
-  it("boosts same-project records", () => {
-    const db = getDb();
-    const records = db
-      .prepare(
-        `SELECT r.*, 0 as rank FROM records r
-         WHERE r.text LIKE '%TypeScript%' AND r.status = 'active'`,
-      )
-      .all() as unknown as (RecordRow & { rank: number })[];
-
-    const ranked = rankAndFilter(records, "/home/test-project", false);
-
-    const sameProject = ranked.filter(
-      (r) => r.record.project_id === "/home/test-project",
-    );
-    assert.ok(sameProject.length > 0);
-    assert.ok(sameProject.some((r) => r.reasons.includes("same-project")));
-  });
-
-  it("filters out cross-project records when crossProjectEnabled is false", () => {
-    const db = getDb();
-    const records = db
-      .prepare(
-        `SELECT r.*, 0 as rank FROM records r
-         WHERE r.text LIKE '%PostgreSQL%' AND r.status = 'active'`,
-      )
-      .all() as unknown as (RecordRow & { rank: number })[];
-
-    const ranked = rankAndFilter(records, "/home/test-project", false);
-
-    const otherProject = ranked.filter(
-      (r) => r.record.project_id === "/home/other-project",
-    );
-    assert.equal(otherProject.length, 0);
-  });
-
-  it("filters out global-scope records from other projects when cross-project is disabled", () => {
-    upsertRecord({
-      kind: "preference",
-      scope: "global",
-      project_id: "/home/other-project",
-      text: "Other project global preference about bullet lists",
-      tags: "global,other-project",
-    });
-
-    const db = getDb();
-    const records = db
-      .prepare(
-        `SELECT r.*, 0 as rank FROM records r
-         WHERE r.text LIKE '%Other project global preference%'`,
-      )
-      .all() as unknown as (RecordRow & { rank: number })[];
-
-    const ranked = rankAndFilter(records, "/home/test-project", false);
-    assert.equal(ranked.length, 0);
-  });
-
-  it("includes global-scope records from other projects when cross-project", () => {
-    const db = getDb();
-    const records = db
-      .prepare(
-        `SELECT r.*, 0 as rank FROM records r
-         WHERE r.text LIKE '%bullet%' AND r.status = 'active'`,
-      )
-      .all() as unknown as (RecordRow & { rank: number })[];
-
-    const ranked = rankAndFilter(records, "/home/test-project", true);
-
-    const globalRecords = ranked.filter((r) => r.record.scope === "global");
-    assert.ok(globalRecords.length > 0);
-  });
-
-  it("preserves soft-forgotten status on duplicate upsert", () => {
-    const id = upsertRecord({
-      kind: "decision",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "Remember not to resurrect this duplicate memory",
-    });
-
-    softForgetRecord(id);
-    upsertRecord({
-      kind: "decision",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "Remember not to resurrect this duplicate memory",
-    });
-
-    assert.equal(getRecord(id)?.status, "soft_forgotten");
-  });
-
-  it("keeps duplicate text separate across projects", () => {
-    const id1 = upsertRecord({
-      kind: "decision",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "Use the same deployment checklist everywhere",
-    });
-    const id2 = upsertRecord({
-      kind: "decision",
-      scope: "project",
-      project_id: "/home/other-project",
-      text: "Use the same deployment checklist everywhere",
-    });
-
-    assert.notEqual(id1, id2);
-    assert.equal(getRecord(id1)?.project_id, "/home/test-project");
-    assert.equal(getRecord(id2)?.project_id, "/home/other-project");
-  });
-
-  it("redacts secrets at the record storage boundary", () => {
-    const id = upsertRecord({
-      kind: "preference",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "Store password=superSecret123 for later",
-      tags: "token=abcdef0123456789",
-    });
-
-    const record = getRecord(id);
-    assert.ok(record);
-    assert.ok(record.text.includes("[REDACTED:password]"));
-    assert.ok(!record.text.includes("superSecret123"));
-    assert.ok(record.tags?.includes("[REDACTED:token]"));
-    assert.ok(!record.tags?.includes("abcdef0123456789"));
-  });
-
-  it("hard deletion removes injection audit rows that reference the record", () => {
-    const id = upsertRecord({
-      kind: "decision",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "Delete this audit-visible memory",
-    });
-
-    insertInjection({
-      session_id: "session-with-deleted-memory",
-      injected_refs: id,
-      packet: `Memory text for ${id}: Delete this audit-visible memory`,
-    });
-    assert.ok(getLastInjection("session-with-deleted-memory"));
-
-    hardDeleteRecord(id);
-    assert.equal(getLastInjection("session-with-deleted-memory"), undefined);
-  });
-
-  it("filters out non-active records", () => {
-    // Create a soft-forgotten record
-    upsertRecord({
-      kind: "decision",
-      scope: "project",
-      project_id: "/home/test-project",
-      text: "Forgotten decision about architecture",
-      status: "soft_forgotten",
-    });
-
-    const db = getDb();
-    const records = db
-      .prepare(
-        `SELECT r.*, 0 as rank FROM records r
-         WHERE r.text LIKE '%Forgotten decision%'`,
-      )
-      .all() as unknown as (RecordRow & { rank: number })[];
-
-    const ranked = rankAndFilter(records, "/home/test-project", false);
-    assert.equal(ranked.length, 0);
-  });
-});
-
-describe("buildInjectionPacket", () => {
-  it("builds a structured injection packet", () => {
-    const results = [
-      {
-        record: {
-          id: "abc123",
-          kind: "decision" as RecordKind,
-          text: "Decided to use TypeScript",
-          project_id: "/home/test-project",
-          created_at: Date.now() - 1000,
-        } as RecordRow,
-        score: 0.95,
-        reasons: ["same-project"],
-      },
-    ];
-
-    const packet = buildInjectionPacket(results);
-    assert.ok(packet.header.includes("Memory: loaded"));
-    assert.equal(packet.items.length, 1);
-    assert.equal(packet.items[0].ref, "abc123");
-    assert.ok(packet.items[0].text.includes("TypeScript"));
-    assert.ok(packet.footer.includes("memory-forget"));
-  });
-
-  it("adds stale hints for old records", () => {
-    const thirtyDaysAgo = Date.now() - 31 * 24 * 60 * 60 * 1000;
-    const results = [
-      {
-        record: {
-          id: "old123",
-          kind: "decision" as RecordKind,
-          text: "Old decision",
-          project_id: "/home/test-project",
-          created_at: thirtyDaysAgo,
-        } as RecordRow,
-        score: 0.5,
-        reasons: [],
-      },
-    ];
-
-    const packet = buildInjectionPacket(results);
-    assert.ok(packet.items[0].staleHint);
-    assert.ok(packet.items[0].staleHint!.includes("stale"));
-  });
-});
-
-describe("formatInjectionForLlm", () => {
-  it("formats packet for LLM consumption", () => {
-    const packet = {
-      header: "Memory: loaded 2 items",
-      items: [
-        { ref: "abc", kind: "decision", text: "Use TypeScript" },
-        { ref: "def", kind: "preference", text: "2-space indent" },
-      ],
-      footer: "Use /memory-forget to remove",
-      recordCount: 2,
-    };
-
-    const formatted = formatInjectionForLlm(packet, 1000);
-    assert.ok(formatted.includes("Memory: loaded"));
-    assert.ok(formatted.includes("[decision ref=abc]"));
-    assert.ok(formatted.includes("[preference ref=def]"));
-    assert.ok(formatted.includes("/memory-forget"));
-  });
-
-  it("respects token budget", () => {
-    const longText = "x".repeat(5000);
-    const packet = {
-      header: "Header",
-      items: [{ ref: "abc", kind: "decision", text: longText }],
-      footer: "Footer",
-      recordCount: 1,
-    };
-
-    const formatted = formatInjectionForLlm(packet, 10);
-    assert.ok(
-      formatted.length < 200,
-      `Expected <200 chars but got ${formatted.length}`,
-    );
-  });
-});

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "skipLibCheck": true,
-    "noEmit": true,
-    "types": ["node"],
-    "allowImportingTsExtensions": false
-  },
-  "include": ["src/**/*.ts", "test/**/*.ts"]
-}