@malindar/whyline 0.1.0

package/tests/exportImport.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { openDb } from "../src/db/connection.js";
+import { runMigrations } from "../src/db/migrations.js";
+import { saveMemory, generateMemoryId, getAllMemories, getMemoryById } from "../src/memory/saveMemory.js";
+import { runExport } from "../src/commands/export.js";
+import { runImport } from "../src/commands/import.js";
+import type { CodingMemory } from "../src/memory/types.js";
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "whyline-exportimport-"));
+const dbPath = path.join(tmpDir, "memory.db");
+
+vi.mock("../src/config.js", () => ({
+  isInitialized: () => true,
+  resolveConfig: () => ({ storage: { dbPath } }),
+}));
+
+import { vi } from "vitest";
+
+type ExportEnvelope = { schemaVersion: number; memories: CodingMemory[] };
+
+function readExport(file: string): ExportEnvelope {
+  return JSON.parse(fs.readFileSync(file, "utf-8")) as ExportEnvelope;
+}
+
+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"],
+    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: ["Use long-lived tokens"],
+    risks: ["Requires client to handle new token on every response"],
+    followUps: ["Monitor token churn rate"],
+    source: "cli",
+    embeddingText: "Add refresh token rotation to prevent replay attacks",
+    ...overrides,
+  };
+}
+
+describe("export", () => {
+  let outFile: string;
+
+  beforeEach(() => {
+    if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+    const setupDb = openDb(dbPath);
+    runMigrations(setupDb);
+    setupDb.close();
+    outFile = path.join(tmpDir, `export-${Date.now()}.json`);
+  });
+
+  it("exports JSON with schemaVersion envelope", async () => {
+    const realDb = openDb(dbPath);
+    saveMemory(realDb, makeMemory({ id: "mem_a" }));
+    saveMemory(realDb, makeMemory({ id: "mem_b", repoId: "repo-xyz" }));
+    realDb.close();
+
+    await runExport({ format: "json", output: outFile, repo: false, tag: [], since: undefined, before: undefined });
+
+    const envelope = readExport(outFile);
+    expect(envelope.schemaVersion).toBe(1);
+    expect(envelope.memories.length).toBe(2);
+    const ids = envelope.memories.map((m) => m.id);
+    expect(ids).toContain("mem_a");
+    expect(ids).toContain("mem_b");
+  });
+
+  it("exports as markdown with --format md", async () => {
+    const realDb = openDb(dbPath);
+    saveMemory(realDb, makeMemory({ id: "mem_md" }));
+    realDb.close();
+
+    const mdOut = path.join(tmpDir, "export.md");
+    await runExport({ format: "md", output: mdOut, repo: false, tag: [], since: undefined, before: undefined });
+
+    const text = fs.readFileSync(mdOut, "utf-8");
+    expect(text).toContain("# mem_md");
+    expect(text).toContain("Intent:");
+    expect(text).toContain("Decision:");
+  });
+
+  it("--since filters out old memories", async () => {
+    const realDb = openDb(dbPath);
+    saveMemory(realDb, makeMemory({ id: "mem_old", createdAt: "2024-01-15T00:00:00.000Z" }));
+    saveMemory(realDb, makeMemory({ id: "mem_new", createdAt: "2025-06-15T00:00:00.000Z" }));
+    realDb.close();
+
+    await runExport({ format: "json", output: outFile, repo: false, tag: [], since: "2025-01-01", before: undefined });
+
+    const { memories } = readExport(outFile);
+    expect(memories.length).toBe(1);
+    expect(memories[0].id).toBe("mem_new");
+  });
+
+  it("--before filters out new memories", async () => {
+    const realDb = openDb(dbPath);
+    saveMemory(realDb, makeMemory({ id: "mem_old2", createdAt: "2024-01-15T00:00:00.000Z" }));
+    saveMemory(realDb, makeMemory({ id: "mem_new2", createdAt: "2025-06-15T00:00:00.000Z" }));
+    realDb.close();
+
+    await runExport({ format: "json", output: outFile, repo: false, tag: [], since: undefined, before: "2024-12-31" });
+
+    const { memories } = readExport(outFile);
+    expect(memories.length).toBe(1);
+    expect(memories[0].id).toBe("mem_old2");
+  });
+
+  it("--tag filters by tag", async () => {
+    const realDb = openDb(dbPath);
+    saveMemory(realDb, makeMemory({ id: "mem_auth", tags: ["auth"] }));
+    saveMemory(realDb, makeMemory({ id: "mem_pay", tags: ["payments"], intent: "Add payment retry logic for failed gateway calls", decision: "Retry with backoff", why: "Transient failures should not block checkout" }));
+    realDb.close();
+
+    await runExport({ format: "json", output: outFile, repo: false, tag: ["auth"], since: undefined, before: undefined });
+
+    const { memories } = readExport(outFile);
+    expect(memories.length).toBe(1);
+    expect(memories[0].id).toBe("mem_auth");
+  });
+
+  it("exports zero memories when no match", async () => {
+    await runExport({ format: "json", output: outFile, repo: false, tag: ["nope"], since: undefined, before: undefined });
+    const { schemaVersion, memories } = readExport(outFile);
+    expect(schemaVersion).toBe(1);
+    expect(memories.length).toBe(0);
+  });
+});
+
+describe("import", () => {
+  let importFile: string;
+
+  beforeEach(() => {
+    if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+    const setupDb = openDb(dbPath);
+    runMigrations(setupDb);
+    setupDb.close();
+    importFile = path.join(tmpDir, `import-${Date.now()}.json`);
+  });
+
+  it("imports from v1 envelope format", async () => {
+    const envelope = { schemaVersion: 1, memories: [makeMemory({ id: "mem_imp1" }), makeMemory({ id: "mem_imp2" })] };
+    fs.writeFileSync(importFile, JSON.stringify(envelope));
+
+    await runImport(importFile);
+
+    const db = openDb(dbPath);
+    const all = getAllMemories(db);
+    db.close();
+    expect(all.length).toBe(2);
+  });
+
+  it("imports from legacy bare array (backward compat)", async () => {
+    const memories = [makeMemory({ id: "mem_legacy1" }), makeMemory({ id: "mem_legacy2" })];
+    fs.writeFileSync(importFile, JSON.stringify(memories));
+
+    await runImport(importFile);
+
+    const db = openDb(dbPath);
+    const all = getAllMemories(db);
+    db.close();
+    expect(all.length).toBe(2);
+  });
+
+  it("skips memories that already exist", async () => {
+    const memory = makeMemory({ id: "mem_dup" });
+    const realDb = openDb(dbPath);
+    saveMemory(realDb, memory);
+    realDb.close();
+
+    fs.writeFileSync(importFile, JSON.stringify({ schemaVersion: 1, memories: [memory] }));
+    await runImport(importFile);
+
+    const db = openDb(dbPath);
+    const all = getAllMemories(db);
+    db.close();
+    expect(all.length).toBe(1);
+  });
+
+  it("skips invalid entries and imports valid ones", async () => {
+    const valid = makeMemory({ id: "mem_valid" });
+    const invalid = { id: "bad", notAMemory: true };
+    fs.writeFileSync(importFile, JSON.stringify({ schemaVersion: 1, memories: [valid, invalid] }));
+
+    await runImport(importFile);
+
+    const db = openDb(dbPath);
+    const m = getMemoryById(db, "mem_valid");
+    db.close();
+    expect(m).not.toBeNull();
+  });
+
+  it("redacts secrets on import", async () => {
+    const memory = makeMemory({
+      id: "mem_secret",
+      intent: "Add auth using token ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef1234",
+    });
+    fs.writeFileSync(importFile, JSON.stringify({ schemaVersion: 1, memories: [memory] }));
+
+    await runImport(importFile);
+
+    const db = openDb(dbPath);
+    const m = getMemoryById(db, "mem_secret");
+    db.close();
+    expect(m?.intent).toContain("[REDACTED_SECRET]");
+    expect(m?.intent).not.toContain("ghp_");
+  });
+
+  it("rejects non-JSON files", async () => {
+    fs.writeFileSync(importFile, "# Not JSON\n## Intent:\nSomething");
+    await expect(runImport(importFile)).rejects.toThrow();
+  });
+
+  it("round-trips: export then import", async () => {
+    const realDb = openDb(dbPath);
+    saveMemory(realDb, makeMemory({ id: "mem_rt1" }));
+    saveMemory(realDb, makeMemory({ id: "mem_rt2", repoId: "repo-xyz" }));
+    realDb.close();
+
+    await runExport({ format: "json", output: importFile, repo: false, tag: [], since: undefined, before: undefined });
+
+    fs.unlinkSync(dbPath);
+    const freshDb = openDb(dbPath);
+    runMigrations(freshDb);
+    freshDb.close();
+
+    await runImport(importFile);
+
+    const db = openDb(dbPath);
+    const all = getAllMemories(db);
+    db.close();
+    expect(all.length).toBe(2);
+    const ids = all.map((m) => m.id);
+    expect(ids).toContain("mem_rt1");
+    expect(ids).toContain("mem_rt2");
+  });
+});

