akm-cli 0.7.0 → 0.7.2

package/dist/tests/core/write-source.test.js

@@ -1,366 +0,0 @@
-/**
- * Tests for src/core/write-source.ts — the single dispatch point for writes.
- *
- * Covers the locked v1 contract from spec §2.6 / §2.7 / §5.4 / §10 step 5:
- *
- *   - writable refusal (default-resolution + explicit `writable: false`)
- *   - plain filesystem write
- *   - git commit on success
- *   - git commit + push when `pushOnCommit` is set
- *   - git delete (commits the deletion)
- *   - rejection of `writable: true` on website / npm at config load
- *   - rejection of unsupported `kind` reaching the helper
- *   - resolveWriteTarget precedence (explicit → defaultWriteTarget → stashDir)
- */
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { ConfigError, UsageError } from "../../src/core/errors";
-import { assertWritableAllowedForKind, deleteAssetFromSource, resolveWritable, resolveWriteTarget, sanitizeCommitMessage, writeAssetToSource, } from "../../src/core/write-source";
-// ── Fixtures ────────────────────────────────────────────────────────────────
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-function initBareGitRepo() {
-    const remoteDir = makeTempDir("akm-write-remote-");
-    const workDir = makeTempDir("akm-write-work-");
-    // Bare remote so `git push` has somewhere to send commits.
-    let r = spawnSync("git", ["init", "--bare", "--initial-branch=main", remoteDir], { encoding: "utf8" });
-    if (r.status !== 0)
-        throw new Error(`git init --bare failed: ${r.stderr}`);
-    r = spawnSync("git", ["init", "--initial-branch=main", workDir], { encoding: "utf8" });
-    if (r.status !== 0)
-        throw new Error(`git init failed: ${r.stderr}`);
-    // Identity for the working tree — write-source supplies its own at commit
-    // time, but a remote add + initial push needs *some* config.
-    spawnSync("git", ["-C", workDir, "config", "user.email", "test@akm.local"], { encoding: "utf8" });
-    spawnSync("git", ["-C", workDir, "config", "user.name", "akm test"], { encoding: "utf8" });
-    spawnSync("git", ["-C", workDir, "remote", "add", "origin", remoteDir], { encoding: "utf8" });
-    // Seed an initial commit so `git push` can fast-forward.
-    fs.writeFileSync(path.join(workDir, "README.md"), "seed\n");
-    spawnSync("git", ["-C", workDir, "add", "README.md"], { encoding: "utf8" });
-    spawnSync("git", ["-C", workDir, "commit", "-m", "seed"], { encoding: "utf8" });
-    spawnSync("git", ["-C", workDir, "push", "-u", "origin", "main"], { encoding: "utf8" });
-    return { remoteDir, workDir };
-}
-afterEach(() => {
-    while (tempDirs.length > 0) {
-        const dir = tempDirs.pop();
-        if (dir)
-            fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-// ── resolveWritable ─────────────────────────────────────────────────────────
-describe("resolveWritable", () => {
-    test("defaults to true for filesystem", () => {
-        expect(resolveWritable({ type: "filesystem" })).toBe(true);
-    });
-    test("defaults to false for git", () => {
-        expect(resolveWritable({ type: "git" })).toBe(false);
-    });
-    test("defaults to false for website / npm", () => {
-        expect(resolveWritable({ type: "website" })).toBe(false);
-        expect(resolveWritable({ type: "npm" })).toBe(false);
-    });
-    test("explicit value wins for filesystem", () => {
-        expect(resolveWritable({ type: "filesystem", writable: false })).toBe(false);
-    });
-    test("explicit value wins for git", () => {
-        expect(resolveWritable({ type: "git", writable: true })).toBe(true);
-    });
-});
-// ── assertWritableAllowedForKind ────────────────────────────────────────────
-describe("assertWritableAllowedForKind", () => {
-    test("rejects writable: true on website", () => {
-        expect(() => assertWritableAllowedForKind({ type: "website", writable: true, name: "docs" })).toThrow(ConfigError);
-    });
-    test("rejects writable: true on npm", () => {
-        expect(() => assertWritableAllowedForKind({ type: "npm", writable: true, name: "pkg" })).toThrow(ConfigError);
-    });
-    test("allows writable: true on git", () => {
-        expect(() => assertWritableAllowedForKind({ type: "git", writable: true })).not.toThrow();
-    });
-    test("allows writable: true on filesystem", () => {
-        expect(() => assertWritableAllowedForKind({ type: "filesystem", writable: true })).not.toThrow();
-    });
-    test("ignores absent / false writable on website + npm (no-op)", () => {
-        expect(() => assertWritableAllowedForKind({ type: "website" })).not.toThrow();
-        expect(() => assertWritableAllowedForKind({ type: "npm", writable: false })).not.toThrow();
-    });
-});
-// ── writeAssetToSource — filesystem ─────────────────────────────────────────
-describe("writeAssetToSource — filesystem", () => {
-    test("writes the asset to the expected on-disk location", async () => {
-        const dir = makeTempDir("akm-write-fs-");
-        const source = { kind: "filesystem", name: "mine", path: dir };
-        const config = { type: "filesystem", path: dir, name: "mine", writable: true };
-        const result = await writeAssetToSource(source, config, { type: "memory", name: "alpha" }, "hello world");
-        expect(result.path).toBe(path.join(dir, "memories", "alpha.md"));
-        expect(result.ref).toBe("memory:alpha");
-        expect(fs.readFileSync(result.path, "utf8")).toBe("hello world\n");
-    });
-    test("creates intermediate directories", async () => {
-        const dir = makeTempDir("akm-write-fs-nested-");
-        const source = { kind: "filesystem", name: "mine", path: dir };
-        const config = { type: "filesystem", path: dir, writable: true };
-        const result = await writeAssetToSource(source, config, { type: "knowledge", name: "topic/sub" }, "body");
-        expect(fs.existsSync(result.path)).toBe(true);
-        expect(result.path.endsWith(path.join("knowledge", "topic", "sub.md"))).toBe(true);
-    });
-    test("appends a trailing newline when missing", async () => {
-        const dir = makeTempDir("akm-write-fs-nl-");
-        const source = { kind: "filesystem", name: "mine", path: dir };
-        const config = { type: "filesystem", writable: true };
-        const result = await writeAssetToSource(source, config, { type: "memory", name: "a" }, "no-newline");
-        expect(fs.readFileSync(result.path, "utf8")).toBe("no-newline\n");
-    });
-    test("preserves an existing trailing newline (no double newline)", async () => {
-        const dir = makeTempDir("akm-write-fs-nl2-");
-        const source = { kind: "filesystem", name: "mine", path: dir };
-        const config = { type: "filesystem", writable: true };
-        const result = await writeAssetToSource(source, config, { type: "memory", name: "a" }, "with-newline\n");
-        expect(fs.readFileSync(result.path, "utf8")).toBe("with-newline\n");
-    });
-    test("refuses to write when source is not writable", async () => {
-        const dir = makeTempDir("akm-write-readonly-");
-        const source = { kind: "filesystem", name: "ro", path: dir };
-        const config = { type: "filesystem", writable: false };
-        await expect(writeAssetToSource(source, config, { type: "memory", name: "a" }, "body")).rejects.toThrow(UsageError);
-    });
-    test("refuses to write when default-writable would be false (e.g. git default)", async () => {
-        const dir = makeTempDir("akm-write-default-ro-");
-        const source = { kind: "git", name: "upstream", path: dir };
-        const config = { type: "git", url: "https://example.test/x" };
-        await expect(writeAssetToSource(source, config, { type: "memory", name: "a" }, "body")).rejects.toThrow(UsageError);
-    });
-    test("rejects unknown asset types", async () => {
-        const dir = makeTempDir("akm-write-unknown-");
-        const source = { kind: "filesystem", name: "mine", path: dir };
-        const config = { type: "filesystem", writable: true };
-        await expect(writeAssetToSource(source, config, { type: "totally-not-a-type", name: "a" }, "body")).rejects.toThrow(UsageError);
-    });
-    test("rejects path traversal in asset name", async () => {
-        const dir = makeTempDir("akm-write-traversal-");
-        const source = { kind: "filesystem", name: "mine", path: dir };
-        const config = { type: "filesystem", writable: true };
-        await expect(writeAssetToSource(source, config, { type: "memory", name: "../../escape" }, "body")).rejects.toThrow();
-    });
-});
-// ── writeAssetToSource — git ────────────────────────────────────────────────
-describe("writeAssetToSource — git", () => {
-    test("performs a git commit after writing", async () => {
-        const { workDir } = initBareGitRepo();
-        const source = { kind: "git", name: "team", path: workDir };
-        const config = { type: "git", writable: true };
-        await writeAssetToSource(source, config, { type: "memory", name: "alpha" }, "body");
-        const log = spawnSync("git", ["-C", workDir, "log", "--format=%s", "-1"], { encoding: "utf8" });
-        expect(log.stdout.trim()).toBe("Update memory:alpha");
-        // Working tree should be clean post-commit.
-        const status = spawnSync("git", ["-C", workDir, "status", "--porcelain"], { encoding: "utf8" });
-        expect(status.stdout.trim()).toBe("");
-    });
-    test("pushes when pushOnCommit option is set", async () => {
-        const { remoteDir, workDir } = initBareGitRepo();
-        const source = { kind: "git", name: "team", path: workDir };
-        const config = {
-            type: "git",
-            writable: true,
-            options: { pushOnCommit: true },
-        };
-        await writeAssetToSource(source, config, { type: "memory", name: "pushed" }, "body");
-        // Confirm the commit landed on the bare remote.
-        const remoteLog = spawnSync("git", ["--git-dir", remoteDir, "log", "--format=%s", "-1", "main"], {
-            encoding: "utf8",
-        });
-        expect(remoteLog.stdout.trim()).toBe("Update memory:pushed");
-    });
-    test("does not push when pushOnCommit is absent", async () => {
-        const { remoteDir, workDir } = initBareGitRepo();
-        const source = { kind: "git", name: "team", path: workDir };
-        const config = { type: "git", writable: true };
-        await writeAssetToSource(source, config, { type: "memory", name: "local-only" }, "body");
-        const remoteLog = spawnSync("git", ["--git-dir", remoteDir, "log", "--format=%s", "-1", "main"], {
-            encoding: "utf8",
-        });
-        // Remote still only has the seed commit.
-        expect(remoteLog.stdout.trim()).toBe("seed");
-    });
-});
-// ── deleteAssetFromSource ───────────────────────────────────────────────────
-describe("deleteAssetFromSource", () => {
-    test("removes the asset and commits the removal on git sources", async () => {
-        const { workDir } = initBareGitRepo();
-        const source = { kind: "git", name: "team", path: workDir };
-        const config = { type: "git", writable: true };
-        await writeAssetToSource(source, config, { type: "memory", name: "doomed" }, "body");
-        expect(fs.existsSync(path.join(workDir, "memories", "doomed.md"))).toBe(true);
-        await deleteAssetFromSource(source, config, { type: "memory", name: "doomed" });
-        expect(fs.existsSync(path.join(workDir, "memories", "doomed.md"))).toBe(false);
-        const log = spawnSync("git", ["-C", workDir, "log", "--format=%s", "-1"], { encoding: "utf8" });
-        expect(log.stdout.trim()).toBe("Remove memory:doomed");
-    });
-    test("filesystem delete is a plain unlink (no commit)", async () => {
-        const dir = makeTempDir("akm-delete-fs-");
-        const source = { kind: "filesystem", name: "mine", path: dir };
-        const config = { type: "filesystem", writable: true };
-        await writeAssetToSource(source, config, { type: "memory", name: "ephem" }, "body");
-        await deleteAssetFromSource(source, config, { type: "memory", name: "ephem" });
-        expect(fs.existsSync(path.join(dir, "memories", "ephem.md"))).toBe(false);
-    });
-    test("throws when the asset does not exist", async () => {
-        const dir = makeTempDir("akm-delete-missing-");
-        const source = { kind: "filesystem", name: "mine", path: dir };
-        const config = { type: "filesystem", writable: true };
-        await expect(deleteAssetFromSource(source, config, { type: "memory", name: "ghost" })).rejects.toThrow(UsageError);
-    });
-    test("refuses to delete from a non-writable source", async () => {
-        const dir = makeTempDir("akm-delete-ro-");
-        const source = { kind: "filesystem", name: "ro", path: dir };
-        const config = { type: "filesystem", writable: false };
-        await expect(deleteAssetFromSource(source, config, { type: "memory", name: "x" })).rejects.toThrow(UsageError);
-    });
-});
-// ── Unknown kind reaching the helper ────────────────────────────────────────
-describe("writeAssetToSource — unsupported kinds", () => {
-    test("rejects unknown source kinds with ConfigError", async () => {
-        // The config loader would normally catch this, but the helper still
-        // defends itself in case an external caller bypasses the loader.
-        const dir = makeTempDir("akm-write-unsup-");
-        const source = { kind: "website", name: "docs", path: dir };
-        const config = { type: "website", writable: true };
-        await expect(writeAssetToSource(source, config, { type: "memory", name: "a" }, "body")).rejects.toThrow(ConfigError);
-    });
-});
-// ── resolveWriteTarget ──────────────────────────────────────────────────────
-describe("resolveWriteTarget", () => {
-    let savedEnv;
-    let savedCfgEnv;
-    beforeEach(() => {
-        savedEnv = process.env.AKM_STASH_DIR;
-        savedCfgEnv = process.env.AKM_CONFIG_DIR;
-    });
-    afterEach(() => {
-        if (savedEnv === undefined)
-            delete process.env.AKM_STASH_DIR;
-        else
-            process.env.AKM_STASH_DIR = savedEnv;
-        if (savedCfgEnv === undefined)
-            delete process.env.AKM_CONFIG_DIR;
-        else
-            process.env.AKM_CONFIG_DIR = savedCfgEnv;
-    });
-    test("explicit --target wins", () => {
-        const dir = makeTempDir("akm-target-explicit-");
-        const result = resolveWriteTarget({
-            semanticSearchMode: "off",
-            sources: [{ type: "filesystem", path: dir, name: "explicit", writable: true }],
-        }, "explicit");
-        expect(result.source.name).toBe("explicit");
-        expect(result.source.path).toBe(dir);
-    });
-    test("falls back to defaultWriteTarget", () => {
-        const dir = makeTempDir("akm-target-default-");
-        const result = resolveWriteTarget({
-            semanticSearchMode: "off",
-            sources: [{ type: "filesystem", path: dir, name: "default-one", writable: true }],
-            defaultWriteTarget: "default-one",
-        });
-        expect(result.source.name).toBe("default-one");
-    });
-    test("falls back to working stashDir when no explicit target / defaultWriteTarget", () => {
-        const stashDir = makeTempDir("akm-target-stash-");
-        process.env.AKM_STASH_DIR = stashDir;
-        const result = resolveWriteTarget({ semanticSearchMode: "off" });
-        expect(result.source.kind).toBe("filesystem");
-        expect(result.source.path).toBe(stashDir);
-    });
-    test("throws ConfigError when defaultWriteTarget points at a missing source", () => {
-        expect(() => resolveWriteTarget({
-            semanticSearchMode: "off",
-            sources: [{ type: "filesystem", path: "/tmp/akm-missing", name: "exists", writable: true }],
-            defaultWriteTarget: "ghost",
-        })).toThrow(ConfigError);
-    });
-    test("throws UsageError when --target names a missing source", () => {
-        expect(() => resolveWriteTarget({
-            semanticSearchMode: "off",
-            sources: [{ type: "filesystem", path: "/tmp/akm-other", name: "other", writable: true }],
-        }, "nope")).toThrow(UsageError);
-    });
-});
-// ── sanitizeCommitMessage (issue #270) ──────────────────────────────────────
-describe("sanitizeCommitMessage", () => {
-    test("strips newline injection attempts and collapses to a single line", () => {
-        // Classic newline-injection payload: forge a Co-Authored-By trailer.
-        const payload = "Update skill:foo\n\nCo-Authored-By: attacker <evil@example>";
-        const out = sanitizeCommitMessage(payload);
-        expect(out.includes("\n")).toBe(false);
-        expect(out.includes("\r")).toBe(false);
-        // Content survives, just on one line with whitespace runs collapsed.
-        expect(out).toBe("Update skill:foo Co-Authored-By: attacker <evil@example>");
-    });
-    test("strips carriage returns", () => {
-        expect(sanitizeCommitMessage("a\rb\r\nc")).toBe("a b c");
-    });
-    test("strips NUL bytes", () => {
-        const out = sanitizeCommitMessage("subject\x00hidden");
-        expect(out.includes("\x00")).toBe(false);
-        expect(out).toBe("subjecthidden");
-    });
-    test("strips other C0 control characters", () => {
-        // 0x07 BEL, 0x1B ESC, 0x7F DEL — all become spaces (then collapsed).
-        expect(sanitizeCommitMessage("a\x07b\x1Bc\x7Fd")).toBe("a b c d");
-    });
-    test("clamps to 4096 characters", () => {
-        const long = "x".repeat(5000);
-        const out = sanitizeCommitMessage(long);
-        expect(out.length).toBe(4096);
-    });
-    test("returns empty string for empty/whitespace-only input", () => {
-        expect(sanitizeCommitMessage("")).toBe("");
-        expect(sanitizeCommitMessage("   \n\r\t  ")).toBe("");
-    });
-    test("returns empty string for non-string input", () => {
-        expect(sanitizeCommitMessage(undefined)).toBe("");
-        expect(sanitizeCommitMessage(null)).toBe("");
-    });
-});
-// ── git commit message sanitization end-to-end (issue #270) ─────────────────
-describe("writeAssetToSource — commit message sanitization (issue #270)", () => {
-    test("ref.origin with embedded newline does not produce multi-line commit", async () => {
-        const { workDir } = initBareGitRepo();
-        const source = { kind: "git", name: "team", path: workDir };
-        const config = { type: "git", writable: true };
-        // Newline-laden origin: an attacker who controls a config entry could
-        // otherwise smuggle trailers into the commit subject.
-        const malignOrigin = "team\n\nCo-Authored-By: attacker <evil@example>";
-        await writeAssetToSource(source, config, { type: "memory", name: "alpha", origin: malignOrigin }, "body");
-        const fullLog = spawnSync("git", ["-C", workDir, "log", "--format=%B%x00", "-1"], { encoding: "utf8" });
-        // Trim the NUL terminator we used as a record separator. The remaining
-        // body must contain no embedded newlines (other than the trailing one git
-        // always appends to the message).
-        // biome-ignore lint/suspicious/noControlCharactersInRegex: NUL is the explicit record separator.
-        const messageBody = fullLog.stdout.replace(/\x00\s*$/, "").replace(/\n$/, "");
-        expect(messageBody.includes("\n")).toBe(false);
-        expect(messageBody.includes("Co-Authored-By: attacker")).toBe(true);
-        // The injected trailer is part of the *subject*, not a real trailer.
-        expect(messageBody.startsWith("Update team")).toBe(true);
-    });
-    test("ref.origin with NUL byte is sanitized (commit succeeds)", async () => {
-        const { workDir } = initBareGitRepo();
-        const source = { kind: "git", name: "team", path: workDir };
-        const config = { type: "git", writable: true };
-        // A NUL byte in argv would make git reject the commit outright. We strip
-        // it so the commit succeeds with the rest of the origin intact.
-        const malignOrigin = "team\x00hidden";
-        await writeAssetToSource(source, config, { type: "memory", name: "beta", origin: malignOrigin }, "body");
-        const log = spawnSync("git", ["-C", workDir, "log", "--format=%s", "-1"], { encoding: "utf8" });
-        expect(log.stdout.includes("\x00")).toBe(false);
-        expect(log.stdout.trim()).toBe("Update teamhidden//memory:beta");
-    });
-});

package/dist/tests/curate-command.test.js

@@ -1,87 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-const CLI = path.join(__dirname, "..", "src", "cli.ts");
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-function writeFile(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-}
-function runCli(stashDir, args) {
-    const xdgCache = makeTempDir("akm-curate-cache-");
-    const xdgConfig = makeTempDir("akm-curate-config-");
-    const result = spawnSync("bun", [CLI, ...args], {
-        encoding: "utf8",
-        timeout: 30_000,
-        env: {
-            ...process.env,
-            AKM_STASH_DIR: stashDir,
-            XDG_CACHE_HOME: xdgCache,
-            XDG_CONFIG_HOME: xdgConfig,
-        },
-    });
-    expect(result.status).toBe(0);
-    return result.stdout.trim();
-}
-afterEach(() => {
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-describe("curate command", () => {
-    function makeStash() {
-        const stashDir = makeTempDir("akm-curate-stash-");
-        writeFile(path.join(stashDir, "scripts", "deploy.sh"), "#!/usr/bin/env bash\necho deploy\n");
-        writeFile(path.join(stashDir, "commands", "release.md"), "---\ndescription: Release the app\n---\nnpm version {{version}} && git push --follow-tags\n");
-        writeFile(path.join(stashDir, "skills", "release-review", "SKILL.md"), "---\ndescription: Review a release plan\n---\n# Release Review\nCheck rollout, rollback, and validation.\n");
-        writeFile(path.join(stashDir, "knowledge", "release-guide.md"), "# Release Guide\n\nUse this guide to explain the release workflow.\n");
-        return stashDir;
-    }
-    test("returns curated JSON with follow-up commands and previews", () => {
-        const stashDir = makeStash();
-        const output = runCli(stashDir, ["curate", "release deploy", "--format=json"]);
-        const json = JSON.parse(output);
-        expect(json.query).toBe("release deploy");
-        expect(json.summary).toContain("Selected");
-        expect(json.items.length).toBeGreaterThanOrEqual(2);
-        expect(new Set(json.items.map((item) => item.type)).size).toBeGreaterThanOrEqual(2);
-        for (const item of json.items) {
-            if (item.source === "stash") {
-                expect(typeof item.ref).toBe("string");
-                expect(String(item.followUp)).toContain("akm show");
-                expect(typeof item.reason).toBe("string");
-            }
-        }
-    });
-    test("prefers one strong match per asset type by default", () => {
-        const stashDir = makeStash();
-        writeFile(path.join(stashDir, "commands", "release-notes.md"), "---\ndescription: Draft release notes\n---\nWrite release notes for {{version}}\n");
-        const output = runCli(stashDir, ["curate", "release", "--format=json"]);
-        const json = JSON.parse(output);
-        const commandItems = json.items.filter((item) => item.type === "command");
-        expect(commandItems.length).toBe(1);
-    });
-    test("text output includes direct refs and follow-up commands", () => {
-        const stashDir = makeStash();
-        const output = runCli(stashDir, ["curate", "release deploy", "--format=text"]);
-        expect(output).toContain('Curated results for "release deploy"');
-        expect(output).toContain("[command]");
-        expect(output).toContain("ref: command:release");
-        expect(output).toContain("show: akm show command:release");
-    });
-    test("returns a tip when no curated results are found", () => {
-        const stashDir = makeTempDir("akm-curate-empty-stash-");
-        const output = runCli(stashDir, ["curate", "totally unmatched request", "--format=json"]);
-        const json = JSON.parse(output);
-        expect(json.items).toEqual([]);
-        expect(json.summary).toContain("No curated assets were selected");
-        expect(json.tip).toContain("No matching");
-    });
-});

package/dist/tests/db-scoring.test.js

@@ -1,201 +0,0 @@
-import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { closeDatabase, openDatabase, rebuildFts, sanitizeFtsQuery, searchFts, upsertEntry } from "../src/indexer/db";
-// ── Temp directory management ───────────────────────────────────────────────
-const createdTmpDirs = [];
-function tmpDir(label = "db-scoring") {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `akm-${label}-`));
-    createdTmpDirs.push(dir);
-    return dir;
-}
-function tmpDbPath(label = "db-scoring") {
-    const dir = tmpDir(label);
-    return path.join(dir, "test.db");
-}
-afterAll(() => {
-    for (const dir of createdTmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-// ── Environment isolation ───────────────────────────────────────────────────
-const savedEnv = {};
-beforeEach(() => {
-    savedEnv.XDG_CACHE_HOME = process.env.XDG_CACHE_HOME;
-    savedEnv.XDG_CONFIG_HOME = process.env.XDG_CONFIG_HOME;
-    process.env.XDG_CACHE_HOME = tmpDir("cache");
-    process.env.XDG_CONFIG_HOME = tmpDir("config");
-});
-afterEach(() => {
-    for (const [key, val] of Object.entries(savedEnv)) {
-        if (val === undefined) {
-            delete process.env[key];
-        }
-        else {
-            process.env[key] = val;
-        }
-    }
-});
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function makeEntry(overrides) {
-    return {
-        description: "A test entry",
-        ...overrides,
-    };
-}
-function insertTestEntry(db, key, opts) {
-    const type = opts?.type ?? "script";
-    const entry = makeEntry({ name: key, type, description: opts?.description ?? `Description for ${key}` });
-    return upsertEntry(db, key, opts?.dirPath ?? "/test/dir", opts?.filePath ?? `/test/dir/${key}.ts`, opts?.stashDir ?? "/test/stash", entry, opts?.searchText ?? `${key} ${entry.description}`);
-}
-// ── Issue #2: sanitizeFtsQuery preserves identifier tokens ──────────────────
-describe("sanitizeFtsQuery — identifier preservation (Issue #2)", () => {
-    test("hyphenated query becomes AND of component tokens", () => {
-        const result = sanitizeFtsQuery("code-review");
-        // Hyphens are replaced with spaces — FTS5 treats hyphen as NOT in
-        // query context. The result is implicit AND: "code review".
-        expect(result).toContain("code");
-        expect(result).toContain("review");
-        // Must NOT use OR join
-        expect(result).not.toContain(" OR ");
-    });
-    test("dotted query becomes AND of component tokens", () => {
-        const result = sanitizeFtsQuery("k8s.setup");
-        // Dots cause FTS5 syntax errors; replaced with spaces
-        expect(result).toContain("k8s");
-        expect(result).toContain("setup");
-        expect(result).not.toContain(".");
-    });
-    test("preserves underscores in identifiers like deploy_prod", () => {
-        const result = sanitizeFtsQuery("deploy_prod");
-        // Underscores are valid in FTS5 queries (unicode61 treats them as
-        // token separators on both index and query sides)
-        expect(result).toContain("deploy_prod");
-    });
-    test("strips FTS5 syntax characters (quotes, parens, asterisks, colons, carets)", () => {
-        const result = sanitizeFtsQuery('"hello" (world) test*');
-        // The dangerous FTS5 syntax chars should be removed
-        expect(result).not.toContain('"');
-        expect(result).not.toContain("(");
-        expect(result).not.toContain(")");
-        expect(result).not.toContain("*");
-        // But the actual words should remain
-        expect(result).toContain("hello");
-        expect(result).toContain("world");
-        expect(result).toContain("test");
-    });
-    test("strips NEAR operator from query", () => {
-        // NEAR is a special FTS5 operator that should be neutralized
-        const result = sanitizeFtsQuery("NEAR foo bar");
-        expect(result).not.toMatch(/\bNEAR\b/);
-        expect(result).toContain("foo");
-        expect(result).toContain("bar");
-    });
-    test("uses AND (implicit space-separated) rather than OR", () => {
-        const result = sanitizeFtsQuery("deploy production");
-        // Should NOT contain OR — tokens should be AND-joined (space-separated)
-        expect(result).not.toContain(" OR ");
-        // Both tokens should be present
-        expect(result).toContain("deploy");
-        expect(result).toContain("production");
-    });
-    test("returns empty string for empty query", () => {
-        expect(sanitizeFtsQuery("")).toBe("");
-    });
-    test("returns empty string for only-syntax-chars query", () => {
-        expect(sanitizeFtsQuery('"()*:^{}')).toBe("");
-    });
-    test("handles mixed valid and syntax chars", () => {
-        const result = sanitizeFtsQuery('deploy:prod "code-review"');
-        expect(result).not.toContain(":");
-        expect(result).not.toContain('"');
-        expect(result).toContain("deploy");
-        expect(result).toContain("prod");
-        // code-review becomes "code review" (space-separated AND)
-        expect(result).toContain("code");
-        expect(result).toContain("review");
-    });
-});
-// ── Issue #2: Integration test — hyphenated search through searchFts ────────
-describe("searchFts — hyphenated identifier search (Issue #2)", () => {
-    test("searching for 'code-review' matches entry with code-review in search text", () => {
-        const db = openDatabase(tmpDbPath());
-        try {
-            insertTestEntry(db, "code-review", {
-                description: "code-review skill for reviewing pull requests",
-                searchText: "code-review skill for reviewing pull requests",
-            });
-            insertTestEntry(db, "deploy-prod", {
-                description: "deploy-prod deploy to production servers",
-                searchText: "deploy-prod deploy to production servers",
-            });
-            rebuildFts(db);
-            const results = searchFts(db, "code-review", 10);
-            expect(results.length).toBeGreaterThanOrEqual(1);
-            // The code-review entry should be the top result
-            expect(results[0].entry.name).toBe("code-review");
-        }
-        finally {
-            closeDatabase(db);
-        }
-    });
-    test("AND semantics: multi-word query only matches entries containing all terms", () => {
-        const db = openDatabase(tmpDbPath());
-        try {
-            insertTestEntry(db, "deploy-tool", {
-                description: "deploy applications to production servers",
-                searchText: "deploy applications to production servers",
-            });
-            insertTestEntry(db, "code-tool", {
-                description: "code linting and formatting tool",
-                searchText: "code linting and formatting tool",
-            });
-            insertTestEntry(db, "review-tool", {
-                description: "review pull requests and merge code",
-                searchText: "review pull requests and merge code",
-            });
-            rebuildFts(db);
-            // With AND semantics, "code review" should NOT match "deploy-tool"
-            // (which has neither "code" nor "review")
-            // "review-tool" has both "review" and "code" in its search text
-            const results = searchFts(db, "code review", 10);
-            const names = results.map((r) => r.entry.name);
-            expect(names).not.toContain("deploy-tool");
-            // review-tool should match (it contains both "code" and "review")
-            expect(names).toContain("review-tool");
-        }
-        finally {
-            closeDatabase(db);
-        }
-    });
-});
-// ── Issue #9: Single-character queries ──────────────────────────────────────
-describe("sanitizeFtsQuery — single-char tokens (Issue #9)", () => {
-    test("single character token is preserved", () => {
-        const result = sanitizeFtsQuery("R");
-        expect(result).toBe("R");
-    });
-    test("single character query returns FTS results when content matches", () => {
-        const db = openDatabase(tmpDbPath());
-        try {
-            insertTestEntry(db, "r-lang", {
-                searchText: "R programming language for statistics",
-            });
-            insertTestEntry(db, "python-tool", {
-                searchText: "Python scripting language",
-            });
-            rebuildFts(db);
-            const results = searchFts(db, "R", 10);
-            expect(results.length).toBeGreaterThanOrEqual(1);
-        }
-        finally {
-            closeDatabase(db);
-        }
-    });
-    test("mixed single and multi-char tokens are all preserved", () => {
-        const result = sanitizeFtsQuery("R language");
-        expect(result).toContain("R");
-        expect(result).toContain("language");
-    });
-});