@malindar/whyline 0.1.0

package/tests/saveMemory.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import Database from "better-sqlite3";
+import { openDb } from "../src/db/connection.js";
+import { runMigrations } from "../src/db/migrations.js";
+import { saveMemory, getMemoryById, getMemoryByCommit, generateMemoryId, buildEmbeddingText } from "../src/memory/saveMemory.js";
+import type { CodingMemory } from "../src/memory/types.js";
+
+function makeTestDb(): Database.Database {
+  const db = openDb(":memory:");
+  runMigrations(db);
+  return db;
+}
+
+function makeMemory(overrides: Partial<CodingMemory> = {}): CodingMemory {
+  const id = generateMemoryId();
+  const base: CodingMemory = {
+    id,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    repoId: "testrepo123",
+    repoPath: "/home/user/my-app",
+    repoName: "my-app",
+    branch: "main",
+    commitSha: "abc1234567890",
+    files: ["src/comments/sync.ts", "src/comments/render.ts"],
+    tags: ["comments", "optimistic-ui"],
+    intent: "Add optimistic comment rendering",
+    summary: "Implemented optimistic rendering",
+    decision: "Render immediately, reconcile after ack",
+    why: "Server wait made UI feel slow",
+    alternativesRejected: ["Server-confirmed only"],
+    risks: ["Duplicate comments during reconnect"],
+    followUps: ["Add dedupe tests"],
+    source: "cli",
+    embeddingText: "Add optimistic comment rendering Implemented optimistic rendering",
+    ...overrides,
+  };
+  return base;
+}
+
+describe("saveMemory", () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = makeTestDb();
+  });
+
+  it("saves a memory to the memories table", () => {
+    const memory = makeMemory();
+    saveMemory(db, memory);
+    const row = db.prepare("SELECT * FROM memories WHERE id = ?").get(memory.id) as { id: string } | undefined;
+    expect(row).toBeDefined();
+    expect(row?.id).toBe(memory.id);
+  });
+
+  it("saves linked files to memory_files", () => {
+    const memory = makeMemory();
+    saveMemory(db, memory);
+    const files = db
+      .prepare<[string], { file_path: string }>(
+        "SELECT file_path FROM memory_files WHERE memory_id = ?"
+      )
+      .all(memory.id)
+      .map((r) => r.file_path);
+    expect(files).toEqual(expect.arrayContaining(memory.files));
+    expect(files.length).toBe(memory.files.length);
+  });
+
+  it("saves linked tags to memory_tags", () => {
+    const memory = makeMemory();
+    saveMemory(db, memory);
+    const tags = db
+      .prepare<[string], { tag: string }>("SELECT tag FROM memory_tags WHERE memory_id = ?")
+      .all(memory.id)
+      .map((r) => r.tag);
+    expect(tags).toEqual(expect.arrayContaining(memory.tags));
+  });
+
+  it("saves alternatives to memory_alternatives", () => {
+    const memory = makeMemory();
+    saveMemory(db, memory);
+    const alts = db
+      .prepare<[string], { value: string }>(
+        "SELECT value FROM memory_alternatives WHERE memory_id = ?"
+      )
+      .all(memory.id)
+      .map((r) => r.value);
+    expect(alts).toEqual(expect.arrayContaining(memory.alternativesRejected));
+  });
+
+  it("saves risks to memory_risks", () => {
+    const memory = makeMemory();
+    saveMemory(db, memory);
+    const risks = db
+      .prepare<[string], { value: string }>(
+        "SELECT value FROM memory_risks WHERE memory_id = ?"
+      )
+      .all(memory.id)
+      .map((r) => r.value);
+    expect(risks).toEqual(expect.arrayContaining(memory.risks));
+  });
+
+  it("saves followUps to memory_followups", () => {
+    const memory = makeMemory();
+    saveMemory(db, memory);
+    const followUps = db
+      .prepare<[string], { value: string }>(
+        "SELECT value FROM memory_followups WHERE memory_id = ?"
+      )
+      .all(memory.id)
+      .map((r) => r.value);
+    expect(followUps).toEqual(expect.arrayContaining(memory.followUps));
+  });
+
+  it("prevents duplicate junction rows on re-insert attempt", () => {
+    const memory = makeMemory();
+    saveMemory(db, memory);
+    // Manually try to insert a duplicate file — should be silently ignored
+    db.prepare("INSERT OR IGNORE INTO memory_files (memory_id, file_path) VALUES (?, ?)").run(
+      memory.id,
+      memory.files[0]
+    );
+    const files = db
+      .prepare<[string], { file_path: string }>(
+        "SELECT file_path FROM memory_files WHERE memory_id = ?"
+      )
+      .all(memory.id);
+    expect(files.length).toBe(memory.files.length);
+  });
+});
+
+describe("getMemoryById", () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = makeTestDb();
+  });
+
+  it("retrieves a memory by ID with all junction data", () => {
+    const memory = makeMemory();
+    saveMemory(db, memory);
+    const retrieved = getMemoryById(db, memory.id);
+    expect(retrieved).not.toBeNull();
+    expect(retrieved?.id).toBe(memory.id);
+    expect(retrieved?.files).toEqual(expect.arrayContaining(memory.files));
+    expect(retrieved?.tags).toEqual(expect.arrayContaining(memory.tags));
+    expect(retrieved?.risks).toEqual(expect.arrayContaining(memory.risks));
+    expect(retrieved?.followUps).toEqual(expect.arrayContaining(memory.followUps));
+  });
+
+  it("returns null for unknown ID", () => {
+    expect(getMemoryById(db, "nonexistent")).toBeNull();
+  });
+});
+
+describe("getMemoryByCommit", () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = makeTestDb();
+  });
+
+  it("retrieves memory by commit SHA", () => {
+    const memory = makeMemory({ commitSha: "deadbeef1234" });
+    saveMemory(db, memory);
+    const retrieved = getMemoryByCommit(db, "deadbeef1234");
+    expect(retrieved?.id).toBe(memory.id);
+  });
+
+  it("returns null for unknown commit", () => {
+    expect(getMemoryByCommit(db, "unknown")).toBeNull();
+  });
+});
+
+describe("generateMemoryId", () => {
+  it("generates IDs with mem_ prefix", () => {
+    expect(generateMemoryId()).toMatch(/^mem_/);
+  });
+
+  it("generates unique IDs", () => {
+    const ids = new Set(Array.from({ length: 100 }, generateMemoryId));
+    expect(ids.size).toBe(100);
+  });
+});
+
+describe("buildEmbeddingText", () => {
+  it("concatenates all content fields", () => {
+    const memory = makeMemory();
+    const text = buildEmbeddingText(memory);
+    expect(text).toContain(memory.intent);
+    expect(text).toContain(memory.decision);
+    expect(text).toContain(memory.why);
+    expect(text).toContain(memory.files[0]);
+    expect(text).toContain(memory.tags[0]);
+  });
+});