package/tests/fileRename.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { openDb } from "../src/db/connection.js";
+import { runMigrations } from "../src/db/migrations.js";
+import { saveMemory, generateMemoryId, getMemoriesByFile } from "../src/memory/saveMemory.js";
+import type { CodingMemory } from "../src/memory/types.js";
+import type Database from "better-sqlite3";
+
+vi.mock("child_process", () => ({
+  execSync: vi.fn(),
+}));
+
+import { execSync } from "child_process";
+const mockExecSync = vi.mocked(execSync);
+
+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"],
+    intent: "Add refresh token rotation to prevent replay attacks",
+    summary: "Implemented refresh token rotation on every use",
+    decision: "Rotate on every use",
+    why: "One-time-use tokens prevent replay attacks",
+    alternativesRejected: [],
+    risks: [],
+    followUps: [],
+    source: "cli",
+    embeddingText: "Add refresh token rotation",
+    ...overrides,
+  };
+}
+
+describe("getChangedFilesForCommit — rename detection", () => {
+  beforeEach(() => { mockExecSync.mockReset(); });
+
+  it("includes both old and new paths for renamed files", async () => {
+    mockExecSync.mockReturnValue(
+      "R100\tsrc/auth/session.ts\tsrc/authentication/session.ts\n" as unknown as Buffer
+    );
+    const { getChangedFilesForCommit } = await import("../src/git/diff.js");
+    const files = getChangedFilesForCommit("/repo", "abc123");
+    expect(files).toContain("src/auth/session.ts");
+    expect(files).toContain("src/authentication/session.ts");
+  });
+
+  it("includes both old and new paths for copied files", async () => {
+    mockExecSync.mockReturnValue(
+      "C080\tsrc/utils/helper.ts\tsrc/shared/helper.ts\n" as unknown as Buffer
+    );
+    const { getChangedFilesForCommit } = await import("../src/git/diff.js");
+    const files = getChangedFilesForCommit("/repo", "abc123");
+    expect(files).toContain("src/utils/helper.ts");
+    expect(files).toContain("src/shared/helper.ts");
+  });
+
+  it("handles regular modified files normally", async () => {
+    mockExecSync.mockReturnValue(
+      "M\tsrc/auth/login.ts\n" as unknown as Buffer
+    );
+    const { getChangedFilesForCommit } = await import("../src/git/diff.js");
+    const files = getChangedFilesForCommit("/repo", "abc123");
+    expect(files).toEqual(["src/auth/login.ts"]);
+  });
+
+  it("deduplicates paths when same file appears multiple times", async () => {
+    mockExecSync.mockReturnValue(
+      "M\tsrc/auth/session.ts\nR100\tsrc/auth/session.ts\tsrc/authentication/session.ts\n" as unknown as Buffer
+    );
+    const { getChangedFilesForCommit } = await import("../src/git/diff.js");
+    const files = getChangedFilesForCommit("/repo", "abc123");
+    const unique = new Set(files);
+    expect(unique.size).toBe(files.length);
+  });
+});
+
+describe("getFileRenameHistory", () => {
+  beforeEach(() => { mockExecSync.mockReset(); });
+
+  it("returns current path and historical paths", async () => {
+    mockExecSync.mockReturnValue(
+      "src/auth/session.ts\n\nsrc/authentication/session.ts\n" as unknown as Buffer
+    );
+    const { getFileRenameHistory } = await import("../src/git/diff.js");
+    const history = getFileRenameHistory("/repo", "src/authentication/session.ts");
+    expect(history).toContain("src/authentication/session.ts");
+    expect(history).toContain("src/auth/session.ts");
+  });
+
+  it("always includes the requested file even if git returns nothing", async () => {
+    mockExecSync.mockImplementation(() => { throw new Error("git error"); });
+    const { getFileRenameHistory } = await import("../src/git/diff.js");
+    const history = getFileRenameHistory("/repo", "src/auth/session.ts");
+    expect(history).toEqual(["src/auth/session.ts"]);
+  });
+
+  it("deduplicates paths", async () => {
+    mockExecSync.mockReturnValue(
+      "src/auth/session.ts\nsrc/auth/session.ts\n" as unknown as Buffer
+    );
+    const { getFileRenameHistory } = await import("../src/git/diff.js");
+    const history = getFileRenameHistory("/repo", "src/auth/session.ts");
+    const unique = new Set(history);
+    expect(unique.size).toBe(history.length);
+  });
+});
+
+describe("getMemoriesByFile — multiple paths", () => {
+  let db: Database.Database;
+
+  beforeEach(() => { db = makeTestDb(); });
+
+  it("finds memory by old path after rename", () => {
+    const m = makeMemory({ files: ["src/auth/session.ts"] });
+    saveMemory(db, m);
+    // Search with both old and new path (simulating rename history lookup)
+    const results = getMemoriesByFile(db, "repo-abc", ["src/authentication/session.ts", "src/auth/session.ts"], 10);
+    expect(results.length).toBe(1);
+    expect(results[0].id).toBe(m.id);
+  });
+
+  it("finds memory by new path stored at save time", () => {
+    const m = makeMemory({ files: ["src/authentication/session.ts"] });
+    saveMemory(db, m);
+    const results = getMemoriesByFile(db, "repo-abc", ["src/authentication/session.ts", "src/auth/session.ts"], 10);
+    expect(results.length).toBe(1);
+    expect(results[0].id).toBe(m.id);
+  });
+
+  it("deduplicates results when memory matches multiple paths in the list", () => {
+    // Memory stored with both old and new path (as happens at commit time)
+    const m = makeMemory({ files: ["src/auth/session.ts", "src/authentication/session.ts"] });
+    saveMemory(db, m);
+    const results = getMemoriesByFile(db, "repo-abc", ["src/auth/session.ts", "src/authentication/session.ts"], 10);
+    expect(results.length).toBe(1);
+  });
+
+  it("still works with a single path string", () => {
+    const m = makeMemory({ files: ["src/auth/session.ts"] });
+    saveMemory(db, m);
+    const results = getMemoriesByFile(db, "repo-abc", "src/auth/session.ts", 10);
+    expect(results.length).toBe(1);
+  });
+});

