ai-builder 0.1.5 → 0.1.7

package/dist/index.js

@@ -9,6 +9,82 @@ 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,12 +143,24 @@ 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 })
     });
-    logger.debug({ type, slug, cliVersion, status: response.status }, "Install tracked");
+    const result = await response.json();
+    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)");
   }
@@ -92,23 +180,23 @@ async function resolveStack(slug) {
 }
 
 // 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: {} };
@@ -116,11 +204,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) {
@@ -147,14 +235,14 @@ 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}`);
   }
@@ -166,24 +254,24 @@ function installArtifact(artifact, options = {}) {
   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({
@@ -192,19 +280,19 @@ function installArtifact(artifact, options = {}) {
     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;
@@ -242,26 +330,25 @@ async function addCommand(type, 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;
     }
-    trackInstall(type, slug, CLI_VERSION);
+    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);
+    await trackInstall(type, slug, CLI_VERSION);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
     spinner.fail(chalk.red(`Failed to install: ${message}`));
@@ -314,19 +401,26 @@ async function installStack(stackSlug, options) {
     }
     console.log();
     let installed = 0;
-    let skipped = 0;
+    let updated = 0;
     for (const artifact of stack.artifacts) {
-      const artifactSpinner = ora(`Installing ${artifact.name}...`).start();
+      const [artifactAuthor, artifactSlug] = artifact.slug.split("/");
+      const isArtifactUpdate = isInstalled(artifact.type, artifactAuthor, artifactSlug);
+      const actionVerb = isArtifactUpdate ? "Updating" : "Installing";
+      const artifactSpinner = ora(`${actionVerb} ${artifact.name}...`).start();
       try {
         const resolved = await resolveArtifact(artifact.type, artifact.slug);
-        const result = installArtifact(resolved, { force: options.force });
+        const result = installArtifact(resolved, { force: isArtifactUpdate || options.force });
         if (result.installed) {
-          artifactSpinner.succeed(`Installed ${chalk.green(artifact.name)}`);
-          trackInstall(artifact.type, artifact.slug, CLI_VERSION);
-          installed++;
+          if (isArtifactUpdate) {
+            artifactSpinner.succeed(`Updated ${chalk.green(artifact.name)}`);
+            updated++;
+          } else {
+            artifactSpinner.succeed(`Installed ${chalk.green(artifact.name)}`);
+            installed++;
+          }
+          await trackInstall(artifact.type, artifact.slug, CLI_VERSION);
         } else {
-          artifactSpinner.info(`${artifact.name} already installed`);
-          skipped++;
+          artifactSpinner.warn(`${artifact.name} could not be installed`);
         }
       } catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error";
@@ -334,8 +428,16 @@ async function installStack(stackSlug, options) {
       }
     }
     console.log();
+    const parts = [];
+    if (installed > 0) {
+      parts.push(`installed ${installed}`);
+    }
+    if (updated > 0) {
+      parts.push(`updated ${updated}`);
+    }
+    const summary = parts.length > 0 ? parts.join(", ") : "no changes";
     console.log(
-      `${chalk.green("Done!")} Installed ${installed} artifact${installed === 1 ? "" : "s"}${skipped > 0 ? `, skipped ${skipped}` : ""}`
+      `${chalk.green("Done!")} ${summary.charAt(0).toUpperCase() + summary.slice(1)} artifact${installed + updated === 1 ? "" : "s"}`
     );
     console.log();
     console.log(chalk.dim(`Learn more: https://aibuilder.sh/stacks/${stackSlug}`));
@@ -359,9 +461,9 @@ async function confirm(question) {
 }
 
 // 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
@@ -487,14 +589,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;
 }
@@ -522,14 +624,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(`
@@ -765,8 +867,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
@@ -780,8 +882,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")}`
   );

package/package.json

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