akm-cli 0.6.0-rc1 → 0.6.0

package/dist/{completions.js → commands/completions.js}

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { getAssetTypes } from "./asset-spec";
+import { getAssetTypes } from "../core/asset-spec";
 // ── Known flag values ────────────────────────────────────────────────────────
 const FLAG_VALUES = {
     "--format": ["json", "text", "yaml", "jsonl"],

package/dist/{config-cli.js → commands/config-cli.js}

@@ -1,9 +1,18 @@
-import { DEFAULT_CONFIG, } from "./config";
-import { UsageError } from "./errors";
+import { DEFAULT_CONFIG, } from "../core/config";
+import { UsageError } from "../core/errors";
+// ── Merge helpers for LLM/embedding subkey set ───────────────────────────────
+function mergeLlmLike(base, patch) {
+    return { endpoint: "", model: "", ...(base ?? {}), ...patch };
+}
+function mergeLlmLikeEmbedding(base, patch) {
+    return { endpoint: "", model: "", ...(base ?? {}), ...patch };
+}
 export function parseConfigValue(key, value) {
     switch (key) {
         case "stashDir":
             return { stashDir: requireNonEmptyString(value, key) };
+        case "defaultWriteTarget":
+            return { defaultWriteTarget: requireNonEmptyString(value, key) };
         case "semanticSearchMode":
             // Accept legacy boolean-style strings from CLI
             if (value === "true")
@@ -16,12 +25,26 @@ export function parseConfigValue(key, value) {
             return { semanticSearchMode: value };
         case "embedding":
             return { embedding: parseEmbeddingConnectionValue(value) };
+        case "embedding.endpoint":
+            return { embedding: mergeLlmLikeEmbedding(undefined, { endpoint: requireNonEmptyString(value, key) }) };
+        case "embedding.model":
+            return { embedding: mergeLlmLikeEmbedding(undefined, { model: requireNonEmptyString(value, key) }) };
+        case "embedding.apiKey":
+            return { embedding: mergeLlmLikeEmbedding(undefined, { apiKey: requireNonEmptyString(value, key) }) };
         case "llm":
             return { llm: parseLlmConnectionValue(value) };
+        case "llm.endpoint":
+            return { llm: mergeLlmLike(undefined, { endpoint: requireNonEmptyString(value, key) }) };
+        case "llm.model":
+            return { llm: mergeLlmLike(undefined, { model: requireNonEmptyString(value, key) }) };
+        case "llm.apiKey":
+            return { llm: mergeLlmLike(undefined, { apiKey: requireNonEmptyString(value, key) }) };
         case "registries":
             return { registries: parseRegistriesValue(value) };
+        case "sources":
         case "stashes":
-            return { stashes: parseStashesValue(value) };
+            // "stashes" is kept as an alias for backwards-compat; both write to `sources`.
+            return { sources: parseStashesValue(value) };
         case "output.format":
             return { output: { format: parseOutputFormat(value) } };
         case "output.detail":
@@ -46,16 +69,32 @@ export function getConfigValue(config, key) {
     switch (key) {
         case "stashDir":
             return config.stashDir ?? null;
+        case "defaultWriteTarget":
+            return config.defaultWriteTarget ?? null;
         case "semanticSearchMode":
             return config.semanticSearchMode;
         case "embedding":
             return config.embedding ?? null;
+        case "embedding.endpoint":
+            return config.embedding?.endpoint ?? null;
+        case "embedding.model":
+            return config.embedding?.model ?? null;
+        case "embedding.apiKey":
+            return config.embedding?.apiKey ?? null;
         case "llm":
             return config.llm ?? null;
+        case "llm.endpoint":
+            return config.llm?.endpoint ?? null;
+        case "llm.model":
+            return config.llm?.model ?? null;
+        case "llm.apiKey":
+            return config.llm?.apiKey ?? null;
         case "registries":
             return config.registries ?? DEFAULT_CONFIG.registries ?? [];
+        case "sources":
         case "stashes":
-            return config.stashes ?? [];
+            // "stashes" is an alias for "sources" for backwards-compat.
+            return config.sources ?? config.stashes ?? [];
         case "output.format":
             return config.output?.format ?? null;
         case "output.detail":
@@ -85,6 +124,7 @@ export function setConfigValue(config, key, rawValue) {
         case "embedding":
         case "llm":
         case "registries":
+        case "sources":
         case "stashes":
         case "output.format":
         case "output.detail":
@@ -95,6 +135,38 @@ export function setConfigValue(config, key, rawValue) {
         case "security.installAudit.registryWhitelist":
         case "security.installAudit.allowedFindings":
             return mergeConfigValue(config, parseConfigValue(key, rawValue));
+        // Subkey setters use deep-merge so sibling fields are preserved
+        case "embedding.endpoint":
+            return {
+                ...config,
+                embedding: mergeLlmLikeEmbedding(config.embedding, { endpoint: requireNonEmptyString(rawValue, key) }),
+            };
+        case "embedding.model":
+            return {
+                ...config,
+                embedding: mergeLlmLikeEmbedding(config.embedding, { model: requireNonEmptyString(rawValue, key) }),
+            };
+        case "embedding.apiKey":
+            return {
+                ...config,
+                embedding: mergeLlmLikeEmbedding(config.embedding, { apiKey: requireNonEmptyString(rawValue, key) }),
+            };
+        case "llm.endpoint":
+            return { ...config, llm: mergeLlmLike(config.llm, { endpoint: requireNonEmptyString(rawValue, key) }) };
+        case "llm.model":
+            return { ...config, llm: mergeLlmLike(config.llm, { model: requireNonEmptyString(rawValue, key) }) };
+        case "llm.apiKey":
+            return { ...config, llm: mergeLlmLike(config.llm, { apiKey: requireNonEmptyString(rawValue, key) }) };
+        case "defaultWriteTarget": {
+            const name = requireNonEmptyString(rawValue, key);
+            const knownNames = (config.sources ?? config.stashes ?? [])
+                .map((s) => s.name)
+                .filter((n) => typeof n === "string");
+            if (knownNames.length > 0 && !knownNames.includes(name)) {
+                throw new UsageError(`Unknown source name "${name}" for defaultWriteTarget; configured source names: ${knownNames.map((n) => `"${n}"`).join(", ")}`);
+            }
+            return { ...config, defaultWriteTarget: name };
+        }
         default:
             throw new UsageError(`Unknown config key: ${key}`);
     }
@@ -103,14 +175,38 @@ export function unsetConfigValue(config, key) {
     switch (key) {
         case "stashDir":
             return { ...config, stashDir: undefined };
+        case "defaultWriteTarget":
+            return { ...config, defaultWriteTarget: undefined };
         case "embedding":
             return { ...config, embedding: undefined };
+        case "embedding.endpoint":
+            return { ...config, embedding: mergeLlmLikeEmbedding(config.embedding, { endpoint: "" }) };
+        case "embedding.model":
+            return { ...config, embedding: mergeLlmLikeEmbedding(config.embedding, { model: "" }) };
+        case "embedding.apiKey": {
+            if (!config.embedding)
+                return config;
+            const { apiKey: _a, ...rest } = config.embedding;
+            return { ...config, embedding: rest };
+        }
         case "llm":
             return { ...config, llm: undefined };
+        case "llm.endpoint":
+            return { ...config, llm: mergeLlmLike(config.llm, { endpoint: "" }) };
+        case "llm.model":
+            return { ...config, llm: mergeLlmLike(config.llm, { model: "" }) };
+        case "llm.apiKey": {
+            if (!config.llm)
+                return config;
+            const { apiKey: _b, ...restLlm } = config.llm;
+            return { ...config, llm: restLlm };
+        }
         case "registries":
             return { ...config, registries: undefined };
+        case "sources":
         case "stashes":
-            return { ...config, stashes: undefined };
+            // "stashes" is kept as an alias for backwards-compat; both clear `sources`.
+            return { ...config, sources: undefined, stashes: undefined };
         case "output.format":
             return { ...config, output: mergeOutputConfig(config.output, { format: undefined }) };
         case "output.detail":
@@ -155,8 +251,10 @@ export function listConfig(config) {
         output: mergeOutputConfig(DEFAULT_CONFIG.output, config.output) ?? null,
         stashDir: config.stashDir ?? null,
         installed: config.installed ?? [],
-        stashes: config.stashes ?? [],
+        sources: config.sources ?? config.stashes ?? [],
     };
+    if (config.defaultWriteTarget)
+        result.defaultWriteTarget = config.defaultWriteTarget;
     if (config.embedding)
         result.embedding = config.embedding;
     if (config.llm)
@@ -349,7 +447,7 @@ function parseJsonObject(value, key, example) {
     }
     catch {
         throw new UsageError(`Invalid value for ${key}: expected JSON object with endpoint and model` +
-            ` (e.g. '{"endpoint":"${example.endpoint}","model":"${example.model}"}')`);
+            ` (e.g. '{"endpoint":"${example.endpoint}","model":"${example.model}"}')`, "INVALID_JSON_CONFIG_VALUE");
     }
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
         throw new UsageError(`Invalid value for ${key}: expected a JSON object`);
@@ -388,18 +486,18 @@ function parseStashesValue(value) {
         parsed = JSON.parse(value);
     }
     catch {
-        throw new UsageError(`Invalid value for stashes: expected JSON array of {type, path?, url?, name?, enabled?, options?} objects`);
+        throw new UsageError(`Invalid value for sources: expected JSON array of {type, path?, url?, name?, enabled?, options?} objects`);
     }
     if (!Array.isArray(parsed)) {
-        throw new UsageError(`Invalid value for stashes: expected a JSON array`);
+        throw new UsageError(`Invalid value for sources: expected a JSON array`);
     }
     return parsed.map((entry, i) => {
         if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-            throw new UsageError(`Invalid value for stashes[${i}]: expected an object with a "type" field`);
+            throw new UsageError(`Invalid value for sources[${i}]: expected an object with a "type" field`);
         }
         const obj = entry;
         if (typeof obj.type !== "string" || !obj.type) {
-            throw new UsageError(`Invalid value for stashes[${i}]: "type" is required`);
+            throw new UsageError(`Invalid value for sources[${i}]: "type" is required`);
         }
         const result = { type: obj.type };
         if (typeof obj.path === "string" && obj.path)

package/dist/{curate.js → commands/curate.js}

@@ -10,9 +10,10 @@
  * pure helpers (`curateSearchResults`, `orderCuratedTypes`,
  * `deriveCurateFallbackQueries`) by importing them directly.
  */
-import { truncateDescription } from "./output-shapes";
-import { akmSearch, parseSearchSource } from "./stash-search";
-import { akmShowUnified } from "./stash-show";
+import { UsageError } from "../core/errors";
+import { truncateDescription } from "../output/shapes";
+import { akmSearch, parseSearchSource } from "./search";
+import { akmShowUnified } from "./show";
 const CURATE_FALLBACK_FILTER_WORDS = new Set([
     "a",
     "an",
@@ -39,6 +40,10 @@ const DEFAULT_CURATE_LIMIT = 4;
  * `options.searchResponse` is not supplied.
  */
 export async function akmCurate(options) {
+    const trimmedQuery = options.query.trim();
+    if (!trimmedQuery) {
+        throw new UsageError('A curation query is required. Usage: akm curate "<task or prompt>" [--type <type>] [--limit <n>]', "MISSING_REQUIRED_ARGUMENT");
+    }
     const limit = options.limit && options.limit > 0 ? options.limit : DEFAULT_CURATE_LIMIT;
     const source = options.source ?? parseSearchSource("stash");
     const searchResponse = options.searchResponse ??

package/dist/{info.js → commands/info.js}

@@ -1,10 +1,10 @@
 import fs from "node:fs";
-import { getAssetTypes } from "./asset-spec";
-import { loadConfig } from "./config";
-import { closeDatabase, getEntryCount, getMeta, isVecAvailable, openDatabase } from "./db";
-import { getDbPath } from "./paths";
-import { getEffectiveSemanticStatus, readSemanticStatus } from "./semantic-status";
-import { pkgVersion } from "./version";
+import { getAssetTypes } from "../core/asset-spec";
+import { loadConfig } from "../core/config";
+import { getDbPath } from "../core/paths";
+import { closeDatabase, getEntryCount, getMeta, isVecAvailable, openDatabase } from "../indexer/db";
+import { getEffectiveSemanticStatus, readSemanticStatus } from "../indexer/semantic-status";
+import { pkgVersion } from "../version";
 /**
  * Assemble system info describing the current capabilities, configuration,
  * and index state. Used by `akm info`.
@@ -29,8 +29,14 @@ export function assembleInfo(options) {
         ...(r.provider ? { provider: r.provider } : {}),
         ...(r.enabled !== undefined ? { enabled: r.enabled } : {}),
     }));
-    // Stash providers
-    const stashProviders = (config.stashes ?? []).map((s) => ({
+    // Stash providers — prefer `sources[]`; fall back to `stashDir` when the
+    // user has not yet migrated to the sources[] config shape so that info
+    // always reflects at least one provider when a stash is configured.
+    const configuredSources = config.sources ?? config.stashes ?? [];
+    const stashesList = configuredSources.length === 0 && config.stashDir
+        ? [{ type: "filesystem", path: config.stashDir, name: "primary" }]
+        : configuredSources;
+    const sourceProviders = stashesList.map((s) => ({
         type: s.type,
         ...(s.name ? { name: s.name } : {}),
         ...(s.path ? { path: s.path } : {}),
@@ -51,7 +57,7 @@ export function assembleInfo(options) {
             ...(semanticRuntime?.message ? { message: semanticRuntime.message } : {}),
         },
         registries,
-        stashProviders,
+        sourceProviders,
         indexStats,
     };
 }

package/dist/{init.js → commands/init.js}

@@ -7,10 +7,10 @@
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { TYPE_DIRS } from "./asset-spec";
-import { getConfigPath, loadUserConfig, saveConfig } from "./config";
-import { getBinDir, getDefaultStashDir } from "./paths";
-import { ensureRg } from "./ripgrep-install";
+import { TYPE_DIRS } from "../core/asset-spec";
+import { getConfigPath, loadUserConfig, saveConfig } from "../core/config";
+import { getBinDir, getDefaultStashDir } from "../core/paths";
+import { ensureRg } from "../setup/ripgrep-install";
 export async function akmInit(options) {
     const stashDir = options?.dir ? path.resolve(options.dir) : getDefaultStashDir();
     let created = false;

package/dist/{install-audit.js → commands/install-audit.js}

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { filterNonEmptyStrings } from "./common";
+import { filterNonEmptyStrings, toPosix } from "../core/common";
 const DEFAULT_INSTALL_AUDIT_CONFIG = {
     enabled: true,
     blockOnCritical: true,
@@ -363,12 +363,9 @@ function matchesAllowedFinding(finding, ref, allowedFindings) {
 function normalizeWaiverPath(value) {
     if (!value)
         return value;
-    // Strip a leading `./`, collapse duplicate slashes via path.normalize, and
-    // POSIX-ify so Windows path separators don't trigger spurious mismatches.
-    const normalized = path
-        .normalize(value)
-        .replace(/\\/g, "/")
-        .replace(/^\.\/+/, "");
+    // Strip a leading `./` and POSIX-ify after path.normalize so Windows path
+    // separators don't trigger spurious mismatches.
+    const normalized = toPosix(path.normalize(value)).replace(/^\.\/+/, "");
     return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function addUrlLabels(labels, rawUrl) {

package/dist/{installed-stashes.js → commands/installed-stashes.js}

@@ -6,36 +6,38 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { resolveStashDir } from "./common";
-import { loadConfig } from "./config";
-import { NotFoundError, UsageError } from "./errors";
-import { akmIndex } from "./indexer";
+import { resolveStashDir } from "../core/common";
+import { loadConfig } from "../core/config";
+import { NotFoundError, UsageError } from "../core/errors";
+import { akmIndex } from "../indexer/indexer";
+import { removeLockEntry, upsertLockEntry } from "../integrations/lockfile";
+import { parseRegistryRef } from "../registry/resolve";
+import { syncFromRef } from "../sources/providers/sync-from-ref";
+import { ensureWebsiteMirror } from "../sources/providers/website";
 import { auditInstallCandidate, deriveRegistryLabels, enforceRegistryInstallPolicy, formatInstallAuditFailure, } from "./install-audit";
-import { removeLockEntry, upsertLockEntry } from "./lockfile";
-import { parseRegistryRef } from "./registry-resolve";
-import { removeInstalledRegistryEntry, upsertInstalledRegistryEntry } from "./stash-add";
-import { syncFromRef } from "./stash-providers/sync-from-ref";
-import { removeStash } from "./stash-source-manage";
+import { removeInstalledRegistryEntry, upsertInstalledRegistryEntry } from "./source-add";
+import { removeStash } from "./source-manage";
 export async function akmListSources(input) {
     const stashDir = input?.stashDir ?? resolveStashDir();
     const config = loadConfig();
     const kindFilter = input?.kind;
     const sources = [];
-    // Stash entries → local or remote sources
-    for (const stash of config.stashes ?? []) {
-        const isRemote = stash.url != null;
-        const kind = isRemote ? "remote" : "local";
+    // Stash entries — each entry exposes its provider type as kind (spec §2.1).
+    // Writable defaults: true for filesystem, false for git/npm/website (CLAUDE.md "Writes").
+    for (const stash of config.sources ?? config.stashes ?? []) {
+        const kind = stash.type ?? "filesystem";
         if (kindFilter && !kindFilter.includes(kind))
             continue;
+        const isFilesystem = kind === "filesystem";
+        const writableDefault = isFilesystem;
         const name = stash.name ?? stash.path ?? stash.url ?? "unknown";
         sources.push({
             name,
             kind,
             wiki: stash.wikiName,
             path: stash.path,
-            provider: isRemote ? stash.type : undefined,
-            updatable: false,
-            writable: stash.writable === true,
+            provider: stash.url != null ? stash.type : undefined,
+            writable: stash.writable !== undefined ? stash.writable : writableDefault,
             status: { exists: stash.path ? directoryExists(stash.path) : true },
         });
     }
@@ -51,7 +53,6 @@ export async function akmListSources(input) {
             path: entry.stashRoot,
             ref: entry.ref,
             version: entry.resolvedVersion,
-            updatable: true,
             writable: entry.writable === true,
             status: { exists: directoryExists(entry.stashRoot) },
         });
@@ -91,7 +92,7 @@ export async function akmRemove(input) {
                 stashRoot: entry.stashRoot,
             },
             config: {
-                stashCount: updatedConfig.stashes?.length ?? 0,
+                sourceCount: (updatedConfig.sources ?? updatedConfig.stashes ?? []).length,
                 installedKitCount: updatedConfig.installed?.length ?? 0,
             },
             index: {
@@ -105,7 +106,7 @@ export async function akmRemove(input) {
     // Fall through to stashes[] (local/remote sources)
     const stashResult = removeStash(target);
     if (!stashResult.removed || !stashResult.entry) {
-        throw new NotFoundError(`No matching source for target: ${target}`);
+        throw new NotFoundError(`No matching source for target: ${target}`, "SOURCE_NOT_FOUND");
     }
     const removedEntry = stashResult.entry;
     const index = await akmIndex({ stashDir });
@@ -122,7 +123,7 @@ export async function akmRemove(input) {
             stashRoot: removedEntry.path ?? "",
         },
         config: {
-            stashCount: updatedConfig.stashes?.length ?? 0,
+            sourceCount: (updatedConfig.sources ?? updatedConfig.stashes ?? []).length,
             installedKitCount: updatedConfig.installed?.length ?? 0,
         },
         index: {
@@ -138,9 +139,51 @@ export async function akmUpdate(input) {
     const target = input?.target?.trim();
     const all = input?.all === true;
     const force = input?.force === true;
-    const installedEntries = loadConfig().installed ?? [];
+    const config = loadConfig();
+    const installedEntries = config.installed ?? [];
+    // Check if the target refers to a website source — those are syncable via
+    // ensureWebsiteMirror and are stored in sources[] not installed[].
+    if (target && !all) {
+        const stashes = config.sources ?? config.stashes ?? [];
+        const isUrl = target.startsWith("http://") || target.startsWith("https://");
+        const resolvedPath = !isUrl ? path.resolve(target) : undefined;
+        const websiteMatch = stashes.find((s) => {
+            if (s.type !== "website")
+                return false;
+            if (isUrl && s.url === target)
+                return true;
+            if (s.name === target)
+                return true;
+            if (resolvedPath && s.path && path.resolve(s.path) === resolvedPath)
+                return true;
+            return false;
+        });
+        if (websiteMatch) {
+            // TODO: full incremental re-crawl with delta tracking (#19)
+            await ensureWebsiteMirror(websiteMatch, { requireStashDir: true, force: true });
+            const index = await akmIndex({ stashDir });
+            const updatedConfig = loadConfig();
+            return {
+                schemaVersion: 1,
+                stashDir,
+                target,
+                all,
+                processed: [],
+                config: {
+                    sourceCount: (updatedConfig.sources ?? updatedConfig.stashes ?? []).length,
+                    installedKitCount: updatedConfig.installed?.length ?? 0,
+                },
+                index: {
+                    mode: index.mode,
+                    totalEntries: index.totalEntries,
+                    directoriesScanned: index.directoriesScanned,
+                    directoriesSkipped: index.directoriesSkipped,
+                },
+            };
+        }
+    }
     const selectedEntries = selectTargets(installedEntries, target, all);
-    const auditConfig = loadConfig();
+    const auditConfig = config;
     const processed = [];
     for (const entry of selectedEntries) {
         if (force && shouldCleanupCache(entry)) {
@@ -210,7 +253,7 @@ export async function akmUpdate(input) {
         });
     }
     const index = await akmIndex({ stashDir });
-    const config = loadConfig();
+    const finalConfig = loadConfig();
     return {
         schemaVersion: 1,
         stashDir,
@@ -218,8 +261,8 @@ export async function akmUpdate(input) {
         all,
         processed,
         config: {
-            stashCount: config.stashes?.length ?? 0,
-            installedKitCount: config.installed?.length ?? 0,
+            sourceCount: (finalConfig.sources ?? finalConfig.stashes ?? []).length,
+            installedKitCount: finalConfig.installed?.length ?? 0,
         },
         index: {
             mode: index.mode,
@@ -231,19 +274,19 @@ export async function akmUpdate(input) {
 }
 function selectTargets(installed, target, all) {
     if (all && target) {
-        throw new UsageError("Specify either <target> or --all, not both.");
+        throw new UsageError("Specify either <target> or --all, not both.", "MISSING_OR_AMBIGUOUS_TARGET");
     }
     if (all)
         return installed;
     if (!target) {
-        throw new UsageError("Either <target> or --all is required.");
+        throw new UsageError("Either <target> or --all is required.", "MISSING_OR_AMBIGUOUS_TARGET");
     }
     const found = tryResolveInstalledTarget(installed, target);
     if (found)
         return [found];
     // Check if target matches a stash source and give a helpful message
     const config = loadConfig();
-    const stashes = config.stashes ?? [];
+    const stashes = config.sources ?? config.stashes ?? [];
     const isUrl = target.startsWith("http://") || target.startsWith("https://");
     const resolvedPath = !isUrl ? path.resolve(target) : undefined;
     const stashMatch = stashes.find((s) => {
@@ -256,10 +299,13 @@ function selectTargets(installed, target, all) {
         return false;
     });
     if (stashMatch) {
-        if (stashMatch.url) {
-            throw new UsageError(`"${target}" is a remote provider — it queries live data and has nothing to update.`);
+        if (stashMatch.type === "website") {
+            // Website sources should be handled before reaching selectTargets.
+            // This path should not be reached; surface a clear message if it is.
+            throw new UsageError(`"${target}" is a website source — website caching not yet implemented for --all. ` +
+                `Run \`akm update ${target}\` to re-mirror this source individually.`, "TARGET_NOT_UPDATABLE");
         }
-        throw new UsageError(`"${target}" is a local directory — it reflects your files in place. To refresh the search index, run: akm index`);
+        throw new UsageError(`"${target}" is a local directory — it reflects your files in place. To refresh the search index, run: akm index`, "TARGET_NOT_UPDATABLE");
     }
     throw new NotFoundError(`No matching source for target: ${target}`);
 }

package/dist/{migration-help.js → commands/migration-help.js}

@@ -10,11 +10,11 @@ const MIGRATION_DOC_URL = "https://github.com/itlackey/akm/blob/main/docs/migrat
  * `files[]` array in `package.json`.
  */
 function releaseNotesDir() {
-    return path.resolve(import.meta.dir, "../docs/migration/release-notes");
+    return path.resolve(import.meta.dir, "../../docs/migration/release-notes");
 }
 function loadChangelog() {
     try {
-        const changelogPath = path.resolve(import.meta.dir, "../CHANGELOG.md");
+        const changelogPath = path.resolve(import.meta.dir, "../../CHANGELOG.md");
         if (fs.existsSync(changelogPath)) {
             return fs.readFileSync(changelogPath, "utf8");
         }

package/dist/{registry-search.js → commands/registry-search.js}

@@ -1,8 +1,8 @@
-import { toErrorMessage } from "./common";
-import { DEFAULT_CONFIG, loadConfig } from "./config";
-import { resolveProviderFactory } from "./registry-factory";
+import { toErrorMessage } from "../core/common";
+import { DEFAULT_CONFIG, loadConfig } from "../core/config";
+import { resolveProviderFactory } from "../registry/factory";
 // ── Eagerly import providers to trigger self-registration ───────────────────
-import "./providers/index";
+import "../registry/providers/index";
 // ── Public API ──────────────────────────────────────────────────────────────
 export async function searchRegistry(query, options) {
     const trimmed = query.trim();
@@ -24,7 +24,8 @@ export async function searchRegistry(query, options) {
     // Merge results grouped by provider
     const allHits = [];
     const allAssetHits = [];
-    for (const result of results) {
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
         if (result.status === "rejected") {
             warnings.push(toErrorMessage(result.reason));
             continue;
@@ -32,6 +33,7 @@ export async function searchRegistry(query, options) {
         const value = result.value;
         if (!value)
             continue;
+        const registryLabel = entries[i].name ? `"${entries[i].name}"` : entries[i].url;
         let dropped = 0;
         for (const hit of value.hits) {
             if (isCompleteHit(hit)) {
@@ -52,7 +54,7 @@ export async function searchRegistry(query, options) {
             }
         }
         if (dropped > 0) {
-            warnings.push(`Registry returned ${dropped} incomplete hit(s); dropped from response.`);
+            warnings.push(`Registry ${registryLabel} returned ${dropped} incomplete hit(s); dropped from response.`);
         }
         if (value.warnings)
             warnings.push(...value.warnings);