akm-cli 0.7.1 → 0.7.3

package/dist/setup/setup.js

@@ -5,6 +5,8 @@
  * registry selection, stash sources, and agent platform discovery.
  * Collects all choices and writes config once at the end.
  */
+import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import * as p from "@clack/prompts";
 import { akmInit } from "../commands/init";
@@ -19,15 +21,22 @@ import { probeLlmCapabilities } from "../llm/client";
 import { checkEmbeddingAvailability, DEFAULT_LOCAL_MODEL, isTransformersAvailable } from "../llm/embedder";
 import { detectAgentPlatforms, detectOllama } from "./detect";
 import { createSetupContext, runSetupSteps } from "./steps";
-// ── Constants ───────────────────────────────────────────────────────────────
 /**
  * Recommended GitHub repositories shown during setup.
- *
- * Currently empty — populating from the akm-registry at runtime is a
- * separate feature. The wizard prompt infrastructure is retained for that
- * future use.
  */
-const RECOMMENDED_GITHUB_REPOS = [];
+const RECOMMENDED_GITHUB_REPOS = [
+    {
+        url: "https://github.com/itlackey/akm-stash",
+        name: "itlackey/akm-stash",
+        hint: "official onboarding stash",
+        defaultSelected: true,
+    },
+    {
+        url: "https://github.com/andrewyng/context-hub",
+        name: "andrewyng/context-hub",
+        hint: "optional community prompt and context stash",
+    },
+];
 // Approximate first-download sizes used in the setup note.
 // LOCAL_MODEL_APPROX_SIZE_MB tracks the default local model (DEFAULT_LOCAL_MODEL).
 const LOCAL_MODEL_APPROX_SIZE_MB = 130;
@@ -83,6 +92,114 @@ async function promptOrBack(fn) {
         return null;
     return result;
 }
