ai-builder 0.1.6 → 0.1.8

package/README.md

@@ -19,7 +19,6 @@
 ## Features
 
 - **Install artifacts** - Add skills, agents, and commands from the registry
-- **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
@@ -72,7 +71,7 @@ Install an artifact from the registry:
 npx ai-builder add <type> <author/slug>
 ```
 
-**Types:** `skill`, `agent`, `command`, `stack`
+**Types:** `skill`, `agent`, `command`
 
 **Examples:**
 
@@ -90,16 +89,6 @@ npx ai-builder add skill anthropic/mcp-builder
 npx ai-builder add agent git-town/code_reviewer --force
 ```
 
-**Stacks** bundle multiple artifacts together:
-
-```bash
-# Install a stack (prompts for confirmation)
-npx ai-builder add stack my-stack
-
-# Skip confirmation
-npx ai-builder add stack my-stack --yes
-```
-
 ### Remove
 
 Remove an installed artifact:
@@ -219,7 +208,6 @@ ai-builder completion zsh >> ~/.zshrc
 | **skill** | Background capabilities that enhance Claude's abilities | `.claude/skills/{name}/` |
 | **agent** | Specialized agents invoked with `@agent-name` | `.claude/agents/{name}.md` |
 | **command** | Slash commands invoked with `/command-name` | `.claude/commands/{name}.md` |
-| **stack** | Bundles of artifacts for specific workflows | Various locations |
 
 ---
 

package/dist/index.js

@@ -5,10 +5,85 @@ import chalk8 from "chalk";
 import { Command } from "commander";
 
 // src/commands/add.ts
-import * as readline from "readline";
 import chalk from "chalk";
 import ora from "ora";
 
+// src/services/metadata.ts
+import * as os2 from "os";
+
+// src/services/anonymous-id.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var CONFIG_DIR = path.join(os.homedir(), ".config", "ai-builder");
+var ANONYMOUS_ID_FILE = path.join(CONFIG_DIR, "anonymous-id");
+function isValidUuid(str) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(str);
+}
+function getAnonymousId() {
+  if (fs.existsSync(ANONYMOUS_ID_FILE)) {
+    try {
+      const id = fs.readFileSync(ANONYMOUS_ID_FILE, "utf-8").trim();
+      if (isValidUuid(id)) {
+        return id;
+      }
+    } catch {
+    }
+  }
+  const newId = crypto.randomUUID();
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(ANONYMOUS_ID_FILE, `${newId}
+`, { mode: 384 });
+  } catch {
+  }
+  return newId;
+}
+
+// src/services/metadata.ts
+function getShell() {
+  const shell = process.env.SHELL || process.env.COMSPEC;
+  if (!shell) return null;
+  const parts = shell.split(/[/\\]/);
+  return parts[parts.length - 1] || null;
+}
+function getTerminal() {
+  return process.env.TERM_PROGRAM || // iTerm.app, Apple_Terminal, vscode
+  process.env.TERMINAL_EMULATOR || // Some Linux terminals
+  (process.env.WT_SESSION ? "windows-terminal" : null);
+}
+function detectCi() {
+  return !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.BUILD_NUMBER || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.JENKINS_URL);
+}
+function getLocale() {
+  return process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || process.env.LANGUAGE || null;
+}
+function getTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return process.env.TZ || null;
+  }
+}
+function collectMetadata() {
+  return {
+    anonymousId: getAnonymousId(),
+    osType: os2.platform(),
+    osVersion: os2.release(),
+    osArch: os2.arch(),
+    nodeVersion: process.version,
+    shell: getShell(),
+    terminal: getTerminal(),
+    isCi: detectCi(),
+    locale: getLocale(),
+    timezone: getTimezone()
+  };
+}
+
 // src/services/api.ts
 var API_BASE = process.env.AI_BUILDER_API_URL || "https://aibuilder.sh/api";
 var isDebug = process.env.DEBUG?.includes("ai-builder");
