akm-cli 0.7.0-rc1 → 0.7.1

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

@@ -1,272 +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 { akmSearch } from "../src/commands/search";
-import { saveConfig } from "../src/core/config";
-import { closeDatabase, openDatabase, rebuildFts, searchFts, setMeta, upsertEmbedding, upsertEntry, } from "../src/indexer/db";
-import { akmIndex } from "../src/indexer/indexer";
-import { clearEmbeddingCache } from "../src/llm/embedder";
-// ── Temp directory management ───────────────────────────────────────────────
-const createdTmpDirs = [];
-function createTmpDir(prefix = "akm-parallel-") {
-    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 });
-    }
-});
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function writeFile(filePath, content = "") {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-}
-function tmpStash() {
-    const dir = createTmpDir("akm-parallel-stash-");
-    for (const sub of ["skills", "commands", "agents", "knowledge", "scripts"]) {
-        fs.mkdirSync(path.join(dir, sub), { recursive: true });
-    }
-    return dir;
-}
-function tmpDbPath(label = "parallel") {
-    const dir = createTmpDir(`akm-${label}-`);
-    return path.join(dir, "test.db");
-}
-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}`);
-}
-async function buildTestIndex(stashDir, files) {
-    for (const [relPath, content] of Object.entries(files)) {
-        const fullPath = path.join(stashDir, relPath);
-        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-        fs.writeFileSync(fullPath, content);
-    }
-    process.env.AKM_STASH_DIR = stashDir;
-    saveConfig({ semanticSearchMode: "off" });
-    await akmIndex({ stashDir, full: true });
-}
-// ── Environment isolation ───────────────────────────────────────────────────
-const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
-const originalAkmStashDir = process.env.AKM_STASH_DIR;
-let testCacheDir = "";
-let testConfigDir = "";
-beforeEach(() => {
-    testCacheDir = createTmpDir("akm-parallel-cache-");
-    testConfigDir = createTmpDir("akm-parallel-config-");
-    process.env.XDG_CACHE_HOME = testCacheDir;
-    process.env.XDG_CONFIG_HOME = testConfigDir;
-    clearEmbeddingCache();
-});
-afterEach(() => {
-    if (originalXdgCacheHome === undefined) {
-        delete process.env.XDG_CACHE_HOME;
-    }
-    else {
-        process.env.XDG_CACHE_HOME = originalXdgCacheHome;
-    }
-    if (originalXdgConfigHome === undefined) {
-        delete process.env.XDG_CONFIG_HOME;
-    }
-    else {
-        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
-    }
-    if (originalAkmStashDir === undefined) {
-        delete process.env.AKM_STASH_DIR;
-    }
-    else {
-        process.env.AKM_STASH_DIR = originalAkmStashDir;
-    }
-    if (testCacheDir) {
-        fs.rmSync(testCacheDir, { recursive: true, force: true });
-        testCacheDir = "";
-    }
-    if (testConfigDir) {
-        fs.rmSync(testConfigDir, { recursive: true, force: true });
-        testConfigDir = "";
-    }
-});
-// ── Test 1: Search results identical to sequential execution ────────────────
-describe("Parallel search: result parity", () => {
-    test("FTS-only search results are identical with parallel execution", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "scripts", "deploy", "deploy.sh"), "#!/bin/bash\necho deploy\n");
-        writeFile(path.join(stashDir, "scripts", "deploy", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "deploy",
-                    type: "script",
-                    description: "Deploy application to production servers",
-                    tags: ["deploy", "production"],
-                    filename: "deploy.sh",
-                },
-            ],
-        }));
-        writeFile(path.join(stashDir, "scripts", "test", "test.sh"), "#!/bin/bash\necho test\n");
-        writeFile(path.join(stashDir, "scripts", "test", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "test-runner",
-                    type: "script",
-                    description: "Run test suite for deployment validation",
-                    tags: ["test", "deploy"],
-                    filename: "test.sh",
-                },
-            ],
-        }));
-        await buildTestIndex(stashDir, {});
-        // Run the same query twice and verify identical results
-        const result1 = await akmSearch({ query: "deploy", source: "local" });
-        const result2 = await akmSearch({ query: "deploy", source: "local" });
-        const localHits1 = result1.hits.filter((h) => h.type !== "registry");
-        const localHits2 = result2.hits.filter((h) => h.type !== "registry");
-        expect(localHits1.length).toBeGreaterThan(0);
-        expect(localHits1.length).toBe(localHits2.length);
-        for (let i = 0; i < localHits1.length; i++) {
-            expect(localHits1[i].name).toBe(localHits2[i].name);
-            expect(localHits1[i].score).toBe(localHits2[i].score);
-            expect(localHits1[i].ref).toBe(localHits2[i].ref);
-        }
-    });
-});
-// ── Test 2: Embedding cache ─────────────────────────────────────────────────
-describe("Embedding cache", () => {
-    test("clearEmbeddingCache is callable without error", () => {
-        // Verify the exported function exists and can be called
-        expect(() => clearEmbeddingCache()).not.toThrow();
-    });
-    test("clearEmbeddingCache is idempotent and does not throw on repeated calls", () => {
-        clearEmbeddingCache();
-        clearEmbeddingCache();
-        // Verify idempotence: calling clear multiple times should never throw
-        expect(() => clearEmbeddingCache()).not.toThrow();
-    });
-});
-// ── Test 3: Search works when vector search is unavailable ──────────────────
-describe("Parallel search: vector unavailable", () => {
-    test("search returns FTS results when no embeddings exist in DB", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "scripts", "lint", "lint.sh"), "#!/bin/bash\necho lint\n");
-        writeFile(path.join(stashDir, "scripts", "lint", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "lint",
-                    type: "script",
-                    description: "Lint source code for errors and style violations",
-                    filename: "lint.sh",
-                },
-            ],
-        }));
-        await buildTestIndex(stashDir, {});
-        const result = await akmSearch({ query: "lint", source: "local" });
-        const localHits = result.hits.filter((h) => h.type !== "registry");
-        expect(localHits.length).toBeGreaterThanOrEqual(1);
-        const lintHit = localHits.find((h) => h.name === "lint");
-        expect(lintHit).toBeDefined();
-        expect(lintHit?.score).toBeGreaterThan(0);
-        // With semanticSearchMode disabled, should use FTS ranking
-        expect(lintHit?.whyMatched).toContain("fts bm25 relevance");
-    });
-});
-// ── Test 4: Search works when FTS returns empty ─────────────────────────────
-describe("Parallel search: FTS empty", () => {
-    test("search returns empty when FTS has no matches and no vec", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "scripts", "alpha", "alpha.sh"), "#!/bin/bash\necho alpha\n");
-        writeFile(path.join(stashDir, "scripts", "alpha", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "alpha",
-                    type: "script",
-                    description: "Alpha tool for testing",
-                    filename: "alpha.sh",
-                },
-            ],
-        }));
-        await buildTestIndex(stashDir, {});
-        // Query for something that won't match any FTS tokens
-        const result = await akmSearch({ query: "zzzznonexistent", source: "local" });
-        const localHits = result.hits.filter((h) => h.type !== "registry");
-        // Should return 0 results without crashing
-        expect(localHits.length).toBe(0);
-    });
-    test("search with DB having vec entries but FTS empty returns vec-only results", async () => {
-        // This test uses the low-level DB API to set up a scenario where
-        // FTS has no matches but vec does (simulating semantic-only match)
-        const dbPath = tmpDbPath("fts-empty");
-        const db = openDatabase(dbPath, { embeddingDim: 4 });
-        try {
-            const id = insertTestEntry(db, "semantic-tool", {
-                description: "A tool found only via semantic similarity",
-                searchText: "vector embedding similarity neural network",
-                stashDir: "/test/stash",
-                dirPath: "/test/dir",
-                filePath: "/test/dir/semantic-tool.ts",
-            });
-            upsertEmbedding(db, id, [1, 0, 0, 0]);
-            setMeta(db, "hasEmbeddings", "1");
-            setMeta(db, "stashDir", "/test/stash");
-            rebuildFts(db);
-            // Searching for "garbledftsquery" won't match FTS, but we verify
-            // the search doesn't crash when FTS is empty
-            const ftsResults = searchFts(db, "garbledftsquery", 10);
-            expect(ftsResults).toHaveLength(0);
-        }
-        finally {
-            closeDatabase(db);
-        }
-    });
-});
-// ── Test 5: Promise.all structure verification ──────────────────────────────
-describe("Parallel search: FTS result ordering", () => {
-    test("FTS search returns results sorted by score descending (semanticSearchMode off)", async () => {
-        // NOTE: Despite the original "hybrid" naming, this test runs with
-        // semanticSearchMode: "off", so only FTS scoring is exercised. True hybrid
-        // (FTS + vector) coverage lives in tests/vector-search.test.ts.
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "scripts", "build", "build.sh"), "#!/bin/bash\necho build\n");
-        writeFile(path.join(stashDir, "scripts", "build", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "build",
-                    type: "script",
-                    description: "Build the project from source",
-                    tags: ["build", "compile"],
-                    filename: "build.sh",
-                },
-            ],
-        }));
-        writeFile(path.join(stashDir, "scripts", "compile", "compile.sh"), "#!/bin/bash\necho compile\n");
-        writeFile(path.join(stashDir, "scripts", "compile", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "compile",
-                    type: "script",
-                    description: "Compile source code into binary artifacts",
-                    tags: ["compile"],
-                    filename: "compile.sh",
-                },
-            ],
-        }));
-        await buildTestIndex(stashDir, {});
-        const result = await akmSearch({ query: "build compile", source: "local" });
-        const localHits = result.hits.filter((h) => h.type !== "registry");
-        // Both entries should be found
-        expect(localHits.length).toBeGreaterThanOrEqual(1);
-        // Results should be sorted by score descending
-        for (let i = 1; i < localHits.length; i++) {
-            expect(localHits[i - 1].score ?? 0).toBeGreaterThanOrEqual(localHits[i].score ?? 0);
-        }
-    });
-});

package/dist/tests/parameter-metadata.test.js

@@ -1,365 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { getDbPath } from "../src/core/paths";
-import { closeDatabase, getAllEntries, openDatabase } from "../src/indexer/db";
-import { akmIndex } from "../src/indexer/indexer";
-import { extractCommandParameters, generateMetadataFlat } from "../src/indexer/metadata";
-import { buildSearchText } from "../src/indexer/search-fields";
-let testConfigDir = "";
-let testCacheDir = "";
-const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
-const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-beforeEach(() => {
-    testConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-param-config-"));
-    testCacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-param-cache-"));
-    process.env.XDG_CONFIG_HOME = testConfigDir;
-    process.env.XDG_CACHE_HOME = testCacheDir;
-    const dbPath = getDbPath();
-    for (const f of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-        try {
-            fs.unlinkSync(f);
-        }
-        catch {
-            /* ignore */
-        }
-    }
-});
-afterEach(() => {
-    if (originalXdgConfigHome === undefined) {
-        delete process.env.XDG_CONFIG_HOME;
-    }
-    else {
-        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
-    }
-    if (originalXdgCacheHome === undefined) {
-        delete process.env.XDG_CACHE_HOME;
-    }
-    else {
-        process.env.XDG_CACHE_HOME = originalXdgCacheHome;
-    }
-    if (testConfigDir) {
-        fs.rmSync(testConfigDir, { recursive: true, force: true });
-        testConfigDir = "";
-    }
-    if (testCacheDir) {
-        fs.rmSync(testCacheDir, { recursive: true, force: true });
-        testCacheDir = "";
-    }
-});
-function tmpStash() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-param-"));
-    for (const sub of ["skills", "commands", "agents", "knowledge", "scripts"]) {
-        fs.mkdirSync(path.join(dir, sub), { recursive: true });
-    }
-    return dir;
-}
-function writeFile(filePath, content = "") {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-}
-// ── Test 1: Commands with $1, $2 have parameters auto-extracted ──────────
-describe("command parameter extraction", () => {
-    test("commands with $1 and $2 have parameters auto-extracted", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "commands", "deploy.md"), '---\ndescription: "Deploy a Docker image"\n---\nDeploy $1 to environment $2\n');
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "commands", "deploy.md")]);
-        expect(result.entries.length).toBe(1);
-        const entry = result.entries[0];
-        expect(entry.parameters).toBeDefined();
-        expect(entry.parameters?.length).toBe(2);
-        expect(entry.parameters?.[0].name).toBe("$1");
-        expect(entry.parameters?.[1].name).toBe("$2");
-    });
-    test("commands with $ARGUMENTS have parameters auto-extracted", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "commands", "run.md"), '---\ndescription: "Run a command"\n---\nExecute the following with $ARGUMENTS\n');
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "commands", "run.md")]);
-        expect(result.entries.length).toBe(1);
-        const entry = result.entries[0];
-        expect(entry.parameters).toBeDefined();
-        expect(entry.parameters?.some((p) => p.name === "ARGUMENTS")).toBe(true);
-    });
-    test("commands with {{named}} placeholders have parameters auto-extracted", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "commands", "build.md"), '---\ndescription: "Build image"\n---\ndocker build -t {{image_name}} --platform {{platform}} .\n');
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "commands", "build.md")]);
-        expect(result.entries.length).toBe(1);
-        const entry = result.entries[0];
-        expect(entry.parameters).toBeDefined();
-        expect(entry.parameters?.some((p) => p.name === "image_name")).toBe(true);
-        expect(entry.parameters?.some((p) => p.name === "platform")).toBe(true);
-    });
-});
-// ── Test 2: Scripts with @param JSDoc have parameters extracted ──────────
-describe("script @param extraction", () => {
-    test("scripts with @param JSDoc have parameters extracted", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "scripts", "deploy.ts"), [
-            "/**",
-            " * Deploy to production",
-            " * @param name - The deployment name",
-            " * @param environment - Target environment (staging or production)",
-            " */",
-            "console.log('deploy')",
-        ].join("\n"));
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "scripts", "deploy.ts")]);
-        expect(result.entries.length).toBe(1);
-        const entry = result.entries[0];
-        expect(entry.parameters).toBeDefined();
-        expect(entry.parameters?.length).toBe(2);
-        expect(entry.parameters?.[0].name).toBe("name");
-        expect(entry.parameters?.[0].description).toBe("The deployment name");
-        expect(entry.parameters?.[1].name).toBe("environment");
-        expect(entry.parameters?.[1].description).toBe("Target environment (staging or production)");
-    });
-    test("scripts with typed @param have type extracted", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "scripts", "resize.ts"), [
-            "/**",
-            " * Resize an image",
-            " * @param {string} filename - The image file path",
-            " * @param {number} width - Target width in pixels",
-            " */",
-            "console.log('resize')",
-        ].join("\n"));
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "scripts", "resize.ts")]);
-        expect(result.entries.length).toBe(1);
-        const entry = result.entries[0];
-        expect(entry.parameters).toBeDefined();
-        expect(entry.parameters?.length).toBe(2);
-        expect(entry.parameters?.[0].name).toBe("filename");
-        expect(entry.parameters?.[0].type).toBe("string");
-        expect(entry.parameters?.[0].description).toBe("The image file path");
-        expect(entry.parameters?.[1].name).toBe("width");
-        expect(entry.parameters?.[1].type).toBe("number");
-        expect(entry.parameters?.[1].description).toBe("Target width in pixels");
-    });
-    test("bash scripts with # @param have parameters extracted", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "scripts", "backup.sh"), [
-            "#!/bin/bash",
-            "# Backup database",
-            "# @param source - The source database name",
-            "# @param destination - The backup destination path",
-            "echo 'backup'",
-        ].join("\n"));
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "scripts", "backup.sh")]);
-        expect(result.entries.length).toBe(1);
-        const entry = result.entries[0];
-        expect(entry.parameters).toBeDefined();
-        expect(entry.parameters?.length).toBe(2);
-        expect(entry.parameters?.[0].name).toBe("source");
-        expect(entry.parameters?.[0].description).toBe("The source database name");
-        expect(entry.parameters?.[1].name).toBe("destination");
-        expect(entry.parameters?.[1].description).toBe("The backup destination path");
-    });
-});
-// ── Test 3: Frontmatter params key is parsed into parameters ─────────────
-describe("frontmatter params extraction", () => {
-    test("frontmatter params key is parsed into parameters", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "commands", "provision.md"), [
-            "---",
-            'description: "Provision infrastructure"',
-            "params:",
-            "  region: AWS region to deploy to",
-            "  instance_type: EC2 instance type",
-            "---",
-            "Provision $1 in $2",
-        ].join("\n"));
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "commands", "provision.md")]);
-        expect(result.entries.length).toBe(1);
-        const entry = result.entries[0];
-        expect(entry.parameters).toBeDefined();
-        expect(entry.parameters?.some((p) => p.name === "region" && p.description === "AWS region to deploy to")).toBe(true);
-        expect(entry.parameters?.some((p) => p.name === "instance_type" && p.description === "EC2 instance type")).toBe(true);
-    });
-});
-// ── Test 4: Parameter names are included in search text ──────────────────
-describe("parameter search text inclusion", () => {
-    test("parameter names and descriptions are included in search text", () => {
-        const entry = {
-            name: "deploy",
-            type: "command",
-            description: "Deploy a service",
-            parameters: [
-                { name: "image_name", description: "Docker image name to deploy" },
-                { name: "environment", description: "Target environment" },
-            ],
-        };
-        const text = buildSearchText(entry);
-        expect(text).toContain("image_name");
-        expect(text).toContain("docker image name to deploy");
-        expect(text).toContain("environment");
-        expect(text).toContain("target environment");
-    });
-});
-// ── Test 5: Assets without parameters have undefined parameters field ────
-describe("no parameters", () => {
-    test("assets without parameters have undefined parameters field", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "knowledge", "guide.md"), '---\ndescription: "A guide"\n---\n# Getting Started\nIntro.\n');
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "knowledge", "guide.md")]);
-        expect(result.entries.length).toBe(1);
-        expect(result.entries[0].parameters).toBeUndefined();
-    });
-});
-// ── Test 6: Multiple parameters are extracted in order ───────────────────
-describe("parameter ordering", () => {
-    test("multiple parameters are extracted in order", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "commands", "multi.md"), '---\ndescription: "Multi param command"\n---\nRun $1 then $2 then $3 with $ARGUMENTS\n');
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "commands", "multi.md")]);
-        expect(result.entries.length).toBe(1);
-        const entry = result.entries[0];
-        expect(entry.parameters).toBeDefined();
-        // $ARGUMENTS comes first (matches existing extractParameters logic), then $1, $2, $3
-        const names = entry.parameters?.map((p) => p.name);
-        expect(names).toEqual(["ARGUMENTS", "$1", "$2", "$3"]);
-    });
-});
-// ── Test 7: Parameter descriptions are captured ──────────────────────────
-describe("parameter descriptions", () => {
-    test("JSDoc @param descriptions are captured accurately", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "scripts", "transform.ts"), [
-            "/**",
-            " * Transform data",
-            " * @param inputFile - Path to the input CSV file",
-            " * @param outputFormat - Output format (json, xml, yaml)",
-            " * @param verbose - Enable verbose logging",
-            " */",
-            "console.log('transform')",
-        ].join("\n"));
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "scripts", "transform.ts")]);
-        expect(result.entries.length).toBe(1);
-        const entry = result.entries[0];
-        expect(entry.parameters).toBeDefined();
-        expect(entry.parameters?.length).toBe(3);
-        expect(entry.parameters?.[0]).toEqual({ name: "inputFile", description: "Path to the input CSV file" });
-        expect(entry.parameters?.[1]).toEqual({ name: "outputFormat", description: "Output format (json, xml, yaml)" });
-        expect(entry.parameters?.[2]).toEqual({ name: "verbose", description: "Enable verbose logging" });
-    });
-});
-// ── Test 8: validateStashEntry round-trips parameters ────────────────────
-describe("validateStashEntry with parameters", () => {
-    test("validateStashEntry preserves valid parameters", async () => {
-        const { validateStashEntry } = await import("../src/indexer/metadata");
-        const raw = {
-            name: "test-cmd",
-            type: "command",
-            parameters: [
-                { name: "image", type: "string", description: "Docker image", required: true, default: "latest" },
-                { name: "count", type: "number", description: "Instance count" },
-            ],
-        };
-        const entry = validateStashEntry(raw);
-        expect(entry).not.toBeNull();
-        expect(entry?.parameters).toBeDefined();
-        expect(entry?.parameters?.length).toBe(2);
-        expect(entry?.parameters?.[0].name).toBe("image");
-        expect(entry?.parameters?.[0].type).toBe("string");
-        expect(entry?.parameters?.[0].description).toBe("Docker image");
-        expect(entry?.parameters?.[0].required).toBe(true);
-        expect(entry?.parameters?.[0].default).toBe("latest");
-        expect(entry?.parameters?.[1].name).toBe("count");
-        expect(entry?.parameters?.[1].type).toBe("number");
-    });
-    test("validateStashEntry filters invalid parameter objects", async () => {
-        const { validateStashEntry } = await import("../src/indexer/metadata");
-        const raw = {
-            name: "test-cmd",
-            type: "command",
-            parameters: [
-                { name: "valid", description: "A valid param" },
-                { notAName: "invalid" }, // missing name field
-                "just a string", // not an object
-                null,
-            ],
-        };
-        const entry = validateStashEntry(raw);
-        expect(entry).not.toBeNull();
-        expect(entry?.parameters).toBeDefined();
-        expect(entry?.parameters?.length).toBe(1);
-        expect(entry?.parameters?.[0].name).toBe("valid");
-    });
-});
-// ── Test 9: Full indexing pipeline includes parameters in search text ────
-describe("indexing pipeline with parameters", () => {
-    test("indexed command entries include parameters in search text", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "commands", "docker-deploy.md"), '---\ndescription: "Deploy Docker container"\n---\nDeploy $1 to $2 using {{registry_url}}\n');
-        process.env.AKM_STASH_DIR = stashDir;
-        await akmIndex({ stashDir });
-        const db = openDatabase();
-        const entries = getAllEntries(db, "command");
-        expect(entries.length).toBe(1);
-        // The search text stored in the DB should include parameter names
-        const searchText = entries[0].searchText;
-        expect(searchText).toContain("registry_url");
-        closeDatabase(db);
-    });
-});
-// ── Test 10: Knowledge articles should NOT have command parameters extracted ──
-describe("knowledge articles skip command parameter extraction", () => {
-    test("knowledge article with {{variable}} should NOT have parameters extracted", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "knowledge", "template-guide.md"), [
-            "---",
-            'description: "Template syntax guide"',
-            "---",
-            "# Template Guide",
-            "",
-            "Use {{variable}} placeholders in your templates.",
-            "For example: {{project_name}} and {{region}}.",
-        ].join("\n"));
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "knowledge", "template-guide.md")]);
-        expect(result.entries.length).toBe(1);
-        expect(result.entries[0].type).toBe("knowledge");
-        // Knowledge articles should NOT have command parameters extracted
-        expect(result.entries[0].parameters).toBeUndefined();
-    });
-    test("knowledge article with frontmatter params should still have parameters", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "knowledge", "config-ref.md"), [
-            "---",
-            'description: "Configuration reference"',
-            "params:",
-            "  api_key: Your API key",
-            "---",
-            "# Configuration",
-            "",
-            "Set {{api_key}} in your config file.",
-        ].join("\n"));
-        const result = await generateMetadataFlat(stashDir, [path.join(stashDir, "knowledge", "config-ref.md")]);
-        expect(result.entries.length).toBe(1);
-        expect(result.entries[0].type).toBe("knowledge");
-        // Frontmatter params: should still be extracted for all types
-        expect(result.entries[0].parameters).toBeDefined();
-        expect(result.entries[0].parameters?.length).toBe(1);
-        expect(result.entries[0].parameters?.[0].name).toBe("api_key");
-        // But {{api_key}} from the body should NOT be extracted (not a command)
-    });
-});
-// ── Test 11: Positional regex should not match $10 as $1 ─────────────────
-describe("positional parameter boundary matching", () => {
-    test("$10 should not produce a $1 parameter", () => {
-        const params = extractCommandParameters("Process $10 items");
-        expect(params).toBeUndefined();
-    });
-    test("$1 followed by non-digit is still matched", () => {
-        const params = extractCommandParameters("Deploy $1 to $2");
-        expect(params).toBeDefined();
-        expect(params?.length).toBe(2);
-        expect(params?.[0].name).toBe("$1");
-        expect(params?.[1].name).toBe("$2");
-    });
-    test("$1 at end of string is matched", () => {
-        const params = extractCommandParameters("Deploy $1");
-        expect(params).toBeDefined();
-        expect(params?.length).toBe(1);
-        expect(params?.[0].name).toBe("$1");
-    });
-});