akm-cli 0.0.22 → 0.0.23

package/dist/cli.js

@@ -17,7 +17,7 @@ import { agentikitAdd } from "./stash-add";
 import { agentikitClone } from "./stash-clone";
 import { agentikitSearch, parseSearchSource } from "./stash-search";
 import { agentikitShowUnified } from "./stash-show";
-import { resolveStashSources } from "./stash-source";
+import { addStashSource, listStashSources, removeStashSource } from "./stash-source-manage";
 import { setQuiet, warn } from "./warn";
 // Version: prefer compile-time define, then package.json, then fallback
 const pkgVersion = (() => {
@@ -814,23 +814,17 @@ const registryCommand = defineCommand({
         }),
     },
 });
-const sourcesCommand = defineCommand({
-    meta: { name: "sources", description: "Manage stash sources (local paths and remote providers)" },
-    subCommands: {
+/**
+ * Shared subcommand definitions for stash source management.
+ * Used by both `akm stash` (preferred) and `akm sources` (legacy alias).
+ */
+function buildSourceSubCommands(outputPrefix) {
+    return {
         list: defineCommand({
             meta: { name: "list", description: "List all stash sources" },
             run() {
                 return runWithJsonErrors(() => {
-                    const config = loadConfig();
-                    const localSources = resolveStashSources();
-                    const stashes = config.stashes ?? [];
-                    // Legacy fallback: show remoteStashSources if no stashes config
-                    const legacyRemote = !config.stashes ? (config.remoteStashSources ?? []) : [];
-                    output("sources", {
-                        localSources,
-                        stashes,
-                        ...(legacyRemote.length > 0 ? { remoteSources: legacyRemote } : {}),
-                    });
+                    output(`${outputPrefix}`, listStashSources());
                 });
             },
         }),
@@ -844,50 +838,31 @@ const sourcesCommand = defineCommand({
             },
             run({ args }) {
                 return runWithJsonErrors(() => {
-                    const config = loadConfig();
-                    const stashes = [...(config.stashes ?? [])];
-                    const isUrl = args.target.startsWith("http://") || args.target.startsWith("https://");
-                    if (isUrl) {
-                        if (args.target.startsWith("http://")) {
-                            warn("Warning: source URL uses plain HTTP (not HTTPS). For security, prefer https:// to protect against eavesdropping and tampering.");
-                        }
-                        const providerType = args.provider;
-                        if (!providerType) {
-                            throw new UsageError("--provider is required for URL sources (e.g. --provider openviking)");
-                        }
-                        if (stashes.some((s) => s.url === args.target)) {
-                            output("sources-add", { stashes, added: false, message: "Source URL already configured" });
-                            return;
-                        }
-                        const entry = { type: providerType, url: args.target };
-                        if (args.name)
-                            entry.name = args.name;
-                        if (args.options) {
-                            try {
-                                entry.options = JSON.parse(args.options);
-                            }
-                            catch {
-                                throw new UsageError("--options must be valid JSON");
+                    if (args.target.startsWith("http://")) {
+                        warn("Warning: source URL uses plain HTTP (not HTTPS). For security, prefer https:// to protect against eavesdropping and tampering.");
+                    }
+                    let parsedOptions;
+                    if (args.options) {
+                        try {
+                            const parsed = JSON.parse(args.options);
+                            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                                throw new UsageError("--options must be a JSON object");
                             }
+                            parsedOptions = parsed;
                         }
-                        stashes.push(entry);
-                    }
-                    else {
-                        // Filesystem path
-                        const resolvedPath = path.resolve(args.target);
-                        if (stashes.some((s) => s.path === resolvedPath)) {
-                            output("sources-add", { stashes, added: false, message: "Source path already configured" });
-                            return;
+                        catch (err) {
+                            if (err instanceof UsageError)
+                                throw err;
+                            throw new UsageError("--options must be valid JSON");
                         }
-                        const entry = { type: "filesystem", path: resolvedPath };
-                        if (args.name)
-                            entry.name = args.name;
-                        stashes.push(entry);
                     }
-                    // Migrate: remove remoteStashSources when moving to stashes
-                    const { remoteStashSources, ...rest } = config;
-                    saveConfig({ ...rest, stashes });
-                    output("sources-add", { stashes, added: true });
+                    const result = addStashSource({
+                        target: args.target,
+                        name: args.name,
+                        providerType: args.provider,
+                        options: parsedOptions,
+                    });
+                    output(`${outputPrefix}-add`, result);
                 });
             },
         }),
@@ -898,21 +873,20 @@ const sourcesCommand = defineCommand({
             },
             run({ args }) {
                 return runWithJsonErrors(() => {
-                    const config = loadConfig();
-                    const stashes = [...(config.stashes ?? [])];
-                    const resolvedTarget = args.target.startsWith("http") ? args.target : path.resolve(args.target);
-                    const idx = stashes.findIndex((s) => s.url === resolvedTarget || s.path === resolvedTarget || s.name === resolvedTarget);
-                    if (idx === -1) {
-                        output("sources-remove", { stashes, removed: false, message: "No matching source found" });
-                        return;
-                    }
-                    const removed = stashes.splice(idx, 1)[0];
-                    saveConfig({ ...config, stashes });
-                    output("sources-remove", { stashes, removed: true, entry: removed });
+                    const result = removeStashSource(args.target);
+                    output(`${outputPrefix}-remove`, result);
                 });
             },
         }),
-    },
+    };
+}
+const stashCommand = defineCommand({
+    meta: { name: "stash", description: "Manage stash sources (local paths and remote providers)" },
+    subCommands: buildSourceSubCommands("stash"),
+});
+const sourcesCommand = defineCommand({
+    meta: { name: "sources", description: "Manage stash sources (alias for 'akm stash')" },
+    subCommands: buildSourceSubCommands("sources"),
 });
 const hintsCommand = defineCommand({
     meta: {
@@ -949,6 +923,7 @@ const main = defineCommand({
         search: searchCommand,
         show: showCommand,
         clone: cloneCommand,
+        stash: stashCommand,
         sources: sourcesCommand,
         registry: registryCommand,
         config: configCommand,

package/dist/config-cli.js

@@ -25,8 +25,6 @@ export function parseConfigValue(key, value) {
             return { llm: parseLlmConnectionValue(value) };
         case "registries":
             return { registries: parseRegistriesValue(value) };
-        case "remoteStashSources":
-            return { remoteStashSources: parseStashesValue(value) };
         case "stashes":
             return { stashes: parseStashesValue(value) };
         case "output.format":
@@ -51,8 +49,6 @@ export function getConfigValue(config, key) {
             return config.llm ?? null;
         case "registries":
             return config.registries ?? DEFAULT_CONFIG.registries ?? [];
-        case "remoteStashSources":
-            return config.remoteStashSources ?? [];
         case "stashes":
             return config.stashes ?? [];
         case "output.format":
@@ -71,7 +67,6 @@ export function setConfigValue(config, key, rawValue) {
         case "embedding":
         case "llm":
         case "registries":
-        case "remoteStashSources":
         case "stashes":
         case "output.format":
         case "output.detail":
@@ -90,8 +85,6 @@ export function unsetConfigValue(config, key) {
             return { ...config, llm: undefined };
         case "registries":
             return { ...config, registries: undefined };
-        case "remoteStashSources":
-            return { ...config, remoteStashSources: undefined };
         case "stashes":
             return { ...config, stashes: undefined };
         case "output.format":
@@ -115,11 +108,8 @@ export function listConfig(config) {
         result.embedding = config.embedding;
     if (config.llm)
         result.llm = config.llm;
-    // Show legacy keys only if they still have content
     if (config.searchPaths?.length)
         result.searchPaths = config.searchPaths;
-    if (config.remoteStashSources?.length)
-        result.remoteStashSources = config.remoteStashSources;
     return result;
 }
 function mergeConfigValue(config, partial) {

package/dist/config.js

@@ -23,7 +23,7 @@ export function getConfigPath() {
 }
 // ── Load / Save / Update ────────────────────────────────────────────────────
 let cachedConfig;
-export function loadConfig(opts) {
+export function loadConfig() {
     const configPath = getConfigPath();
     let stat;
     try {
@@ -51,94 +51,11 @@ export function loadConfig(opts) {
         if (envKey)
             config.llm.apiKey = envKey;
     }
-    if (!opts?.readOnly) {
-        // Migrate installed[source: "local"] → stashes[type: "filesystem"]
-        try {
-            migrateLocalInstalledToStashes(config);
-        }
-        catch (err) {
-            console.warn("[agentikit] Warning: config migration (local→stashes) failed:", err instanceof Error ? err.message : String(err));
-        }
-        // Migrate remoteStashSources → stashes[]
-        try {
-            migrateRemoteStashSourcesToStashes(config);
-        }
-        catch (err) {
-            console.warn("[agentikit] Warning: config migration (remoteStashSources→stashes) failed:", err instanceof Error ? err.message : String(err));
-        }
-    }
     // Cache the parsed config with its path and mtime for subsequent calls.
     // Reuse the stat already obtained above (avoids a second syscall + TOCTOU gap).
     cachedConfig = { config, path: configPath, mtime: stat.mtimeMs };
     return config;
 }
-/**
- * Migrate installed entries with source "local" to stashes[] as filesystem entries.
- * Local directories are search paths, not registry kits — they don't need version
- * tracking, cache management, or update support.
- *
- * Mutates the config in place and persists to disk if any entries are migrated.
- */
-function migrateLocalInstalledToStashes(config) {
-    const installed = config.installed;
-    if (!installed)
-        return;
-    const localEntries = installed.filter((e) => e.source === "local");
-    if (localEntries.length === 0)
-        return;
-    const stashes = [...(config.stashes ?? [])];
-    const existingPaths = new Set(stashes.filter((s) => !!s.path).map((s) => path.resolve(s.path)));
-    let migrated = 0;
-    for (const entry of localEntries) {
-        const resolved = path.resolve(entry.stashRoot);
-        if (existingPaths.has(resolved))
-            continue;
-        stashes.push({
-            type: "filesystem",
-            path: resolved,
-            name: entry.id,
-        });
-        existingPaths.add(resolved);
-        migrated++;
-    }
-    if (migrated === 0)
-        return;
-    // Remove local entries from installed, add to stashes
-    config.installed = installed.filter((e) => e.source !== "local");
-    config.stashes = stashes;
-    saveConfig(config);
-}
-/**
- * Migrate remoteStashSources[] to stashes[] entries.
- * Each remote source becomes a typed stash entry (e.g. type: "openviking").
- *
- * Mutates the config in place and persists to disk if any entries are migrated.
- */
-function migrateRemoteStashSourcesToStashes(config) {
-    const remoteSources = config.remoteStashSources;
-    if (!remoteSources || remoteSources.length === 0)
-        return;
-    const stashes = [...(config.stashes ?? [])];
-    const existingUrls = new Set(stashes.filter((s) => !!s.url).map((s) => s.url));
-    let migrated = 0;
-    for (const entry of remoteSources) {
-        if (!entry.url || existingUrls.has(entry.url))
-            continue;
-        stashes.push({
-            type: entry.type ?? "openviking",
-            url: entry.url,
-            name: entry.name,
-            options: entry.options,
-        });
-        existingUrls.add(entry.url);
-        migrated++;
-    }
-    if (migrated === 0)
-        return;
-    config.stashes = stashes;
-    config.remoteStashSources = undefined;
-    saveConfig(config);
-}
 export function saveConfig(config) {
     cachedConfig = undefined;
     const configPath = getConfigPath();
@@ -175,11 +92,9 @@ function sanitizeConfigForWrite(config) {
         const { apiKey, ...rest } = config.llm;
         sanitized.llm = rest;
     }
-    // Drop empty/migrated keys to keep config clean
+    // Drop empty keys to keep config clean
     if (!config.searchPaths?.length)
         delete sanitized.searchPaths;
-    if (!config.remoteStashSources?.length)
-        delete sanitized.remoteStashSources;
     return sanitized;
 }
 export function updateConfig(partial) {
@@ -225,9 +140,6 @@ function pickKnownKeys(raw) {
     const registries = parseRegistriesConfig(raw.registries);
     if (registries)
         config.registries = registries;
-    const remoteStash = parseStashesConfig(raw.remoteStashSources);
-    if (remoteStash)
-        config.remoteStashSources = remoteStash;
     const stashes = parseStashesConfig(raw.stashes);
     if (stashes)
         config.stashes = stashes;

package/dist/stash-provider-factory.js

@@ -19,33 +19,18 @@ export function resolveStashProviderFactory(type) {
 }
 /**
  * Resolve all non-filesystem stash providers from config.
- * Sources come from `stashes` (new) or `remoteStashSources` (legacy).
  * Filesystem entries are excluded — they are handled by resolveStashSources().
  */
 export function resolveStashProviders(config) {
     const providers = [];
-    // New config: stashes[]
-    if (config.stashes) {
-        for (const entry of config.stashes) {
-            if (entry.enabled === false)
-                continue;
-            if (entry.type === "filesystem")
-                continue;
-            const factory = registry.resolve(entry.type);
-            if (factory) {
-                providers.push(factory(entry));
-            }
-        }
-    }
-    // Legacy config: remoteStashSources[] → map to stash providers
-    if (!config.stashes && config.remoteStashSources) {
-        for (const entry of config.remoteStashSources) {
-            if (entry.enabled === false)
-                continue;
-            const factory = registry.resolve(entry.type ?? "openviking");
-            if (factory) {
-                providers.push(factory(entry));
-            }
+    for (const entry of config.stashes ?? []) {
+        if (entry.enabled === false)
+            continue;
+        if (entry.type === "filesystem")
+            continue;
+        const factory = registry.resolve(entry.type);
+        if (factory) {
+            providers.push(factory(entry));
         }
     }
     return providers;

package/dist/stash-source-manage.js

@@ -0,0 +1,82 @@
+import path from "node:path";
+import { loadConfig, saveConfig } from "./config";
+import { UsageError } from "./errors";
+import { resolveStashSources } from "./stash-source";
+// ── Operations ──────────────────────────────────────────────────────────────
+/**
+ * Add a stash source (filesystem path or remote provider URL) to config.
+ *
+ * Filesystem paths are auto-detected when `target` does not start with
+ * `http://` or `https://`. URL sources require a `providerType` option
+ * (e.g. "openviking").
+ */
+export function addStashSource(opts) {
+    const { target, name, providerType, options: providerOptions } = opts;
+    const config = loadConfig();
+    const stashes = [...(config.stashes ?? [])];
+    const isUrl = target.startsWith("http://") || target.startsWith("https://");
+    let entry;
+    if (isUrl) {
+        if (!providerType) {
+            throw new UsageError("--provider is required for URL sources (e.g. --provider openviking)");
+        }
+        // Deduplicate by URL
+        if (stashes.some((s) => s.url === target)) {
+            return { stashes, added: false, message: "Source URL already configured" };
+        }
+        entry = { type: providerType, url: target };
+        if (name)
+            entry.name = name;
+        if (providerOptions)
+            entry.options = providerOptions;
+    }
+    else {
+        // Filesystem path
+        const resolvedPath = path.resolve(target);
+        if (stashes.some((s) => s.path && path.resolve(s.path) === resolvedPath)) {
+            return { stashes, added: false, message: "Source path already configured" };
+        }
+        entry = { type: "filesystem", path: resolvedPath };
+        if (name)
+            entry.name = name;
+    }
+    stashes.push(entry);
+    saveConfig({ ...config, stashes });
+    return { stashes, added: true, entry };
+}
+/**
+ * Remove a stash source by URL, path, or name.
+ * Match priority: URL > path > name (most specific first).
+ */
+export function removeStashSource(target) {
+    const config = loadConfig();
+    const stashes = [...(config.stashes ?? [])];
+    const isUrl = target.startsWith("http://") || target.startsWith("https://");
+    const resolvedPath = !isUrl ? path.resolve(target) : undefined;
+    // Try URL match first, then path, then name (most specific → least specific)
+    let idx = -1;
+    if (isUrl) {
+        idx = stashes.findIndex((s) => s.url === target);
+    }
+    if (idx === -1 && resolvedPath) {
+        idx = stashes.findIndex((s) => s.path && path.resolve(s.path) === resolvedPath);
+    }
+    if (idx === -1) {
+        idx = stashes.findIndex((s) => s.name === target);
+    }
+    if (idx === -1) {
+        return { stashes, removed: false, message: "No matching source found" };
+    }
+    const removed = stashes.splice(idx, 1)[0];
+    saveConfig({ ...config, stashes });
+    return { stashes, removed: true, entry: removed };
+}
+/**
+ * List all stash sources (local filesystem + configured stashes).
+ */
+export function listStashSources() {
+    const config = loadConfig();
+    const localSources = resolveStashSources();
+    const stashes = config.stashes ?? [];
+    return { localSources, stashes };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "type": "module",
   "description": "CLI tool to search, open, and run extension assets from an akm stash directory.",
   "keywords": [