@@ -67,49 +142,47 @@ async function searchArtifacts(options) {
 }
 async function trackInstall(type, slug, cliVersion) {
   try {
+    const metadata = collectMetadata();
     const response = await fetch(`${API_BASE}/install-events`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ type, slug, cliVersion })
+      body: JSON.stringify({ type, slug, cliVersion, metadata })
     });
     const result = await response.json();
-    logger.debug({ type, slug, cliVersion, status: response.status, result }, "Install tracked");
+    logger.debug(
+      {
+        type,
+        slug,
+        cliVersion,
+        anonymousId: metadata.anonymousId,
+        status: response.status,
+        result
+      },
+      "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)}`;
-  const timer = logger.startTimer("api-resolve-stack");
-  const response = await fetch(url);
-  if (!response.ok) {
-    const errorBody = await response.json().catch(() => ({ error: "Unknown error" }));
-    timer.done({ slug, status: response.status, success: false });
-    throw new Error(errorBody.error || `Failed to resolve stack: ${response.status}`);
-  }
-  const result = await response.json();
-  timer.done({ slug, artifactCount: result.artifactCount, status: response.status, success: true });
-  return result;
-}
 
 // src/services/installer.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 
 // src/services/lock-file.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 var LOCK_FILE_NAME = "ai-builder.lock.json";
 function getLockFilePath() {
-  return path.join(process.cwd(), ".claude", LOCK_FILE_NAME);
+  return path2.join(process.cwd(), ".claude", LOCK_FILE_NAME);
 }
 function readLockFile() {
   const lockPath = getLockFilePath();
-  if (!fs.existsSync(lockPath)) {
+  if (!fs2.existsSync(lockPath)) {
     return { version: 1, artifacts: {} };
   }
   try {
-    const content = fs.readFileSync(lockPath, "utf-8");
+    const content = fs2.readFileSync(lockPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, artifacts: {} };
@@ -117,11 +190,11 @@ function readLockFile() {
 }
 function writeLockFile(lockFile) {
   const lockPath = getLockFilePath();
-  const lockDir = path.dirname(lockPath);
-  if (!fs.existsSync(lockDir)) {
-    fs.mkdirSync(lockDir, { recursive: true });
+  const lockDir = path2.dirname(lockPath);
+  if (!fs2.existsSync(lockDir)) {
+    fs2.mkdirSync(lockDir, { recursive: true });
   }
-  fs.writeFileSync(lockPath, `${JSON.stringify(lockFile, null, 2)}
+  fs2.writeFileSync(lockPath, `${JSON.stringify(lockFile, null, 2)}
 `);
 }
 function addToLockFile(entry) {
@@ -148,82 +221,82 @@ function isInstalled(type, author, slug) {
 
 // src/services/installer.ts
 function getInstallPath(type, artifactName) {
-  const basePath = path2.join(process.cwd(), ".claude");
+  const basePath = path3.join(process.cwd(), ".claude");
   switch (type) {
     case "skill":
-      return path2.join(basePath, "skills", artifactName);
+      return path3.join(basePath, "skills", artifactName);
     case "agent":
-      return path2.join(basePath, "agents", `${artifactName}.md`);
+      return path3.join(basePath, "agents", `${artifactName}.md`);
     case "command":
-      return path2.join(basePath, "commands", `${artifactName}.md`);
+      return path3.join(basePath, "commands", `${artifactName}.md`);
     default:
       throw new Error(`Unknown artifact type: ${type}`);
   }
 }
 function installArtifact(artifact, options = {}) {
-  const artifactName = artifact.slug.split("/")[1];
+  const artifactName = artifact.name;
   const installPath = getInstallPath(artifact.type, artifactName);
   const files = [];
   if (!options.force && isInstalled(artifact.type, artifact.author, artifactName || artifact.name)) {
     return { installed: false, files: [] };
   }
-  const dir = artifact.type === "skill" ? installPath : path2.dirname(installPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  const dir = artifact.type === "skill" ? installPath : path3.dirname(installPath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
   }
   if (artifact.type === "skill") {
-    const skillMdPath = path2.join(installPath, "SKILL.md");
-    fs2.writeFileSync(skillMdPath, artifact.content);
+    const skillMdPath = path3.join(installPath, "SKILL.md");
+    fs3.writeFileSync(skillMdPath, artifact.content);
     files.push(skillMdPath);
     if (artifact.bundleFiles) {
       for (const [filename, content] of Object.entries(artifact.bundleFiles)) {
-        const filePath = path2.join(installPath, filename);
-        fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
-        fs2.writeFileSync(filePath, content);
+        const filePath = path3.join(installPath, filename);
+        fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+        fs3.writeFileSync(filePath, content);
         files.push(filePath);
       }
     }
   } else {
-    fs2.writeFileSync(installPath, artifact.content);
+    fs3.writeFileSync(installPath, artifact.content);
     files.push(installPath);
   }
   addToLockFile({
     type: artifact.type,
-    slug: artifactName || artifact.name,
+    slug: artifact.name,
     author: artifact.author,
     name: artifact.name,
     installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    files: files.map((f) => path2.relative(process.cwd(), f))
+    files: files.map((f) => path3.relative(process.cwd(), f))
   });
   return { installed: true, files };
 }
 function uninstallArtifact(type, author, slug) {
   const installPath = getInstallPath(type, slug);
-  if (!fs2.existsSync(installPath)) {
+  if (!fs3.existsSync(installPath)) {
     return false;
   }
   if (type === "skill") {
-    fs2.rmSync(installPath, { recursive: true, force: true });
+    fs3.rmSync(installPath, { recursive: true, force: true });
   } else {
-    fs2.unlinkSync(installPath);
+    fs3.unlinkSync(installPath);
   }
   removeFromLockFile(type, author, slug);
   return true;
 }
 
 // src/commands/add.ts
-var VALID_TYPES = ["skill", "agent", "command", "stack"];
+var VALID_TYPES = ["skill", "agent", "command"];
 var CLI_VERSION = "0.1.0";
 async function addCommand(type, slug, options) {
   if (!type) {
     console.log(chalk.red("Error: Missing artifact type."));
     console.log("Usage: ai-builder add <type> <author/slug>");
-    console.log("Types: skill, agent, command, stack");
+    console.log("Types: skill, agent, command");
     process.exit(1);
   }
   if (!VALID_TYPES.includes(type)) {
     console.log(chalk.red(`Error: Invalid type "${type}".`));
-    console.log("Valid types: skill, agent, command, stack");
+    console.log("Valid types: skill, agent, command");
     process.exit(1);
   }
   if (!slug) {
@@ -232,33 +305,28 @@ async function addCommand(type, slug, options) {
     console.log("Example: ai-builder add agent anthropic/frontend-tester");
     process.exit(1);
   }
-  if (type !== "stack" && !slug.includes("/")) {
+  if (!slug.includes("/")) {
     console.log(chalk.red("Error: Invalid slug format."));
     console.log("Expected format: author/artifact-name");
     console.log("Example: anthropic/frontend-tester");
     process.exit(1);
   }
-  if (type === "stack") {
-    await installStack(slug, options);
-    return;
-  }
   const [author, artifactSlug] = slug.split("/");
-  if (!options.force && isInstalled(type, author, artifactSlug)) {
-    console.log(chalk.yellow(`${type} ${chalk.bold(slug)} is already installed.`));
-    console.log("Use --force to reinstall.");
-    return;
-  }
-  const spinner = ora(`Resolving ${type} ${chalk.cyan(slug)}...`).start();
+  const isUpdate = isInstalled(type, author, artifactSlug);
+  const actionVerb = isUpdate ? "Updating" : "Resolving";
+  const spinner = ora(`${actionVerb} ${type} ${chalk.cyan(slug)}...`).start();
   try {
     const artifact = await resolveArtifact(type, slug);
-    spinner.text = `Installing ${artifact.name}...`;
-    const { installed } = installArtifact(artifact, { force: options.force });
+    const installVerb = isUpdate ? "Updating" : "Installing";
+    spinner.text = `${installVerb} ${artifact.name}...`;
+    const { installed } = installArtifact(artifact, { force: isUpdate || options.force });
     if (!installed) {
-      spinner.warn(`${artifact.name} is already installed. Use --force to reinstall.`);
+      spinner.warn(`${artifact.name} could not be installed.`);
       return;
     }
+    const successVerb = isUpdate ? "Updated" : "Installed";
     spinner.succeed(
-      `Installed ${chalk.green(artifact.name)} to ${chalk.dim(artifact.installPath)}`
+      `${successVerb} ${chalk.green(artifact.name)} to ${chalk.dim(artifact.installPath)}`
     );
     console.log();
     printUsageHint(type, artifactSlug);
@@ -284,85 +352,11 @@ function printUsageHint(type, slug) {
       break;
   }
 }
-async function installStack(stackSlug, options) {
-  const spinner = ora(`Resolving stack ${chalk.cyan(stackSlug)}...`).start();
-  try {
-    const stack = await resolveStack(stackSlug);
-    spinner.stop();
-    console.log();
-    console.log(chalk.bold(`Stack: ${stack.title}`));
-    if (stack.summary) {
-      console.log(chalk.dim(stack.summary));
-    }
-    console.log();
-    console.log(`This will install ${chalk.cyan(stack.artifactCount)} artifacts:`);
-    console.log();
-    for (const artifact of stack.artifacts) {
-      const typeColor = artifact.type === "skill" ? chalk.blue : artifact.type === "agent" ? chalk.magenta : chalk.green;
-      console.log(`  ${typeColor(`[${artifact.type}]`)} ${artifact.name}`);
-      console.log(`    ${chalk.dim(artifact.slug)}`);
-      if (artifact.installNotes) {
-        console.log(`    ${chalk.yellow(`Note: ${artifact.installNotes}`)}`);
-      }
-    }
-    console.log();
-    if (!options.yes) {
-      const confirmed = await confirm("Proceed with installation?");
-      if (!confirmed) {
-        console.log("Cancelled.");
-        return;
-      }
-    }
-    console.log();
-    let installed = 0;
-    let skipped = 0;
-    for (const artifact of stack.artifacts) {
-      const artifactSpinner = ora(`Installing ${artifact.name}...`).start();
-      try {
-        const resolved = await resolveArtifact(artifact.type, artifact.slug);
-        const result = installArtifact(resolved, { force: options.force });
-        if (result.installed) {
-          artifactSpinner.succeed(`Installed ${chalk.green(artifact.name)}`);
-          await trackInstall(artifact.type, artifact.slug, CLI_VERSION);
-          installed++;
-        } else {
-          artifactSpinner.info(`${artifact.name} already installed`);
-          skipped++;
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        artifactSpinner.fail(`Failed to install ${artifact.name}: ${chalk.dim(message)}`);
-      }
-    }
-    console.log();
-    console.log(
-      `${chalk.green("Done!")} Installed ${installed} artifact${installed === 1 ? "" : "s"}${skipped > 0 ? `, skipped ${skipped}` : ""}`
-    );
-    console.log();
-    console.log(chalk.dim(`Learn more: https://aibuilder.sh/stacks/${stackSlug}`));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    spinner.fail(chalk.red(`Failed to resolve stack: ${message}`));
-    process.exit(1);
-  }
-}
-async function confirm(question) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve) => {
-    rl.question(`${question} ${chalk.dim("[y/N]")} `, (answer) => {
-      rl.close();
-      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
-    });
-  });
-}
 
 // src/commands/completion.ts
-import * as fs3 from "fs";
-import * as os from "os";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as os3 from "os";
+import * as path4 from "path";
 import chalk2 from "chalk";
 var BASH_COMPLETION = `
 # ai-builder bash completion
@@ -371,7 +365,7 @@ _ai_builder_completions() {
     _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"
+    local types="skill agent command"
 
     case "\${prev}" in
         ai-builder)
@@ -425,7 +419,7 @@ _ai_builder() {
     local -a commands types
 
     commands=(
-        'add:Install an artifact or stack'
+        'add:Install an artifact'
         'remove:Remove an installed artifact'
         'rm:Remove an installed artifact'
         'list:List installed artifacts'
@@ -436,7 +430,7 @@ _ai_builder() {
         'completion:Generate shell completions'
     )
 
-    types=(skill agent command stack)
+    types=(skill agent command)
 
     _arguments -C \\
         '1:command:->command' \\
@@ -450,10 +444,9 @@ _ai_builder() {
             case "$words[1]" in
                 add|remove|rm)
                     _arguments \\
-                        '1:type:(skill agent command stack)' \\
+                        '1:type:(skill agent command)' \\
                         '2:slug:' \\
                         '--force[Overwrite existing artifacts]' \\
-                        '--yes[Skip confirmation]' \\
                         '--help[Show help]'
                     ;;
                 list|ls)
@@ -488,14 +481,14 @@ _ai_builder() {
 _ai_builder "$@"
 `.trim();
 function getShellConfigPath(shell) {
-  const home = os.homedir();
+  const home = os3.homedir();
   if (shell === "bash") {
-    const bashrc = path3.join(home, ".bashrc");
-    const bashProfile = path3.join(home, ".bash_profile");
-    return fs3.existsSync(bashrc) ? bashrc : bashProfile;
+    const bashrc = path4.join(home, ".bashrc");
+    const bashProfile = path4.join(home, ".bash_profile");
+    return fs4.existsSync(bashrc) ? bashrc : bashProfile;
   }
   if (shell === "zsh") {
-    return path3.join(home, ".zshrc");
+    return path4.join(home, ".zshrc");
   }
   return null;
 }
@@ -523,14 +516,14 @@ function completionCommand(shell, options) {
     }
     const completion = detectedShell === "zsh" ? ZSH_COMPLETION : BASH_COMPLETION;
     const marker = "# ai-builder completion";
-    const existingContent = fs3.existsSync(configPath) ? fs3.readFileSync(configPath, "utf-8") : "";
+    const existingContent = fs4.existsSync(configPath) ? fs4.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, `
+    fs4.appendFileSync(configPath, `
 ${completion}
 `);
     console.log(chalk2.green(`
@@ -634,7 +627,7 @@ function formatDate(isoDate) {
 }
 
 // src/commands/remove.ts
-import * as readline2 from "readline";
+import * as readline from "readline";
 import chalk4 from "chalk";
 var VALID_TYPES2 = ["skill", "agent", "command"];
 async function removeCommand(type, slug, options) {
@@ -667,7 +660,7 @@ async function removeCommand(type, slug, options) {
     return;
   }
   if (!options.yes) {
-    const confirmed = await confirm2(`Remove ${type} ${chalk4.cyan(slug)}?`);
+    const confirmed = await confirm(`Remove ${type} ${chalk4.cyan(slug)}?`);
     if (!confirmed) {
       console.log("Cancelled.");
       return;
@@ -681,8 +674,8 @@ async function removeCommand(type, slug, options) {
     process.exit(1);
   }
 }
-async function confirm2(question) {
-  const rl = readline2.createInterface({
+async function confirm(question) {
+  const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
@@ -766,8 +759,8 @@ function formatNumber(num) {
 }
 
 // src/commands/status.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 import chalk6 from "chalk";
 
 // src/version.ts
@@ -781,8 +774,8 @@ 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);
+  const claudeDir = path5.join(process.cwd(), ".claude");
+  const claudeDirExists = fs5.existsSync(claudeDir);
   console.log(
     `  ${chalk6.dim("Claude dir:")}   ${claudeDirExists ? chalk6.green(".claude/ found") : chalk6.yellow(".claude/ not found")}`
   );
@@ -883,7 +876,7 @@ async function updateCommand(options) {
 // src/index.ts
 var program = new Command();
 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("add").description("Install an artifact").argument("[type]", "Artifact type: skill, agent, or command").argument("[slug]", "Artifact slug in author/name format").option("-f, --force", "Overwrite existing artifacts").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);
@@ -904,7 +897,7 @@ program.action(() => {
   console.log("    ai-builder update                     Update CLI");
   console.log("\n  Examples:");
   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 add skill anthropic/code-reviewer`);
   console.log(`${chalk8.green("    $ ")}ai-builder search "test generator"`);
   console.log(`
   Learn more at ${chalk8.cyan("https://aibuilder.sh")}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-builder",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "CLI for installing Claude Code artifacts from aibuilder.sh",
   "type": "module",
   "bin": {