package/tests/searchFilters.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { openDb } from "../src/db/connection.js";
+import { runMigrations } from "../src/db/migrations.js";
+import { saveMemory, generateMemoryId } from "../src/memory/saveMemory.js";
+import { searchMemory } from "../src/memory/searchMemory.js";
+import type { CodingMemory } from "../src/memory/types.js";
+import type Database from "better-sqlite3";
+
+function makeTestDb(): Database.Database {
+  const db = openDb(":memory:");
+  runMigrations(db);
+  return db;
+}
+
+function makeMemory(overrides: Partial<CodingMemory> = {}): CodingMemory {
+  return {
+    id: generateMemoryId(),
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    repoId: "repo-abc",
+    repoPath: "/home/user/my-app",
+    repoName: "my-app",
+    branch: "main",
+    commitSha: "abc123",
+    files: ["src/auth/session.ts"],
+    tags: ["auth", "security"],
+    intent: "Add refresh token rotation to prevent replay attacks",
+    summary: "Implemented refresh token rotation",
+    decision: "Rotate tokens on every request",
+    why: "One-time-use tokens prevent replay attacks",
+    alternativesRejected: [],
+    risks: [],
+    followUps: [],
+    source: "cli",
+    embeddingText: "Add refresh token rotation to prevent replay attacks",
+    ...overrides,
+  };
+}
+
+describe("search — tag filtering", () => {
+  let db: Database.Database;
+  beforeEach(() => { db = makeTestDb(); });
+
+  it("returns only memories that have the requested tag", () => {
+    saveMemory(db, makeMemory({ id: generateMemoryId(), tags: ["auth", "security"] }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), tags: ["payments"], intent: "Add payment gateway retry logic for failed transactions", decision: "Retry with exponential backoff", why: "Transient failures should not block checkout permanently" }));
+
+    const results = searchMemory(db, { query: "", tags: ["auth"] });
+    expect(results.length).toBe(1);
+    expect(results[0].memory.tags).toContain("auth");
+  });
+
+  it("returns only memories that have ALL requested tags", () => {
+    saveMemory(db, makeMemory({ id: generateMemoryId(), tags: ["auth", "security"] }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), tags: ["auth"], intent: "Add auth session expiry handling for idle users", decision: "Expire after 30 minutes idle", why: "Reduces attack surface for stolen sessions" }));
+
+    const results = searchMemory(db, { query: "", tags: ["auth", "security"] });
+    expect(results.length).toBe(1);
+    expect(results[0].memory.tags).toContain("security");
+  });
+
+  it("is case-insensitive for tags", () => {
+    saveMemory(db, makeMemory({ tags: ["Auth", "Security"] }));
+    const results = searchMemory(db, { query: "", tags: ["auth"] });
+    expect(results.length).toBe(1);
+  });
+
+  it("returns empty when no memory matches the tag", () => {
+    saveMemory(db, makeMemory({ tags: ["auth"] }));
+    const results = searchMemory(db, { query: "", tags: ["payments"] });
+    expect(results.length).toBe(0);
+  });
+
+  it("works alongside a keyword query", () => {
+    saveMemory(db, makeMemory({ tags: ["auth"], intent: "Add refresh token rotation to prevent replay attacks", decision: "Rotate tokens on every request", why: "One-time-use tokens prevent replay attacks" }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), tags: ["payments"], intent: "Add retry logic for payment gateway token failures in checkout", decision: "Retry three times with backoff", why: "Token failures are transient and retryable" }));
+
+    const results = searchMemory(db, { query: "token", tags: ["auth"] });
+    expect(results.length).toBe(1);
+    expect(results[0].memory.tags).toContain("auth");
+  });
+});
+
+describe("search — date filters", () => {
+  let db: Database.Database;
+  beforeEach(() => { db = makeTestDb(); });
+
+  it("--since filters out memories before the date", () => {
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2024-01-15T00:00:00.000Z" }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2024-06-15T00:00:00.000Z" }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2025-01-15T00:00:00.000Z" }));
+
+    const results = searchMemory(db, { query: "", since: "2024-06-01" });
+    expect(results.length).toBe(2);
+    for (const r of results) {
+      expect(new Date(r.memory.createdAt).getTime()).toBeGreaterThanOrEqual(new Date("2024-06-01").getTime());
+    }
+  });
+
+  it("--before filters out memories after the date", () => {
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2024-01-15T00:00:00.000Z" }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2024-06-15T00:00:00.000Z" }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2025-01-15T00:00:00.000Z" }));
+
+    const results = searchMemory(db, { query: "", before: "2024-12-31" });
+    expect(results.length).toBe(2);
+    for (const r of results) {
+      expect(new Date(r.memory.createdAt).getTime()).toBeLessThanOrEqual(new Date("2024-12-31").getTime());
+    }
+  });
+
+  it("--since and --before can be combined", () => {
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2024-01-15T00:00:00.000Z" }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2024-06-15T00:00:00.000Z" }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2025-01-15T00:00:00.000Z" }));
+
+    const results = searchMemory(db, { query: "", since: "2024-03-01", before: "2024-12-31" });
+    expect(results.length).toBe(1);
+    expect(results[0].memory.createdAt).toBe("2024-06-15T00:00:00.000Z");
+  });
+
+  it("returns all when no date filters given", () => {
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2024-01-15T00:00:00.000Z" }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2025-01-15T00:00:00.000Z" }));
+    const results = searchMemory(db, { query: "" });
+    expect(results.length).toBe(2);
+  });
+
+  it("date and tag filters can be combined", () => {
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2024-06-15T00:00:00.000Z", tags: ["auth"] }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2024-06-15T00:00:00.000Z", tags: ["payments"], intent: "Add payment gateway retry logic for failed transactions", decision: "Retry with exponential backoff", why: "Transient failures should not block checkout permanently" }));
+    saveMemory(db, makeMemory({ id: generateMemoryId(), createdAt: "2023-01-01T00:00:00.000Z", tags: ["auth"], intent: "Implement auth session expiry for security compliance", decision: "Expire sessions after 30 minutes idle", why: "Reduces attack surface for stolen session tokens" }));
+
+    const results = searchMemory(db, { query: "", tags: ["auth"], since: "2024-01-01" });
+    expect(results.length).toBe(1);
+    expect(results[0].memory.tags).toContain("auth");
+    expect(results[0].memory.createdAt).toBe("2024-06-15T00:00:00.000Z");
+  });
+});

