akm-cli 0.6.1 → 0.7.0

package/dist/tests/fts-field-weighting.test.js

@@ -0,0 +1,254 @@
+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, DB_VERSION, openDatabase, rebuildFts, searchFts, upsertEntry } from "../src/indexer/db";
+import { buildSearchFields } from "../src/indexer/search-fields";
+// ── Temp directory management ───────────────────────────────────────────────
+const createdTmpDirs = [];
+function tmpDir(label = "fts") {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `akm-${label}-`));
+    createdTmpDirs.push(dir);
+    return dir;
+}
+function tmpDbPath(label = "fts") {
+    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 insertEntry(db, key, entry, searchText) {
+    return upsertEntry(db, key, "/test/dir", `/test/dir/${key}.ts`, "/test/stash", entry, searchText);
+}
+// ── Test 1: Name match ranks higher than description-only match ─────────────
+describe("FTS5 field weighting", () => {
+    test("name match ranks higher than description-only match", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            // Entry with "deploy" in the name
+            const nameEntry = makeEntry({
+                name: "deploy",
+                type: "script",
+                description: "Runs a production release process",
+            });
+            insertEntry(db, "name-deploy", nameEntry, "deploy");
+            // Entry with "deploy" only in the description
+            const descEntry = makeEntry({
+                name: "release-tool",
+                type: "script",
+                description: "Used to deploy applications to staging servers",
+            });
+            insertEntry(db, "desc-deploy", descEntry, "deploy");
+            rebuildFts(db);
+            const results = searchFts(db, "deploy", 10);
+            expect(results.length).toBe(2);
+            // The name match should rank first (lower bm25 score = better in FTS5)
+            expect(results[0].entry.name).toBe("deploy");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    // ── Test 2: Name match ranks higher than tag-only match ─────────────────
+    test("name match ranks higher than tag-only match", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            // Entry with "kubernetes" in the name
+            const nameEntry = makeEntry({
+                name: "kubernetes",
+                type: "script",
+                description: "Container orchestration management tool",
+            });
+            insertEntry(db, "name-k8s", nameEntry, "kubernetes");
+            // Entry with "kubernetes" only in tags
+            const tagEntry = makeEntry({
+                name: "container-manager",
+                type: "script",
+                description: "Manages container lifecycle operations",
+                tags: ["kubernetes", "docker"],
+            });
+            insertEntry(db, "tag-k8s", tagEntry, "kubernetes");
+            rebuildFts(db);
+            const results = searchFts(db, "kubernetes", 10);
+            expect(results.length).toBe(2);
+            expect(results[0].entry.name).toBe("kubernetes");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    // ── Test 3: Description match ranks higher than content-only (TOC) match ──
+    test("description match ranks higher than content-only match", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            // Entry with "terraform" in description
+            const descEntry = makeEntry({
+                name: "infra-tool",
+                type: "script",
+                description: "Uses terraform to provision cloud infrastructure",
+            });
+            insertEntry(db, "desc-tf", descEntry, "terraform");
+            // Entry with "terraform" only in content/TOC
+            const contentEntry = makeEntry({
+                name: "cloud-guide",
+                type: "knowledge",
+                description: "Guide to cloud architecture patterns",
+                toc: [{ text: "terraform setup", level: 2, line: 1 }],
+            });
+            insertEntry(db, "content-tf", contentEntry, "terraform");
+            rebuildFts(db);
+            const results = searchFts(db, "terraform", 10);
+            expect(results.length).toBe(2);
+            expect(results[0].entry.name).toBe("infra-tool");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    // ── Test 4: Multi-field matches rank highest ──────────────────────────────
+    test("multi-field matches rank highest", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            // Entry with "deploy" in BOTH name and description
+            const multiEntry = makeEntry({
+                name: "deploy",
+                type: "script",
+                description: "Deploy applications to production deploy pipelines",
+                tags: ["deploy"],
+            });
+            insertEntry(db, "multi-deploy", multiEntry, "deploy");
+            // Entry with "deploy" only in name
+            const nameOnlyEntry = makeEntry({
+                name: "deploy-lite",
+                type: "script",
+                description: "Lightweight release process for staging",
+            });
+            insertEntry(db, "name-deploy", nameOnlyEntry, "deploy");
+            rebuildFts(db);
+            const results = searchFts(db, "deploy", 10);
+            expect(results.length).toBe(2);
+            // The multi-field match should rank first
+            expect(results[0].entry.name).toBe("deploy");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    // ── Test 5: FTS5 table has separate columns ───────────────────────────────
+    test("FTS5 table has separate columns", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            // Query the FTS5 table config to verify it has the expected columns
+            // FTS5 tables expose column info via sqlite_master
+            const row = db.prepare("SELECT sql FROM sqlite_master WHERE name = 'entries_fts'").get();
+            expect(row).toBeDefined();
+            const sql = row.sql.toLowerCase();
+            // Should have separate columns instead of a single search_text
+            expect(sql).toContain("name");
+            expect(sql).toContain("description");
+            expect(sql).toContain("tags");
+            expect(sql).toContain("hints");
+            expect(sql).toContain("content");
+            // Should NOT have the old single search_text column
+            expect(sql).not.toContain("search_text");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    // ── Test 6: DB_VERSION is incremented ─────────────────────────────────────
+    test("DB_VERSION is at least 7 (multi-column FTS5)", () => {
+        expect(DB_VERSION).toBeGreaterThanOrEqual(7);
+    });
+    // ── Test 7: Existing search queries still return results ──────────────────
+    test("existing search queries still return results (no regression)", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            const entry = makeEntry({
+                name: "deploy-tool",
+                type: "script",
+                description: "Deploy applications to production servers",
+                tags: ["deploy", "production"],
+                searchHints: ["release management"],
+            });
+            insertEntry(db, "deploy-tool", entry, "deploy tool deploy applications to production servers deploy production release management");
+            rebuildFts(db);
+            // Verify various query patterns still work
+            const deployResults = searchFts(db, "deploy", 10);
+            expect(deployResults.length).toBeGreaterThanOrEqual(1);
+            const productionResults = searchFts(db, "production", 10);
+            expect(productionResults.length).toBeGreaterThanOrEqual(1);
+            const multiWordResults = searchFts(db, "deploy production", 10);
+            expect(multiWordResults.length).toBeGreaterThanOrEqual(1);
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+});
+// ── Test buildSearchFields ──────────────────────────────────────────────────
+describe("buildSearchFields", () => {
+    test("returns separate field strings from entry", () => {
+        const entry = makeEntry({
+            name: "deploy-tool",
+            type: "script",
+            description: "Deploy applications to production",
+            tags: ["deploy", "production"],
+            searchHints: ["release management", "rollout"],
+            toc: [
+                { text: "Getting Started", level: 1, line: 1 },
+                { text: "Configuration", level: 2, line: 5 },
+            ],
+        });
+        const fields = buildSearchFields(entry);
+        expect(fields.name).toContain("deploy");
+        expect(fields.name).toContain("tool");
+        expect(fields.description).toContain("deploy applications to production");
+        expect(fields.tags).toContain("deploy");
+        expect(fields.tags).toContain("production");
+        expect(fields.hints).toContain("release management");
+        expect(fields.hints).toContain("rollout");
+        expect(fields.content).toContain("getting started");
+        expect(fields.content).toContain("configuration");
+    });
+    test("handles entry with minimal fields", () => {
+        const entry = makeEntry({
+            name: "simple",
+            type: "script",
+        });
+        const fields = buildSearchFields(entry);
+        expect(fields.name).toBe("simple");
+        expect(fields.description).toBe("a test entry");
+        expect(fields.tags).toBe("");
+        expect(fields.hints).toBe("");
+        expect(fields.content).toBe("");
+    });
+});

package/dist/tests/fuzzy-search.test.js

@@ -0,0 +1,230 @@
+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, searchFts, upsertEntry } from "../src/indexer/db";
+// ── Temp directory management ───────────────────────────────────────────────
+const createdTmpDirs = [];
+function tmpDir(label = "fuzzy") {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `akm-${label}-`));
+    createdTmpDirs.push(dir);
+    return dir;
+}
+function tmpDbPath(label = "fuzzy") {
+    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 ?? "skill";
+    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}`);
+}
+// ── Fuzzy / prefix fallback tests ───────────────────────────────────────────
+describe("Fuzzy prefix fallback in searchFts", () => {
+    test("exact match still works normally", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            insertTestEntry(db, "kubernetes", {
+                searchText: "kubernetes container orchestration platform",
+            });
+            rebuildFts(db);
+            const results = searchFts(db, "kubernetes", 10);
+            expect(results.length).toBe(1);
+            expect(results[0].entry.name).toBe("kubernetes");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("truncated prefix — 'kubernet' matches 'kubernetes' via prefix expansion", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            insertTestEntry(db, "kubernetes", {
+                searchText: "kubernetes container orchestration platform",
+            });
+            rebuildFts(db);
+            // "kubernet" has no exact FTS match; the prefix fallback expands it to "kubernet*".
+            const results = searchFts(db, "kubernet", 10);
+            expect(results.length).toBe(1);
+            expect(results[0].entry.name).toBe("kubernetes");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("partial prefix match — 'kube' finds 'kubernetes' assets", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            insertTestEntry(db, "kubernetes", {
+                searchText: "kubernetes container orchestration",
+            });
+            insertTestEntry(db, "kubelet", {
+                searchText: "kubelet node agent kubernetes",
+            });
+            rebuildFts(db);
+            // "kube" should not match exactly (FTS5 uses full token matching).
+            // The prefix fallback should append * and find both "kubernetes" and "kubelet".
+            const results = searchFts(db, "kube", 10);
+            expect(results.length).toBe(2);
+            const names = results.map((r) => r.entry.name).sort();
+            expect(names).toContain("kubernetes");
+            expect(names).toContain("kubelet");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("multiple token query with prefix fallback", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            insertTestEntry(db, "deploy-kubernetes", {
+                searchText: "deploy kubernetes production cluster",
+            });
+            insertTestEntry(db, "deploy-docker", {
+                searchText: "deploy docker containers locally",
+            });
+            rebuildFts(db);
+            // "deploy kube" — "deploy" matches exactly, "kube" needs prefix fallback.
+            // Should find "deploy-kubernetes" because "deploy" AND "kube*" matches.
+            const results = searchFts(db, "deploy kube", 10);
+            expect(results.length).toBeGreaterThanOrEqual(1);
+            const names = results.map((r) => r.entry.name);
+            expect(names).toContain("deploy-kubernetes");
+            // "deploy-docker" should NOT match since "kube*" doesn't match "docker"
+            expect(names).not.toContain("deploy-docker");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("non-matching query returns empty even with prefix fallback", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            insertTestEntry(db, "kubernetes", {
+                searchText: "kubernetes container orchestration",
+            });
+            rebuildFts(db);
+            // "xyznonexist" has no prefix match in the index
+            const results = searchFts(db, "xyznonexist", 10);
+            expect(results).toEqual([]);
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("short tokens (1-2 chars) should NOT get prefix expansion", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            insertTestEntry(db, "kubernetes", {
+                searchText: "kubernetes container orchestration",
+            });
+            insertTestEntry(db, "kafka", {
+                searchText: "kafka streaming events",
+            });
+            rebuildFts(db);
+            // "k" is a 1-char token — should NOT be prefix-expanded to "k*" which
+            // would match everything starting with "k".
+            // Since "k" doesn't match any full token, should return empty.
+            const results = searchFts(db, "k", 10);
+            expect(results).toEqual([]);
+            // "ka" is a 2-char token — also should not be prefix-expanded.
+            const results2 = searchFts(db, "ka", 10);
+            expect(results2).toEqual([]);
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("all short tokens produce no prefix fallback and return empty", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            insertTestEntry(db, "golang-setup", {
+                searchText: "go golang setup configuration",
+            });
+            insertTestEntry(db, "js-tooling", {
+                searchText: "js javascript tooling bundler",
+            });
+            rebuildFts(db);
+            const results = searchFts(db, "go js", 10);
+            expect(results).toEqual([]);
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("prefix fallback only triggers when exact match returns zero results", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            insertTestEntry(db, "deploy", {
+                searchText: "deploy application production",
+            });
+            insertTestEntry(db, "deployment-manager", {
+                searchText: "deployment manager orchestration",
+            });
+            rebuildFts(db);
+            // "deploy" matches exactly — should return results from exact match,
+            // not the prefix fallback. FTS5 with porter stemmer may match
+            // "deployment" as well through stemming, but the key point is that
+            // the exact query runs first and returns results.
+            const results = searchFts(db, "deploy", 10);
+            expect(results.length).toBeGreaterThanOrEqual(1);
+            // The first result should be "deploy" (exact match has best BM25)
+            expect(results[0].entry.name).toBe("deploy");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+    test("prefix fallback with entryType filter", () => {
+        const db = openDatabase(tmpDbPath());
+        try {
+            insertTestEntry(db, "kubernetes-skill", {
+                type: "skill",
+                searchText: "kubernetes container management skill",
+            });
+            insertTestEntry(db, "kubernetes-script", {
+                type: "script",
+                searchText: "kubernetes deployment script automation",
+            });
+            rebuildFts(db);
+            // "kube" with type filter "skill" should only return the skill entry
+            const results = searchFts(db, "kube", 10, "skill");
+            expect(results.length).toBe(1);
+            expect(results[0].entry.name).toBe("kubernetes-skill");
+            expect(results[0].entry.type).toBe("skill");
+        }
+        finally {
+            closeDatabase(db);
+        }
+    });
+});

package/dist/tests/git-provider-clone.test.js

@@ -0,0 +1,45 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { cloneRepo } from "../src/sources/providers/git";
+// ── Helpers ──────────────────────────────────────────────────────────────────
+const createdTmpDirs = [];
+function makeTempDir(prefix = "akm-clone-test-") {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    createdTmpDirs.push(dir);
+    return dir;
+}
+afterAll(() => {
+    for (const dir of createdTmpDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("cloneRepo: safe staging on failure", () => {
+    test("leaves an existing destDir untouched when the remote is unreachable", () => {
+        const destDir = makeTempDir("akm-clone-dest-");
+        // Seed destDir with a sentinel file that proves the directory was already
+        // populated before the failed clone attempt.
+        const sentinelPath = path.join(destDir, "sentinel.txt");
+        fs.writeFileSync(sentinelPath, "cached-content", "utf8");
+        // A bogus git URL that will never succeed (no service listening on port 1).
+        const bogusUrl = "git://127.0.0.1:1/nothing.git";
+        // The clone must throw — network is down.
+        expect(() => cloneRepo(bogusUrl, null, destDir)).toThrow();
+        // Critical assertion: the previously-valid destDir must still be intact.
+        expect(fs.existsSync(sentinelPath)).toBe(true);
+        expect(fs.readFileSync(sentinelPath, "utf8")).toBe("cached-content");
+    });
+    test("does not leave orphaned temp dirs after a failed clone", () => {
+        const parentDir = makeTempDir("akm-clone-parent-");
+        const destDir = path.join(parentDir, "repo");
+        // destDir does not pre-exist — fresh clone scenario.
+        const bogusUrl = "git://127.0.0.1:1/nothing.git";
+        expect(() => cloneRepo(bogusUrl, null, destDir)).toThrow();
+        // Ensure no .tmp-* sibling was left behind.
+        const siblings = fs.readdirSync(parentDir);
+        const tmpSiblings = siblings.filter((f) => f.includes(".tmp-"));
+        expect(tmpSiblings).toHaveLength(0);
+    });
+});