+function configuredSourceKey(source) {
+    return `${source.type}:${source.path ?? source.url ?? source.name ?? "unknown"}`;
+}
+function describeConfiguredSource(source) {
+    const target = source.path ?? source.url ?? "(unknown target)";
+    const typeLabel = source.type === "git" ? "Git" : source.type === "filesystem" ? "Filesystem" : source.type;
+    return {
+        value: configuredSourceKey(source),
+        label: source.name ?? target,
+        hint: `${typeLabel}: ${target}`,
+    };
+}
+function renderConfiguredSourceList(sources) {
+    return sources
+        .map((source) => {
+        const described = describeConfiguredSource(source);
+        return `- ${described.label} (${described.hint})`;
+    })
+        .join("\n");
+}
+function renderInstalledSourceList(installed) {
+    return installed.map((entry) => `- ${entry.id} (${entry.source})`).join("\n");
+}
+function cloneLlmConfig(llm) {
+    if (!llm)
+        return undefined;
+    return {
+        ...llm,
+        ...(llm.capabilities ? { capabilities: { ...llm.capabilities } } : {}),
+        ...(llm.features ? { features: { ...llm.features } } : {}),
+        ...(llm.extraParams ? { extraParams: { ...llm.extraParams } } : {}),
+    };
+}
+async function stepAdditionalSources(currentSources) {
+    const sources = [...currentSources];
+    let addMore = true;
+    while (addMore) {
+        const action = await prompt(() => p.select({
+            message: "Add another stash source?",
+            options: [
+                { value: "done", label: "Done — no more sources" },
+                { value: "github-repo", label: "GitHub repository", hint: "custom URL" },
+                { value: "filesystem", label: "Filesystem path", hint: "local directory" },
+            ],
+            initialValue: "done",
+        }));
+        if (action === "done") {
+            addMore = false;
+            break;
+        }
+        if (action === "github-repo") {
+            const url = await promptOrBack(() => p.text({
+                message: "Enter the GitHub repository URL:",
+                placeholder: "https://github.com/owner/repo",
+                validate: (v) => {
+                    if (!v?.trim())
+                        return "URL cannot be empty";
+                },
+            }));
+            if (url === null)
+                continue;
+            const name = await promptOrBack(() => p.text({
+                message: "Give this stash a name (optional):",
+                placeholder: "my-repo",
+            }));
+            if (name === null)
+                continue;
+            const entry = { type: "git", url: url.trim() };
+            if (name.trim())
+                entry.name = name.trim();
+            if (!sources.some((s) => s.url === entry.url)) {
+                sources.push(entry);
+            }
+            else {
+                p.log.warn("This URL is already configured.");
+            }
+        }
+        if (action === "filesystem") {
+            const fsPath = await promptOrBack(() => p.text({
+                message: "Enter the directory path:",
+                placeholder: "/path/to/stash",
+                validate: (v) => {
+                    if (!v?.trim())
+                        return "Path cannot be empty";
+                },
+            }));
+            if (fsPath === null)
+                continue;
+            const resolved = fsPath.trim();
+            const name = await promptOrBack(() => p.text({
+                message: "Give this stash a name (optional):",
+                placeholder: "my-stash",
+            }));
+            if (name === null)
+                continue;
+            const entry = { type: "filesystem", path: resolved };
+            if (name.trim())
+                entry.name = name.trim();
+            if (!sources.some((s) => s.path === entry.path)) {
+                sources.push(entry);
+            }
+            else {
+                p.log.warn("This path is already configured.");
+            }
+        }
+    }
+    return sources;
+}
 /**
  * Quick connectivity check. Returns true if we can reach a public
  * endpoint within 3 seconds, false otherwise. Used to skip network-
@@ -189,8 +306,10 @@ async function prepareSemanticSearchAssets(config) {
     }
     spin.stop(remote ? "Remote embedding endpoint is ready." : "Local embedding model downloaded and ready.");
     let db;
+    let probeDir;
     try {
-        db = openDatabase();
+        probeDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-setup-vec-probe-"));
+        db = openDatabase(path.join(probeDir, "probe.db"), config.embedding?.dimension ? { embeddingDim: config.embedding.dimension } : undefined);
         if (isVecAvailable(db)) {
             p.log.info("sqlite-vec is available for fast vector search.");
         }
@@ -206,6 +325,14 @@ async function prepareSemanticSearchAssets(config) {
     finally {
         if (db)
             closeDatabase(db);
+        if (probeDir) {
+            try {
+                fs.rmSync(probeDir, { recursive: true, force: true });
+            }
+            catch {
+                /* ignore cleanup failure */
+            }
+        }
     }
     return { ok: true };
 }
@@ -375,7 +502,7 @@ export async function stepLlm(current, ollamaEndpoint, ollamaChatModels) {
         initialValue,
     }));
     if (choice === "keep")
-        return current.llm;
+        return cloneLlmConfig(current.llm);
     if (choice === "none")
         return undefined;
     let llm;
@@ -466,7 +593,7 @@ export async function stepLlm(current, ollamaEndpoint, ollamaChatModels) {
     }
     return llm;
 }
