akm-cli 0.1.2 → 0.1.3

package/README.md

@@ -25,12 +25,15 @@ Upgrade in place with `akm upgrade`.
 ## Quick Start
 
 ```sh
-akm init                          # Initialize your working stash
+akm setup                         # Guided setup: configure, initialize, and index
 akm add github:owner/repo         # Add a kit from GitHub
 akm search "deploy"               # Find assets
 akm show script:deploy.sh         # View details and run command
 ```
 
+If you want to skip the wizard, `akm init --dir ~/custom-stash` initializes the
+working stash at a custom path.
+
 ## Features
 
 ### Works with Any AI Agent

package/dist/cli.js

@@ -405,6 +405,18 @@ function formatSearchPlain(r, detail) {
  * - registry-*  : Kit discovery from remote registries (npm, GitHub)
  * - installed-kits : Management of kits already installed locally
  */
+const setupCommand = defineCommand({
+    meta: {
+        name: "setup",
+        description: "Interactive configuration wizard for embeddings, LLM, registries, and stash sources",
+    },
+    async run() {
+        await runWithJsonErrors(async () => {
+            const { runSetupWizard } = await import("./setup");
+            await runSetupWizard();
+        });
+    },
+});
 const initCommand = defineCommand({
     meta: {
         name: "init",
@@ -977,6 +989,7 @@ const main = defineCommand({
         quiet: { type: "boolean", alias: "q", description: "Suppress stderr warnings", default: false },
     },
     subCommands: {
+        setup: setupCommand,
         init: initCommand,
         index: indexCommand,
         add: addCommand,

package/dist/detect.js

@@ -0,0 +1,120 @@
+/**
+ * Service detection utilities for the setup wizard.
+ *
+ * Pure detection functions with no user interaction — each returns
+ * a result object describing what was found.
+ */
+import fs from "node:fs";
+import path from "node:path";
+// ── Ollama Detection ────────────────────────────────────────────────────────
+const OLLAMA_BASE = "http://localhost:11434";
+/**
+ * Detect if Ollama is running and list available models.
+ *
+ * Tries the HTTP API first (`/api/tags`), then falls back to `ollama list`
+ * via subprocess. Returns available models sorted alphabetically.
+ */
+export async function detectOllama() {
+    const result = { available: false, models: [], endpoint: OLLAMA_BASE };
+    // Try HTTP API first
+    try {
+        const response = await fetch(`${OLLAMA_BASE}/api/tags`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (response.ok) {
+            const data = (await response.json());
+            if (Array.isArray(data.models)) {
+                result.models = data.models
+                    .map((m) => (typeof m.name === "string" ? m.name.replace(/:latest$/, "") : ""))
+                    .filter(Boolean)
+                    .sort();
+                result.available = true;
+                return result;
+            }
+        }
+    }
+    catch {
+        // HTTP failed — try CLI fallback
+    }
+    // CLI fallback
+    try {
+        const proc = Bun.spawn(["ollama", "list"], {
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        const text = await new Response(proc.stdout).text();
+        const exitCode = await proc.exited;
+        if (exitCode === 0 && text.trim()) {
+            const lines = text.trim().split("\n").slice(1); // skip header
+            result.models = lines
+                .map((line) => {
+                const name = line.split(/\s+/)[0]?.replace(/:latest$/, "");
+                return name || "";
+            })
+                .filter(Boolean)
+                .sort();
+            result.available = true;
+        }
+    }
+    catch {
+        // Ollama not installed or not in PATH
+    }
+    return result;
+}
+// ── Agent Platform Detection ────────────────────────────────────────────────
+const AGENT_PLATFORMS = [
+    { name: "Claude Code", relPath: ".claude" },
+    { name: "OpenCode", relPath: ".config/opencode" },
+    { name: "Continue", relPath: ".continue" },
+    { name: "Codeium / Windsurf", relPath: ".codeium" },
+    { name: "Cursor", relPath: ".cursor" },
+    { name: "Codex CLI", relPath: ".codex" },
+];
+/**
+ * Scan the user's home directory for known agent platform config directories.
+ * Supports both HOME (Unix) and USERPROFILE (Windows).
+ */
+export function detectAgentPlatforms() {
+    const home = process.env.HOME?.trim() || process.env.USERPROFILE?.trim();
+    if (!home)
+        return [];
+    return AGENT_PLATFORMS.filter((p) => {
+        const fullPath = path.join(home, p.relPath);
+        try {
+            return fs.statSync(fullPath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }).map((p) => ({
+        name: p.name,
+        path: path.join(home, p.relPath),
+    }));
+}
+// ── OpenViking Detection ────────────────────────────────────────────────────
+/**
+ * Check if an OpenViking server is reachable at the given URL.
+ * Uses the lightweight /api/v1/fs/stat endpoint (GET) rather than
+ * the search endpoint which requires a running search index.
+ */
+export async function detectOpenViking(url) {
+    const normalized = url.replace(/\/+$/, "");
+    try {
+        // Any HTTP response (even non-2xx) from the API endpoint means the server is reachable.
+        // Only network errors / timeouts indicate the server is truly unavailable.
+        await fetch(`${normalized}/api/v1/fs/stat?uri=${encodeURIComponent("viking://")}`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        return { available: true, url: normalized };
+    }
+    catch {
+        // stat endpoint unreachable — try root URL as fallback
+        try {
+            await fetch(normalized, { signal: AbortSignal.timeout(5000) });
+            return { available: true, url: normalized };
+        }
+        catch {
+            return { available: false, url: normalized };
+        }
+    }
+}

package/dist/setup.js

@@ -0,0 +1,506 @@
+/**
+ * Interactive configuration wizard for akm.
+ *
+ * Walks users through service detection, embedding/LLM setup,
+ * registry selection, stash sources, and agent platform discovery.
+ * Collects all choices and writes config once at the end.
+ */
+import * as p from "@clack/prompts";
+import { DEFAULT_CONFIG, getConfigPath, loadConfig, saveConfig } from "./config";
+import { detectAgentPlatforms, detectOllama, detectOpenViking } from "./detect";
+import { akmIndex } from "./indexer";
+import { akmInit } from "./init";
+import { getDefaultStashDir } from "./paths";
+// ── Constants ───────────────────────────────────────────────────────────────
+/** Recommended GitHub repositories shown during setup. */
+const RECOMMENDED_GITHUB_REPOS = [
+    {
+        url: "https://github.com/andrewyng/context-hub",
+        name: "context-hub",
+        hint: "community knowledge",
+    },
+];
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function bail() {
+    p.cancel("Setup cancelled. No changes were saved.");
+    process.exit(0);
+}
+/**
+ * Check if a prompt result was cancelled (Escape). If so, ask the user
+ * whether they really want to quit. Returns true if the user chose to
+ * stay (i.e. the caller should re-prompt), or calls bail() to exit.
+ *
+ * @internal Exported for testing only.
+ */
+export async function onCancel(value) {
+    if (!p.isCancel(value))
+        return false;
+    const confirmExit = await p.confirm({
+        message: "Exit the wizard? No changes will be saved.",
+        initialValue: false,
+    });
+    // Only exit when the user explicitly confirms "Yes".
+    // Pressing Escape on the confirmation (isCancel) or choosing "No"
+    // both mean "stay in the wizard".
+    if (confirmExit === true) {
+        bail();
+    }
+    // User chose to stay
+    return true;
+}
+/**
+ * Run a prompt function in a loop, retrying if the user presses Escape
+ * but decides to stay. Returns the non-cancelled result.
+ */
+async function prompt(fn) {
+    for (;;) {
+        const result = await fn();
+        if (await onCancel(result))
+            continue;
+        return result;
+    }
+}
+/**
+ * Like `prompt`, but pressing Escape returns `null` instead of re-prompting.
+ * Use inside sub-actions so the user can back out to the parent menu.
+ */
+async function promptOrBack(fn) {
+    const result = await fn();
+    if (p.isCancel(result))
+        return null;
+    return result;
+}
+// ── Steps ───────────────────────────────────────────────────────────────────
+async function stepStashDir(current) {
+    const defaultDir = current.stashDir ?? getDefaultStashDir();
+    const choice = await prompt(() => p.select({
+        message: "Where should akm store skills, commands, and other assets?",
+        options: [
+            { value: "default", label: defaultDir, hint: current.stashDir ? "current" : "default" },
+            { value: "custom", label: "Enter a custom path..." },
+        ],
+    }));
+    if (choice === "default")
+        return defaultDir;
+    const customPath = await prompt(() => p.text({
+        message: "Enter the stash directory path:",
+        placeholder: defaultDir,
+        validate: (v) => {
+            if (!v?.trim())
+                return "Path cannot be empty";
+        },
+    }));
+    return customPath.trim();
+}
+async function stepOllama(current) {
+    const spin = p.spinner();
+    spin.start("Checking for Ollama...");
+    const ollama = await detectOllama();
+    if (!ollama.available) {
+        spin.stop("Ollama not detected");
+        p.log.info("Ollama is not running. Embeddings will use the built-in local model.\n" +
+            "To use Ollama later, install it from https://ollama.com and re-run `akm setup`.");
+        // Preserve existing embedding/LLM config when Ollama is not available
+        return { embedding: current.embedding, llm: current.llm };
+    }
+    spin.stop(`Ollama detected at ${ollama.endpoint}`);
+    if (ollama.models.length > 0) {
+        p.log.info(`Available models: ${ollama.models.join(", ")}`);
+    }
+    // Embedding model selection
+    const embeddingModels = ollama.models.filter((m) => m.includes("embed") || m.includes("nomic") || m.includes("minilm") || m.includes("bge"));
+    const hasEmbeddingModels = embeddingModels.length > 0;
+    let embedding;
+    const embeddingOptions = [];
+    for (const m of embeddingModels) {
+        embeddingOptions.push({ value: m, label: m, hint: "Ollama" });
+    }
+    embeddingOptions.push({
+        value: "local",
+        label: "Built-in local embeddings",
+        hint: "no server needed",
+    });
+    if (current.embedding) {
+        embeddingOptions.push({
+            value: "keep",
+            label: `Keep current: ${current.embedding.provider ?? current.embedding.endpoint}`,
+            hint: current.embedding.model,
+        });
+    }
+    const embChoice = await prompt(() => p.select({
+        message: "Which embedding provider should akm use?",
+        options: embeddingOptions,
+        initialValue: hasEmbeddingModels ? embeddingModels[0] : "local",
+    }));
+    if (embChoice === "keep") {
+        embedding = current.embedding;
+    }
+    else if (embChoice !== "local") {
+        // Ask for dimension — different models produce different sizes
+        const dimChoice = await prompt(() => p.text({
+            message: "Embedding dimension (must match your index; 384 is common for MiniLM/nomic):",
+            placeholder: "384",
+            defaultValue: "384",
+            validate: (v) => {
+                const n = Number(v);
+                if (!Number.isInteger(n) || n <= 0)
+                    return "Must be a positive integer";
+            },
+        }));
+        embedding = {
+            provider: "ollama",
+            endpoint: `${ollama.endpoint}/v1/embeddings`,
+            model: embChoice,
+            dimension: Number(dimChoice),
+        };
+    }
+    // else: undefined → use built-in local
+    // LLM model selection
+    const chatModels = ollama.models.filter((m) => !embeddingModels.includes(m));
+    const allLlmCandidates = chatModels.length > 0 ? chatModels : ollama.models;
+    let llm;
+    const llmOptions = [];
+    for (const m of allLlmCandidates) {
+        llmOptions.push({ value: m, label: m, hint: "Ollama" });
+    }
+    llmOptions.push({
+        value: "none",
+        label: "Skip LLM enhancement",
+        hint: "use heuristic metadata",
+    });
+    if (current.llm) {
+        llmOptions.push({
+            value: "keep",
+            label: `Keep current: ${current.llm.provider ?? current.llm.endpoint}`,
+            hint: current.llm.model,
+        });
+    }
+    const llmChoice = await prompt(() => p.select({
+        message: "Use an LLM for richer metadata during indexing?",
+        options: llmOptions,
+        initialValue: allLlmCandidates.length > 0 ? allLlmCandidates[0] : "none",
+    }));
+    if (llmChoice === "keep") {
+        llm = current.llm;
+    }
+    else if (llmChoice !== "none") {
+        llm = {
+            provider: "ollama",
+            endpoint: `${ollama.endpoint}/v1/chat/completions`,
+            model: llmChoice,
+            temperature: 0.3,
+            maxTokens: 512,
+        };
+    }
+    return { embedding, llm };
+}
+async function stepRegistries(current) {
+    const defaults = DEFAULT_CONFIG.registries ?? [];
+    const currentRegistries = current.registries ?? defaults;
+    const defaultUrls = new Set(defaults.map((r) => r.url));
+    const enabledUrls = new Set(currentRegistries.filter((r) => r.enabled !== false).map((r) => r.url));
+    // Collect custom (non-default) registries to preserve them
+    const customRegistries = currentRegistries.filter((r) => !defaultUrls.has(r.url));
+    // Show default registries for toggling
+    const options = defaults.map((r) => ({
+        value: r.url,
+        label: r.name ?? r.url,
+        hint: r.provider ?? "static index",
+    }));
+    if (customRegistries.length > 0) {
+        p.log.info(`You have ${customRegistries.length} custom registr${customRegistries.length === 1 ? "y" : "ies"} that will be preserved.`);
+    }
+    const selected = await prompt(() => p.multiselect({
+        message: "Which built-in registries should be enabled?",
+        options,
+        initialValues: options.filter((o) => enabledUrls.has(o.value)).map((o) => o.value),
+    }));
+    // If all defaults are selected and there are no custom registries,
+    // return undefined to use the built-in defaults (avoids pinning)
+    const allDefaultsSelected = defaults.every((r) => selected.includes(r.url));
+    if (allDefaultsSelected && customRegistries.length === 0) {
+        return undefined;
+    }
+    // Build explicit list: toggled defaults + preserved custom registries
+    const result = defaults.map((r) => ({
+        ...r,
+        enabled: selected.includes(r.url),
+    }));
+    // Re-add custom registries unchanged
+    for (const custom of customRegistries) {
+        result.push(custom);
+    }
+    return result;
+}
+/**
+ * @internal Exported for testing only.
+ */
+export async function stepStashSources(current) {
+    const stashes = [...(current.stashes ?? [])];
+    if (stashes.length > 0) {
+        p.log.info(`You have ${stashes.length} existing stash source(s).`);
+    }
+    // ── Recommended GitHub repos ───────────────────────────────────────────
+    const existingUrls = new Set(stashes.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 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),
+        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: "github", 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);
+            if (idx !== -1) {
+                stashes.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: "openviking", label: "OpenViking server", hint: "remote stash" },
+                { 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 === "openviking") {
+            const url = await promptOrBack(() => p.text({
+                message: "Enter the OpenViking server URL:",
+                placeholder: "https://your-openviking-server.example.com",
+                validate: (v) => {
+                    if (!v?.trim())
+                        return "URL cannot be empty";
+                    if (!v.startsWith("http://") && !v.startsWith("https://"))
+                        return "URL must start with http:// or https://";
+                },
+            }));
+            if (url === null)
+                continue;
+            const spin = p.spinner();
+            spin.start("Checking OpenViking server...");
+            const result = await detectOpenViking(url.trim());
+            if (result.available) {
+                spin.stop("Server is reachable");
+            }
+            else {
+                spin.stop("Server not reachable — adding anyway (it may be temporarily down)");
+            }
+            const name = await promptOrBack(() => p.text({
+                message: "Give this stash a name (optional):",
+                placeholder: "my-openviking",
+            }));
+            if (name === null)
+                continue;
+            // Use the normalized URL from detection (trailing slashes stripped)
+            const entry = { type: "openviking", url: result.url };
+            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 === "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: "github", 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.");
+            }
+        }
+    }
+    return stashes;
+}
+async function stepAgentPlatforms(current) {
+    const platforms = detectAgentPlatforms();
+    if (platforms.length === 0) {
+        p.log.info("No agent platform configurations detected.");
+        return [];
+    }
+    const existingPaths = new Set((current.stashes ?? []).map((s) => s.path));
+    // Filter out platforms already configured
+    const newPlatforms = platforms.filter((pl) => !existingPaths.has(pl.path));
+    if (newPlatforms.length === 0) {
+        p.log.info(`Detected ${platforms.length} agent platform(s), all already configured as stash sources.`);
+        return [];
+    }
+    const selected = await prompt(() => p.multiselect({
+        message: "Found agent platform configurations. Add as stash sources?",
+        options: newPlatforms.map((pl) => ({
+            value: pl.path,
+            label: pl.name,
+            hint: pl.path,
+        })),
+        required: false,
+    }));
+    const entries = [];
+    for (const selectedPath of selected) {
+        const platform = newPlatforms.find((pl) => pl.path === selectedPath);
+        if (platform) {
+            entries.push({
+                type: "filesystem",
+                path: platform.path,
+                name: platform.name.toLowerCase().replace(/\s+/g, "-"),
+            });
+        }
+    }
+    return entries;
+}
+// ── Main Wizard ─────────────────────────────────────────────────────────────
+export async function runSetupWizard() {
+    p.intro("akm setup");
+    const current = loadConfig();
+    const configPath = getConfigPath();
+    // Step 1: Stash directory
+    p.log.step("Step 1: Stash Directory");
+    const stashDir = await stepStashDir(current);
+    // Step 2: Ollama / Embedding / LLM
+    p.log.step("Step 2: Embedding & LLM");
+    const { embedding, llm } = await stepOllama(current);
+    // Step 3: Registries
+    p.log.step("Step 3: Registries");
+    const registries = await stepRegistries(current);
+    // Step 4: Stash sources
+    p.log.step("Step 4: Stash Sources");
+    const stashes = await stepStashSources(current);
+    // Step 5: Agent platform detection
+    p.log.step("Step 5: Agent Platform Detection");
+    const platformStashes = await stepAgentPlatforms(current);
+    // Merge platform stashes into main stashes list
+    const allStashes = [...stashes];
+    for (const ps of platformStashes) {
+        if (!allStashes.some((s) => s.path === ps.path)) {
+            allStashes.push(ps);
+        }
+    }
+    // Build final config
+    const newConfig = {
+        ...current,
+        stashDir,
+        embedding,
+        llm,
+        registries,
+        stashes: allStashes.length > 0 ? allStashes : undefined,
+        // Preserve existing fields
+        semanticSearch: current.semanticSearch,
+        installed: current.installed,
+        output: current.output,
+    };
+    // Confirm before saving
+    const effectiveRegistries = registries ?? DEFAULT_CONFIG.registries ?? [];
+    p.note([
+        `Stash directory:  ${stashDir}`,
+        `Embedding:        ${embedding ? `${embedding.provider ?? "remote"} / ${embedding.model}` : "built-in local"}`,
+        `LLM:              ${llm ? `${llm.provider ?? "remote"} / ${llm.model}` : "disabled"}`,
+        `Registries:       ${effectiveRegistries.filter((r) => r.enabled !== false).length} enabled`,
+        `Stash sources:    ${allStashes.length}`,
+    ].join("\n"), "Configuration Summary");
+    const shouldSave = await prompt(() => p.confirm({
+        message: "Save this configuration?",
+        initialValue: true,
+    }));
+    if (!shouldSave)
+        bail();
+    // Save config
+    saveConfig(newConfig);
+    // Initialize stash directory
+    await akmInit({ dir: stashDir });
+    // Build search index
+    const spin = p.spinner();
+    spin.start("Building search index...");
+    try {
+        const indexResult = await akmIndex({ stashDir });
+        spin.stop(`Indexed ${indexResult.totalEntries} assets.`);
+    }
+    catch (err) {
+        spin.stop("Indexing failed — you can run `akm index` manually later.");
+        p.log.warn(String(err));
+    }
+    // API key reminder
+    if (embedding?.apiKey === undefined && embedding?.provider !== "ollama") {
+        // Only remind about API keys for non-Ollama remote providers
+        if (embedding?.endpoint && !embedding.endpoint.includes("localhost")) {
+            p.log.info("Reminder: Set your embedding API key via the AKM_EMBED_API_KEY environment variable.");
+        }
+    }
+    if (llm?.apiKey === undefined && llm?.provider !== "ollama") {
+        if (llm?.endpoint && !llm.endpoint.includes("localhost")) {
+            p.log.info("Reminder: Set your LLM API key via the AKM_LLM_API_KEY environment variable.");
+        }
+    }
+    p.outro(`Configuration saved to ${configPath}`);
+}

package/dist/stash-providers/context-hub.js

@@ -80,6 +80,7 @@ class ContextHubStashProvider {
     }
 }
 registerStashProvider("context-hub", (config) => new ContextHubStashProvider(config));
+registerStashProvider("github", (config) => new ContextHubStashProvider(config));
 function getCachePaths(repoUrl) {
     const key = createHash("sha256").update(repoUrl).digest("hex").slice(0, 16);
     const rootDir = path.join(getRegistryIndexCacheDir(), `context-hub-${key}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "description": "CLI tool to search, open, and run extension assets from an akm stash directory.",
   "keywords": [
@@ -58,6 +58,7 @@
     "bun": ">=1.0.0"
   },
   "dependencies": {
+    "@clack/prompts": "^1.1.0",
     "citty": "^0.2.1"
   }
 }