ai-builder 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,545 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import chalk5 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/api.ts
+var API_BASE = process.env.AI_BUILDER_API_URL || "https://aibuilder.sh/api";
+async function resolveArtifact(type, slug) {
+  const url = `${API_BASE}/resolve?type=${encodeURIComponent(type)}&slug=${encodeURIComponent(slug)}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(errorBody.error || `Failed to resolve artifact: ${response.status}`);
+  }
+  return response.json();
+}
+async function searchArtifacts(options) {
+  const params = new URLSearchParams();
+  if (options.query) params.set("q", options.query);
+  if (options.type) params.set("type", options.type);
+  if (options.task) params.set("task", options.task);
+  if (options.limit) params.set("limit", options.limit.toString());
+  const url = `${API_BASE}/artifacts?${params.toString()}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to search artifacts: ${response.status}`);
+  }
+  return response.json();
+}
+async function trackInstall(type, slug, cliVersion) {
+  try {
+    await fetch(`${API_BASE}/install-events`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type, slug, cliVersion })
+    });
+  } catch {
+  }
+}
+async function resolveStack(slug) {
+  const url = `${API_BASE}/stacks/${encodeURIComponent(slug)}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(errorBody.error || `Failed to resolve stack: ${response.status}`);
+  }
+  return response.json();
+}
+
+// src/services/installer.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/services/lock-file.ts
+import * as fs from "fs";
+import * as path from "path";
+var LOCK_FILE_NAME = "ai-builder.lock.json";
+function getLockFilePath() {
+  return path.join(process.cwd(), ".claude", LOCK_FILE_NAME);
+}
+function readLockFile() {
+  const lockPath = getLockFilePath();
+  if (!fs.existsSync(lockPath)) {
+    return { version: 1, artifacts: {} };
+  }
+  try {
+    const content = fs.readFileSync(lockPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, artifacts: {} };
+  }
+}
+function writeLockFile(lockFile) {
+  const lockPath = getLockFilePath();
+  const lockDir = path.dirname(lockPath);
+  if (!fs.existsSync(lockDir)) {
+    fs.mkdirSync(lockDir, { recursive: true });
+  }
+  fs.writeFileSync(lockPath, `${JSON.stringify(lockFile, null, 2)}
+`);
+}
+function addToLockFile(entry) {
+  const lockFile = readLockFile();
+  const key = `${entry.type}:${entry.author}/${entry.slug}`;
+  lockFile.artifacts[key] = entry;
+  writeLockFile(lockFile);
+}
+function removeFromLockFile(type, author, slug) {
+  const lockFile = readLockFile();
+  const key = `${type}:${author}/${slug}`;
+  delete lockFile.artifacts[key];
+  writeLockFile(lockFile);
+}
+function getInstalledArtifacts() {
+  const lockFile = readLockFile();
+  return Object.values(lockFile.artifacts);
+}
+function isInstalled(type, author, slug) {
+  const lockFile = readLockFile();
+  const key = `${type}:${author}/${slug}`;
+  return key in lockFile.artifacts;
+}
+
+// src/services/installer.ts
+function getInstallPath(type, artifactName) {
+  const basePath = path2.join(process.cwd(), ".claude");
+  switch (type) {
+    case "skill":
+      return path2.join(basePath, "skills", artifactName);
+    case "agent":
+      return path2.join(basePath, "agents", `${artifactName}.md`);
+    case "command":
+      return path2.join(basePath, "commands", `${artifactName}.md`);
+    default:
+      throw new Error(`Unknown artifact type: ${type}`);
+  }
+}
+function installArtifact(artifact, options = {}) {
+  const [, artifactName] = artifact.installPath.includes("/") ? artifact.installPath.split("/").filter(Boolean) : [null, artifact.installPath.replace(".claude/", "").replace(".md", "").split("/").pop()];
+  const installPath = getInstallPath(artifact.type, artifactName || artifact.name);
+  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 });
+  }
+  if (artifact.type === "skill") {
+    const skillMdPath = path2.join(installPath, "SKILL.md");
+    fs2.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);
+        files.push(filePath);
+      }
+    }
+  } else {
+    fs2.writeFileSync(installPath, artifact.content);
+    files.push(installPath);
+  }
+  addToLockFile({
+    type: artifact.type,
+    slug: artifactName || artifact.name,
+    author: artifact.author,
+    name: artifact.name,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: files.map((f) => path2.relative(process.cwd(), f))
+  });
+  return { installed: true, files };
+}
+function uninstallArtifact(type, author, slug) {
+  const installPath = getInstallPath(type, slug);
+  if (!fs2.existsSync(installPath)) {
+    return false;
+  }
+  if (type === "skill") {
+    fs2.rmSync(installPath, { recursive: true, force: true });
+  } else {
+    fs2.unlinkSync(installPath);
+  }
+  removeFromLockFile(type, author, slug);
+  return true;
+}
+
+// src/commands/add.ts
+var VALID_TYPES = ["skill", "agent", "command", "stack"];
+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");
+    process.exit(1);
+  }
+  if (!VALID_TYPES.includes(type)) {
+    console.log(chalk.red(`Error: Invalid type "${type}".`));
+    console.log("Valid types: skill, agent, command, stack");
+    process.exit(1);
+  }
+  if (!slug) {
+    console.log(chalk.red("Error: Missing artifact slug."));
+    console.log("Usage: ai-builder add <type> <author/slug>");
+    console.log("Example: ai-builder add agent anthropic/frontend-tester");
+    process.exit(1);
+  }
+  if (type !== "stack" && !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();
+  try {
+    const artifact = await resolveArtifact(type, slug);
+    spinner.text = `Installing ${artifact.name}...`;
+    const { installed } = installArtifact(artifact, { force: options.force });
+    if (!installed) {
+      spinner.warn(`${artifact.name} is already installed. Use --force to reinstall.`);
+      return;
+    }
+    trackInstall(type, slug, CLI_VERSION);
+    spinner.succeed(
+      `Installed ${chalk.green(artifact.name)} to ${chalk.dim(artifact.installPath)}`
+    );
+    console.log();
+    printUsageHint(type, artifactSlug);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail(chalk.red(`Failed to install: ${message}`));
+    process.exit(1);
+  }
+}
+function printUsageHint(type, slug) {
+  switch (type) {
+    case "agent":
+      console.log(chalk.dim("  Try it:"));
+      console.log(`  ${chalk.green(`@${slug}`)} write tests for my auth module`);
+      break;
+    case "command":
+      console.log(chalk.dim("  Try it:"));
+      console.log(`  ${chalk.green(`/${slug}`)}`);
+      break;
+    case "skill":
+      console.log(chalk.dim("  This skill will be available in Claude Code automatically."));
+      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)}`);
+          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/list.ts
+import chalk2 from "chalk";
+var TYPE_COLORS = {
+  skill: chalk2.blue,
+  agent: chalk2.magenta,
+  command: chalk2.green
+};
+async function listCommand(options) {
+  let artifacts = getInstalledArtifacts();
+  if (options.type) {
+    artifacts = artifacts.filter((a) => a.type === options.type);
+  }
+  if (artifacts.length === 0) {
+    if (options.type) {
+      console.log(chalk2.dim(`No ${options.type}s installed.`));
+    } else {
+      console.log(chalk2.dim("No artifacts installed."));
+    }
+    console.log();
+    console.log("Install artifacts with:");
+    console.log(`${chalk2.green("  $ ")}ai-builder add agent anthropic/frontend-tester`);
+    return;
+  }
+  console.log();
+  console.log(chalk2.bold("Installed Artifacts"));
+  console.log();
+  console.log(
+    `${chalk2.dim("  ") + padEnd("TYPE", 10) + padEnd("NAME", 30) + padEnd("AUTHOR", 15)}INSTALLED`
+  );
+  console.log(chalk2.dim(`  ${"-".repeat(70)}`));
+  for (const artifact of artifacts) {
+    const typeColor = TYPE_COLORS[artifact.type] || chalk2.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));
+    console.log(`  ${typeLabel}${name}${author}${date}`);
+  }
+  console.log();
+  console.log(
+    chalk2.dim(`  ${artifacts.length} artifact${artifacts.length === 1 ? "" : "s"} installed`)
+  );
+  console.log();
+}
+function padEnd(str, length) {
+  return str.length >= length ? str : str + " ".repeat(length - str.length);
+}
+function formatDate(isoDate) {
+  const date = new Date(isoDate);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays === 0) {
+    return "today";
+  }
+  if (diffDays === 1) {
+    return "yesterday";
+  }
+  if (diffDays < 7) {
+    return `${diffDays} days ago`;
+  }
+  if (diffDays < 30) {
+    const weeks = Math.floor(diffDays / 7);
+    return `${weeks} week${weeks === 1 ? "" : "s"} ago`;
+  }
+  return date.toLocaleDateString();
+}
+
+// src/commands/remove.ts
+import * as readline2 from "readline";
+import chalk3 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("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("Valid types: skill, agent, command");
+    process.exit(1);
+  }
+  if (!slug) {
+    console.log(chalk3.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("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.`));
+    return;
+  }
+  if (!options.yes) {
+    const confirmed = await confirm2(`Remove ${type} ${chalk3.cyan(slug)}?`);
+    if (!confirmed) {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+  const removed = uninstallArtifact(type, author, artifactSlug);
+  if (removed) {
+    console.log(chalk3.green(`Removed ${type} ${chalk3.bold(slug)}`));
+  } else {
+    console.log(chalk3.red(`Failed to remove ${type} ${slug}`));
+    process.exit(1);
+  }
+}
+async function confirm2(question) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`${question} ${chalk3.dim("[y/N]")} `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+// src/commands/search.ts
+import chalk4 from "chalk";
+import ora2 from "ora";
+var TYPE_COLORS2 = {
+  skill: chalk4.blue,
+  agent: chalk4.magenta,
+  command: chalk4.green
+};
+async function searchCommand(query, options) {
+  const limit = Number.parseInt(options.limit || "10", 10);
+  const spinner = ora2(`Searching for "${query}"...`).start();
+  try {
+    const { artifacts, total } = await searchArtifacts({
+      query,
+      type: options.type,
+      task: options.task,
+      limit
+    });
+    spinner.stop();
+    if (artifacts.length === 0) {
+      console.log(chalk4.dim(`No results found for "${query}"`));
+      return;
+    }
+    console.log();
+    console.log(chalk4.bold(`Found ${total} result${total === 1 ? "" : "s"}`));
+    console.log();
+    for (const artifact of artifacts) {
+      const typeColor = TYPE_COLORS2[artifact.type] || chalk4.white;
+      const typeLabel = typeColor(`[${artifact.type}]`);
+      const fullSlug = `${artifact.author}/${artifact.slug}`;
+      console.log(`  ${typeLabel} ${chalk4.bold(artifact.name)}`);
+      console.log(`    ${chalk4.cyan(fullSlug)}`);
+      if (artifact.summary) {
+        console.log(`    ${chalk4.dim(truncate(artifact.summary, 60))}`);
+      }
+      console.log(`    ${chalk4.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();
+    }
+    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}`
+      );
+    }
+    console.log();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail(chalk4.red(`Search failed: ${message}`));
+    process.exit(1);
+  }
+}
+function truncate(str, length) {
+  if (str.length <= length) return str;
+  return `${str.slice(0, length - 3)}...`;
+}
+function formatNumber(num) {
+  if (num >= 1e6) {
+    return `${(num / 1e6).toFixed(1)}M`;
+  }
+  if (num >= 1e3) {
+    return `${(num / 1e3).toFixed(1)}K`;
+  }
+  return num.toString();
+}
+
+// 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.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.action(() => {
+  console.log(chalk5.cyan.bold("\n  ai-builder") + chalk5.dim(" - Claude Code artifact registry\n"));
+  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("\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(`
+  Learn more at ${chalk5.cyan("https://aibuilder.sh")}
+`);
+});
+program.parse();

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "ai-builder",
+  "version": "0.1.0",
+  "description": "CLI for installing Claude Code artifacts from aibuilder.sh",
+  "type": "module",
+  "bin": {
+    "ai-builder": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "pnpm run build",
+    "preversion": "pnpm run type-check",
+    "release:patch": "npm version patch -m 'chore(cli): release v%s'",
+    "release:minor": "npm version minor -m 'chore(cli): release v%s'",
+    "release:major": "npm version major -m 'chore(cli): release v%s'"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "tsup": "^8.3.6",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": ["claude", "claude-code", "ai", "cli", "artifacts", "skills", "agents", "commands"],
+  "author": "",
+  "license": "MIT",
+  "homepage": "https://aibuilder.sh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BrainGridAI/ai-builder"
+  }
+}