-async function stepRegistries(current) {
+export async function stepRegistries(current) {
     const defaults = DEFAULT_CONFIG.registries ?? [];
     const currentRegistries = current.registries ?? defaults;
     const defaultUrls = new Set(defaults.map((r) => r.url));
@@ -507,119 +634,70 @@ async function stepRegistries(current) {
 /**
  * @internal Exported for testing only.
  */
-export async function stepAddSources(current) {
-    const stashes = [...(current.sources ?? current.stashes ?? [])];
-    if (stashes.length > 0) {
-        p.log.info(`You have ${stashes.length} existing stash source(s).`);
+export async function stepAddSources(current, options) {
+    const existingSources = [...(current.sources ?? current.stashes ?? [])];
+    const sources = [];
+    if (existingSources.length > 0) {
+        p.note(renderConfiguredSourceList(existingSources), "Configured stash sources");
+        const options = existingSources.map(describeConfiguredSource);
+        const selected = await prompt(() => p.multiselect({
+            message: "Configured stash sources — uncheck any you want to disable:",
+            options,
+            initialValues: options.map((option) => option.value),
+            required: false,
+        }));
+        for (const source of existingSources) {
+            if (selected.includes(configuredSourceKey(source))) {
+                sources.push(source);
+            }
+        }
+    }
+    if ((current.installed?.length ?? 0) > 0) {
+        p.note(renderInstalledSourceList(current.installed ?? []), "Installed managed stashes (preserved)");
     }
     // ── Recommended GitHub repos ───────────────────────────────────────────
     // Skip the prompt entirely when there are no recommendations to show.
     // The infrastructure is retained for a future registry-driven version.
     if (RECOMMENDED_GITHUB_REPOS.length > 0) {
-        const existingUrls = new Set(stashes.map((s) => s.url));
+        const existingUrls = new Set(sources.map((s) => s.url));
         const repoOptions = RECOMMENDED_GITHUB_REPOS.map((r) => ({
             value: r.url,
             label: r.name,
             hint: existingUrls.has(r.url) ? `${r.hint} (already added)` : r.hint,
         }));
+        const initialValues = sources.length > 0
+            ? repoOptions.filter((o) => existingUrls.has(o.value)).map((o) => o.value)
+            : RECOMMENDED_GITHUB_REPOS.filter((r) => r.defaultSelected).map((r) => r.url);
         const selectedRepos = await prompt(() => p.multiselect({
             message: "Recommended GitHub repositories — toggle to add or remove:",
             options: repoOptions,
-            initialValues: repoOptions.filter((o) => existingUrls.has(o.value)).map((o) => o.value),
+            initialValues,
             required: false,
         }));
         // Add newly selected repos
         for (const url of selectedRepos) {
             if (!existingUrls.has(url)) {
                 const rec = RECOMMENDED_GITHUB_REPOS.find((r) => r.url === url);
-                stashes.push({ type: "git", url, name: rec?.name });
+                sources.push({ type: "git", url, name: rec?.name });
                 existingUrls.add(url);
             }
         }
         // Remove deselected repos that were previously configured
         for (const rec of RECOMMENDED_GITHUB_REPOS) {
             if (existingUrls.has(rec.url) && !selectedRepos.includes(rec.url)) {
-                const idx = stashes.findIndex((s) => s.url === rec.url);
+                const idx = sources.findIndex((s) => s.url === rec.url);
                 if (idx !== -1) {
-                    stashes.splice(idx, 1);
+                    sources.splice(idx, 1);
                     existingUrls.delete(rec.url);
                     p.log.info(`Removed ${rec.name}.`);
                 }
             }
         }
     }
-    // ── Additional stash sources loop ──────────────────────────────────────
-    let addMore = true;
-    while (addMore) {
-        const action = await prompt(() => p.select({
-            message: "Add another stash source?",
-            options: [
-                { value: "github-repo", label: "GitHub repository", hint: "custom URL" },
-                { value: "filesystem", label: "Filesystem path", hint: "local directory" },
-                { value: "done", label: "Done — no more sources" },
-            ],
-        }));
-        if (action === "done") {
-            addMore = false;
-            break;
-        }
-        if (action === "github-repo") {
-            const url = await promptOrBack(() => p.text({
-                message: "Enter the GitHub repository URL:",
-                placeholder: "https://github.com/owner/repo",
-                validate: (v) => {
-                    if (!v?.trim())
-                        return "URL cannot be empty";
-                },
-            }));
-            if (url === null)
-                continue;
-            const name = await promptOrBack(() => p.text({
-                message: "Give this stash a name (optional):",
-                placeholder: "my-repo",
-            }));
-            if (name === null)
-                continue;
-            const entry = { type: "git", url: url.trim() };
-            if (name.trim())
-                entry.name = name.trim();
-            if (!stashes.some((s) => s.url === entry.url)) {
-                stashes.push(entry);
-            }
-            else {
-                p.log.warn("This URL is already configured.");
-            }
-        }
-        if (action === "filesystem") {
-            const fsPath = await promptOrBack(() => p.text({
-                message: "Enter the directory path:",
-                placeholder: "/path/to/stash",
-                validate: (v) => {
-                    if (!v?.trim())
-                        return "Path cannot be empty";
-                },
-            }));
-            if (fsPath === null)
-                continue;
-            const resolved = fsPath.trim();
-            const name = await promptOrBack(() => p.text({
-                message: "Give this stash a name (optional):",
-                placeholder: "my-stash",
-            }));
-            if (name === null)
-                continue;
-            const entry = { type: "filesystem", path: resolved };
-            if (name.trim())
-                entry.name = name.trim();
-            if (!stashes.some((s) => s.path === entry.path)) {
-                stashes.push(entry);
-            }
-            else {
-                p.log.warn("This path is already configured.");
-            }
-        }
+    if (options?.promptForAdditional === false) {
+        return sources;
     }
-    return stashes;
+    return stepAdditionalSources(sources);
 }
 async function stepAgentPlatforms(current) {
     const platforms = detectAgentPlatforms();
@@ -627,7 +705,7 @@ async function stepAgentPlatforms(current) {
         p.log.info("No agent platform configurations detected.");
         return [];
     }
-    const existingPaths = new Set((current.stashes ?? []).map((s) => s.path));
+    const existingPaths = new Set((current.sources ?? current.stashes ?? []).map((s) => s.path));
     // Filter out platforms already configured
     const newPlatforms = platforms.filter((pl) => !existingPaths.has(pl.path));
     if (newPlatforms.length === 0) {
@@ -656,6 +734,60 @@ async function stepAgentPlatforms(current) {
     }
     return entries;
 }
+export async function stepAgentSelection(current, detections) {
+    const available = detections.filter((d) => d.available);
+    if (available.length === 0) {
+        return current.agent;
+    }
+    const initialValue = pickDefaultAgentProfile(detections, current.agent?.default) ?? available[0]?.name;
+    const selectedDefault = await prompt(() => p.select({
+        message: "Which detected agent CLI should be the default?",
+        options: [
+            ...available.map((d) => ({
+                value: d.name,
+                label: d.name,
+                hint: d.resolvedPath ?? d.bin,
+            })),
+            { value: "disabled", label: "Disabled", hint: "do not configure a default agent CLI" },
+        ],
+        initialValue,
+    }));
+    if (selectedDefault === "disabled") {
+        if (!current.agent?.profiles && !current.agent?.timeoutMs) {
+            return undefined;
+        }
+        return {
+            ...(current.agent ?? {}),
+            default: undefined,
+        };
+    }
+    return {
+        ...(current.agent ?? {}),
+        default: selectedDefault,
+    };
+}
+export async function stepOutputConfig(current) {
+    const defaultOutput = current.output ?? DEFAULT_CONFIG.output ?? { format: "json", detail: "brief" };
+    const format = await prompt(() => p.select({
+        message: "Default output format?",
+        options: [
+            { value: "json", label: "json", hint: "structured default" },
+            { value: "text", label: "text", hint: "human-readable CLI output" },
+            { value: "yaml", label: "yaml", hint: "structured text" },
+        ],
+        initialValue: defaultOutput.format ?? "json",
+    }));
+    const detail = await prompt(() => p.select({
+        message: "Default output detail level?",
+        options: [
+            { value: "brief", label: "brief", hint: "compact summaries" },
+            { value: "normal", label: "normal", hint: "balanced detail" },
+            { value: "full", label: "full", hint: "max available detail" },
+        ],
+        initialValue: defaultOutput.detail ?? "brief",
+    }));
+    return { format: format, detail: detail };
+}
 /**
  * Detect installed agent CLIs and produce an updated `agent` config block
  * with a sensible `default` (the first detected profile that the user has
@@ -751,20 +883,20 @@ export function buildSetupSteps(options) {
             id: "stash-sources",
             label: "Stash Sources",
             async run(ctx) {
-                const stashes = await stepAddSources(ctx.config);
-                const platforms = await stepAgentPlatforms(ctx.config);
+                const stashes = await stepAddSources(ctx.config, { promptForAdditional: false });
+                const platforms = await stepAgentPlatforms({ ...ctx.config, sources: stashes });
                 const merged = [...stashes];
                 for (const ps of platforms) {
                     if (!merged.some((s) => s.path === ps.path))
                         merged.push(ps);
                 }
-                ctx.apply({ sources: merged.length > 0 ? merged : undefined });
+                const withAdditional = await stepAdditionalSources(merged);
+                ctx.apply({ sources: withAdditional.length > 0 ? withAdditional : undefined });
             },
         },
         {
             id: "agent-cli",
             label: "Agent CLI",
-            nonInteractive: true,
             async run(ctx) {
                 const result = stepAgentCliDetection(ctx.config);
                 const detected = result.detections.filter((d) => d.available);
@@ -775,7 +907,16 @@ export function buildSetupSteps(options) {
                 else {
                     p.log.info("No agent CLIs detected on PATH. Agent commands will be disabled until one is installed and `akm setup` is re-run.");
                 }
-                ctx.apply({ agent: result.agent });
+                const agent = await stepAgentSelection({ ...ctx.config, agent: result.agent }, result.detections);
+                ctx.apply({ agent });
+            },
+        },
+        {
+            id: "output",
+            label: "Output Defaults",
+            async run(ctx) {
+                const output = await stepOutputConfig(ctx.config);
+                ctx.apply({ output });
             },
         },
     ];
@@ -811,7 +952,6 @@ export async function runSetupWizard() {
         ...ctx.config,
         // Preserve fields the steps don't manage explicitly.
         installed: current.installed,
-        output: current.output,
     };
     const semanticSearchMode = outcome.semantic;
     const stashDir = newConfig.stashDir ?? current.stashDir ?? getDefaultStashDir();
@@ -828,6 +968,8 @@ export async function runSetupWizard() {
         `Semantic search:  ${semanticSearchMode.mode}`,
         `Registries:       ${effectiveRegistries.filter((r) => r.enabled !== false).length} enabled`,
         `Stash sources:    ${allStashes.length}`,
+        `Agent default:    ${newConfig.agent?.default ?? "disabled"}`,
+        `Output:           ${newConfig.output?.format ?? "json"} / ${newConfig.output?.detail ?? "brief"}`,
     ].join("\n"), "Configuration Summary");
     const shouldSave = await prompt(() => p.confirm({
         message: "Save this configuration?",

package/dist/sources/providers/git.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { TYPE_DIRS } from "../../core/asset-spec";
 import { resolveStashDir } from "../../core/common";
 import { loadConfig } from "../../core/config";
 import { ConfigError, UsageError } from "../../core/errors";
@@ -123,7 +124,7 @@ async function ensureGitMirror(repo, cachePaths, options) {
  * shared registry-index cache (12h TTL) and exposes the working tree as the
  * stash content directory.
  */
-async function syncMirroredRepo(config, options) {
+export async function syncMirroredRepo(config, options) {
     if (!config.url) {
         throw new ConfigError("git stash entry requires a URL when no install ref is supplied");
     }
@@ -303,7 +304,18 @@ function pullRepo(repoDir) {
 }
 function hasExtractedRepo(repoDir) {
     try {
-        return fs.statSync(repoDir).isDirectory() && fs.statSync(path.join(repoDir, "content")).isDirectory();
+        if (!fs.statSync(repoDir).isDirectory())
+            return false;
+        if (fs.statSync(path.join(repoDir, "content")).isDirectory())
+            return true;
+    }
+    catch {
+        /* fall through to root-layout detection */
+    }
+    try {
+        if (!fs.statSync(repoDir).isDirectory())
+            return false;
+        return Object.values(TYPE_DIRS).some((dirName) => fs.existsSync(path.join(repoDir, dirName)));
     }
     catch {
         return false;