akm-cli 0.7.0-rc1 → 0.7.0

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

@@ -485,6 +485,206 @@ describe("AKM_REGISTRY_URL env var", () => {
             srv2.close();
         }
     });
+    // Problem A: env-based override must preserve provider type
+    test("provider::url syntax routes to the declared provider type", async () => {
+        // Stand up a skills-sh-shaped endpoint
+        const skillsSrv = Bun.serve({
+            port: 0,
+            fetch() {
+                return new Response(JSON.stringify({
+                    skills: [{ id: "org/tools/my-skill", name: "my-skill", installs: 200, source: "org/tools" }],
+                }), { headers: { "Content-Type": "application/json" } });
+            },
+        });
+        process.env.AKM_REGISTRY_URL = `skills-sh::http://localhost:${skillsSrv.port}`;
+        try {
+            const result = await searchRegistry("my-skill");
+            // skills-sh provider should have handled this — hits use skills-sh id format
+            expect(result.hits.length).toBeGreaterThan(0);
+            expect(result.hits[0].id).toBe("skills-sh:org/tools/my-skill");
+            expect(result.hits[0].installRef).toBe("github:org/tools");
+            expect(result.warnings).toEqual([]);
+        }
+        finally {
+            skillsSrv.stop(true);
+        }
+    });
+    test("bare URL in env var defaults to static-index provider", async () => {
+        const srv = serveIndex(FIXTURE_INDEX);
+        process.env.AKM_REGISTRY_URL = srv.url;
+        try {
+            const result = await searchRegistry("openkit");
+            expect(result.hits.length).toBeGreaterThan(0);
+            // static-index uses the stash id directly
+            expect(result.hits[0].id).toBe("npm:@itlackey/openkit");
+        }
+        finally {
+            srv.close();
+        }
+    });
+    test("unknown provider type in env var produces warning, not crash", async () => {
+        process.env.AKM_REGISTRY_URL = `no-such-provider::http://127.0.0.1:1/index.json`;
+        const result = await searchRegistry("anything");
+        expect(result.hits).toEqual([]);
+        expect(result.warnings.length).toBe(1);
+        expect(result.warnings[0]).toContain("no-such-provider");
+    });
+    test("mixed provider types in comma-separated env var", async () => {
+        const staticSrv = serveIndex({
+            version: 3,
+            updatedAt: "2026-01-01T00:00:00Z",
+            stashes: [
+                {
+                    id: "npm:env-static-stash",
+                    name: "env-static-stash",
+                    ref: "env-static-stash",
+                    source: "npm",
+                    tags: ["deploy"],
+                },
+            ],
+        });
+        const skillsSrv = Bun.serve({
+            port: 0,
+            fetch() {
+                return new Response(JSON.stringify({
+                    skills: [{ id: "user/tools/env-skill", name: "env-skill", installs: 100, source: "user/tools" }],
+                }), { headers: { "Content-Type": "application/json" } });
+            },
+        });
+        process.env.AKM_REGISTRY_URL = `${staticSrv.url},skills-sh::http://localhost:${skillsSrv.port}`;
+        try {
+            const result = await searchRegistry("env");
+            const ids = result.hits.map((h) => h.id);
+            expect(ids).toContain("npm:env-static-stash");
+            expect(ids).toContain("skills-sh:user/tools/env-skill");
+            expect(result.warnings).toEqual([]);
+        }
+        finally {
+            staticSrv.close();
+            skillsSrv.stop(true);
+        }
+    });
+});
+// ── Score normalization (Problem B) ─────────────────────────────────────────
+describe("cross-provider score normalization", () => {
+    test("scores from all providers are in [0, 1] after normalization", async () => {
+        // static-index raw scores can exceed 1 (e.g. exact name + tag + description).
+        // After normalization, all scores in the merged response must be <= 1.
+        const srv = serveIndex(FIXTURE_INDEX);
+        try {
+            const result = await searchRegistry("openkit bun typescript starter", {
+                registries: [{ url: srv.url }],
+            });
+            for (const hit of result.hits) {
+                if (hit.score !== undefined) {
+                    expect(hit.score).toBeGreaterThanOrEqual(0);
+                    expect(hit.score).toBeLessThanOrEqual(1);
+                }
+            }
+        }
+        finally {
+            srv.close();
+        }
+    });
+    test("top hit within a provider batch retains score = 1 after normalization", async () => {
+        // The highest-scored hit in each provider batch should map to exactly 1.0.
+        const srv = serveIndex(FIXTURE_INDEX);
+        try {
+            const result = await searchRegistry("openkit", {
+                registries: [{ url: srv.url }],
+            });
+            expect(result.hits.length).toBeGreaterThan(0);
+            const topScore = result.hits[0].score;
+            expect(topScore).toBe(1);
+        }
+        finally {
+            srv.close();
+        }
+    });
+    test("merged multi-provider results are ordered by normalized score", async () => {
+        // Provider A: static-index with a moderate-relevance match.
+        // Provider B: skills-sh with a high-installs match.
+        // After normalization each batch has max=1; the better-matched kit wins.
+        const staticSrv = serveIndex({
+            version: 3,
+            updatedAt: "2026-01-01T00:00:00Z",
+            stashes: [
+                {
+                    id: "npm:exact-name-match",
+                    name: "deploy",
+                    description: "exact match",
+                    ref: "exact-name-match",
+                    source: "npm",
+                    tags: ["deploy"],
+                },
+                {
+                    id: "npm:partial-match",
+                    name: "deployment-helper",
+                    description: "partial",
+                    ref: "partial-match",
+                    source: "npm",
+                    tags: [],
+                },
+            ],
+        });
+        const skillsSrv = Bun.serve({
+            port: 0,
+            fetch() {
+                return new Response(JSON.stringify({
+                    skills: [
+                        { id: "org/deploy-skill", name: "deploy-skill", installs: 1000, source: "org/deploy-skill" },
+                        { id: "org/other-skill", name: "other-skill", installs: 100, source: "org/other" },
+                    ],
+                }), { headers: { "Content-Type": "application/json" } });
+            },
+        });
+        try {
+            const result = await searchRegistry("deploy", {
+                registries: [{ url: staticSrv.url }, { url: `http://localhost:${skillsSrv.port}`, provider: "skills-sh" }],
+            });
+            // All scores in [0, 1]
+            for (const hit of result.hits) {
+                if (hit.score !== undefined) {
+                    expect(hit.score).toBeGreaterThanOrEqual(0);
+                    expect(hit.score).toBeLessThanOrEqual(1);
+                }
+            }
+            // Results should be sorted descending
+            for (let i = 1; i < result.hits.length; i++) {
+                expect((result.hits[i - 1].score ?? 0) >= (result.hits[i].score ?? 0)).toBe(true);
+            }
+        }
+        finally {
+            staticSrv.close();
+            skillsSrv.stop(true);
+        }
+    });
+    test("single-hit provider batch normalizes to score 1", async () => {
+        const srv = serveIndex({
+            version: 3,
+            updatedAt: "2026-01-01T00:00:00Z",
+            stashes: [
+                {
+                    id: "npm:only-stash",
+                    name: "only-stash",
+                    description: "only one",
+                    ref: "only-stash",
+                    source: "npm",
+                    tags: ["unique"],
+                },
+            ],
+        });
+        try {
+            const result = await searchRegistry("unique", {
+                registries: [{ url: srv.url }],
+            });
+            expect(result.hits.length).toBe(1);
+            expect(result.hits[0].score).toBe(1);
+        }
+        finally {
+            srv.close();
+        }
+    });
 });
 // ── Provenance tagging ──────────────────────────────────────────────────────
 describe("provenance tagging", () => {

package/dist/tests/remember-frontmatter.test.js

@@ -67,6 +67,13 @@ describe("zero-flag remember", () => {
         const content = fs.readFileSync(json.path, "utf8");
         expect(content.startsWith("---")).toBe(false);
     });
+    test("reads stdin when --format json is present", () => {
+        const { result } = runCli(["remember", "--name", "from-stdin", "--format", "json"], { input: "stdin body" });
+        expect(result.status).toBe(0);
+        const json = JSON.parse(result.stdout);
+        expect(fs.readFileSync(json.path, "utf8")).toContain("stdin body");
+        expect(fs.readFileSync(json.path, "utf8")).not.toContain("\njson");
+    });
 });
 // ── CLI args (Mode 1) ────────────────────────────────────────────────────────
 describe("remember --tag", () => {
@@ -227,21 +234,12 @@ describe("remember --auto", () => {
         expect(parsed.data.observed_at).toBe("2026-01-15");
         void result; // suppress unused variable warning
     });
-    test("--auto without any tags from heuristics or CLI rejects with missing-fields error", () => {
+    test("--auto without any tags from heuristics or CLI still writes the memory", () => {
         // Plain text body — no code block, no URL. Heuristics won't derive any tags.
         const { result } = runCli(["remember", "Plain text note without any tags derivable", "--auto"]);
-        // If no heuristic tags are derived and no CLI tags provided, should fail
-        // (The auto heuristic only adds "code" for code blocks, none for plain text)
-        // This tests that the guard fires correctly
-        if (result.status !== 0) {
-            const json = JSON.parse(result.stderr);
-            expect(json.error).toContain("tags");
-        }
-        else {
-            // If some future heuristic adds tags for plain text, just verify the file is written
-            const json = JSON.parse(result.stdout);
-            expect(fs.existsSync(json.path)).toBe(true);
-        }
+        expect(result.status).toBe(0);
+        const json = JSON.parse(result.stdout);
+        expect(fs.existsSync(json.path)).toBe(true);
     });
     test("--auto + explicit --tag satisfies required-field check", () => {
         const body = "No special content here";

package/dist/tests/source-qa-fixes.test.js

@@ -14,7 +14,9 @@ import os from "node:os";
 import path from "node:path";
 import { akmListSources, akmUpdate } from "../src/commands/installed-stashes";
 import { akmAdd } from "../src/commands/source-add";
+import { addStash } from "../src/commands/source-manage";
 import { loadConfig, saveConfig } from "../src/core/config";
+import { ConfigError } from "../src/core/errors";
 const createdTmpDirs = [];
 function createTmpDir(prefix = "akm-qa-") {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
@@ -115,6 +117,22 @@ describe("issue #9: --name flag persisted for filesystem sources", () => {
         expect(typeof added?.name).toBe("string");
     });
 });
+describe("manual QA add validation", () => {
+    test("akmAdd rejects writable installs for npm refs before syncing", async () => {
+        saveConfig({ semanticSearchMode: "off" });
+        await expect(akmAdd({ ref: "npm:left-pad", writable: true })).rejects.toThrow(ConfigError);
+    });
+    test("addStash rejects openviking providers before persisting config", () => {
+        saveConfig({ semanticSearchMode: "off" });
+        expect(() => addStash({ target: "https://example.com", providerType: "openviking" })).toThrow(ConfigError);
+        expect(loadConfig().sources).toBeUndefined();
+    });
+    test("addStash rejects writable website sources before persisting config", () => {
+        saveConfig({ semanticSearchMode: "off" });
+        expect(() => addStash({ target: "https://example.com", providerType: "website", writable: true })).toThrow(ConfigError);
+        expect(loadConfig().sources).toBeUndefined();
+    });
+});
 // ── Issue #10: filesystem kind = "filesystem" in list output ──────────────
 describe("issue #10: filesystem kind in list output", () => {
     test("filesystem source has kind='filesystem' in akmListSources", async () => {

package/dist/tests/source-registry.test.js

@@ -155,9 +155,9 @@ describe("akmListSources", () => {
             semanticSearchMode: "off",
             installed: [
                 {
-                    id: "github:owner/repo",
-                    source: "github",
-                    ref: "github:owner/repo",
+                    id: "git:https://github.com/owner/repo",
+                    source: "git",
+                    ref: "git:https://github.com/owner/repo.git",
                     artifactUrl: "https://github.com/owner/repo.git",
                     stashRoot,
                     cacheDir,

package/dist/tests/source-source.test.js

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { saveConfig } from "../src/core/config";
-import { findSourceForPath, getPrimarySource, isEditable, resolveAllStashDirs, resolveSourceEntries, } from "../src/indexer/search-source";
+import { ensureSourceCaches, findSourceForPath, getPrimarySource, isEditable, resolveAllStashDirs, resolveSourceEntries, } from "../src/indexer/search-source";
 const originalStashDir = process.env.AKM_STASH_DIR;
 const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
 let testConfigDir = "";
@@ -219,3 +219,63 @@ describe("isEditable", () => {
         expect(isEditable("/some/random/path/file.sh")).toBe(true);
     });
 });
+// ── ensureSourceCaches ────────────────────────────────────────────────────────
+describe("ensureSourceCaches", () => {
+    test("completes without error when sources[] is empty", async () => {
+        const config = { semanticSearchMode: "off", sources: [] };
+        await expect(ensureSourceCaches(config)).resolves.toBeUndefined();
+    });
+    test("completes without error when sources[] has filesystem entries (no sync needed)", async () => {
+        const config = {
+            semanticSearchMode: "off",
+            sources: [{ type: "filesystem", path: stashDir }],
+        };
+        await expect(ensureSourceCaches(config)).resolves.toBeUndefined();
+    });
+    test("reads from sources[] not stashes[] — git entries in sources[] are processed", async () => {
+        // A config where sources[] has a git entry and stashes is undefined.
+        // We can't run a real git mirror in unit tests, but we verify that the
+        // function does NOT throw even when the git URL is unreachable (it warns).
+        const config = {
+            semanticSearchMode: "off",
+            sources: [
+                {
+                    type: "git",
+                    url: "https://github.com/example/nonexistent-repo.git",
+                    name: "test-git",
+                },
+            ],
+        };
+        // Should resolve (not reject) — failures are warn-only
+        await expect(ensureSourceCaches(config)).resolves.toBeUndefined();
+    });
+    test("reads from sources[] not stashes[] — website entries in sources[] are processed", async () => {
+        // A config where sources[] has a website entry and stashes is undefined.
+        // The mirror will fail (unreachable host) but the function warns, not throws.
+        const config = {
+            semanticSearchMode: "off",
+            sources: [
+                {
+                    type: "website",
+                    url: "https://example.invalid/docs",
+                    name: "test-website",
+                },
+            ],
+        };
+        await expect(ensureSourceCaches(config)).resolves.toBeUndefined();
+    });
+    test("stashes[] entries are still processed for one-release backwards compat", async () => {
+        // stashes[] is deprecated but still accepted in the runtime shape for one release.
+        const config = {
+            semanticSearchMode: "off",
+            stashes: [
+                {
+                    type: "git",
+                    url: "https://github.com/example/nonexistent-repo.git",
+                    name: "legacy-git",
+                },
+            ],
+        };
+        await expect(ensureSourceCaches(config)).resolves.toBeUndefined();
+    });
+});

package/dist/tests/workflow-qa-fixes.test.js

@@ -282,6 +282,24 @@ describe("workflow status with workflow ref", () => {
         const err = JSON.parse(status.stderr);
         expect(err.error).toContain("No workflow runs found");
     });
+    test("next with an unknown run id returns WORKFLOW_NOT_FOUND", () => {
+        const env = createWorkflowEnv();
+        setupWorkflow(env);
+        const next = runCli(["workflow", "next", "bogus-run-id"], env);
+        expect(next.status).toBe(1);
+        const err = JSON.parse(next.stderr);
+        expect(err.code).toBe("WORKFLOW_NOT_FOUND");
+        expect(err.hint).toContain("akm workflow list --active");
+    });
+    test("status with an unknown run id returns WORKFLOW_NOT_FOUND", () => {
+        const env = createWorkflowEnv();
+        setupWorkflow(env);
+        const status = runCli(["workflow", "status", "bogus-run-id"], env);
+        expect(status.status).toBe(1);
+        const err = JSON.parse(status.stderr);
+        expect(err.code).toBe("WORKFLOW_NOT_FOUND");
+        expect(err.hint).toContain("akm workflow list --active");
+    });
 });
 // ---------------------------------------------------------------------------
 // 7. workflow create name validation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.7.0-rc1",
+  "version": "0.7.0",
   "type": "module",
   "description": "akm (Agent Kit Manager) — A package manager for AI agent skills, commands, tools, and knowledge. Works with Claude Code, OpenCode, Cursor, and any AI coding assistant.",
   "keywords": [