package/tests/gitHelpers.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { normalizeRemoteUrl, getRepoId, getRepoName } from "../src/git/repoId.js";
+
+// Mock child_process for getRepoId/getRepoName tests that use execSync
+vi.mock("child_process", () => ({
+  execSync: vi.fn(),
+}));
+
+import { execSync } from "child_process";
+const mockExecSync = vi.mocked(execSync);
+
+describe("normalizeRemoteUrl", () => {
+  it("strips .git suffix", () => {
+    expect(normalizeRemoteUrl("https://github.com/user/repo.git")).toBe(
+      "https://github.com/user/repo"
+    );
+  });
+
+  it("converts git@ SSH URL to https", () => {
+    expect(normalizeRemoteUrl("git@github.com:user/repo.git")).toBe(
+      "https://github.com/user/repo"
+    );
+  });
+
+  it("lowercases the URL", () => {
+    expect(normalizeRemoteUrl("https://GitHub.com/User/Repo")).toBe(
+      "https://github.com/user/repo"
+    );
+  });
+
+  it("handles URLs without .git suffix", () => {
+    expect(normalizeRemoteUrl("https://github.com/user/repo")).toBe(
+      "https://github.com/user/repo"
+    );
+  });
+});
+
+describe("getRepoId", () => {
+  beforeEach(() => {
+    mockExecSync.mockReset();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns a 32-char hex string when remote exists", () => {
+    mockExecSync.mockReturnValue("git@github.com:user/repo.git\n" as unknown as Buffer);
+    const id = getRepoId("/some/path");
+    expect(id).toMatch(/^[0-9a-f]{32}$/);
+  });
+
+  it("produces the same ID for the same remote URL regardless of path", () => {
+    mockExecSync.mockReturnValue("git@github.com:user/repo.git\n" as unknown as Buffer);
+    const id1 = getRepoId("/path/one");
+    const id2 = getRepoId("/path/two");
+    expect(id1).toBe(id2);
+  });
+
+  it("falls back to path hash when execSync throws (no remote)", () => {
+    mockExecSync.mockImplementation(() => {
+      throw new Error("no remote");
+    });
+    const id = getRepoId("/some/repo/path");
+    expect(id).toMatch(/^[0-9a-f]{32}$/);
+  });
+
+  it("produces different IDs for different repos", () => {
+    mockExecSync
+      .mockReturnValueOnce("git@github.com:user/repo-a.git\n" as unknown as Buffer)
+      .mockReturnValueOnce("git@github.com:user/repo-b.git\n" as unknown as Buffer);
+    const id1 = getRepoId("/path");
+    const id2 = getRepoId("/path");
+    expect(id1).not.toBe(id2);
+  });
+});
+
+describe("getRepoName", () => {
+  beforeEach(() => {
+    mockExecSync.mockReset();
+  });
+
+  it("extracts repo name from remote URL", () => {
+    mockExecSync.mockReturnValue("git@github.com:user/my-project.git\n" as unknown as Buffer);
+    expect(getRepoName("/some/path")).toBe("my-project");
+  });
+
+  it("falls back to directory name when no remote", () => {
+    mockExecSync.mockImplementation(() => {
+      throw new Error("no remote");
+    });
+    expect(getRepoName("/home/user/my-app")).toBe("my-app");
+  });
+});