package/tests/searchMemory.test.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { openDb } from "../src/db/connection.js";
+import { runMigrations } from "../src/db/migrations.js";
+import { saveMemory, generateMemoryId } from "../src/memory/saveMemory.js";
+import { searchMemory, scoreMemory, explainRelevance } from "../src/memory/searchMemory.js";
+import type { CodingMemory, ScoreBreakdown } from "../src/memory/types.js";
+import Database from "better-sqlite3";
+
+function makeTestDb(): Database.Database {
+  const db = openDb(":memory:");
+  runMigrations(db);
+  return db;
+}
+
+function makeMemory(overrides: Partial<CodingMemory> = {}): CodingMemory {
+  return {
+    id: generateMemoryId(),
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    repoId: "default-repo",
+    repoPath: "/home/user/default-app",
+    repoName: "default-app",
+    branch: "main",
+    commitSha: "abc123",
+    files: ["src/app.ts"],
+    tags: ["feature"],
+    intent: "Default intent",
+    summary: "Default summary",
+    decision: "Default decision",
+    why: "Default rationale",
+    alternativesRejected: [],
+    risks: [],
+    followUps: [],
+    source: "cli",
+    embeddingText: "Default intent Default summary Default decision Default rationale",
+    ...overrides,
+  };
+}
+
+describe("scoreMemory", () => {
+  it("gives +10 for same repo", () => {
+    const memory = makeMemory({ repoId: "my-repo" });
+    const score = scoreMemory(memory, "query", "my-repo", []);
+    expect(score.sameRepo).toBe(10);
+  });
+
+  it("gives 0 for different repo", () => {
+    const memory = makeMemory({ repoId: "other-repo" });
+    const score = scoreMemory(memory, "query", "my-repo", []);
+    expect(score.sameRepo).toBe(0);
+  });
+
+  it("gives +8 for file overlap", () => {
+    const memory = makeMemory({ files: ["src/auth.ts"] });
+    const score = scoreMemory(memory, "query", null, ["src/auth.ts"]);
+    expect(score.fileOverlap).toBe(8);
+  });
+
+  it("gives +5 for tag match", () => {
+    const memory = makeMemory({ tags: ["optimistic-ui"] });
+    const score = scoreMemory(memory, "optimistic", null, []);
+    expect(score.tagMatch).toBe(5);
+  });
+
+  it("gives +4 for keyword in decision", () => {
+    const memory = makeMemory({ decision: "Use optimistic rendering" });
+    const score = scoreMemory(memory, "optimistic", null, []);
+    expect(score.decisionMatch).toBe(4);
+  });
+
+  it("gives +3 for keyword in why", () => {
+    const memory = makeMemory({ why: "Server was too slow" });
+    const score = scoreMemory(memory, "slow", null, []);
+    expect(score.whyMatch).toBe(3);
+  });
+
+  it("gives +2 for keyword in summary", () => {
+    const memory = makeMemory({ summary: "Implemented caching layer" });
+    const score = scoreMemory(memory, "caching", null, []);
+    expect(score.summaryMatch).toBe(2);
+  });
+
+  it("gives +2 for keyword in file path", () => {
+    const memory = makeMemory({ files: ["src/comments/sync.ts"] });
+    const score = scoreMemory(memory, "comments", null, []);
+    expect(score.filePathMatch).toBe(2);
+  });
+
+  it("gives +1 recency for recent memory", () => {
+    const memory = makeMemory({ createdAt: new Date().toISOString() });
+    const score = scoreMemory(memory, "query", null, []);
+    expect(score.recency).toBe(1);
+  });
+
+  it("gives 0 recency for old memory", () => {
+    const oldDate = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000).toISOString();
+    const memory = makeMemory({ createdAt: oldDate });
+    const score = scoreMemory(memory, "query", null, []);
+    expect(score.recency).toBe(0);
+  });
+
+  it("computes total as sum of all components", () => {
+    const memory = makeMemory({
+      repoId: "my-repo",
+      tags: ["comments"],
+      decision: "Use optimistic rendering",
+      files: ["src/comments/sync.ts"],
+      createdAt: new Date().toISOString(),
+    });
+    const score = scoreMemory(memory, "comments optimistic", "my-repo", []);
+    expect(score.total).toBe(
+      score.sameRepo +
+        score.fileOverlap +
+        score.tagMatch +
+        score.decisionMatch +
+        score.whyMatch +
+        score.summaryMatch +
+        score.filePathMatch +
+        score.recency
+    );
+  });
+});
+
+describe("explainRelevance", () => {
+  it("returns non-empty string for any non-zero score", () => {
+    const score: ScoreBreakdown = {
+      total: 10,
+      sameRepo: 10,
+      fileOverlap: 0,
+      tagMatch: 0,
+      decisionMatch: 0,
+      whyMatch: 0,
+      summaryMatch: 0,
+      filePathMatch: 0,
+      recency: 0,
+    };
+    expect(explainRelevance(score)).toContain("same repo");
+  });
+
+  it("returns 'No specific match factors' for zero score", () => {
+    const score: ScoreBreakdown = {
+      total: 0,
+      sameRepo: 0,
+      fileOverlap: 0,
+      tagMatch: 0,
+      decisionMatch: 0,
+      whyMatch: 0,
+      summaryMatch: 0,
+      filePathMatch: 0,
+      recency: 0,
+    };
+    expect(explainRelevance(score)).toBe("No specific match factors");
+  });
+
+  it("includes all non-zero factors in the explanation", () => {
+    const score: ScoreBreakdown = {
+      total: 15,
+      sameRepo: 10,
+      fileOverlap: 0,
+      tagMatch: 5,
+      decisionMatch: 0,
+      whyMatch: 0,
+      summaryMatch: 0,
+      filePathMatch: 0,
+      recency: 0,
+    };
+    const reason = explainRelevance(score);
+    expect(reason).toContain("same repo");
+    expect(reason).toContain("tag match");
+  });
+});
+
+describe("searchMemory", () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = makeTestDb();
+    // Insert 4 memories for testing
+    saveMemory(
+      db,
+      makeMemory({
+        repoId: "my-repo",
+        tags: ["optimistic-ui"],
+        decision: "Use optimistic rendering for comments",
+        why: "Server wait was too slow",
+        files: ["src/comments/sync.ts"],
+        commitSha: "commit1",
+      })
+    );
+    saveMemory(
+      db,
+      makeMemory({
+        repoId: "my-repo",
+        tags: ["auth"],
+        decision: "Use JWT tokens for auth",
+        why: "Simple and stateless",
+        files: ["src/auth/session.ts"],
+        commitSha: "commit2",
+      })
+    );
+    saveMemory(
+      db,
+      makeMemory({
+        repoId: "other-repo",
+        tags: ["caching"],
+        decision: "Redis cache for hot data",
+        why: "DB was bottleneck",
+        files: ["src/cache.ts"],
+        commitSha: "commit3",
+      })
+    );
+    saveMemory(
+      db,
+      makeMemory({
+        repoId: "my-repo",
+        tags: ["checkout"],
+        decision: "Validate cart before checkout",
+        why: "Prevent invalid orders",
+        files: ["src/checkout.ts"],
+        commitSha: "commit4",
+      })
+    );
+  });
+
+  it("returns results matching the query keyword", () => {
+    const results = searchMemory(db, { query: "optimistic", repoId: "my-repo" });
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].memory.tags).toContain("optimistic-ui");
+  });
+
+  it("ranks same-repo memories higher than cross-repo memories", () => {
+    const results = searchMemory(db, { query: "cache", repoId: "my-repo" });
+    const repoIds = results.map((r) => r.memory.repoId);
+    if (repoIds.includes("my-repo") && repoIds.includes("other-repo")) {
+      const myRepoIdx = repoIds.indexOf("my-repo");
+      const otherRepoIdx = repoIds.indexOf("other-repo");
+      expect(myRepoIdx).toBeLessThan(otherRepoIdx);
+    }
+  });
+
+  it("respects --limit", () => {
+    const results = searchMemory(db, { query: "", repoId: "my-repo", limit: 2 });
+    expect(results.length).toBeLessThanOrEqual(2);
+  });
+
+  it("returns empty array when no memories match query", () => {
+    const results = searchMemory(db, { query: "xyznonexistentterm", repoId: "my-repo" });
+    expect(results.length).toBe(0);
+  });
+
+  it("falls back to repoPath search when repoId yields no results", () => {
+    const results = searchMemory(db, {
+      query: "optimistic",
+      repoId: "unknown-repo-id",
+      repoPath: "/home/user/default-app",
+    });
+    expect(results.length).toBeGreaterThanOrEqual(0);
+  });
+
+  it("includes relevanceReason in each result", () => {
+    const results = searchMemory(db, { query: "optimistic", repoId: "my-repo" });
+    for (const result of results) {
+      expect(result.relevanceReason).toBeTruthy();
+    }
+  });
+
+  it("results are sorted by score descending", () => {
+    const results = searchMemory(db, { query: "optimistic comments", repoId: "my-repo" });
+    for (let i = 1; i < results.length; i++) {
+      expect(results[i - 1].score.total).toBeGreaterThanOrEqual(results[i].score.total);
+    }
+  });
+});

