akm-cli 0.7.0 → 0.7.1

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

@@ -1,254 +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, 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

@@ -1,230 +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, 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

@@ -1,45 +0,0 @@
-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);
-    });
-});