ai-builder 0.1.2 → 0.1.4

package/README.md

@@ -22,6 +22,8 @@
 - **Install stacks** - Bundle multiple artifacts together for specific workflows
 - **Search the registry** - Find artifacts by name, description, or task category
 - **Manage installed artifacts** - List and remove artifacts from your project
+- **Self-update** - Keep the CLI up to date with a single command
+- **Shell completions** - Tab completion for bash and zsh
 
 ---
 
@@ -156,6 +158,58 @@ npx ai-builder search "nextjs" --task frontend
 npx ai-builder search "database" --limit 5
 ```
 
+### Status
+
+Show CLI status and installed artifacts:
+
+```bash
+npx ai-builder status
+```
+
+**Output includes:**
+- CLI version
+- Claude directory detection
+- Installed artifact counts by type
+- Registry connectivity check
+
+### Update
+
+Update the CLI to the latest version:
+
+```bash
+npx ai-builder update
+```
+
+**Options:**
+
+```bash
+# Check for updates without installing
+npx ai-builder update --check
+```
+
+### Completion
+
+Generate shell completions for bash or zsh:
+
+```bash
+# Output completion script
+npx ai-builder completion bash
+npx ai-builder completion zsh
+
+# Auto-install for current shell
+npx ai-builder completion --setup
+```
+
+**Manual installation:**
+
+```bash
+# Bash
+ai-builder completion bash >> ~/.bashrc
+
+# Zsh
+ai-builder completion zsh >> ~/.zshrc
+```
+
 ---
 
 ## Artifact Types

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk5 from "chalk";
+import chalk8 from "chalk";
 import { Command } from "commander";
 
 // src/commands/add.ts
@@ -10,19 +10,34 @@ import chalk from "chalk";
 import ora from "ora";
 
 // src/services/api.ts
-import { createCliLogger } from "@aibuilder/logger/adapters/cli";
 var API_BASE = process.env.AI_BUILDER_API_URL || "https://aibuilder.sh/api";
-var logger = createCliLogger({ base: { module: "cli:api" } });
+var isDebug = process.env.DEBUG?.includes("ai-builder");
+var logger = {
+  debug: (ctx, msg) => {
+    if (isDebug) console.error(`[debug] ${msg}`, ctx);
+  },
+  startTimer: (name) => {
+    const start = Date.now();
+    return {
+      done: (ctx) => {
+        if (isDebug) {
+          const durationMs = Date.now() - start;
+          console.error(`[debug] ${name}`, { ...ctx, durationMs });
+        }
+      }
+    };
+  }
+};
 async function resolveArtifact(type, slug) {
   const url = `${API_BASE}/resolve?type=${encodeURIComponent(type)}&slug=${encodeURIComponent(slug)}`;
-  logger.debug({ type, slug, url }, "Resolving artifact");
+  const timer = logger.startTimer("api-resolve");
   const response = await fetch(url);
   if (!response.ok) {
     const errorBody = await response.json().catch(() => ({ error: "Unknown error" }));
-    logger.error({ type, slug, status: response.status }, "Failed to resolve artifact");
+    timer.done({ type, slug, status: response.status, success: false });
     throw new Error(errorBody.error || `Failed to resolve artifact: ${response.status}`);
   }
-  logger.debug({ type, slug }, "Artifact resolved successfully");
+  timer.done({ type, slug, status: response.status, success: true });
   return response.json();
 }
 async function searchArtifacts(options) {
@@ -35,39 +50,44 @@ async function searchArtifacts(options) {
   if (options.task) params.set("task", options.task);
   if (options.limit) params.set("limit", options.limit.toString());
   const url = `${API_BASE}/artifacts?${params.toString()}`;
-  logger.debug({ options, url }, "Searching artifacts");
+  const timer = logger.startTimer("api-search");
   const response = await fetch(url);
   if (!response.ok) {
-    logger.error({ status: response.status, options }, "Search failed");
+    timer.done({ query: options.query, status: response.status, success: false });
     throw new Error(`Failed to search artifacts: ${response.status}`);
   }
   const result = await response.json();
-  logger.debug({ resultCount: result.artifacts.length, total: result.total }, "Search completed");
+  timer.done({
+    query: options.query,
+    resultCount: result.artifacts.length,
+    total: result.total,
+    success: true
+  });
   return result;
 }
 async function trackInstall(type, slug, cliVersion) {
   try {
-    await fetch(`${API_BASE}/install-events`, {
+    const response = await fetch(`${API_BASE}/install-events`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ type, slug, cliVersion })
     });
-    logger.debug({ type, slug, cliVersion }, "Install tracked");
+    logger.debug({ type, slug, cliVersion, status: response.status }, "Install tracked");
   } catch (error) {
     logger.debug({ err: error, type, slug }, "Install tracking failed (non-critical)");
   }
 }
 async function resolveStack(slug) {
   const url = `${API_BASE}/stacks/${encodeURIComponent(slug)}`;
-  logger.debug({ slug, url }, "Resolving stack");
+  const timer = logger.startTimer("api-resolve-stack");
   const response = await fetch(url);
   if (!response.ok) {
     const errorBody = await response.json().catch(() => ({ error: "Unknown error" }));
-    logger.error({ slug, status: response.status }, "Failed to resolve stack");
+    timer.done({ slug, status: response.status, success: false });
     throw new Error(errorBody.error || `Failed to resolve stack: ${response.status}`);
   }
   const result = await response.json();
-  logger.debug({ slug, artifactCount: result.artifactCount }, "Stack resolved successfully");
+  timer.done({ slug, artifactCount: result.artifactCount, status: response.status, success: true });
   return result;
 }
 
@@ -338,12 +358,218 @@ async function confirm(question) {
   });
 }
 
-// src/commands/list.ts
+// src/commands/completion.ts
+import * as fs3 from "fs";
+import * as os from "os";
+import * as path3 from "path";
 import chalk2 from "chalk";
+var BASH_COMPLETION = `
+# ai-builder bash completion
+_ai_builder_completions() {
+    local cur prev words cword
+    _get_comp_words_by_ref -n : cur prev words cword
+
+    local commands="add remove rm list ls search status update completion"
+    local types="skill agent command stack"
+
+    case "\${prev}" in
+        ai-builder)
+            COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+            return 0
+            ;;
+        add|remove|rm)
+            COMPREPLY=( $(compgen -W "\${types}" -- "\${cur}") )
+            return 0
+            ;;
+        -t|--type)
+            COMPREPLY=( $(compgen -W "skill agent command" -- "\${cur}") )
+            return 0
+            ;;
+        completion)
+            COMPREPLY=( $(compgen -W "bash zsh --setup" -- "\${cur}") )
+            return 0
+            ;;
+    esac
+
+    if [[ "\${cur}" == -* ]]; then
+        local opts="--help --version"
+        case "\${words[1]}" in
+            add)
+                opts="--force --yes --help"
+                ;;
+            remove|rm)
+                opts="--yes --help"
+                ;;
+            list|ls)
+                opts="--type --help"
+                ;;
+            search)
+                opts="--type --task --limit --help"
+                ;;
+            update)
+                opts="--check --help"
+                ;;
+        esac
+        COMPREPLY=( $(compgen -W "\${opts}" -- "\${cur}") )
+        return 0
+    fi
+}
+
+complete -F _ai_builder_completions ai-builder
+`.trim();
+var ZSH_COMPLETION = `
+#compdef ai-builder
+
+_ai_builder() {
+    local -a commands types
+
+    commands=(
+        'add:Install an artifact or stack'
+        'remove:Remove an installed artifact'
+        'rm:Remove an installed artifact'
+        'list:List installed artifacts'
+        'ls:List installed artifacts'
+        'search:Search the registry for artifacts'
+        'status:Show CLI status'
+        'update:Update the CLI'
+        'completion:Generate shell completions'
+    )
+
+    types=(skill agent command stack)
+
+    _arguments -C \\
+        '1:command:->command' \\
+        '*::arg:->args'
+
+    case "$state" in
+        command)
+            _describe -t commands 'ai-builder command' commands
+            ;;
+        args)
+            case "$words[1]" in
+                add|remove|rm)
+                    _arguments \\
+                        '1:type:(skill agent command stack)' \\
+                        '2:slug:' \\
+                        '--force[Overwrite existing artifacts]' \\
+                        '--yes[Skip confirmation]' \\
+                        '--help[Show help]'
+                    ;;
+                list|ls)
+                    _arguments \\
+                        '--type[Filter by type]:type:(skill agent command)' \\
+                        '--help[Show help]'
+                    ;;
+                search)
+                    _arguments \\
+                        '1:query:' \\
+                        '--type[Filter by type]:type:(skill agent command)' \\
+                        '--task[Filter by task category]:task:' \\
+                        '--limit[Number of results]:limit:' \\
+                        '--help[Show help]'
+                    ;;
+                update)
+                    _arguments \\
+                        '--check[Check for updates without installing]' \\
+                        '--help[Show help]'
+                    ;;
+                completion)
+                    _arguments \\
+                        '1:shell:(bash zsh)' \\
+                        '--setup[Auto-install to shell config]' \\
+                        '--help[Show help]'
+                    ;;
+            esac
+            ;;
+    esac
+}
+
+_ai_builder "$@"
+`.trim();
+function getShellConfigPath(shell) {
+  const home = os.homedir();
+  if (shell === "bash") {
+    const bashrc = path3.join(home, ".bashrc");
+    const bashProfile = path3.join(home, ".bash_profile");
+    return fs3.existsSync(bashrc) ? bashrc : bashProfile;
+  }
+  if (shell === "zsh") {
+    return path3.join(home, ".zshrc");
+  }
+  return null;
+}
+function detectShell() {
+  const shell = process.env.SHELL || "";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("bash")) return "bash";
+  return null;
+}
+function completionCommand(shell, options) {
+  if (options?.setup) {
+    const detectedShell = detectShell();
+    if (!detectedShell) {
+      console.error(chalk2.red("\n  Could not detect shell. Use:"));
+      console.error(chalk2.dim("  ai-builder completion bash >> ~/.bashrc"));
+      console.error(chalk2.dim("  ai-builder completion zsh >> ~/.zshrc\n"));
+      process.exit(1);
+    }
+    const configPath = getShellConfigPath(detectedShell);
+    if (!configPath) {
+      console.error(chalk2.red(`
+  Could not find config for ${detectedShell}
+`));
+      process.exit(1);
+    }
+    const completion = detectedShell === "zsh" ? ZSH_COMPLETION : BASH_COMPLETION;
+    const marker = "# ai-builder completion";
+    const existingContent = fs3.existsSync(configPath) ? fs3.readFileSync(configPath, "utf-8") : "";
+    if (existingContent.includes(marker)) {
+      console.log(chalk2.yellow(`
+  Completion already installed in ${configPath}`));
+      console.log(chalk2.dim("  Restart your terminal to apply changes\n"));
+      return;
+    }
+    fs3.appendFileSync(configPath, `
+${completion}
+`);
+    console.log(chalk2.green(`
+  Completion installed to ${configPath}`));
+    console.log(chalk2.dim(`  Restart your terminal or run: source ${configPath}
+`));
+    return;
+  }
+  if (!shell) {
+    console.log(chalk2.cyan.bold("\n  ai-builder completion\n"));
+    console.log("  Generate shell completions for ai-builder.\n");
+    console.log("  Usage:");
+    console.log("    ai-builder completion bash      Output bash completion");
+    console.log("    ai-builder completion zsh       Output zsh completion");
+    console.log("    ai-builder completion --setup   Auto-install for current shell\n");
+    console.log("  Manual installation:");
+    console.log(chalk2.dim("    ai-builder completion bash >> ~/.bashrc"));
+    console.log(chalk2.dim("    ai-builder completion zsh >> ~/.zshrc\n"));
+    return;
+  }
+  if (shell === "bash") {
+    console.log(BASH_COMPLETION);
+    return;
+  }
+  if (shell === "zsh") {
+    console.log(ZSH_COMPLETION);
+    return;
+  }
+  console.error(chalk2.red(`
+  Unsupported shell: ${shell}`));
+  console.error(chalk2.dim("  Supported: bash, zsh\n"));
+  process.exit(1);
+}
+
+// src/commands/list.ts
+import chalk3 from "chalk";
 var TYPE_COLORS = {
-  skill: chalk2.blue,
-  agent: chalk2.magenta,
-  command: chalk2.green
+  skill: chalk3.blue,
+  agent: chalk3.magenta,
+  command: chalk3.green
 };
 async function listCommand(options) {
   let artifacts = getInstalledArtifacts();
@@ -352,33 +578,33 @@ async function listCommand(options) {
   }
   if (artifacts.length === 0) {
     if (options.type) {
-      console.log(chalk2.dim(`No ${options.type}s installed.`));
+      console.log(chalk3.dim(`No ${options.type}s installed.`));
     } else {
-      console.log(chalk2.dim("No artifacts installed."));
+      console.log(chalk3.dim("No artifacts installed."));
     }
     console.log();
     console.log("Install artifacts with:");
-    console.log(`${chalk2.green("  $ ")}ai-builder add agent anthropic/frontend-tester`);
+    console.log(`${chalk3.green("  $ ")}ai-builder add agent anthropic/frontend-tester`);
     return;
   }
   console.log();
-  console.log(chalk2.bold("Installed Artifacts"));
+  console.log(chalk3.bold("Installed Artifacts"));
   console.log();
   console.log(
-    `${chalk2.dim("  ") + padEnd("TYPE", 10) + padEnd("NAME", 30) + padEnd("AUTHOR", 15)}INSTALLED`
+    `${chalk3.dim("  ") + padEnd("TYPE", 10) + padEnd("NAME", 30) + padEnd("AUTHOR", 15)}INSTALLED`
   );
-  console.log(chalk2.dim(`  ${"-".repeat(70)}`));
+  console.log(chalk3.dim(`  ${"-".repeat(70)}`));
   for (const artifact of artifacts) {
-    const typeColor = TYPE_COLORS[artifact.type] || chalk2.white;
+    const typeColor = TYPE_COLORS[artifact.type] || chalk3.white;
     const typeLabel = typeColor(padEnd(artifact.type, 10));
     const name = padEnd(artifact.name, 30);
-    const author = chalk2.dim(padEnd(artifact.author, 15));
-    const date = chalk2.dim(formatDate(artifact.installedAt));
+    const author = chalk3.dim(padEnd(artifact.author, 15));
+    const date = chalk3.dim(formatDate(artifact.installedAt));
     console.log(`  ${typeLabel}${name}${author}${date}`);
   }
   console.log();
   console.log(
-    chalk2.dim(`  ${artifacts.length} artifact${artifacts.length === 1 ? "" : "s"} installed`)
+    chalk3.dim(`  ${artifacts.length} artifact${artifacts.length === 1 ? "" : "s"} installed`)
   );
   console.log();
 }
@@ -408,39 +634,39 @@ function formatDate(isoDate) {
 
 // src/commands/remove.ts
 import * as readline2 from "readline";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 var VALID_TYPES2 = ["skill", "agent", "command"];
 async function removeCommand(type, slug, options) {
   if (!type) {
-    console.log(chalk3.red("Error: Missing artifact type."));
+    console.log(chalk4.red("Error: Missing artifact type."));
     console.log("Usage: ai-builder remove <type> <author/slug>");
     console.log("Types: skill, agent, command");
     process.exit(1);
   }
   if (!VALID_TYPES2.includes(type)) {
-    console.log(chalk3.red(`Error: Invalid type "${type}".`));
+    console.log(chalk4.red(`Error: Invalid type "${type}".`));
     console.log("Valid types: skill, agent, command");
     process.exit(1);
   }
   if (!slug) {
-    console.log(chalk3.red("Error: Missing artifact slug."));
+    console.log(chalk4.red("Error: Missing artifact slug."));
     console.log("Usage: ai-builder remove <type> <author/slug>");
     console.log("Example: ai-builder remove agent anthropic/frontend-tester");
     process.exit(1);
   }
   if (!slug.includes("/")) {
-    console.log(chalk3.red("Error: Invalid slug format."));
+    console.log(chalk4.red("Error: Invalid slug format."));
     console.log("Expected format: author/artifact-name");
     console.log("Example: anthropic/frontend-tester");
     process.exit(1);
   }
   const [author, artifactSlug] = slug.split("/");
   if (!isInstalled(type, author, artifactSlug)) {
-    console.log(chalk3.yellow(`${type} ${chalk3.bold(slug)} is not installed.`));
+    console.log(chalk4.yellow(`${type} ${chalk4.bold(slug)} is not installed.`));
     return;
   }
   if (!options.yes) {
-    const confirmed = await confirm2(`Remove ${type} ${chalk3.cyan(slug)}?`);
+    const confirmed = await confirm2(`Remove ${type} ${chalk4.cyan(slug)}?`);
     if (!confirmed) {
       console.log("Cancelled.");
       return;
@@ -448,9 +674,9 @@ async function removeCommand(type, slug, options) {
   }
   const removed = uninstallArtifact(type, author, artifactSlug);
   if (removed) {
-    console.log(chalk3.green(`Removed ${type} ${chalk3.bold(slug)}`));
+    console.log(chalk4.green(`Removed ${type} ${chalk4.bold(slug)}`));
   } else {
-    console.log(chalk3.red(`Failed to remove ${type} ${slug}`));
+    console.log(chalk4.red(`Failed to remove ${type} ${slug}`));
     process.exit(1);
   }
 }
@@ -460,7 +686,7 @@ async function confirm2(question) {
     output: process.stdout
   });
   return new Promise((resolve) => {
-    rl.question(`${question} ${chalk3.dim("[y/N]")} `, (answer) => {
+    rl.question(`${question} ${chalk4.dim("[y/N]")} `, (answer) => {
       rl.close();
       resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
@@ -468,12 +694,12 @@ async function confirm2(question) {
 }
 
 // src/commands/search.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import ora2 from "ora";
 var TYPE_COLORS2 = {
-  skill: chalk4.blue,
-  agent: chalk4.magenta,
-  command: chalk4.green
+  skill: chalk5.blue,
+  agent: chalk5.magenta,
+  command: chalk5.green
 };
 async function searchCommand(query, options) {
   const limit = Number.parseInt(options.limit || "10", 10);
@@ -487,40 +713,40 @@ async function searchCommand(query, options) {
     });
     spinner.stop();
     if (artifacts.length === 0) {
-      console.log(chalk4.dim(`No results found for "${query}"`));
+      console.log(chalk5.dim(`No results found for "${query}"`));
       return;
     }
     console.log();
-    console.log(chalk4.bold(`Found ${total} result${total === 1 ? "" : "s"}`));
+    console.log(chalk5.bold(`Found ${total} result${total === 1 ? "" : "s"}`));
     console.log();
     for (const artifact of artifacts) {
-      const typeColor = TYPE_COLORS2[artifact.type] || chalk4.white;
+      const typeColor = TYPE_COLORS2[artifact.type] || chalk5.white;
       const typeLabel = typeColor(`[${artifact.type}]`);
       const fullSlug = `${artifact.author}/${artifact.slug}`;
-      console.log(`  ${typeLabel} ${chalk4.bold(artifact.name)}`);
-      console.log(`    ${chalk4.cyan(fullSlug)}`);
+      console.log(`  ${typeLabel} ${chalk5.bold(artifact.name)}`);
+      console.log(`    ${chalk5.cyan(fullSlug)}`);
       if (artifact.summary) {
-        console.log(`    ${chalk4.dim(truncate(artifact.summary, 60))}`);
+        console.log(`    ${chalk5.dim(truncate(artifact.summary, 60))}`);
       }
-      console.log(`    ${chalk4.dim(`${formatNumber(artifact.installCount)} installs`)}`);
+      console.log(`    ${chalk5.dim(`${formatNumber(artifact.installCount)} installs`)}`);
       console.log();
     }
     if (total > artifacts.length) {
-      console.log(chalk4.dim(`  ... and ${total - artifacts.length} more results`));
-      console.log(chalk4.dim("  Use --limit to see more results"));
+      console.log(chalk5.dim(`  ... and ${total - artifacts.length} more results`));
+      console.log(chalk5.dim("  Use --limit to see more results"));
       console.log();
     }
     console.log("Install with:");
     if (artifacts.length > 0) {
       const first = artifacts[0];
       console.log(
-        `${chalk4.green("  $ ")}ai-builder add ${first.type} ${first.author}/${first.slug}`
+        `${chalk5.green("  $ ")}ai-builder add ${first.type} ${first.author}/${first.slug}`
       );
     }
     console.log();
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    spinner.fail(chalk4.red(`Search failed: ${message}`));
+    spinner.fail(chalk5.red(`Search failed: ${message}`));
     process.exit(1);
   }
 }
@@ -538,26 +764,149 @@ function formatNumber(num) {
   return num.toString();
 }
 
+// src/commands/status.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import chalk6 from "chalk";
+
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var version = pkg.version;
+
+// src/commands/status.ts
+var API_BASE2 = process.env.AI_BUILDER_API_URL || "https://aibuilder.sh/api";
+async function statusCommand() {
+  console.log(chalk6.cyan.bold("\n  ai-builder status\n"));
+  console.log(`  ${chalk6.dim("Version:")}      ${chalk6.white(version)}`);
+  const claudeDir = path4.join(process.cwd(), ".claude");
+  const claudeDirExists = fs4.existsSync(claudeDir);
+  console.log(
+    `  ${chalk6.dim("Claude dir:")}   ${claudeDirExists ? chalk6.green(".claude/ found") : chalk6.yellow(".claude/ not found")}`
+  );
+  const installed = getInstalledArtifacts();
+  const byType = installed.reduce(
+    (acc, artifact) => {
+      acc[artifact.type] = (acc[artifact.type] || 0) + 1;
+      return acc;
+    },
+    {}
+  );
+  if (installed.length === 0) {
+    console.log(`  ${chalk6.dim("Installed:")}    ${chalk6.dim("none")}`);
+  } else {
+    const summary = Object.entries(byType).map(([type, count]) => `${count} ${type}${count > 1 ? "s" : ""}`).join(", ");
+    console.log(`  ${chalk6.dim("Installed:")}    ${chalk6.white(summary)}`);
+  }
+  process.stdout.write(`  ${chalk6.dim("Registry:")}     `);
+  try {
+    const start = Date.now();
+    const response = await fetch(`${API_BASE2}/artifacts?limit=1`);
+    const latency = Date.now() - start;
+    if (response.ok) {
+      console.log(chalk6.green("connected") + chalk6.dim(` (${latency}ms)`));
+    } else {
+      console.log(chalk6.red(`error ${response.status}`));
+    }
+  } catch {
+    console.log(chalk6.red("unreachable"));
+  }
+  console.log();
+}
+
+// src/commands/update.ts
+import { execFileSync } from "child_process";
+import chalk7 from "chalk";
+var NPM_REGISTRY = "https://registry.npmjs.org/ai-builder";
+async function getLatestVersion() {
+  const response = await fetch(NPM_REGISTRY);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch package info: ${response.status}`);
+  }
+  const data = await response.json();
+  return data["dist-tags"].latest;
+}
+function compareVersions(current, latest) {
+  const currentParts = current.split(".").map(Number);
+  const latestParts = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (latestParts[i] > currentParts[i]) return 1;
+    if (latestParts[i] < currentParts[i]) return -1;
+  }
+  return 0;
+}
+async function updateCommand(options) {
+  console.log(chalk7.cyan.bold("\n  ai-builder update\n"));
+  console.log(`  ${chalk7.dim("Current version:")} ${chalk7.white(version)}`);
+  process.stdout.write(`  ${chalk7.dim("Latest version:")}  `);
+  let latestVersion;
+  try {
+    latestVersion = await getLatestVersion();
+    console.log(chalk7.white(latestVersion));
+  } catch {
+    console.log(chalk7.red("failed to fetch"));
+    console.log(chalk7.dim("\n  Could not reach npm registry\n"));
+    process.exit(1);
+  }
+  const comparison = compareVersions(version, latestVersion);
+  if (comparison === 0) {
+    console.log(chalk7.green("\n  You are on the latest version!\n"));
+    return;
+  }
+  if (comparison < 0) {
+    console.log(chalk7.yellow("\n  Your version is newer than published\n"));
+    return;
+  }
+  if (options.check) {
+    console.log(chalk7.yellow(`
+  Update available: ${version} \u2192 ${latestVersion}`));
+    console.log(chalk7.dim(`  Run 'ai-builder update' to install
+`));
+    return;
+  }
+  console.log(chalk7.dim(`
+  Updating to ${latestVersion}...`));
+  try {
+    execFileSync("npm", ["install", "-g", "ai-builder@latest"], { stdio: "inherit" });
+    console.log(chalk7.green(`
+  Updated to ${latestVersion}!
+`));
+  } catch {
+    console.log(chalk7.red("\n  Update failed. Try running:"));
+    console.log(chalk7.dim("  npm install -g ai-builder@latest\n"));
+    process.exit(1);
+  }
+}
+
 // src/index.ts
 var program = new Command();
