akm-cli 0.9.0-beta.5 → 0.9.0-beta.51

package/dist/output/renderers.js

@@ -377,7 +377,7 @@ const envFileRenderer = {
             type: "env",
             name,
             path: ctx.absPath,
-            action: "Environment — keys + comments only. Use `akm env run <ref> -- <command>` to run with the whole .env injected (the safe path — values never reach stdout). `akm env export <ref> --out <file>` writes a sourceable script to a file. Never `source` the raw file. Values stay on disk and are never written to akm's stdout.",
+            action: "Environment — keys + comments only. Use `akm env run <ref> -- <command>` to run with the whole .env injected; prefer `--clean` to minimize inherited parent env. AKM itself does not print values, but child stdout/stderr is not redacted. `akm env export <ref> --out <file>` writes a sourceable script to a file. Never `source` the raw file. Values stay on disk and are never written to akm's stdout.",
             description: comments.length > 0 ? comments.join("\n") : undefined,
             keys,
             comments,
@@ -468,6 +468,44 @@ const sessionMdRenderer = {
         };
     },
 };
+// ── 9. fact-md ───────────────────────────────────────────────────────────────
+/**
+ * Renderer for the `fact` asset type. A fact is durable stash-level semantic
+ * knowledge (personal/team/project details, coding conventions, stash-meta).
+ * It carries `category` (personal|team|project|convention|meta) and an
+ * optional `pinned` flag marking it as part of the always-injected core. The
+ * renderer surfaces a one-liner (category + pinned marker) so an agent can tell
+ * at a glance what kind of fact it is and whether it is core context.
+ */
+const factMdRenderer = {
+    name: "fact-md",
+    buildShowResponse(ctx) {
+        const name = deriveName(ctx);
+        const parsed = parseFrontmatter(ctx.content());
+        const fm = parsed.data;
+        const category = asNonEmptyString(fm.category);
+        const description = asNonEmptyString(fm.description);
+        const pinned = fm.pinned === true;
+        const headerParts = [
+            category ? `category: ${category}` : undefined,
+            pinned ? "pinned (core context)" : undefined,
+        ].filter((p) => !!p);
+        const action = [
+            "Durable stash fact — apply it as background context.",
+            headerParts.length > 0 ? headerParts.join("  ") : undefined,
+        ]
+            .filter((p) => !!p)
+            .join("\n");
+        return {
+            type: "fact",
+            name,
+            path: ctx.absPath,
+            action,
+            description,
+            content: parsed.content,
+        };
+    },
+};
 function applySessionMetadata(entry, ctx) {
     try {
         const fm = applyFrontmatterDescriptionAndTags(entry, ctx);
@@ -501,6 +539,34 @@ function applyTocMetadata(entry, ctx) {
         // Non-fatal: skip TOC if file can't be read
     }
 }
+/**
+ * Fact metadata: surface `category` and the `pinned` core marker as tags +
+ * search hints (no dedicated DB columns — same encoding pattern as session /
+ * task). `pinned` is mirrored to both a `pinned` tag and a `pinned` search
+ * hint so the ranking contributor can detect it and queries can target it.
+ */
+function applyFactMetadata(entry, ctx) {
+    try {
+        const fm = applyFrontmatterDescriptionAndTags(entry, ctx);
+        const tags = new Set([...(entry.tags ?? []), "fact"]);
+        const hints = new Set(entry.searchHints ?? []);
+        const category = asNonEmptyString(fm.category);
+        if (category) {
+            tags.add(category);
+            hints.add(`category:${category}`);
+        }
+        if (fm.pinned === true) {
+            tags.add("pinned");
+            hints.add("pinned");
+        }
+        entry.tags = Array.from(tags).filter(Boolean);
+        if (hints.size > 0)
+            entry.searchHints = Array.from(hints).filter(Boolean);
+    }
+    catch {
+        // Non-fatal: skip metadata extraction on parse error
+    }
+}
 /**
  * Parse frontmatter, apply description (if not already set) and merge tags
  * into `entry`. Returns the raw frontmatter data object so callers can access
@@ -660,6 +726,11 @@ registerMetadataContributor({
     appliesTo: ({ rendererName }) => rendererName === "session-md",
     contribute: (entry, ctx) => applySessionMetadata(entry, ctx.renderContext),
 });
+registerMetadataContributor({
+    name: "fact-md-metadata",
+    appliesTo: ({ rendererName }) => rendererName === "fact-md",
+    contribute: (entry, ctx) => applyFactMetadata(entry, ctx.renderContext),
+});
 // ── Registration ─────────────────────────────────────────────────────────────
 /** All built-in renderers. */
 const builtinRenderers = [
@@ -676,6 +747,7 @@ const builtinRenderers = [
     secretFileRenderer,
     taskMdRenderer,
     sessionMdRenderer,
+    factMdRenderer,
 ];
 /**
  * Register all built-in renderers with the file-context registry.
@@ -687,4 +759,4 @@ export function registerBuiltinRenderers() {
     }
 }
 // ── Named exports for testing ────────────────────────────────────────────────
-export { agentMdRenderer, commandMdRenderer, envFileRenderer, INTERPRETER_MAP, knowledgeMdRenderer, lessonMdRenderer, memoryMdRenderer, SETUP_SIGNALS, scriptSourceRenderer, secretFileRenderer, skillMdRenderer, wikiMdRenderer, workflowMdRenderer, };
+export { agentMdRenderer, commandMdRenderer, envFileRenderer, factMdRenderer, INTERPRETER_MAP, knowledgeMdRenderer, lessonMdRenderer, memoryMdRenderer, SETUP_SIGNALS, scriptSourceRenderer, secretFileRenderer, skillMdRenderer, wikiMdRenderer, workflowMdRenderer, };

package/dist/output/shapes/curate.js

@@ -5,7 +5,7 @@ import { capDescription, NORMAL_DESCRIPTION_LIMIT, pickFields } from "./helpers.
 // Curation is a small, high-signal top-N. Even at `brief` we keep `followUp`
 // (the actionable `akm show <ref>` command) and `reason` (why this asset was
 // selected) — these are the point of curate, unlike a bulk search listing.
-const BRIEF_FIELDS = ["source", "type", "name", "ref", "id", "followUp", "reason"];
+const BRIEF_FIELDS = ["source", "type", "name", "ref", "id", "supportRefs", "followUp", "reason"];
 const NORMAL_FIELDS = [
     "source",
     "type",
@@ -17,12 +17,24 @@ const NORMAL_FIELDS = [
     "keys",
     "parameters",
     "run",
+    "supportRefs",
     "followUp",
     "reason",
     "score",
 ];
 // Agent shape: the minimal field set an LLM needs to decide and act.
-const AGENT_FIELDS = ["source", "type", "name", "ref", "id", "description", "followUp", "reason", "score"];
+const AGENT_FIELDS = [
+    "source",
+    "type",
+    "name",
+    "ref",
+    "id",
+    "description",
+    "supportRefs",
+    "followUp",
+    "reason",
+    "score",
+];
 function shapeCurateItem(item, detail, shape) {
     if (shape === "agent") {
         return capDescription(pickFields(item, AGENT_FIELDS), NORMAL_DESCRIPTION_LIMIT);

package/dist/output/shapes/passthrough.js

@@ -23,7 +23,6 @@ const PASSTHROUGH_COMMANDS = [
     "agent-result",
     "clone",
     "config",
-    "db-backups",
     "disable",
     "enable",
     "env-create",

package/dist/output/text/helpers.js

@@ -1005,6 +1005,15 @@ export function formatCuratePlain(r, detail) {
             lines.push(`  run: ${String(item.run)}`);
         if (item.followUp)
             lines.push(`  show: ${String(item.followUp)}`);
+        if (Array.isArray(item.supportRefs) && item.supportRefs.length > 0) {
+            for (const support of item.supportRefs) {
+                if (!support.ref)
+                    continue;
+                const label = typeof support.type === "string" ? `[${support.type}] ` : "";
+                const why = typeof support.reason === "string" ? ` — ${support.reason}` : "";
+                lines.push(`  support: ${label}${String(support.ref)}${why}`);
+            }
+        }
         if (detail !== "brief" && item.reason)
             lines.push(`  why: ${String(item.reason)}`);
     }
@@ -1026,8 +1035,14 @@ export function formatCuratePlain(r, detail) {
 }
 export function formatInitPlain(r) {
     let out = `Stash initialized at ${r.stashDir ?? "unknown"}`;
-    if (r.configPath)
+    // When --dir scaffolded a secondary stash but the default was deliberately
+    // left untouched, tell the user instead of silently repointing their default.
+    if (r.defaultStashUpdated === false && typeof r.previousStashDir === "string" && r.previousStashDir) {
+        out += `\nYour default stash is unchanged (${r.previousStashDir}). Re-run with --set-default to make ${r.stashDir} the default.`;
+    }
+    else if (r.configPath) {
         out += `\nConfig saved to ${r.configPath}`;
+    }
     return out;
 }
 export function formatIndexPlain(r) {

package/dist/registry/providers/skills-sh.js

@@ -2,46 +2,12 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { fetchWithRetry } from "../../core/common.js";
-import { rethrowIfTestIsolationError } from "../../core/errors.js";
-import { closeDatabase, getRegistryIndexCache, openDatabase, upsertRegistryIndexCache } from "../../indexer/db/db.js";
 import { md5Hex } from "../../runtime.js";
+import { fetchCachedJson } from "../../storage/repositories/registry-cache.js";
 import { registerProvider } from "../factory.js";
 // ── Constants ───────────────────────────────────────────────────────────────
 /** Per-query cache TTL in milliseconds (15 minutes). */
 const QUERY_CACHE_TTL_MS = 15 * 60 * 1000;
-// ── Cache DB lifecycle ────────────────────────────────────────────────────────
-/**
- * RAII-style lifecycle helper for the registry cache DB. Opens the DB (treating
- * a failed open exactly like the legacy fall-through: the bun-test isolation
- * guard is re-thrown, any other failure yields `db = undefined`), runs `fn`,
- * and guarantees the DB is closed in a `finally` after `fn` has fully settled
- * (the await is required: the callbacks are async, and closing before they
- * settle would tear the DB down mid-write).
- */
-async function withRegistryCacheDb(fn) {
-    let db;
-    try {
-        db = openDatabase();
-    }
-    catch (err) {
-        // Never mask the bun-test isolation guard as "DB unavailable".
-        rethrowIfTestIsolationError(err);
-        db = undefined;
-    }
-    try {
-        return await fn(db);
-    }
-    finally {
-        if (db) {
-            try {
-                closeDatabase(db);
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-}
 // ── Provider class ──────────────────────────────────────────────────────────
 class SkillsShProvider {
     type = "skills-sh";
@@ -66,131 +32,39 @@ class SkillsShProvider {
             return { hits: [], warnings: [`Registry ${label}: ${message}`] };
         }
     }
-    // ── v1-spec §3.1 surface ────────────────────────────────────────────────
-    async searchKits(q) {
-        const result = await this.search({
-            query: q.text,
-            limit: q.limit ?? 20,
-            includeAssets: false,
-        });
-        return result.hits.map((hit) => ({
-            id: hit.id,
-            title: hit.title,
-            summary: hit.description,
-            installRef: hit.installRef,
-            score: hit.score,
-        }));
-    }
-    async searchAssets(q) {
-        const result = await this.search({
-            query: q.text,
-            limit: q.limit ?? 20,
-            includeAssets: true,
-        });
-        return (result.assetHits ?? []).map((hit) => ({
-            kitId: hit.stash.id,
-            type: hit.assetType,
-            name: hit.assetName,
-            summary: hit.description,
-            cloneRef: hit.action.replace(/^akm add\s+/, ""),
-        }));
-    }
-    /**
-     * skills.sh has no `getKit` API — every entry corresponds to a GitHub
-     * repository whose metadata we already include in the search result. We
-     * synthesize a manifest from the search hit when the caller knows the stash
-     * id; if not present in the most recent results, return null.
-     */
-    async getKit(id) {
-        if (!id.startsWith("skills-sh:"))
-            return null;
-        const slug = id.slice("skills-sh:".length);
-        // Best-effort: the API gives us search-by-name; extract the leaf segment.
-        const segments = slug.split("/").filter(Boolean);
-        const leaf = segments[segments.length - 1] ?? slug;
-        const result = await this.search({ query: leaf, limit: 50, includeAssets: false });
-        const match = result.hits.find((hit) => hit.id === id);
-        if (!match)
-            return null;
-        return { id: match.id, installRef: match.installRef };
-    }
-    /**
-     * skills.sh entries are always GitHub repositories. Claim only refs whose
-     * parsed source is `github`; defer everything else (npm tarballs, local
-     * paths, raw git URLs) to other registries.
-     */
-    canHandle(ref) {
-        return ref.source === "github";
-    }
     async fetchSkills(query, limit) {
         // Build a stable DB cache key for this query
         const dbCacheKey = this.queryDbCacheKey(query, limit);
-        return withRegistryCacheDb(async (db) => {
-            // ── Step 1: Try DB cache (index.db) ───────────────────────────────────
-            let dbCacheResult;
-            try {
-                if (db) {
-                    dbCacheResult = getRegistryIndexCache(db, dbCacheKey, QUERY_CACHE_TTL_MS);
-                }
-            }
-            catch (err) {
-                // Never mask the bun-test isolation guard as "DB unavailable" — see
-                // rethrowIfTestIsolationError in src/core/errors.ts. Without this,
-                // a leaky test silently gets a cold cache + fresh fetch instead of
-                // the loud TEST_ISOLATION_MISSING failure the guard intends.
-                rethrowIfTestIsolationError(err);
-                // index.db not available yet (pre-migration install or test env) — fall through
-            }
-            if (dbCacheResult) {
+        const baseUrl = this.config.url.replace(/\/+$/, "");
+        const url = `${baseUrl}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`;
+        return fetchCachedJson({
+            cacheKey: dbCacheKey,
+            ttlMs: QUERY_CACHE_TTL_MS,
+            // A fresh hit returns even an empty array; a stale fallback only when
+            // non-empty. Corrupt cache JSON is swallowed and treated as a miss.
+            parseCache: (json, { stale }) => {
                 try {
-                    const parsed = JSON.parse(dbCacheResult.indexJson);
-                    if (Array.isArray(parsed)) {
-                        const entries = parsed.filter(isValidSkillsEntry);
-                        return entries;
-                    }
+                    const parsed = JSON.parse(json);
+                    if (!Array.isArray(parsed))
+                        return undefined;
+                    const entries = parsed.filter(isValidSkillsEntry);
+                    if (stale && entries.length === 0)
+                        return undefined;
+                    return entries;
                 }
                 catch {
-                    /* corrupt DB entry — fall through */
+                    return undefined;
                 }
-            }
-            // ── Step 2: Fetch from API ─────────────────────────────────────────────
-            const baseUrl = this.config.url.replace(/\/+$/, "");
-            const url = `${baseUrl}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`;
-            try {
+            },
+            fetchFresh: async () => {
                 const response = await fetchWithRetry(url, undefined, { timeout: 10_000, retries: 1 });
                 if (!response.ok) {
                     throw new Error(`HTTP ${response.status}`);
                 }
                 const data = (await response.json());
                 const entries = parseSkillsResponse(data);
-                // Write to DB cache (primary)
-                if (db) {
-                    try {
-                        upsertRegistryIndexCache(db, dbCacheKey, JSON.stringify(entries));
-                    }
-                    catch {
-                        /* best-effort */
-                    }
-                }
-                return entries;
-            }
-            catch (err) {
-                // Fetch failed — use stale DB cache if available
-                if (dbCacheResult) {
-                    try {
-                        const parsed = JSON.parse(dbCacheResult.indexJson);
-                        if (Array.isArray(parsed)) {
-                            const entries = parsed.filter(isValidSkillsEntry);
-                            if (entries.length > 0)
-                                return entries;
-                        }
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-                throw err;
-            }
+                return { value: entries, cacheJson: JSON.stringify(entries) };
+            },
         });
     }
     mapToHits(entries) {

package/dist/registry/providers/static-index.js

@@ -2,10 +2,10 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { fetchWithRetry, jsonWithByteCap, toErrorMessage } from "../../core/common.js";
-import { rethrowIfTestIsolationError } from "../../core/errors.js";
-import { closeDatabase, getRegistryIndexCache, openDatabase, upsertRegistryIndexCache } from "../../indexer/db/db.js";
 import { asString } from "../../integrations/github.js";
+import { fetchCachedJson } from "../../storage/repositories/registry-cache.js";
 import { registerProvider } from "../factory.js";
+import { buildInstallRef } from "../resolve.js";
 // ── Constants ───────────────────────────────────────────────────────────────
 /** Cache TTL in milliseconds (1 hour). */
 const CACHE_TTL_MS = 60 * 60 * 1000;
@@ -30,51 +30,6 @@ class StaticIndexProvider {
         }
         return { hits, assetHits, warnings: warnings.length > 0 ? warnings : undefined };
     }
-    // ── v1-spec §3.1 surface ────────────────────────────────────────────────
-    async searchKits(q) {
-        const result = await this.search({
-            query: q.text,
-            limit: q.limit ?? 20,
-            includeAssets: false,
-        });
-        return result.hits.map(hitToKitResult);
-    }
-    async searchAssets(q) {
-        const result = await this.search({
-            query: q.text,
-            limit: q.limit ?? 20,
-            includeAssets: true,
-        });
-        return (result.assetHits ?? []).map(assetHitToPreview);
-    }
-    async getKit(id) {
-        const allKits = await this.loadAllKits([]);
-        const found = allKits.find(({ stash }) => stash.id === id);
-        if (!found)
-            return null;
-        const installRef = buildInstallRef(found.stash.source, found.stash.ref);
-        return {
-            id: found.stash.id,
-            installRef,
-            assets: found.stash.assets?.map((asset) => ({
-                kitId: found.stash.id,
-                type: asset.type,
-                name: asset.name,
-                summary: asset.description,
-                cloneRef: installRef,
-            })),
-        };
-    }
-    /**
-     * Static-index doesn't own a URL prefix — any `ParsedRegistryRef` could
-     * theoretically be backed by an entry in some static-index registry. We
-     * therefore claim every ref. The orchestrator picks the first matching
-     * provider, and `static-index` is registered first by `index.ts`, so this
-     * is effectively the default catch-all.
-     */
-    canHandle(_ref) {
-        return true;
-    }
     // ── Internals ───────────────────────────────────────────────────────────
     async loadAllKits(warnings) {
         const allKits = [];
@@ -94,84 +49,17 @@ class StaticIndexProvider {
         return allKits;
     }
 }
-function hitToKitResult(hit) {
-    return {
-        id: hit.id,
-        title: hit.title,
-        summary: hit.description,
-        installRef: hit.installRef,
-        score: hit.score,
-    };
-}
-function assetHitToPreview(hit) {
-    return {
-        kitId: hit.stash.id,
-        type: hit.assetType,
-        name: hit.assetName,
-        summary: hit.description,
-        cloneRef: hit.action.replace(/^akm add\s+/, ""),
-    };
-}
 // ── Self-register ───────────────────────────────────────────────────────────
 registerProvider("static-index", (config) => new StaticIndexProvider(config));
 // ── Index loading with cache ────────────────────────────────────────────────
-/**
- * RAII-style lifecycle helper for the registry cache DB. Opens the DB (treating
- * a failed open exactly like the legacy fall-through: the bun-test isolation
- * guard is re-thrown, any other failure yields `db = undefined`), runs `fn`,
- * and guarantees the DB is closed in a `finally` after `fn` has fully settled
- * (the await is required: the callbacks are async, and closing before they
- * settle would tear the DB down mid-write).
- */
-async function withRegistryCacheDb(fn) {
-    let db;
-    try {
-        db = openDatabase();
-    }
-    catch (err) {
-        // Never mask the bun-test isolation guard as "DB unavailable".
-        rethrowIfTestIsolationError(err);
-        db = undefined;
-    }
-    try {
-        return await fn(db);
-    }
-    finally {
-        if (db) {
-            try {
-                closeDatabase(db);
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-}
 async function loadIndex(entry) {
-    return withRegistryCacheDb(async (db) => {
-        // ── Step 1: Try DB cache (index.db) ─────────────────────────────────────
-        let dbCacheResult;
-        try {
-            if (db) {
-                dbCacheResult = getRegistryIndexCache(db, entry.url, CACHE_TTL_MS);
-            }
-        }
-        catch (err) {
-            // Never mask the bun-test isolation guard as "DB unavailable" — see
-            // rethrowIfTestIsolationError in src/core/errors.ts. Without this, a
-            // leaky test silently gets a cold cache instead of the loud
-            // TEST_ISOLATION_MISSING failure the guard intends.
-            rethrowIfTestIsolationError(err);
-            // index.db read failed (pre-migration install or test env) — fall through
-        }
-        if (dbCacheResult) {
-            const index = parseRegistryIndex(JSON.parse(dbCacheResult.indexJson));
-            if (index) {
-                return index;
-            }
-        }
-        // ── Step 2: Fetch fresh index from remote ────────────────────────────────
-        try {
+    return fetchCachedJson({
+        cacheKey: entry.url,
+        ttlMs: CACHE_TTL_MS,
+        // Both the fresh hit and the stale fallback parse identically; a corrupt
+        // cache row lets JSON.parse throw out of the load (legacy behaviour).
+        parseCache: (json) => parseRegistryIndex(JSON.parse(json)) ?? undefined,
+        fetchFresh: async () => {
             const response = await fetchWithRetry(entry.url, undefined, { timeout: 10_000 });
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}`);
@@ -180,31 +68,13 @@ async function loadIndex(entry) {
             // responses from a compromised server would OOM us.
             const data = await jsonWithByteCap(response, 50 * 1024 * 1024);
             const index = parseRegistryIndex(data);
-            if (index) {
-                // Write to DB cache (primary)
-                if (db) {
-                    try {
-                        const etag = response.headers.get("etag") ?? undefined;
-                        const lastModified = response.headers.get("last-modified") ?? undefined;
-                        upsertRegistryIndexCache(db, entry.url, JSON.stringify(index), { etag, lastModified });
-                    }
-                    catch {
-                        /* best-effort */
-                    }
-                }
-                return index;
-            }
-            throw new Error("Invalid registry index format");
-        }
-        catch (err) {
-            // Fetch failed — use stale DB cache if available
-            if (dbCacheResult) {
-                const index = parseRegistryIndex(JSON.parse(dbCacheResult.indexJson));
-                if (index)
-                    return index;
+            if (!index) {
+                throw new Error("Invalid registry index format");
             }
-            throw err;
-        }
+            const etag = response.headers.get("etag") ?? undefined;
+            const lastModified = response.headers.get("last-modified") ?? undefined;
+            return { value: index, cacheJson: JSON.stringify(index), cacheOpts: { etag, lastModified } };
+        },
     });
 }
 export function isCacheExpired(mtimeMs) {
@@ -431,15 +301,3 @@ function asStringArray(value) {
     const filtered = value.filter((v) => typeof v === "string");
     return filtered.length > 0 ? filtered : undefined;
 }
-function buildInstallRef(source, ref) {
-    switch (source) {
-        case "npm":
-            return `npm:${ref}`;
-        case "git":
-            return `git+${ref}`;
-        case "local":
-            return `file:${ref}`;
-        default:
-            return `github:${ref}`;
-    }
-}

package/dist/registry/resolve.js

@@ -70,6 +70,19 @@ export function parseRegistryRef(rawRef) {
     }
     return parseGithubShorthand(ref, ref);
 }
+/** Inverse of {@link parseRegistryRef}: build the install ref for a source kind. */
+export function buildInstallRef(source, ref) {
+    switch (source) {
+        case "npm":
+            return `npm:${ref}`;
+        case "git":
+            return `git+${ref}`;
+        case "local":
+            return `file:${ref}`;
+        case "github":
+            return `github:${ref}`;
+    }
+}
 /**
  * Known prefixes that `parseRegistryRef` handles as installable sources.
  * Anything with a colon that doesn't start with one of these is likely a
@@ -105,16 +118,16 @@ function detectRegistrySearchId(ref) {
     return lines.join("\n");
 }
 export async function resolveRegistryArtifact(parsed) {
-    if (parsed.source === "npm") {
-        return resolveNpmArtifact(parsed);
-    }
-    if (parsed.source === "local") {
-        return resolveLocalArtifact(parsed);
-    }
-    if (parsed.source === "git") {
-        return resolveGitArtifact(parsed);
+    switch (parsed.source) {
+        case "npm":
+            return resolveNpmArtifact(parsed);
+        case "local":
+            return resolveLocalArtifact(parsed);
+        case "git":
+            return resolveGitArtifact(parsed);
+        case "github":
+            return resolveGithubArtifact(parsed);
     }
-    return resolveGithubArtifact(parsed);
 }
 function parseNpmRef(input, originalRef) {
     const trimmed = input.trim();