package/tests/init.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { runInit } from "../src/commands/init.js";
+import { openDb } from "../src/db/connection.js";
+
+function makeTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "whyline-test-"));
+}
+
+describe("init command", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTempDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("creates the data directory", () => {
+    const dataDir = path.join(tmpDir, "data");
+    runInit({ dataDir });
+    expect(fs.existsSync(dataDir)).toBe(true);
+  });
+
+  it("creates config.json with correct structure", () => {
+    const dataDir = path.join(tmpDir, "data");
+    runInit({ dataDir });
+    const configPath = path.join(dataDir, "config.json");
+    expect(fs.existsSync(configPath)).toBe(true);
+    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    expect(config.version).toBe(1);
+    expect(config.storage.dbPath).toContain("memory.db");
+  });
+
+  it("creates memory.db", () => {
+    const dataDir = path.join(tmpDir, "data");
+    runInit({ dataDir });
+    expect(fs.existsSync(path.join(dataDir, "memory.db"))).toBe(true);
+  });
+
+  it("creates a valid SQLite database with all tables", () => {
+    const dataDir = path.join(tmpDir, "data");
+    runInit({ dataDir });
+    const dbPath = path.join(dataDir, "memory.db");
+    const db = openDb(dbPath);
+
+    const tables = db
+      .prepare<[], { name: string }>(
+        "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
+      )
+      .all()
+      .map((r) => r.name);
+
+    db.close();
+
+    expect(tables).toContain("memories");
+    expect(tables).toContain("memory_files");
+    expect(tables).toContain("memory_tags");
+    expect(tables).toContain("memory_alternatives");
+    expect(tables).toContain("memory_risks");
+    expect(tables).toContain("memory_followups");
+    expect(tables).toContain("migrations");
+  });
+
+  it("records migration version in migrations table", () => {
+    const dataDir = path.join(tmpDir, "data");
+    runInit({ dataDir });
+    const db = openDb(path.join(dataDir, "memory.db"));
+    const rows = db
+      .prepare<[], { version: number }>("SELECT version FROM migrations")
+      .all();
+    db.close();
+    expect(rows.map((r) => r.version)).toContain(1);
+  });
+
+  it("is idempotent — second init does not throw or duplicate migrations", () => {
+    const dataDir = path.join(tmpDir, "data");
+    runInit({ dataDir });
+    expect(() => runInit({ dataDir })).not.toThrow();
+
+    const db = openDb(path.join(dataDir, "memory.db"));
+    const rows = db
+      .prepare<[], { version: number }>("SELECT version FROM migrations")
+      .all();
+    db.close();
+    const versions = rows.map((r) => r.version);
+    expect(versions.filter((v) => v === 1).length).toBe(1);
+  });
+});