package/tests/stale.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import { isStale, STALE_THRESHOLD_DAYS } from "../src/memory/searchMemory.js";
+import type { CodingMemory } from "../src/memory/types.js";
+
+function makeMemory(daysAgo: number): CodingMemory {
+  const createdAt = new Date(Date.now() - daysAgo * 24 * 60 * 60 * 1000).toISOString();
+  return {
+    id: "mem_test",
+    createdAt,
+    updatedAt: createdAt,
+    repoId: "repo1",
+    files: [],
+    tags: [],
+    intent: "test",
+    summary: "test",
+    decision: "test",
+    why: "test",
+    alternativesRejected: [],
+    risks: [],
+    followUps: [],
+    source: "cli",
+    embeddingText: "",
+  };
+}
+
+describe("isStale", () => {
+  it("returns false for a memory created today", () => {
+    expect(isStale(makeMemory(0))).toBe(false);
+  });
+
+  it("returns false for a memory 89 days old", () => {
+    expect(isStale(makeMemory(89))).toBe(false);
+  });
+
+  it("returns true for a memory exactly at threshold", () => {
+    expect(isStale(makeMemory(STALE_THRESHOLD_DAYS + 1))).toBe(true);
+  });
+
+  it("returns true for a memory 180 days old", () => {
+    expect(isStale(makeMemory(180))).toBe(true);
+  });
+
+  it("respects a custom threshold", () => {
+    expect(isStale(makeMemory(10), 7)).toBe(true);
+    expect(isStale(makeMemory(5), 7)).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+  },
+});