akm-cli 0.6.1 → 0.7.0

package/dist/tests/completions.test.js

@@ -0,0 +1,142 @@
+import { afterAll, 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";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+const tempDirs = [];
+function makeTempDir() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-completions-"));
+    tempDirs.push(dir);
+    return dir;
+}
+afterAll(() => {
+    for (const dir of tempDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+const xdgCache = makeTempDir();
+const xdgConfig = makeTempDir();
+const isolatedHome = makeTempDir();
+function runCli(...args) {
+    const result = spawnSync("bun", ["./src/cli.ts", ...args], {
+        encoding: "utf8",
+        timeout: 10_000,
+        cwd: path.resolve(import.meta.dir, ".."),
+        env: {
+            ...process.env,
+            AKM_STASH_DIR: undefined,
+            HOME: isolatedHome,
+            XDG_CACHE_HOME: xdgCache,
+            XDG_CONFIG_HOME: xdgConfig,
+            XDG_DATA_HOME: undefined,
+        },
+    });
+    return {
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        status: result.status ?? 1,
+    };
+}
+// ── Unit tests (generated script content) ────────────────────────────────────
+describe("completions command", () => {
+    const { stdout, status } = runCli("completions");
+    const script = stdout;
+    test("exits 0 and outputs a bash script", () => {
+        expect(status).toBe(0);
+        expect(script).toStartWith("#!/bin/bash");
+    });
+    test("contains complete -F _akm akm", () => {
+        expect(script).toContain("complete -F _akm akm");
+    });
+    test("contains all top-level subcommands", () => {
+        const expected = [
+            "init",
+            "index",
+            "add",
+            "list",
+            "remove",
+            "update",
+            "upgrade",
+            "search",
+            "curate",
+            "show",
+            "workflow",
+            "remember",
+            "import",
+            "clone",
+            "save",
+            "feedback",
+            "registry",
+            "config",
+            "help",
+            "hints",
+            "completions",
+        ];
+        for (const cmd of expected) {
+            expect(script).toContain(cmd);
+        }
+    });
+    test("contains nested config subcommands", () => {
+        expect(script).toContain('"akm config"');
+        for (const sub of ["path", "list", "get", "set", "unset"]) {
+            expect(script).toContain(sub);
+        }
+    });
+    test("contains nested registry subcommands", () => {
+        expect(script).toContain('"akm registry"');
+        for (const sub of ["list", "add", "remove", "search", "build-index"]) {
+            expect(script).toContain(sub);
+        }
+    });
+    test("contains flag value completions for --format", () => {
+        expect(script).toContain("--format)");
+        expect(script).toContain("json text yaml jsonl");
+    });
+    test("contains flag value completions for --detail", () => {
+        expect(script).toContain("--detail)");
+        expect(script).toContain("brief normal full summary");
+    });
+    test("contains flag value completions for --type", () => {
+        expect(script).toContain("--type)");
+        expect(script).toContain("skill command agent knowledge workflow script memory vault wiki lesson any");
+    });
+    test("contains flag value completions for --source", () => {
+        expect(script).toContain("--source)");
+        expect(script).toContain("stash registry both");
+    });
+});
+// ── Integration: --install ───────────────────────────────────────────────────
+describe("completions --install", () => {
+    test("writes completion file to XDG_DATA_HOME path", () => {
+        const xdgData = makeTempDir();
+        const result = spawnSync("bun", ["./src/cli.ts", "completions", "--install"], {
+            encoding: "utf8",
+            timeout: 10_000,
+            cwd: path.resolve(import.meta.dir, ".."),
+            env: {
+                ...process.env,
+                AKM_STASH_DIR: undefined,
+                HOME: isolatedHome,
+                XDG_CACHE_HOME: xdgCache,
+                XDG_CONFIG_HOME: xdgConfig,
+                XDG_DATA_HOME: xdgData,
+            },
+        });
+        expect(result.status).toBe(0);
+        const expectedPath = path.join(xdgData, "bash-completion", "completions", "akm");
+        expect(result.stderr).toContain(expectedPath);
+        expect(fs.existsSync(expectedPath)).toBe(true);
+        const content = fs.readFileSync(expectedPath, "utf8");
+        expect(content).toStartWith("#!/bin/bash");
+        expect(content).toContain("complete -F _akm akm");
+    });
+});
+// ── Unsupported shell ────────────────────────────────────────────────────────
+describe("completions unsupported shell", () => {
+    test("rejects unsupported shell type", () => {
+        const { stderr, status } = runCli("completions", "--shell", "zsh");
+        expect(status).not.toBe(0);
+        expect(stderr).toContain("Unsupported shell");
+    });
+});

package/dist/tests/config-cli.test.js

@@ -0,0 +1,193 @@
+import { describe, expect, test } from "bun:test";
+import { getConfigValue, listConfig, parseConfigValue, setConfigValue, unsetConfigValue, } from "../src/commands/config-cli";
+describe("config CLI helpers", () => {
+    test("listConfig omits unconfigured embedding and llm", () => {
+        const config = listConfig({ semanticSearchMode: "auto" });
+        expect(config.embedding).toBeUndefined();
+        expect(config.llm).toBeUndefined();
+        expect(config.output).toEqual({ format: "json", detail: "brief" });
+    });
+    test("parseConfigValue supports output config keys", () => {
+        expect(parseConfigValue("output.format", "yaml")).toEqual({ output: { format: "yaml" } });
+        expect(parseConfigValue("output.detail", "full")).toEqual({ output: { detail: "full" } });
+    });
+    test("parseConfigValue supports install audit config keys", () => {
+        expect(parseConfigValue("security.installAudit.enabled", "false")).toEqual({
+            security: { installAudit: { enabled: false } },
+        });
+        expect(parseConfigValue("security.installAudit.registryAllowlist", '["npm","github.com"]')).toEqual({
+            security: { installAudit: { registryAllowlist: ["npm", "github.com"] } },
+        });
+        expect(parseConfigValue("security.installAudit.allowedFindings", '[{"id":"prompt-reveal-hidden-secrets","ref":"github:owner/repo","path":"skills/review/SKILL.md","reason":"false positive"}]')).toEqual({
+            security: {
+                installAudit: {
+                    allowedFindings: [
+                        {
+                            id: "prompt-reveal-hidden-secrets",
+                            ref: "github:owner/repo",
+                            path: "skills/review/SKILL.md",
+                            reason: "false positive",
+                        },
+                    ],
+                },
+            },
+        });
+    });
+    test("parseConfigValue still accepts registryWhitelist as a legacy alias", () => {
+        expect(parseConfigValue("security.installAudit.registryWhitelist", '["npm"]')).toEqual({
+            security: { installAudit: { registryAllowlist: ["npm"] } },
+        });
+    });
+    test("parseConfigValue supports embedding JSON with dimensions", () => {
+        expect(parseConfigValue("embedding", '{"endpoint":"https://api.openai.com/v1/embeddings","model":"text-embedding-3-small","dimension":384}')).toEqual({
+            embedding: {
+                endpoint: "https://api.openai.com/v1/embeddings",
+                model: "text-embedding-3-small",
+                dimension: 384,
+            },
+        });
+    });
+    test("parseConfigValue supports llm JSON with sampling fields", () => {
+        expect(parseConfigValue("llm", '{"endpoint":"https://api.openai.com/v1/chat/completions","model":"gpt-4o-mini","temperature":0.6,"maxTokens":300}')).toEqual({
+            llm: {
+                endpoint: "https://api.openai.com/v1/chat/completions",
+                model: "gpt-4o-mini",
+                temperature: 0.6,
+                maxTokens: 300,
+            },
+        });
+    });
+    test("setConfigValue sets embedding via JSON", () => {
+        const base = { semanticSearchMode: "auto" };
+        const updated = setConfigValue(base, "embedding", '{"endpoint":"http://localhost:11434/v1/embeddings","model":"nomic-embed-text"}');
+        expect(updated.embedding).toEqual({
+            endpoint: "http://localhost:11434/v1/embeddings",
+            model: "nomic-embed-text",
+        });
+    });
+    test("setConfigValue sets llm via JSON", () => {
+        const base = { semanticSearchMode: "auto" };
+        const updated = setConfigValue(base, "llm", '{"endpoint":"http://localhost:11434/v1/chat/completions","model":"llama3.2","temperature":0.3}');
+        expect(updated.llm).toEqual({
+            endpoint: "http://localhost:11434/v1/chat/completions",
+            model: "llama3.2",
+            temperature: 0.3,
+        });
+    });
+    test("getConfigValue returns null for unconfigured embedding/llm", () => {
+        const base = { semanticSearchMode: "auto" };
+        expect(getConfigValue(base, "embedding")).toBeNull();
+        expect(getConfigValue(base, "llm")).toBeNull();
+    });
+    test("getConfigValue returns configured embedding/llm objects", () => {
+        const base = {
+            semanticSearchMode: "auto",
+            embedding: {
+                endpoint: "https://api.openai.com/v1/embeddings",
+                model: "text-embedding-3-small",
+            },
+            llm: {
+                endpoint: "http://localhost:11434/v1/chat/completions",
+                model: "llama3.2",
+                temperature: 0.3,
+            },
+        };
+        expect(getConfigValue(base, "embedding")).toEqual(base.embedding);
+        expect(getConfigValue(base, "llm")).toEqual(base.llm);
+    });
+    test("set/get/unset support install audit config keys", () => {
+        const base = { semanticSearchMode: "auto" };
+        const configured = setConfigValue(base, "security.installAudit.enabled", "true");
+        const withWhitelist = setConfigValue(configured, "security.installAudit.registryAllowlist", '["npm","github.com"]');
+        const withAllowedFindings = setConfigValue(withWhitelist, "security.installAudit.allowedFindings", '[{"id":"bundled-package-directory","path":"venv"}]');
+        expect(getConfigValue(withAllowedFindings, "security.installAudit.enabled")).toBe(true);
+        expect(getConfigValue(withAllowedFindings, "security.installAudit.registryAllowlist")).toEqual([
+            "npm",
+            "github.com",
+        ]);
+        expect(getConfigValue(withAllowedFindings, "security.installAudit.allowedFindings")).toEqual([
+            { id: "bundled-package-directory", path: "venv" },
+        ]);
+        expect(unsetConfigValue(withAllowedFindings, "security.installAudit.registryAllowlist").security).toEqual({
+            installAudit: { enabled: true, allowedFindings: [{ id: "bundled-package-directory", path: "venv" }] },
+        });
+        expect(unsetConfigValue(withAllowedFindings, "security.installAudit.allowedFindings").security).toEqual({
+            installAudit: { enabled: true, registryAllowlist: ["npm", "github.com"] },
+        });
+    });
+    test("unsetConfigValue clears embedding and llm", () => {
+        const base = {
+            semanticSearchMode: "auto",
+            embedding: {
+                endpoint: "https://api.openai.com/v1/embeddings",
+                model: "text-embedding-3-small",
+            },
+            llm: {
+                endpoint: "http://localhost:11434/v1/chat/completions",
+                model: "llama3.2",
+            },
+        };
+        const noEmbed = unsetConfigValue(base, "embedding");
+        expect(noEmbed.embedding).toBeUndefined();
+        const noLlm = unsetConfigValue(base, "llm");
+        expect(noLlm.llm).toBeUndefined();
+    });
+    test("setConfigValue merges output format and detail", () => {
+        const base = { semanticSearchMode: "auto" };
+        const withFormat = setConfigValue(base, "output.format", "text");
+        const withDetail = setConfigValue(withFormat, "output.detail", "full");
+        expect(withDetail.output).toEqual({ format: "text", detail: "full" });
+    });
+    test("getConfigValue reads output keys", () => {
+        const base = {
+            semanticSearchMode: "auto",
+            output: { format: "yaml", detail: "normal" },
+        };
+        expect(getConfigValue(base, "output.format")).toBe("yaml");
+        expect(getConfigValue(base, "output.detail")).toBe("normal");
+    });
+    test("unsetConfigValue clears individual output keys", () => {
+        const base = {
+            semanticSearchMode: "auto",
+            output: { format: "yaml", detail: "normal" },
+        };
+        expect(unsetConfigValue(base, "output.format").output).toEqual({ detail: "normal" });
+        expect(unsetConfigValue(base, "output.detail").output).toEqual({ format: "yaml" });
+    });
+    test("setConfigValue rejects unknown keys", () => {
+        const base = { semanticSearchMode: "auto" };
+        expect(() => setConfigValue(base, "embedding.provider", "ollama")).toThrow("Unknown config key");
+        expect(() => setConfigValue(base, "llm.temperature", "0.5")).toThrow("Unknown config key");
+    });
+    test("parseConfigValue rejects non-integer embedding dimension in JSON", () => {
+        expect(() => parseConfigValue("embedding", '{"endpoint":"https://api.openai.com/v1/embeddings","model":"text-embedding-3-small","dimension":384.5}')).toThrow("expected a positive integer");
+    });
+    test("parseConfigValue rejects invalid output values", () => {
+        expect(() => parseConfigValue("output.format", "xml")).toThrow("expected one of json|yaml|text");
+        expect(() => parseConfigValue("output.detail", "max")).toThrow("expected one of brief|normal|full");
+    });
+    test("parseConfigValue rejects invalid install audit values", () => {
+        expect(() => parseConfigValue("security.installAudit.enabled", "yes")).toThrow("expected true or false");
+        expect(() => parseConfigValue("security.installAudit.registryAllowlist", '{"npm":true}')).toThrow("expected a JSON array of strings");
+        expect(() => parseConfigValue("security.installAudit.allowedFindings", '{"id":"x"}')).toThrow("expected a JSON array");
+    });
+    test("parseConfigValue coerces 'true' to 'auto' for semanticSearchMode", () => {
+        const result = parseConfigValue("semanticSearchMode", "true");
+        expect(result).toEqual({ semanticSearchMode: "auto" });
+    });
+    test("parseConfigValue coerces 'false' to 'off' for semanticSearchMode", () => {
+        const result = parseConfigValue("semanticSearchMode", "false");
+        expect(result).toEqual({ semanticSearchMode: "off" });
+    });
+    test("parseConfigValue accepts 'auto' for semanticSearchMode", () => {
+        const result = parseConfigValue("semanticSearchMode", "auto");
+        expect(result).toEqual({ semanticSearchMode: "auto" });
+    });
+    test("parseConfigValue accepts 'off' for semanticSearchMode", () => {
+        const result = parseConfigValue("semanticSearchMode", "off");
+        expect(result).toEqual({ semanticSearchMode: "off" });
+    });
+    test("parseConfigValue rejects invalid semanticSearchMode", () => {
+        expect(() => parseConfigValue("semanticSearchMode", "yes")).toThrow("Invalid value for semanticSearchMode");
+    });
+});

package/dist/tests/config-llm-features.test.js

@@ -0,0 +1,139 @@
+/**
+ * Config-load contract for `llm.features.*` (v1 spec §14, #227).
+ *
+ * Locks:
+ *   - All locked keys with runtime consumers parse through into the runtime
+ *     `LlmFeatureFlags`.
+ *   - Defaults are absent (interpreted as `false` at every call site —
+ *     `isLlmFeatureEnabled` is the seam, see tests/llm-feature-gate.test.ts).
+ *   - Non-boolean values are warn-and-skipped (no throw, the rest of the
+ *     features block continues to parse).
+ *   - Unknown keys are warn-and-skipped (no throw, no schema mutation).
+ */
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { getConfigPath, loadConfig, resetConfigCache } from "../src/core/config";
+const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
+const originalHome = process.env.HOME;
+let testConfigHome = "";
+function makeTmpDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "akm-cfg-llm-features-"));
+}
+function writeConfig(content) {
+    const cfgPath = getConfigPath();
+    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+    fs.writeFileSync(cfgPath, JSON.stringify(content));
+}
+beforeEach(() => {
+    testConfigHome = makeTmpDir();
+    process.env.XDG_CONFIG_HOME = testConfigHome;
+    resetConfigCache();
+});
+afterEach(() => {
+    if (originalXdgConfigHome === undefined)
+        delete process.env.XDG_CONFIG_HOME;
+    else
+        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
+    if (originalHome === undefined)
+        delete process.env.HOME;
+    else
+        process.env.HOME = originalHome;
+    if (testConfigHome) {
+        fs.rmSync(testConfigHome, { recursive: true, force: true });
+        testConfigHome = "";
+    }
+    resetConfigCache();
+});
+describe("loadConfig — llm.features (v1 spec §14)", () => {
+    test("parses all locked feature keys with runtime consumers", () => {
+        writeConfig({
+            llm: {
+                endpoint: "http://localhost:11434/v1/chat/completions",
+                model: "llama3.2",
+                features: {
+                    curate_rerank: true,
+                    feedback_distillation: true,
+                    memory_inference: true,
+                    graph_extraction: true,
+                },
+            },
+        });
+        const cfg = loadConfig();
+        expect(cfg.llm?.features).toEqual({
+            curate_rerank: true,
+            feedback_distillation: true,
+            memory_inference: true,
+            graph_extraction: true,
+        });
+    });
+    test("absent keys remain absent (default-false at call sites)", () => {
+        writeConfig({
+            llm: {
+                endpoint: "http://localhost:11434/v1/chat/completions",
+                model: "llama3.2",
+                features: { curate_rerank: true },
+            },
+        });
+        const cfg = loadConfig();
+        expect(cfg.llm?.features?.curate_rerank).toBe(true);
+        expect(cfg.llm?.features?.feedback_distillation).toBeUndefined();
+        expect(cfg.llm?.features?.memory_inference).toBeUndefined();
+        expect(cfg.llm?.features?.graph_extraction).toBeUndefined();
+    });
+    test("non-boolean values warn and are skipped without breaking siblings", () => {
+        const warnSpy = spyOn(console, "warn").mockImplementation(() => { });
+        try {
+            writeConfig({
+                llm: {
+                    endpoint: "http://localhost:11434/v1/chat/completions",
+                    model: "llama3.2",
+                    features: {
+                        curate_rerank: "yes",
+                        graph_extraction: 1,
+                        feedback_distillation: true,
+                    },
+                },
+            });
+            const cfg = loadConfig();
+            expect(cfg.llm?.features?.curate_rerank).toBeUndefined();
+            expect(cfg.llm?.features?.graph_extraction).toBeUndefined();
+            // The valid sibling continues to parse.
+            expect(cfg.llm?.features?.feedback_distillation).toBe(true);
+            const messages = warnSpy.mock.calls.map((c) => String(c[0]));
+            expect(messages.some((m) => m.includes("curate_rerank") && m.includes("expected boolean"))).toBe(true);
+            expect(messages.some((m) => m.includes("graph_extraction") && m.includes("expected boolean"))).toBe(true);
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    });
+    test("unknown keys warn and are dropped without affecting locked keys", () => {
+        const warnSpy = spyOn(console, "warn").mockImplementation(() => { });
+        try {
+            writeConfig({
+                llm: {
+                    endpoint: "http://localhost:11434/v1/chat/completions",
+                    model: "llama3.2",
+                    features: {
+                        curate_rerank: true,
+                        // Unknown keys must be warn-and-ignore (v1 spec §14.3).
+                        future_feature: true,
+                        another_one: false,
+                    },
+                },
+            });
+            const cfg = loadConfig();
+            expect(cfg.llm?.features?.curate_rerank).toBe(true);
+            expect(cfg.llm?.features?.future_feature).toBeUndefined();
+            expect(cfg.llm?.features?.another_one).toBeUndefined();
+            const messages = warnSpy.mock.calls.map((c) => String(c[0]));
+            expect(messages.some((m) => m.includes("future_feature") && m.includes("Ignoring"))).toBe(true);
+            expect(messages.some((m) => m.includes("another_one") && m.includes("Ignoring"))).toBe(true);
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    });
+});