-program.name("ai-builder").description("CLI for installing Claude Code artifacts from aibuilder.sh").version("0.1.0");
+program.name("ai-builder").description("CLI for installing Claude Code artifacts from aibuilder.sh").version(version);
 program.command("add").description("Install an artifact or stack").argument("[type]", "Artifact type: skill, agent, command, or stack").argument("[slug]", "Artifact slug in author/name format").option("-f, --force", "Overwrite existing artifacts").option("-y, --yes", "Skip confirmation for stacks").action(addCommand);
 program.command("remove").alias("rm").description("Remove an installed artifact").argument("[type]", "Artifact type: skill, agent, or command").argument("[slug]", "Artifact slug in author/name format").option("-y, --yes", "Skip confirmation").action(removeCommand);
 program.command("list").alias("ls").description("List installed artifacts").option("-t, --type <type>", "Filter by type: skill, agent, or command").action(listCommand);
 program.command("search").description("Search the registry for artifacts").argument("<query>", "Search query").option("-t, --type <type>", "Filter by type: skill, agent, or command").option("--task <task>", "Filter by task category").option("-l, --limit <number>", "Number of results", "10").action(searchCommand);
+program.command("status").description("Show CLI status and installed artifacts").action(statusCommand);
+program.command("update").description("Update the CLI to the latest version").option("-c, --check", "Check for updates without installing").action(updateCommand);
+program.command("completion").description("Generate shell completions").argument("[shell]", "Shell type: bash or zsh").option("-s, --setup", "Auto-install completion for current shell").action(completionCommand);
 program.action(() => {
-  console.log(chalk5.cyan.bold("\n  ai-builder") + chalk5.dim(" - Claude Code artifact registry\n"));
+  console.log(
+    chalk8.cyan.bold("\n  ai-builder") + chalk8.dim(` v${version} - Claude Code artifact registry
+`)
+  );
   console.log("  Usage:");
   console.log("    ai-builder add <type> <author/slug>   Install an artifact");
   console.log("    ai-builder remove <type> <slug>       Remove an artifact");
   console.log("    ai-builder list                       List installed");
   console.log("    ai-builder search <query>             Search registry");
+  console.log("    ai-builder status                     Show CLI status");
+  console.log("    ai-builder update                     Update CLI");
   console.log("\n  Examples:");
-  console.log(`${chalk5.green("    $ ")}ai-builder add agent anthropic/frontend-tester`);
-  console.log(`${chalk5.green("    $ ")}ai-builder add stack nextjs-fullstack`);
-  console.log(`${chalk5.green("    $ ")}ai-builder search "test generator"`);
+  console.log(`${chalk8.green("    $ ")}ai-builder add agent anthropic/frontend-tester`);
+  console.log(`${chalk8.green("    $ ")}ai-builder add stack nextjs-fullstack`);
+  console.log(`${chalk8.green("    $ ")}ai-builder search "test generator"`);
   console.log(`
-  Learn more at ${chalk5.cyan("https://aibuilder.sh")}
+  Learn more at ${chalk8.cyan("https://aibuilder.sh")}
 `);
 });
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-builder",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "CLI for installing Claude Code artifacts from aibuilder.sh",
   "type": "module",
   "bin": {
@@ -22,7 +22,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@aibuilder/logger": "workspace:*",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "ora": "^8.1.0"