akm-cli 0.6.0-rc1 → 0.6.0-rc2

package/dist/{stash-providers → sources/providers}/git.js

@@ -2,12 +2,12 @@ import { spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { resolveStashDir } from "../common";
-import { loadConfig } from "../config";
-import { ConfigError, UsageError } from "../errors";
-import { getRegistryCacheDir, getRegistryIndexCacheDir } from "../paths";
-import { parseRegistryRef, resolveRegistryArtifact, validateGitRef, validateGitUrl } from "../registry-resolve";
-import { registerStashProvider } from "../stash-provider-factory";
+import { resolveStashDir } from "../../core/common";
+import { loadConfig } from "../../core/config";
+import { ConfigError, UsageError } from "../../core/errors";
+import { getRegistryCacheDir, getRegistryIndexCacheDir } from "../../core/paths";
+import { parseRegistryRef, resolveRegistryArtifact, validateGitRef, validateGitUrl } from "../../registry/resolve";
+import { registerSourceProvider } from "../provider-factory";
 import { applyAkmIncludeConfig, buildInstallCacheDir, copyDirectoryContents, detectStashRoot, isDirectory, isExpired, sanitizeString, } from "./provider-utils";
 /** Cache TTL before refreshing the mirrored repo (12 hours). */
 const CACHE_TTL_MS = 12 * 60 * 60 * 1000;
@@ -15,74 +15,63 @@ const CACHE_TTL_MS = 12 * 60 * 60 * 1000;
 const CACHE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
 const GIT_STASH_TYPES = new Set(["git"]);
 /**
- * Git stash provider. Implements {@link SyncableStashProvider} (which extends
- * the LiveStashProvider surface) — the indexer walks the cloned repo, and
- * `sync()` clones/pulls into a local mirror.
+ * Git source provider — clones (and re-pulls) a remote repo into a local
+ * cache directory. Implements the v1 {@link SourceProvider} interface (spec
+ * §2.1, §2.5): `{ name, kind, init, path, sync }`.
+ *
+ * Reading is the indexer's job — this class doesn't implement `search` or
+ * `show`. The install-time helpers `syncRegistryGitRef` / `syncMirroredRepo`
+ * live below as standalone functions used by `akm add` / `akm update`.
  */
-class GitStashProvider {
-    type = "git";
-    kind = "syncable";
+class GitSourceProvider {
+    kind = "git";
     name;
-    config;
+    #config;
+    #path = null;
     constructor(config) {
-        this.config = config;
+        this.#config = config;
         this.name = config.name ?? "git";
     }
-    /** Content is indexed through the standard FTS5 pipeline. */
-    async search(_options) {
-        return { hits: [] };
-    }
-    /** Content is local files, shown via showLocal. */
-    async show(_ref, _view) {
-        throw new Error("Git provider content is shown via local index");
-    }
-    /** Content is local; no remote show needed. */
-    canShow(_ref) {
-        return false;
+    async init(_ctx) {
+        // Resolve the on-disk content directory once. For configured git sources
+        // this is the cached working tree; for one-shot install refs it's the
+        // path the install pipeline materialised.
+        this.#path = resolveGitContentDir(this.#config);
+    }
+    path() {
+        if (this.#path == null) {
+            // Lazy resolution: providers are sometimes constructed without an
+            // explicit init() call (e.g. by legacy callers that just want the
+            // path). Resolve on demand and cache.
+            this.#path = resolveGitContentDir(this.#config);
+        }
+        return this.#path;
     }
-    async sync(config, options) {
+    async sync() {
         // Two execution modes:
-        //   1. Long-lived configured stash (config.url) — mirror into the
+        //   1. Long-lived configured source (config.url) — mirror into the
         //      registry-index cache and serve as a read-only working tree.
-        //   2. One-shot install ref (config.options.ref like "git:..." / "github:...") —
-        //      run the historical clone-into-cache flow used by `akm add`.
-        if (typeof config.options?.ref === "string" && config.options.ref) {
-            return syncRegistryGitRef(String(config.options.ref), options);
-        }
-        return syncMirroredRepo(config, options);
-    }
-    getContentDir(config) {
-        if (config.path)
-            return config.path;
-        if (config.url) {
-            const repo = parseGitRepoUrl(config.url);
-            return getCachePaths(repo.canonicalUrl).repoDir;
-        }
-        throw new ConfigError("git stash entry must have either `path` or `url`");
-    }
-    async remove(config) {
-        if (config.path && isDirectory(config.path)) {
-            try {
-                fs.rmSync(path.dirname(config.path), { recursive: true, force: true });
-            }
-            catch {
-                /* best-effort */
-            }
-        }
-        else if (config.url) {
-            const repo = parseGitRepoUrl(config.url);
-            const paths = getCachePaths(repo.canonicalUrl);
-            try {
-                fs.rmSync(paths.rootDir, { recursive: true, force: true });
-            }
-            catch {
-                /* best-effort */
-            }
+        //   2. One-shot install ref (options.ref like "git:..." / "github:...") —
+        //      delegate to the install-time pipeline.
+        if (typeof this.#config.options?.ref === "string" && this.#config.options.ref) {
+            await syncRegistryGitRef(String(this.#config.options.ref));
+            return;
         }
+        await syncMirroredRepo(this.#config);
     }
 }
+/** Resolve the on-disk content directory for a configured git source. */
+function resolveGitContentDir(config) {
+    if (config.path)
+        return config.path;
+    if (config.url) {
+        const repo = parseGitRepoUrl(config.url);
+        return getCachePaths(repo.canonicalUrl).repoDir;
+    }
+    throw new ConfigError("git source entry must have either `path` or `url`");
+}
 // ── Self-register ───────────────────────────────────────────────────────────
-registerStashProvider("git", (config) => new GitStashProvider(config));
+registerSourceProvider("git", (config) => new GitSourceProvider(config));
 // ── Cache management ────────────────────────────────────────────────────────
 function getCachePaths(repoUrl) {
     const key = createHash("sha256").update(repoUrl).digest("hex").slice(0, 16);
@@ -414,7 +403,7 @@ export function saveGitStash(name, message, writableOverride) {
     let writable = false;
     if (name) {
         const config = loadConfig();
-        const stash = config.stashes?.find((s) => s.name === name || s.url === name);
+        const stash = (config.sources ?? config.stashes ?? []).find((s) => s.name === name || s.url === name);
         if (!stash)
             throw new UsageError(`No git stash found with name "${name}"`);
         if (!GIT_STASH_TYPES.has(stash.type)) {
@@ -476,4 +465,4 @@ export function saveGitStash(name, message, writableOverride) {
     };
 }
 // ── Exports ─────────────────────────────────────────────────────────────────
-export { ensureGitMirror, GitStashProvider, getCachePaths, parseGitRepoUrl };
+export { ensureGitMirror, GitSourceProvider, getCachePaths, parseGitRepoUrl };

package/dist/{stash-providers → sources/providers}/index.js

@@ -1,12 +1,11 @@
 /**
- * Centralized stash provider registration.
+ * Centralized source provider registration.
  *
- * Import this module (side-effect import) to register all built-in stash
+ * Import this module (side-effect import) to register all built-in source
  * providers with the provider registry. This replaces the individual
- * side-effect imports that were duplicated in stash-search.ts and stash-show.ts.
+ * side-effect imports that were duplicated in source-search.ts and source-show.ts.
  */
 import "./filesystem";
 import "./git";
 import "./npm";
-import "./openviking";
 import "./website";

package/dist/sources/providers/install-types.js

@@ -0,0 +1,14 @@
+/**
+ * Install-time types used by `syncFromRef` and the legacy install pipeline.
+ *
+ * Distinct from the v1 {@link SourceProvider} interface (which only deals
+ * with "configured sources" — entries already resolved into a directory).
+ * These types describe the resolution+lockfile step that runs when
+ * `akm add <install-ref>` materialises an upstream artifact into a local
+ * cache directory.
+ *
+ * They live here, outside `provider.ts`, so the v1 SourceProvider
+ * interface stays minimal (`{ name, kind, init, path, sync? }`) per the
+ * architecture spec §2.1.
+ */
+export {};

package/dist/{stash-providers → sources/providers}/npm.js

@@ -12,53 +12,46 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { ConfigError, UsageError } from "../errors";
-import { getRegistryCacheDir } from "../paths";
-import { parseRegistryRef, resolveRegistryArtifact } from "../registry-resolve";
-import { registerStashProvider } from "../stash-provider-factory";
+import { ConfigError, UsageError } from "../../core/errors";
+import { getRegistryCacheDir } from "../../core/paths";
+import { parseRegistryRef, resolveRegistryArtifact } from "../../registry/resolve";
+import { registerSourceProvider } from "../provider-factory";
 import { applyAkmIncludeConfig, buildInstallCacheDir, computeFileHash, detectStashRoot, downloadArchive, isDirectory, } from "./provider-utils";
 import { extractTarGzSecure, verifyArchiveIntegrity } from "./tar-utils";
-class NpmStashProvider {
-    type = "npm";
-    kind = "syncable";
+/**
+ * NPM source provider — fetches a tarball from the npm registry and extracts
+ * it into a local cache. Implements the v1 {@link SourceProvider} interface
+ * (spec §2.1): `{ name, kind, init, path, sync }`.
+ *
+ * The install-time pipeline (`syncNpmRef`) lives below as a standalone
+ * function used by `akm add` / `akm update` — that path produces a
+ * {@link SourceLockData} record for lockfile bookkeeping. The provider's own
+ * `sync()` is a void refresh (delegates to the install pipeline but discards
+ * the lock data, which is owned by `lockfile.ts`).
+ */
+class NpmSourceProvider {
+    kind = "npm";
     name;
+    #config;
     constructor(config) {
+        this.#config = config;
         this.name = config.name ?? config.url ?? "npm";
     }
-    /** Content is indexed through the standard FTS5 pipeline. */
-    async search(_options) {
-        return { hits: [] };
+    async init(_ctx) {
+        // Resolution happens lazily in path(): until `sync()` runs there's no
+        // reliable on-disk path. Init is the registration handshake.
     }
-    /** Content is local files, shown via showLocal. */
-    async show(_ref, _view) {
-        throw new Error("NPM provider content is shown via local index");
+    path() {
+        if (this.#config.path)
+            return this.#config.path;
+        throw new ConfigError(`npm source "${this.name}" has no resolved content path — run \`akm update\` to sync it before indexing.`);
     }
-    canShow(_ref) {
-        return false;
-    }
-    async sync(config, options) {
-        const ref = npmRefFromConfig(config);
-        return syncNpmRef(ref, options);
-    }
-    getContentDir(config) {
-        if (config.path)
-            return config.path;
-        throw new ConfigError("npm stash entry missing resolved content path");
-    }
-    async remove(config) {
-        if (config.path && isDirectory(config.path)) {
-            // Remove the whole versioned cache dir if we know the parent layout.
-            const parent = path.dirname(config.path);
-            try {
-                fs.rmSync(parent, { recursive: true, force: true });
-            }
-            catch {
-                /* best-effort */
-            }
-        }
+    async sync() {
+        const ref = npmRefFromConfig(this.#config);
+        await syncNpmRef(ref);
     }
 }
-registerStashProvider("npm", (config) => new NpmStashProvider(config));
+registerSourceProvider("npm", (config) => new NpmSourceProvider(config));
 function npmRefFromConfig(config) {
     // Prefer an explicit ref-bearing field (set by akmAdd when persisting), else fall back
     // to options or url so the provider stays usable from a hand-rolled config.
@@ -69,7 +62,7 @@ function npmRefFromConfig(config) {
     return candidate.startsWith("npm:") ? candidate : `npm:${candidate}`;
 }
 /**
- * Fetch and extract an npm tarball, returning a populated `StashLockData`.
+ * Fetch and extract an npm tarball, returning a populated `SourceLockData`.
  *
  * Mirrors the historical `installRegistryRef()` path for npm sources:
  *   - resolve artifact URL + integrity from the npm registry
@@ -127,9 +120,17 @@ async function doSyncNpm(parsed, options) {
         verifyArchiveIntegrity(archivePath, resolved.resolvedRevision, resolved.source);
         integrity = await computeFileHash(archivePath);
         extractTarGzSecure(archivePath, extractedDir);
-        provisionalKitRoot = detectStashRoot(extractedDir);
+        const detectedProvisionalKitRoot = detectStashRoot(extractedDir);
+        if (!detectedProvisionalKitRoot) {
+            throw new UsageError(`Unable to detect a stash root in extracted npm package: ${resolved.ref}`);
+        }
+        provisionalKitRoot = detectedProvisionalKitRoot;
         installRoot = applyAkmIncludeConfig(provisionalKitRoot, cacheDir, extractedDir) ?? provisionalKitRoot;
-        stashRoot = detectStashRoot(installRoot);
+        const detectedStashRoot = detectStashRoot(installRoot);
+        if (!detectedStashRoot) {
+            throw new UsageError(`Unable to detect a stash root after applying .akm-include configuration for npm package: ${resolved.ref}`);
+        }
+        stashRoot = detectedStashRoot;
     }
     catch (err) {
         // Clean up so stale or partial extractions don't cause false cache hits.
@@ -156,4 +157,4 @@ async function doSyncNpm(parsed, options) {
         syncedAt,
     };
 }
-export { NpmStashProvider };
+export { NpmSourceProvider };

package/dist/{stash-providers → sources/providers}/provider-utils.js

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { TYPE_DIRS } from "../asset-spec";
-import { fetchWithRetry } from "../common";
-import { copyIncludedPaths, findNearestIncludeConfig } from "../stash-include";
+import { TYPE_DIRS } from "../../core/asset-spec";
+import { fetchWithRetry } from "../../core/common";
+import { copyIncludedPaths, findNearestIncludeConfig } from "../include";
 const REGISTRY_STASH_DIR_NAMES = new Set(Object.values(TYPE_DIRS));
 /** Strip terminal control characters from untrusted strings. */
 export function sanitizeString(value, maxLength = 255) {

package/dist/{stash-providers → sources/providers}/sync-from-ref.js

@@ -9,8 +9,8 @@
  * `akmUpdate`) decide whether to run `auditInstallCandidate` on the
  * synced `contentDir` because they own the `--trust` flag.
  */
-import { UsageError } from "../errors";
-import { parseRegistryRef } from "../registry-resolve";
+import { UsageError } from "../../core/errors";
+import { parseRegistryRef } from "../../registry/resolve";
 import { detectStashRoot } from "./provider-utils";
 export async function syncFromRef(ref, options) {
     const parsed = parseRegistryRef(ref);

package/dist/{stash-providers → sources/providers}/tar-utils.js

@@ -6,15 +6,15 @@
  * and verify integrity hashes (SRI or hex shasum) before extraction.
  *
  * Extracted from `registry-install.ts` and shared by all syncable
- * providers that fetch tarballs (currently `NpmStashProvider` and the
+ * providers that fetch tarballs (currently `NpmSourceProvider` and the
  * registry index builder).
  */
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { isWithin } from "../common";
-import { warn } from "../warn";
+import { isWithin } from "../../core/common";
+import { warn } from "../../core/warn";
 /**
  * Verify an archive's integrity against a known hash. Throws and removes
  * the archive when verification fails.
@@ -103,11 +103,14 @@ function scanExtractedFiles(dir, root) {
                 throw new Error(`Post-extraction scan: symlink escapes destination directory: ${fullPath} -> ${target}`);
             }
         }
-        // Belt-and-suspenders: any regular entry whose resolved path lands outside
-        // the destination root is rejected, regardless of how its name looks. This
-        // catches anything the tar pre-validation missed.
-        if (!entry.isSymbolicLink() && !isWithin(fullPath, root)) {
-            throw new Error(`Post-extraction scan: entry escapes destination directory: ${fullPath}`);
+        // Belt-and-suspenders: check that the resolved path of regular entries
+        // stays within the destination root. This catches path traversal attempts
+        // via symlink TOCTOU, directory renames, or any other anomalies.
+        if (!entry.isSymbolicLink()) {
+            const resolved = path.resolve(fullPath);
+            if (!isWithin(resolved, root)) {
+                throw new Error(`Post-extraction scan: entry escapes destination directory: ${fullPath}`);
+            }
         }
         if (entry.isDirectory()) {
             scanExtractedFiles(fullPath, root);

package/dist/{stash-providers → sources/providers}/website.js

@@ -1,11 +1,12 @@
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { fetchWithRetry, ResponseTooLargeError, readBodyWithByteCap } from "../common";
-import { ConfigError, UsageError } from "../errors";
-import { getRegistryIndexCacheDir } from "../paths";
-import { registerStashProvider } from "../stash-provider-factory";
-import { isDirectory, isExpired, sanitizeString } from "./provider-utils";
+import { fetchWithRetry, ResponseTooLargeError, readBodyWithByteCap } from "../../core/common";
+import { ConfigError, UsageError } from "../../core/errors";
+import { getRegistryIndexCacheDir } from "../../core/paths";
+import { warn } from "../../core/warn";
+import { registerSourceProvider } from "../provider-factory";
+import { isExpired, sanitizeString } from "./provider-utils";
 /** Refresh website snapshots every 12 hours to balance freshness with scraping load. */
 const CACHE_REFRESH_INTERVAL_MS = 12 * 60 * 60 * 1000;
 /** Allow up to 7 days of stale snapshots when refresh fails so search remains available during outages. */
@@ -28,68 +29,34 @@ const WEBSITE_PAGE_BYTE_CAP = 5 * 1024 * 1024;
  */
 const WEBSITE_CRAWL_WALL_CLOCK_MS = 10 * 60 * 1000;
 /**
- * Website stash provider. Implements {@link SyncableStashProvider} (which
- * extends LiveStashProvider) — scrapes pages into a local mirror so the FTS5
- * indexer can walk them.
+ * Website source provider — scrapes pages into a local mirror so the FTS5
+ * indexer can walk them. Implements the v1 {@link SourceProvider} interface
+ * (spec §2.1): `{ name, kind, init, path, sync }`.
+ *
+ * Reading is the indexer's job — this class doesn't implement `search` or
+ * `show`.
  */
-class WebsiteStashProvider {
-    type = "website";
-    kind = "syncable";
+class WebsiteSourceProvider {
+    kind = "website";
     name;
-    config;
+    #config;
+    #url;
     constructor(config) {
-        this.config = config;
+        this.#config = config;
         this.name = config.name ?? "website";
-        validateWebsiteUrl(config.url ?? "");
+        this.#url = validateWebsiteUrl(config.url ?? "");
     }
-    /** Content is indexed through the standard FTS5 pipeline. */
-    async search(_options) {
-        return { hits: [] };
+    async init(_ctx) {
+        // URL validation already happens in the constructor; nothing else to do.
     }
-    /** Content is local files, shown via showLocal. */
-    async show(_ref, _view) {
-        throw new Error("Website provider content is shown via local index");
+    path() {
+        return getCachePaths(this.#url).stashDir;
     }
-    /** Content is local; no remote show needed. */
-    canShow(_ref) {
-        return false;
-    }
-    async sync(config, options) {
-        const cachePaths = await ensureWebsiteMirror(config, { requireStashDir: true, force: options?.force });
-        const syncedAt = (options?.now ?? new Date()).toISOString();
-        const url = config.url ?? "";
-        // #123 added "website" to the StashSource union, so we can use it directly.
-        return {
-            id: url,
-            source: "website",
-            ref: url,
-            artifactUrl: url,
-            contentDir: cachePaths.stashDir,
-            cacheDir: cachePaths.rootDir,
-            extractedDir: cachePaths.stashDir,
-            syncedAt,
-        };
-    }
-    getContentDir(config) {
-        const url = config.url ?? "";
-        return getCachePaths(url).stashDir;
-    }
-    async remove(config) {
-        const url = config.url;
-        if (!url)
-            return;
-        const paths = getCachePaths(url);
-        if (isDirectory(paths.rootDir)) {
-            try {
-                fs.rmSync(paths.rootDir, { recursive: true, force: true });
-            }
-            catch {
-                /* best-effort */
-            }
-        }
+    async sync() {
+        await ensureWebsiteMirror(this.#config, { requireStashDir: true });
     }
 }
-registerStashProvider("website", (config) => new WebsiteStashProvider(config));
+registerSourceProvider("website", (config) => new WebsiteSourceProvider(config));
 function getCachePaths(siteUrl) {
     const key = createHash("sha256").update(normalizeSiteUrl(siteUrl)).digest("hex").slice(0, 16);
     const rootDir = path.join(getRegistryIndexCacheDir(), `website-${key}`);
@@ -182,12 +149,9 @@ async function crawlWebsite(startUrl, options) {
     const visited = new Set();
     const pages = [];
     const deadline = Date.now() + WEBSITE_CRAWL_WALL_CLOCK_MS;
-    let stoppedAtDeadline = false;
     while (queue.length > 0 && pages.length < options.maxPages) {
-        if (Date.now() > deadline) {
-            stoppedAtDeadline = true;
+        if (Date.now() > deadline)
             break;
-        }
         const next = queue.shift();
         if (!next)
             break;
@@ -212,8 +176,8 @@ async function crawlWebsite(startUrl, options) {
             queue.push({ url: candidate, depth: next.depth + 1 });
         }
     }
-    if (stoppedAtDeadline) {
-        console.warn(`[akm] website crawl stopped at the ${WEBSITE_CRAWL_WALL_CLOCK_MS / 1000}s wall-clock cap with ${pages.length}/${options.maxPages} pages collected from ${startUrl}.`);
+    if (Date.now() > deadline) {
+        warn("[akm] website crawl stopped at the %ds wall-clock cap with %d/%d pages collected from %s.", WEBSITE_CRAWL_WALL_CLOCK_MS / 1000, pages.length, options.maxPages, startUrl);
     }
     return pages;
 }
@@ -516,4 +480,4 @@ function safeCodePointToString(value) {
         return undefined;
     }
 }
-export { ensureWebsiteMirror, getCachePaths, validateWebsiteInputUrl, validateWebsiteUrl, WebsiteStashProvider };
+export { ensureWebsiteMirror, getCachePaths, validateWebsiteInputUrl, validateWebsiteUrl, WebsiteSourceProvider };

package/dist/{stash-resolve.js → sources/resolve.js}

@@ -1,10 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { deriveCanonicalAssetNameFromStashRoot, isRelevantAssetFile, resolveAssetPathFromName, TYPE_DIRS, } from "./asset-spec";
-import { hasErrnoCode, isWithin } from "./common";
-import { NotFoundError, UsageError } from "./errors";
-import { runMatchers } from "./file-context";
-import { walkStashFlat } from "./walker";
+import { deriveCanonicalAssetNameFromStashRoot, isRelevantAssetFile, resolveAssetPathFromName, TYPE_DIRS, } from "../core/asset-spec";
+import { hasErrnoCode, isWithin } from "../core/common";
+import { NotFoundError, UsageError } from "../core/errors";
+import { runMatchers } from "../indexer/file-context";
+import { walkStashFlat } from "../indexer/walker";
 /**
  * Resolve an asset path from a stash directory, type, and name.
  */
@@ -50,7 +50,8 @@ function resolveInTypeDir(stashDir, typeDir, type, name) {
 function resolveAndValidateTypeRoot(root, type, name) {
     const rootStat = readTypeRootStat(root, type, name);
     if (!rootStat.isDirectory()) {
-        throw new NotFoundError(`Stash type root is not a directory for ref: ${type}:${name}`);
+        throw new NotFoundError(`Asset directory for ${type} assets is not accessible — got a file where a directory was expected for ref: ${type}:${name}. ` +
+            "Run `akm index` to rebuild the index, or check your source configuration.", "ASSET_NOT_FOUND", "Run `akm list` to see your configured sources and verify the source path exists.");
     }
     return fs.realpathSync(root);
 }
@@ -60,7 +61,7 @@ function readTypeRootStat(root, type, name) {
     }
     catch (error) {
         if (hasErrnoCode(error, "ENOENT")) {
-            throw new NotFoundError(`Stash type root not found for ref: ${type}:${name}`);
+            throw new NotFoundError(`Asset not found for ref: ${type}:${name}. No ${type} assets are present in the configured source.`, "ASSET_NOT_FOUND", "Run `akm list` to see your configured sources, or `akm index` to rebuild the search index.");
         }
         throw error;
     }

package/dist/{wiki.js → wiki/wiki.js}

@@ -15,13 +15,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parse as yamlParse } from "yaml";
-import { isWithin } from "./common";
-import { loadUserConfig, saveConfig } from "./config";
-import { NotFoundError, UsageError } from "./errors";
-import { parseFrontmatter, parseFrontmatterBlock } from "./frontmatter";
-import { resolveStashSources } from "./search-source";
-import { akmSearch } from "./stash-search";
-import { buildIndexMd, buildLogMd, buildSchemaMd } from "./templates/wiki-templates";
+import { akmSearch } from "../commands/search";
+import { isWithin } from "../core/common";
+import { loadUserConfig, saveConfig } from "../core/config";
+import { NotFoundError, UsageError } from "../core/errors";
+import { parseFrontmatter, parseFrontmatterBlock } from "../core/frontmatter";
+import { resolveSourceEntries } from "../indexer/search-source";
+import { buildIndexMd, buildLogMd, buildSchemaMd } from "../templates/wiki-templates";
 // ── Constants ───────────────────────────────────────────────────────────────
 export const WIKIS_SUBDIR = "wikis";
 export const SCHEMA_MD = "schema.md";
@@ -64,7 +64,7 @@ function wikiNotFoundMessage(name) {
     return `Wiki not found: ${name}. Run \`akm wiki create ${name}\` to create it or \`akm wiki register ${name} <path-or-repo>\` to register an external wiki.`;
 }
 function registeredWikiSources(stashDir) {
-    return resolveStashSources(stashDir)
+    return resolveSourceEntries(stashDir)
         .filter((source) => typeof source.wikiName === "string")
         .map((source) => ({
         name: source.wikiName,
@@ -357,11 +357,12 @@ export function removeWiki(stashDir, name, options = {}) {
     const wikiDir = resolved.path;
     if (resolved.mode === "external") {
         const config = loadUserConfig();
-        const stashes = (config.stashes ?? []).filter((entry) => entry.wikiName !== name);
+        const filteredSources = (config.sources ?? config.stashes ?? []).filter((entry) => entry.wikiName !== name);
         const installed = (config.installed ?? []).filter((entry) => entry.wikiName !== name);
         saveConfig({
             ...config,
-            stashes: stashes.length > 0 ? stashes : undefined,
+            sources: filteredSources.length > 0 ? filteredSources : undefined,
+            stashes: undefined,
             installed: installed.length > 0 ? installed : undefined,
         });
         return {
@@ -527,7 +528,7 @@ export async function searchInWiki(input) {
     const rawDir = path.join(wikiDir, RAW_SUBDIR);
     const filtered = [];
     for (const hit of response.hits) {
-        // hits can be StashSearchHit or RegistrySearchResultHit (union); filter
+        // hits can be SourceSearchHit or RegistrySearchResultHit (union); filter
         // by path inclusion. Registry hits have no path and are dropped.
         if (hit.type === "registry")
             continue;