akm-cli 0.6.0-rc1 → 0.6.0

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

@@ -6,10 +6,10 @@
  * CLI entry point stays focused on argument parsing + output routing.
  */
 import { stringify as yamlStringify } from "yaml";
-import { tryReadStdinText } from "./common";
-import { loadConfig } from "./config";
-import { UsageError } from "./errors";
-import { warn } from "./warn";
+import { toErrorMessage, tryReadStdinText } from "../core/common";
+import { loadConfig } from "../core/config";
+import { UsageError } from "../core/errors";
+import { warn } from "../core/warn";
 /**
  * Parse a shorthand duration string to a number of milliseconds.
  * Supports: `30d` (days), `12h` (hours), `6m` (months, approximated as 30d).
@@ -17,7 +17,7 @@ import { warn } from "./warn";
 export function parseDuration(s) {
     const match = s.trim().match(/^(\d+)([dhm])$/i);
     if (!match)
-        throw new UsageError(`Invalid --expires format "${s}". Use shorthand like 30d, 12h, or 6m.`);
+        throw new UsageError(`Invalid --expires format "${s}". Use shorthand like 30d, 12h, or 6m.`, "INVALID_FLAG_VALUE");
     const n = Number(match[1]);
     const unit = match[2].toLowerCase();
     if (unit === "d")
@@ -40,15 +40,15 @@ export function parseDuration(s) {
  */
 export function buildMemoryFrontmatter(fields) {
     const obj = {};
-    if (fields.description && fields.description.trim())
+    if (fields.description?.trim())
         obj.description = fields.description;
     if (fields.tags && fields.tags.length > 0)
         obj.tags = fields.tags;
-    if (fields.source && fields.source.trim())
+    if (fields.source?.trim())
         obj.source = fields.source;
-    if (fields.observed_at && fields.observed_at.trim())
+    if (fields.observed_at?.trim())
         obj.observed_at = fields.observed_at;
-    if (fields.expires && fields.expires.trim())
+    if (fields.expires?.trim())
         obj.expires = fields.expires;
     if (fields.subjective)
         obj.subjective = true;
@@ -86,38 +86,32 @@ export function runAutoHeuristics(body) {
     const urlMatch = body.match(/https?:\/\/[^\s)>'"]+/);
     const source = urlMatch ? urlMatch[0] : undefined;
     // ISO date token or obvious relative date phrase → observed_at
-    let observed_at;
-    const isoMatch = body.match(/\b(\d{4}-\d{2}-\d{2})\b/);
-    if (isoMatch) {
-        observed_at = isoMatch[1];
-    }
-    else {
-        const relMatch = body.match(/\b(today|yesterday|last\s+week|last\s+month)\b/i);
-        if (relMatch) {
-            const phrase = relMatch[1].toLowerCase();
-            const now = new Date();
-            if (phrase === "today") {
-                observed_at = now.toISOString().slice(0, 10);
-            }
-            else if (phrase === "yesterday") {
-                const d = new Date(now);
-                d.setDate(d.getDate() - 1);
-                observed_at = d.toISOString().slice(0, 10);
-            }
-            else if (phrase.startsWith("last week")) {
-                const d = new Date(now);
-                d.setDate(d.getDate() - 7);
-                observed_at = d.toISOString().slice(0, 10);
-            }
-            else if (phrase.startsWith("last month")) {
-                const d = new Date(now);
-                d.setMonth(d.getMonth() - 1);
-                observed_at = d.toISOString().slice(0, 10);
-            }
-        }
-    }
+    const observed_at = detectObservedAt(body);
     return { tags, source, observed_at, subjective };
 }
+const RELATIVE_DATE_OFFSETS = {
+    today: () => { },
+    yesterday: (d) => d.setDate(d.getDate() - 1),
+    "last week": (d) => d.setDate(d.getDate() - 7),
+    "last month": (d) => d.setMonth(d.getMonth() - 1),
+};
+function detectObservedAt(body) {
+    const isoMatch = body.match(/\b(\d{4}-\d{2}-\d{2})\b/);
+    if (isoMatch)
+        return isoMatch[1];
+    const relMatch = body.match(/\b(today|yesterday|last\s+week|last\s+month)\b/i);
+    if (!relMatch)
+        return undefined;
+    // Normalise the matched phrase: lowercase, collapse internal whitespace,
+    // so "last  week" matches the lookup table key.
+    const phrase = relMatch[1].toLowerCase().replace(/\s+/g, " ");
+    const offset = RELATIVE_DATE_OFFSETS[phrase];
+    if (!offset)
+        return undefined;
+    const d = new Date();
+    offset(d);
+    return d.toISOString().slice(0, 10);
+}
 /** Hard timeout for the `--enrich` LLM call. Write-path must not block on a misbehaving endpoint. */
 const LLM_ENRICH_TIMEOUT_MS = 10_000;
 /**
@@ -131,7 +125,8 @@ export async function runLlmEnrich(body) {
         warn("Warning: --enrich requires an LLM to be configured. Run `akm config set llm` to configure one.");
         return { tags: [] };
     }
-    const { chatCompletion, parseJsonResponse } = await import("./llm.js");
+    const llmConfig = config.llm;
+    const { chatCompletion, parseJsonResponse } = await import("../llm/client");
     const prompt = `You are a memory tagger for a developer knowledge base.
 Given the memory text below, return ONLY a JSON object with these fields:
 - "tags": array of 1-5 short lowercase keyword tags
@@ -143,13 +138,25 @@ ${body.slice(0, 2000)}
 
 Return ONLY the JSON object, no prose, no markdown fences.`;
     try {
-        const result = await Promise.race([
-            chatCompletion(config.llm, [
-                { role: "system", content: "Return only valid JSON. No prose." },
-                { role: "user", content: prompt },
-            ], { maxTokens: 256, temperature: 0.1 }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error("LLM enrichment timed out")), LLM_ENRICH_TIMEOUT_MS)),
-        ]);
+        let timeoutHandle;
+        const result = await (async () => {
+            try {
+                return await Promise.race([
+                    chatCompletion(llmConfig, [
+                        { role: "system", content: "Return only valid JSON. No prose." },
+                        { role: "user", content: prompt },
+                    ], { maxTokens: 256, temperature: 0.1 }),
+                    new Promise((_, reject) => {
+                        timeoutHandle = setTimeout(() => reject(new Error("LLM enrichment timed out")), LLM_ENRICH_TIMEOUT_MS);
+                    }),
+                ]);
+            }
+            finally {
+                if (timeoutHandle !== undefined) {
+                    clearTimeout(timeoutHandle);
+                }
+            }
+        })();
         const parsed = parseJsonResponse(result);
         if (!parsed) {
             warn("Warning: --enrich received invalid JSON from the LLM. Writing memory without enrichment.");
@@ -165,8 +172,7 @@ Return ONLY the JSON object, no prose, no markdown fences.`;
         return { tags, description, observed_at };
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        warn(`Warning: --enrich failed (${msg}). Writing memory without enrichment.`);
+        warn(`Warning: --enrich failed (${toErrorMessage(err)}). Writing memory without enrichment.`);
         return { tags: [] };
     }
 }

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

@@ -1,13 +1,23 @@
-import { loadConfig } from "./config";
-import { closeDatabase, openDatabase } from "./db";
-import { searchLocal } from "./db-search";
-import { resolveStashProviders } from "./stash-provider-factory";
-// Eagerly import stash providers to trigger self-registration
-import "./stash-providers/index";
-import { UsageError } from "./errors";
+/**
+ * `akm search` — entry point.
+ *
+ * Spec §6.1: search consults the local FTS5 index. There is one query path
+ * because there is one data store. Provider fan-out is gone.
+ *
+ * The orchestration here is thin: build the FTS query, optionally interleave
+ * a registry search behind `--source registry|both`, and log a usage event.
+ * Provider `search()` methods do not exist.
+ */
+import { loadConfig } from "../core/config";
+import { UsageError } from "../core/errors";
+import { closeDatabase, openDatabase } from "../indexer/db";
+import { searchLocal } from "../indexer/db-search";
+import { resolveSourceEntries } from "../indexer/search-source";
+// Eagerly import source providers to trigger self-registration before the
+// indexer or path-resolution code runs.
+import "../sources/providers/index";
+import { insertUsageEvent } from "../indexer/usage-events";
 import { searchRegistry } from "./registry-search";
-import { resolveStashSources } from "./search-source";
-import { insertUsageEvent } from "./usage-events";
 const DEFAULT_LIMIT = 20;
 export async function akmSearch(input) {
     const t0 = Date.now();
@@ -17,7 +27,7 @@ export async function akmSearch(input) {
     const limit = normalizeLimit(input.limit);
     const source = parseSearchSource(input.source ?? "stash");
     const config = loadConfig();
-    const sources = resolveStashSources(undefined, config);
+    const sources = resolveSourceEntries(undefined, config);
     if (sources.length === 0) {
         // stashDir: "" is a safe sentinel here — the response carries zero hits
         // and a warning, so no downstream code will try to use the empty path.
@@ -35,10 +45,6 @@ export async function akmSearch(input) {
     // Primary stash directory — used for DB path lookups and as the default
     // stash root. Safe because the empty-sources case is handled above.
     const stashDir = sources[0].path;
-    // Resolve additional stash providers (e.g. OpenViking) from config.
-    // Exclude filesystem (handled by resolveStashSources) and git (content
-    // now indexed through the unified FTS5 pipeline).
-    const additionalStashProviders = resolveStashProviders(config).filter((p) => p.type !== "filesystem" && p.type !== "git");
     const localResult = source === "registry"
         ? undefined
         : await searchLocal({
@@ -49,35 +55,17 @@ export async function akmSearch(input) {
             sources,
             config,
         });
-    // Pass original case to providers — FTS5 requires lowercase but remote providers handle case themselves
-    const additionalStashResults = source === "registry" || additionalStashProviders.length === 0
-        ? []
-        : await Promise.all(additionalStashProviders.map(async (provider) => {
-            try {
-                return await provider.search({ query, type: searchType === "any" ? undefined : searchType, limit });
-            }
-            catch (err) {
-                return {
-                    hits: [],
-                    warnings: [`Stash ${provider.name}: ${err instanceof Error ? err.message : String(err)}`],
-                };
-            }
-        }));
-    // Merge stash hits from all providers
-    const additionalHits = additionalStashResults.flatMap((r) => r.hits);
-    const additionalWarnings = additionalStashResults.flatMap((r) => r.warnings ?? []);
     const registryResult = source === "stash" ? undefined : await searchRegistry(query, { limit, registries: config.registries });
     if (source === "stash") {
-        const allStashHits = mergeStashHits(localResult?.hits ?? [], additionalHits, limit);
-        const localWarnings = [...(localResult?.warnings ?? []), ...additionalWarnings];
-        const hasResults = allStashHits.length > 0;
+        const localHits = localResult?.hits ?? [];
+        const hasResults = localHits.length > 0;
         const response = {
             schemaVersion: 1,
             stashDir,
             source,
-            hits: allStashHits,
+            hits: localHits,
             tip: hasResults ? undefined : localResult?.tip,
-            warnings: localWarnings.length > 0 ? localWarnings : undefined,
+            warnings: localResult?.warnings?.length ? localResult.warnings : undefined,
             timing: { totalMs: Date.now() - t0, rankMs: localResult?.rankMs, embedMs: localResult?.embedMs },
         };
         logSearchEvent(query, response);
@@ -116,14 +104,14 @@ export async function akmSearch(input) {
         return response;
     }
     // source === "both"
-    const allStashHits = mergeStashHits(localResult?.hits ?? [], additionalHits, limit * 2);
-    const warnings = [...(localResult?.warnings ?? []), ...additionalWarnings, ...(registryResult?.warnings ?? [])];
+    const allStashHits = (localResult?.hits ?? []).slice(0, limit);
+    const warnings = [...(localResult?.warnings ?? []), ...(registryResult?.warnings ?? [])];
     const hasResults = allStashHits.length > 0 || registryHits.length > 0;
     const response = {
         schemaVersion: 1,
         stashDir,
         source,
-        hits: allStashHits.slice(0, limit),
+        hits: allStashHits,
         registryHits,
         tip: hasResults ? undefined : "No matching stash assets or registry entries were found.",
         warnings: warnings.length ? warnings : undefined,
@@ -184,35 +172,6 @@ function logSearchEvent(query, response, existingDb) {
     }
 }
 // ── Helpers ──────────────────────────────────────────────────────────────────
-/**
- * Merge local and additional stash hits into a single ranked list.
- *
- * Provider hits (e.g. OpenViking) keep their original scores and compete
- * fairly alongside local hits. Duplicates are resolved in favour of the
- * local version.
- *
- * 1. Build set of local hit keys for dedup.
- * 2. Filter provider hits that aren't duplicates.
- * 3. Combine local + non-duplicate provider hits.
- * 4. Sort by score descending.
- * 5. Slice to limit.
- */
-export function mergeStashHits(localHits, additionalHits, limit) {
-    if (additionalHits.length === 0)
-        return localHits.slice(0, limit);
-    // Track local hits by a dedup key (path > ref > name)
-    const localKeys = new Set();
-    for (const h of localHits) {
-        localKeys.add(h.path ?? h.ref ?? h.name);
-    }
-    // Keep non-duplicate provider hits with their original scores
-    const providerOnly = additionalHits.filter((h) => {
-        const key = h.path ?? h.ref ?? h.name;
-        return !localKeys.has(key);
-    });
-    // Combine and sort by score descending
-    return [...localHits, ...providerOnly].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, limit);
-}
 function normalizeLimit(limit) {
     if (typeof limit !== "number" || Number.isNaN(limit) || limit <= 0) {
         return DEFAULT_LIMIT;
@@ -227,7 +186,7 @@ export function parseSearchSource(source) {
         return "stash";
     if (typeof source === "undefined")
         return "stash";
-    throw new UsageError(`Invalid value for --source: ${String(source)}. Expected one of: stash|registry|both`);
+    throw new UsageError(`Invalid value for --source: ${String(source)}. Expected one of: stash|registry|both`, "INVALID_SOURCE_VALUE");
 }
 /**
  * Merge stash hits and registry hits via simple concatenation.

package/dist/{self-update.js → commands/self-update.js}

@@ -2,8 +2,8 @@ import * as childProcess from "node:child_process";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { fetchWithRetry, IS_WINDOWS } from "./common";
-import { githubHeaders } from "./github";
+import { fetchWithRetry, IS_WINDOWS } from "../core/common";
+import { githubHeaders } from "../integrations/github";
 const REPO = "itlackey/akm";
 const DEFAULT_PACKAGE_NAME = "akm-cli";
 const NODE_MODULES_SEGMENT = "/node_modules/";
@@ -80,6 +80,7 @@ export async function checkForUpdate(currentVersion) {
 export async function performUpgrade(check, opts) {
     const { currentVersion, latestVersion, installMethod } = check;
     const force = opts?.force === true;
+    const skipPostUpgrade = opts?.skipPostUpgrade === true;
     // All install methods can short-circuit here unless the user explicitly forces an upgrade.
     if (!check.updateAvailable && !force) {
         return {
@@ -113,6 +114,7 @@ export async function performUpgrade(check, opts) {
             upgraded: true,
             installMethod,
             message: `akm upgraded via ${installMethod}`,
+            postUpgrade: runPostUpgradeTasks("akm", { skip: skipPostUpgrade }),
         };
     }
     if (installMethod === "unknown") {
@@ -283,8 +285,72 @@ export async function performUpgrade(check, opts) {
         installMethod,
         binaryPath: execPath,
         checksumVerified,
+        // For binary installs, the new binary now lives at execPath; spawn it
+        // directly so the post-upgrade work runs against the new code.
+        postUpgrade: runPostUpgradeTasks(execPath, { skip: skipPostUpgrade }),
     };
 }
+/**
+ * Run the post-upgrade tasks against the *new* binary as a child process.
+ *
+ * Why a child process: the running akm process still has the old code in
+ * memory. Calling loadConfig()/akmIndex() in-process would use the old
+ * implementations and miss any DB_VERSION / config-key changes the new
+ * release introduces.
+ *
+ * The new binary's `akm index` does the work for us:
+ *   1. loadConfig() runs at startup — auto-migrates legacy `stashes` →
+ *      `sources` if the on-disk config still uses the old key.
+ *   2. ensureSchema() detects DB_VERSION mismatch and rebuilds index.db
+ *      tables (preserving usage_events).
+ *   3. The full reindex repopulates entries + workflow_documents + FTS.
+ */
+function runPostUpgradeTasks(akmBin, opts) {
+    if (opts.skip) {
+        return {
+            ok: true,
+            skipped: true,
+            message: "Skipped post-upgrade tasks. Run `akm index` manually to migrate config and rebuild the index.",
+        };
+    }
+    try {
+        const result = childProcess.spawnSync(akmBin, ["index"], {
+            encoding: "utf8",
+            env: process.env,
+            stdio: "pipe",
+        });
+        if (result.error) {
+            return {
+                ok: false,
+                skipped: false,
+                message: `Post-upgrade tasks could not start: ${result.error.message}. Run \`akm index\` manually.`,
+            };
+        }
+        if (result.status !== 0) {
+            const detail = (result.stderr ?? "").trim() || (result.stdout ?? "").trim() || `exit code ${result.status}`;
+            return {
+                ok: false,
+                skipped: false,
+                exitCode: result.status,
+                message: `Post-upgrade \`akm index\` failed (${detail}). Run \`akm index\` manually.`,
+            };
+        }
+        return {
+            ok: true,
+            skipped: false,
+            exitCode: 0,
+            message: "Config migrated (if needed) and index rebuilt against the new binary.",
+        };
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            skipped: false,
+            message: `Post-upgrade tasks failed: ${detail}. Run \`akm index\` manually.`,
+        };
+    }
+}
 function parseChecksumForFile(checksumsText, filename) {
     for (const line of checksumsText.split("\n")) {
         const trimmed = line.trim();
@@ -303,7 +369,7 @@ function normalizePathSeparators(value) {
 }
 function getInstalledPackageName() {
     try {
-        const pkgPath = path.resolve(import.meta.dir ?? __dirname, "../package.json");
+        const pkgPath = path.resolve(import.meta.dir ?? __dirname, "../../package.json");
         if (fs.existsSync(pkgPath)) {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
             if (typeof pkg.name === "string" && pkg.name.trim()) {