akm-cli 0.7.0 → 0.7.1

package/dist/tests/completions.test.js

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

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

@@ -1,139 +0,0 @@
-/**
- * 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();
-        }
-    });
-});