akm-cli 0.0.23 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # Agent Kit Manager
 
-> Agent-i-Kit
+> **akm** — Agent Kit Manager
 
 [![npm version](https://img.shields.io/npm/v/akm-cli)](https://www.npmjs.com/package/akm-cli)
 [![CI](https://github.com/itlackey/agentikit/actions/workflows/ci.yml/badge.svg)](https://github.com/itlackey/agentikit/actions/workflows/ci.yml)
@@ -25,7 +25,7 @@ Upgrade in place with `akm upgrade`.
 ## Quick Start
 
 ```sh
-akm init                          # Initialize your stash
+akm init                          # Initialize your working stash
 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
@@ -89,7 +89,7 @@ Registries are indexes of available kits. The official
 ```sh
 akm registry search "code review"                                        # Search registries
 akm registry add https://example.com/registry/index.json --name team     # Add a registry
-akm sources add http://host:1933 --provider openviking \
+akm stash add http://host:1933 --provider openviking \
   --options '{"apiKey":"key"}'                                            # Add an OpenViking stash source
 akm registry list                                                        # List configured registries
 akm show viking://resources/my-doc                                       # Fetch remote content from OpenViking
@@ -130,7 +130,7 @@ See the [Kit Maker's Guide](docs/kit-makers.md) for a full walkthrough.
 | [Getting Started](docs/getting-started.md) | Quick setup guide |
 | [CLI Reference](docs/cli.md) | All commands and flags |
 | [Configuration](docs/configuration.md) | Settings, providers, and Ollama setup |
-| [Concepts](docs/concepts.md) | Asset types, classification, stash model |
+| [Concepts](docs/concepts.md) | Stashes, kits, registries, asset types |
 | [Kit Maker's Guide](docs/kit-makers.md) | Build and share kits |
 | [Registry](docs/registry.md) | Registries, search, and the v2 index format |
 

package/dist/asset-spec.js

@@ -79,7 +79,7 @@ export function _setAssetTypeHooks(rendererHook, actionBuilderHook) {
     _registerActionBuilder = actionBuilderHook;
 }
 /**
- * Register a custom asset type with the Agentikit asset system.
+ * Register a custom asset type with the akm asset system.
  *
  * ## Full extension registration API
  *

package/dist/cli.js

@@ -3,21 +3,22 @@ import fs from "node:fs";
 import path from "node:path";
 import { defineCommand, runMain } from "citty";
 import { resolveStashDir } from "./common";
+import { generateBashCompletions, installBashCompletions } from "./completions";
 import { DEFAULT_CONFIG, getConfigPath, loadConfig, saveConfig } from "./config";
 import { getConfigValue, listConfig, setConfigValue, unsetConfigValue } from "./config-cli";
 import { ConfigError, NotFoundError, UsageError } from "./errors";
-import { agentikitIndex } from "./indexer";
-import { agentikitInit } from "./init";
-import { agentikitList, agentikitRemove, agentikitUpdate } from "./installed-kits";
+import { akmIndex } from "./indexer";
+import { akmInit } from "./init";
+import { akmList, akmRemove, akmUpdate } from "./installed-kits";
 import { getCacheDir, getDbPath, getDefaultStashDir } from "./paths";
 import { buildRegistryIndex, writeRegistryIndex } from "./registry-build-index";
 import { searchRegistry } from "./registry-search";
 import { checkForUpdate, performUpgrade } from "./self-update";
-import { agentikitAdd } from "./stash-add";
-import { agentikitClone } from "./stash-clone";
-import { agentikitSearch, parseSearchSource } from "./stash-search";
-import { agentikitShowUnified } from "./stash-show";
-import { addStashSource, listStashSources, removeStashSource } from "./stash-source-manage";
+import { akmAdd, akmKitAdd } from "./stash-add";
+import { akmClone } from "./stash-clone";
+import { akmSearch, parseSearchSource } from "./stash-search";
+import { akmShowUnified } from "./stash-show";
+import { addStash, listStashes, removeStash } from "./stash-source-manage";
 import { setQuiet, warn } from "./warn";
 // Version: prefer compile-time define, then package.json, then fallback
 const pkgVersion = (() => {
@@ -405,14 +406,14 @@ function formatSearchPlain(r, detail) {
 const initCommand = defineCommand({
     meta: {
         name: "init",
-        description: "Initialize Agent-i-Kit's working stash directory and persist stashDir in config",
+        description: "Initialize akm's working stash directory and persist stashDir in config",
     },
     args: {
         dir: { type: "string", description: "Custom stash directory path (default: ~/akm)" },
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
-            const result = await agentikitInit({ dir: args.dir });
+            const result = await akmInit({ dir: args.dir });
             output("init", result);
         });
     },
@@ -424,7 +425,7 @@ const indexCommand = defineCommand({
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
-            const result = await agentikitIndex({ full: args.full });
+            const result = await akmIndex({ full: args.full });
             output("index", result);
         });
     },
@@ -451,7 +452,7 @@ const searchCommand = defineCommand({
             }
             const limit = limitRaw;
             const source = parseSearchSource(args.source);
-            const result = await agentikitSearch({ query: args.query, type, limit, source });
+            const result = await akmSearch({ query: args.query, type, limit, source });
             output("search", result);
         });
     },
@@ -467,7 +468,7 @@ const addCommand = defineCommand({
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
-            const result = await agentikitAdd({ ref: args.ref });
+            const result = await akmAdd({ ref: args.ref });
             output("add", result);
         });
     },
@@ -476,7 +477,7 @@ const listCommand = defineCommand({
     meta: { name: "list", description: "List installed kits" },
     async run() {
         await runWithJsonErrors(async () => {
-            const result = await agentikitList();
+            const result = await akmList();
             output("list", result);
         });
     },
@@ -488,7 +489,7 @@ const removeCommand = defineCommand({
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
-            const result = await agentikitRemove({ target: args.target });
+            const result = await akmRemove({ target: args.target });
             output("remove", result);
         });
     },
@@ -502,11 +503,36 @@ const updateCommand = defineCommand({
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
-            const result = await agentikitUpdate({ target: args.target, all: args.all, force: args.force });
+            const result = await akmUpdate({ target: args.target, all: args.all, force: args.force });
             output("update", result);
         });
     },
 });
+const kitAddCommand = defineCommand({
+    meta: { name: "add", description: "Install a kit from npm, GitHub, or any git host" },
+    args: {
+        ref: {
+            type: "positional",
+            description: "Registry ref (npm package, owner/repo, or git URL)",
+            required: true,
+        },
+    },
+    async run({ args }) {
+        await runWithJsonErrors(async () => {
+            const result = await akmKitAdd({ ref: args.ref });
+            output("add", result);
+        });
+    },
+});
+const kitCommand = defineCommand({
+    meta: { name: "kit", description: "Manage installed kits" },
+    subCommands: {
+        add: kitAddCommand,
+        list: listCommand,
+        remove: removeCommand,
+        update: updateCommand,
+    },
+});
 const upgradeCommand = defineCommand({
     meta: { name: "upgrade", description: "Upgrade akm to the latest release" },
     args: {
@@ -568,7 +594,7 @@ const showCommand = defineCommand({
                         throw new UsageError(`Unknown view mode: ${args.akmView}. Expected one of: full|toc|frontmatter|section|lines`);
                 }
             }
-            const result = await agentikitShowUnified({ ref: args.ref, view });
+            const result = await akmShowUnified({ ref: args.ref, view });
             output("show", result);
         });
     },
@@ -672,7 +698,7 @@ const configCommand = defineCommand({
 const cloneCommand = defineCommand({
     meta: {
         name: "clone",
-        description: "Clone an asset from any stash source into the working stash or a custom destination",
+        description: "Clone an asset from any source into the working stash or a custom destination",
     },
     args: {
         ref: { type: "positional", description: "Asset ref (e.g. npm:@scope/pkg//script:deploy.sh)", required: true },
@@ -682,7 +708,7 @@ const cloneCommand = defineCommand({
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
-            const result = await agentikitClone({
+            const result = await akmClone({
                 sourceRef: args.ref,
                 newName: args.name,
                 force: args.force,
@@ -815,21 +841,20 @@ const registryCommand = defineCommand({
     },
 });
 /**
- * Shared subcommand definitions for stash source management.
- * Used by both `akm stash` (preferred) and `akm sources` (legacy alias).
+ * Subcommand definitions for managing additional stashes.
  */
 function buildSourceSubCommands(outputPrefix) {
     return {
         list: defineCommand({
-            meta: { name: "list", description: "List all stash sources" },
+            meta: { name: "list", description: "List all stashes in search order" },
             run() {
                 return runWithJsonErrors(() => {
-                    output(`${outputPrefix}`, listStashSources());
+                    output(`${outputPrefix}`, listStashes());
                 });
             },
         }),
         add: defineCommand({
-            meta: { name: "add", description: "Add a stash source (filesystem path or remote URL)" },
+            meta: { name: "add", description: "Register an additional stash (filesystem path or remote URL)" },
             args: {
                 target: { type: "positional", description: "Path or URL to add", required: true },
                 name: { type: "string", description: "Human-friendly name for the source" },
@@ -856,7 +881,7 @@ function buildSourceSubCommands(outputPrefix) {
                             throw new UsageError("--options must be valid JSON");
                         }
                     }
-                    const result = addStashSource({
+                    const result = addStash({
                         target: args.target,
                         name: args.name,
                         providerType: args.provider,
@@ -867,13 +892,13 @@ function buildSourceSubCommands(outputPrefix) {
             },
         }),
         remove: defineCommand({
-            meta: { name: "remove", description: "Remove a stash source by URL, path, or name" },
+            meta: { name: "remove", description: "Remove an additional stash by URL, path, or name" },
             args: {
                 target: { type: "positional", description: "Source URL, path, or name to remove", required: true },
             },
             run({ args }) {
                 return runWithJsonErrors(() => {
-                    const result = removeStashSource(args.target);
+                    const result = removeStash(args.target);
                     output(`${outputPrefix}-remove`, result);
                 });
             },
@@ -881,13 +906,9 @@ function buildSourceSubCommands(outputPrefix) {
     };
 }
 const stashCommand = defineCommand({
-    meta: { name: "stash", description: "Manage stash sources (local paths and remote providers)" },
+    meta: { name: "stash", description: "Manage additional stashes (local directories 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: {
         name: "hints",
@@ -901,11 +922,43 @@ const hintsCommand = defineCommand({
         process.stdout.write(loadHints(detail));
     },
 });
+const completionsCommand = defineCommand({
+    meta: {
+        name: "completions",
+        description: "Generate or install shell completion script",
+    },
+    args: {
+        install: {
+            type: "boolean",
+            description: "Install completions to the appropriate directory",
+            default: false,
+        },
+        shell: {
+            type: "string",
+            description: "Shell type (bash)",
+            default: "bash",
+        },
+    },
+    run({ args }) {
+        if (args.shell !== "bash") {
+            throw new UsageError(`Unsupported shell: ${args.shell}. Only bash is supported.`);
+        }
+        const script = generateBashCompletions(main);
+        if (args.install) {
+            const dest = installBashCompletions(script);
+            console.error(`Completions installed to ${dest}`);
+            console.error(`Restart your shell or run:  source ${dest}`);
+        }
+        else {
+            process.stdout.write(script);
+        }
+    },
+});
 const main = defineCommand({
     meta: {
         name: "akm",
         version: pkgVersion,
-        description: "CLI tool to search, open, and manage assets from Agent-i-Kit stash.",
+        description: "Agent Kit Manager — search, show, and manage assets from your stash.",
     },
     args: {
         format: { type: "string", description: "Output format (json|text|yaml)" },
@@ -919,15 +972,16 @@ const main = defineCommand({
         list: listCommand,
         remove: removeCommand,
         update: updateCommand,
+        kit: kitCommand,
         upgrade: upgradeCommand,
         search: searchCommand,
         show: showCommand,
         clone: cloneCommand,
         stash: stashCommand,
-        sources: sourcesCommand,
         registry: registryCommand,
         config: configCommand,
         hints: hintsCommand,
+        completions: completionsCommand,
     },
 });
 const CONFIG_SUBCOMMAND_SET = new Set(["path", "list", "get", "set", "unset"]);
@@ -1079,14 +1133,14 @@ function loadHints(detail = "normal") {
 }
 const EMBEDDED_HINTS = `# akm CLI
 
-You have access to a searchable library of scripts, skills, commands, agents, and knowledge documents via \`akm\`. Search the stash first before writing something from scratch.
+You have access to a searchable library of scripts, skills, commands, agents, and knowledge documents via \`akm\`. Search your stashes first before writing something from scratch.
 
 ## Quick Reference
 
 \`\`\`sh
-akm search "<query>"                          # Search for assets
+akm search "<query>"                          # Search your stashes and installed kits
 akm search "<query>" --type skill             # Filter by type
-akm search "<query>" --source both            # Search stash providers and registries for assets
+akm search "<query>" --source both            # Also search registries for installable kits
 akm show <ref>                                # View asset details
 akm add <ref>                                 # Install a kit (npm, GitHub, git, local)
 akm clone <ref>                               # Copy an asset to the working stash (optional --dest arg to clone to specific location)
@@ -1107,14 +1161,14 @@ Run \`akm -h\` for the full command reference.
 `;
 const EMBEDDED_HINTS_FULL = `# akm CLI — Full Reference
 
-You have access to a searchable library of scripts, skills, commands, agents, and knowledge documents via \`akm\`. Search the stash first before writing something from scratch.
+You have access to a searchable library of scripts, skills, commands, agents, and knowledge documents via \`akm\`. Search your stashes first before writing something from scratch.
 
 ## Search
 
 \`\`\`sh
-akm search "<query>"                          # Search local stash
+akm search "<query>"                          # Search your stashes and installed kits
 akm search "<query>" --type skill             # Filter by asset type
-akm search "<query>" --source both            # Search all stash providers and registries
+akm search "<query>" --source both            # Also search registries for installable kits
 akm search "<query>" --source registry        # Search registries only
 akm search "<query>" --limit 10               # Limit results
 akm search "<query>" --detail full            # Include scores, paths, timing
@@ -1155,10 +1209,14 @@ akm show viking://resources/my-doc           # Show remote OpenViking content
 ## Install & Manage Kits
 
 \`\`\`sh
-akm add <ref>                                 # Install a kit
+akm add <ref>                                 # Install a kit (smart router: local dirs become stash adds)
 akm add @scope/kit                            # From npm
 akm add owner/repo                            # From GitHub
-akm add ./path/to/local/kit                   # From local directory
+akm add ./path/to/local/kit                   # From local directory (adds as stash)
+akm kit add <ref>                             # Install a kit (explicit)
+akm kit list                                  # List installed kits
+akm kit remove <target>                       # Remove a kit
+akm kit update --all                          # Update all kits
 akm list                                      # List installed kits
 akm remove <target>                           # Remove by id or ref
 akm update --all                              # Update all installed kits
@@ -1206,13 +1264,16 @@ akm config path --all                         # Show all config paths
 ## Other Commands
 
 \`\`\`sh
-akm init                                      # Initialize stash directory
+akm init                                      # Initialize working stash
 akm index                                     # Rebuild search index
 akm index --full                              # Full reindex
-akm sources                                   # List stash search paths
+akm stash                                     # List all stashes
+akm kit                                       # Kit management (add, list, remove, update)
 akm upgrade                                   # Upgrade akm binary
 akm upgrade --check                           # Check for updates
 akm hints                                     # Print this reference
+akm completions                               # Print bash completion script
+akm completions --install                     # Install completions
 \`\`\`
 
 ## Output Control

package/dist/completions.js

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+// ── Known flag values ────────────────────────────────────────────────────────
+const FLAG_VALUES = {
+    "--format": ["json", "text", "yaml"],
+    "--detail": ["brief", "normal", "full"],
+    "--type": ["skill", "command", "agent", "knowledge", "script", "memory", "any"],
+    "--source": ["stash", "registry", "both"],
+    "--shell": ["bash"],
+};
+function walkCommandTree(cmd, parentPath = "") {
+    const name = cmd.meta?.name ?? "";
+    const currentPath = parentPath ? `${parentPath} ${name}` : name;
+    const result = [];
+    const subcommands = Object.keys(cmd.subCommands ?? {});
+    const flags = [];
+    if (cmd.args) {
+        for (const [flagName, arg] of Object.entries(cmd.args)) {
+            if (arg.type === "positional")
+                continue;
+            flags.push(`--${flagName}`);
+        }
+    }
+    result.push({ path: currentPath, subcommands, flags });
+    if (cmd.subCommands) {
+        for (const sub of Object.values(cmd.subCommands)) {
+            result.push(...walkCommandTree(sub, currentPath));
+        }
+    }
+    return result;
+}
+// ── Bash completion script generator ─────────────────────────────────────────
+export function generateBashCompletions(cmd) {
+    const commands = walkCommandTree(cmd);
+    const rootName = cmd.meta?.name ?? "akm";
+    // Collect global flags from root command
+    const rootInfo = commands.find((c) => c.path === rootName);
+    const globalFlags = rootInfo?.flags ?? [];
+    // Build the case blocks for subcommand completion
+    const caseBlocks = [];
+    for (const info of commands) {
+        const allFlags = [...new Set([...info.flags, ...globalFlags])];
+        if (info.subcommands.length > 0 || allFlags.length > 0) {
+            const matchPath = info.path;
+            const subcmdStr = info.subcommands.join(" ");
+            const flagStr = allFlags.join(" ");
+            caseBlocks.push(`      "${matchPath}")
+        if [[ "\${cur}" == -* ]]; then
+          COMPREPLY=( $(compgen -W "${flagStr}" -- "\${cur}") )
+        else
+          COMPREPLY=( $(compgen -W "${subcmdStr}" -- "\${cur}") )
+        fi
+        return 0
+        ;;`);
+        }
+    }
+    // Build flag-value completion cases
+    const valueCases = [];
+    for (const [flag, values] of Object.entries(FLAG_VALUES)) {
+        valueCases.push(`    ${flag})
+      COMPREPLY=( $(compgen -W "${values.join(" ")}" -- "\${cur}") )
+      return 0
+      ;;`);
+    }
+    const script = `#!/bin/bash
+# Bash completion for ${rootName}
+# Generated by ${rootName} completions
+
+_${rootName}() {
+  local cur prev words cword
+  if type _init_completion &>/dev/null; then
+    _init_completion || return
+  else
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    words=("\${COMP_WORDS[@]}")
+    cword=\${COMP_CWORD}
+  fi
+
+  # Complete flag values
+  case "\${prev}" in
+${valueCases.join("\n")}
+  esac
+
+  # Build the command path from COMP_WORDS
+  local cmd_path="${rootName}"
+  for (( i=1; i < cword; i++ )); do
+    case "\${words[i]}" in
+      -*) continue ;;
+      *) cmd_path="\${cmd_path} \${words[i]}" ;;
+    esac
+  done
+
+  # Complete based on current command path
+  case "\${cmd_path}" in
+${caseBlocks.join("\n")}
+  esac
+
+  return 0
+}
+
+complete -F _${rootName} ${rootName}
+`;
+    return script;
+}
+// ── Install ──────────────────────────────────────────────────────────────────
+export function installBashCompletions(script) {
+    const dest = resolveInstallPath();
+    const dir = path.dirname(dest);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(dest, script, "utf8");
+    return dest;
+}
+function resolveInstallPath() {
+    const xdgData = process.env.XDG_DATA_HOME?.trim();
+    if (xdgData) {
+        return path.join(xdgData, "bash-completion", "completions", "akm");
+    }
+    const home = os.homedir();
+    // Default XDG location
+    const defaultXdg = path.join(home, ".local", "share", "bash-completion", "completions", "akm");
+    const defaultXdgDir = path.dirname(defaultXdg);
+    if (isDir(defaultXdgDir) || isDir(path.dirname(defaultXdgDir))) {
+        return defaultXdg;
+    }
+    // Fallback
+    return path.join(home, ".bash_completion.d", "akm");
+}
+function isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/config-cli.js

@@ -9,16 +9,6 @@ export function parseConfigValue(key, value) {
                 throw new UsageError(`Invalid value for semanticSearch: expected "true" or "false"`);
             }
             return { semanticSearch: value === "true" };
-        case "searchPaths":
-            try {
-                const parsed = JSON.parse(value);
-                if (!Array.isArray(parsed))
-                    throw new UsageError("expected JSON array");
-                return { searchPaths: parsed.filter((d) => typeof d === "string") };
-            }
-            catch {
-                throw new UsageError(`Invalid value for searchPaths: expected JSON array (e.g. '["/path/a","/path/b"]')`);
-            }
         case "embedding":
             return { embedding: parseEmbeddingConnectionValue(value) };
         case "llm":
@@ -41,8 +31,6 @@ export function getConfigValue(config, key) {
             return config.stashDir ?? null;
         case "semanticSearch":
             return config.semanticSearch;
-        case "searchPaths":
-            return [...config.searchPaths];
         case "embedding":
             return config.embedding ?? null;
         case "llm":
@@ -63,7 +51,6 @@ export function setConfigValue(config, key, rawValue) {
     switch (key) {
         case "stashDir":
         case "semanticSearch":
-        case "searchPaths":
         case "embedding":
         case "llm":
         case "registries":
@@ -108,8 +95,6 @@ export function listConfig(config) {
         result.embedding = config.embedding;
     if (config.llm)
         result.llm = config.llm;
-    if (config.searchPaths?.length)
-        result.searchPaths = config.searchPaths;
     return result;
 }
 function mergeConfigValue(config, partial) {

package/dist/config.js

@@ -4,7 +4,6 @@ import { getConfigDir as _getConfigDir, getConfigPath as _getConfigPath } from "
 // ── Defaults ────────────────────────────────────────────────────────────────
 export const DEFAULT_CONFIG = {
     semanticSearch: true,
-    searchPaths: [],
     registries: [
         { url: "https://raw.githubusercontent.com/itlackey/akm-registry/main/index.json", name: "official" },
         { url: "https://skills.sh", name: "skills.sh", provider: "skills-sh" },
@@ -93,8 +92,6 @@ function sanitizeConfigForWrite(config) {
         sanitized.llm = rest;
     }
     // Drop empty keys to keep config clean
-    if (!config.searchPaths?.length)
-        delete sanitized.searchPaths;
     return sanitized;
 }
 export function updateConfig(partial) {
@@ -125,8 +122,18 @@ function pickKnownKeys(raw) {
     if (typeof raw.semanticSearch === "boolean") {
         config.semanticSearch = raw.semanticSearch;
     }
+    // Migrate legacy searchPaths into stashes
     if (Array.isArray(raw.searchPaths)) {
-        config.searchPaths = raw.searchPaths.filter((d) => typeof d === "string");
+        const legacyPaths = raw.searchPaths.filter((d) => typeof d === "string");
+        if (legacyPaths.length > 0) {
+            const existing = config.stashes ?? [];
+            const migrated = legacyPaths
+                .filter((p) => !existing.some((s) => s.type === "filesystem" && s.path === p))
+                .map((p) => ({ type: "filesystem", path: p }));
+            if (migrated.length > 0) {
+                config.stashes = [...existing, ...migrated];
+            }
+        }
     }
     const embedding = parseEmbeddingConfig(raw.embedding);
     if (embedding)
@@ -270,7 +277,7 @@ function parseEmbeddingConfig(value) {
     if (typeof obj.endpoint !== "string" || !obj.endpoint)
         return undefined;
     if (!obj.endpoint.startsWith("http://") && !obj.endpoint.startsWith("https://")) {
-        console.warn(`[agentikit] Ignoring embedding config: endpoint must start with http:// or https://, got "${obj.endpoint}"`);
+        console.warn(`[akm] Ignoring embedding config: endpoint must start with http:// or https://, got "${obj.endpoint}"`);
         return undefined;
     }
     if (typeof obj.model !== "string" || !obj.model)
@@ -303,7 +310,7 @@ function parseLlmConfig(value) {
     if (typeof obj.endpoint !== "string" || !obj.endpoint)
         return undefined;
     if (!obj.endpoint.startsWith("http://") && !obj.endpoint.startsWith("https://")) {
-        console.warn(`[agentikit] Ignoring llm config: endpoint must start with http:// or https://, got "${obj.endpoint}"`);
+        console.warn(`[akm] Ignoring llm config: endpoint must start with http:// or https://, got "${obj.endpoint}"`);
         return undefined;
     }
     if (typeof obj.model !== "string" || !obj.model)

package/dist/github.js

@@ -1,12 +1,31 @@
 export const GITHUB_API_BASE = "https://api.github.com";
-export function githubHeaders() {
+const GITHUB_TOKEN_DOMAINS = new Set(["api.github.com", "github.com", "uploads.github.com"]);
+/**
+ * Build headers for GitHub API requests.
+ * When a `url` is provided, the Authorization header is only included if the
+ * URL points to a known GitHub domain, preventing token leakage on redirects
+ * to third-party hosts.
+ */
+export function githubHeaders(url) {
     const token = process.env.GITHUB_TOKEN?.trim();
     const headers = {
         Accept: "application/vnd.github+json",
         "User-Agent": "akm-registry",
     };
-    if (token)
-        headers.Authorization = `Bearer ${token}`;
+    if (token) {
+        let includeToken = true;
+        if (url) {
+            try {
+                const hostname = new URL(url).hostname;
+                includeToken = GITHUB_TOKEN_DOMAINS.has(hostname);
+            }
+            catch {
+                includeToken = false;
+            }
+        }
+        if (includeToken)
+            headers.Authorization = `Bearer ${token}`;
+    }
     return headers;
 }
 export function asRecord(value) {