claude-prime 1.1.0

package/bin/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+const { version } = require("../package.json");
+
+const HELP = `
+claude-prime v${version}
+
+Usage:
+  claude-prime install [options]   Install Claude Prime into the current directory
+  claude-prime init                Configure/reconfigure Claude Prime in current directory
+  claude-prime --help              Show this help message
+  claude-prime --version           Show CLI version
+
+Options (install):
+  --version <version>              Install a specific version (e.g., 1.0.0)
+
+Environment variables:
+  CLAUDE_PRIME_VERSION             Install a specific version (alternative to --version flag)
+
+Examples:
+  npx claude-prime install
+  npx claude-prime install --version 1.0.0
+  npx claude-prime init
+`;
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (args.includes("--help") || args.includes("-h") || !command) {
+  console.log(HELP.trim());
+  process.exit(0);
+}
+
+if (command === "--version" || command === "-V") {
+  console.log(version);
+  process.exit(0);
+}
+
+const [major] = process.versions.node.split(".").map(Number);
+if (major < 18) {
+  console.error(
+    `Error: claude-prime requires Node.js >= 18 (current: ${process.version})`
+  );
+  process.exit(1);
+}
+
+if (command === "install") {
+  require("../src/install")(args.slice(1)).catch((err) => {
+    const { log } = require("@clack/prompts");
+    log.error(err.message);
+    process.exit(1);
+  });
+} else if (command === "init") {
+  require("../src/init")().catch((err) => {
+    const { log } = require("@clack/prompts");
+    log.error(err.message);
+    process.exit(1);
+  });
+} else {
+  console.error(`Unknown command: ${command}\n`);
+  console.log(HELP.trim());
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "claude-prime",
+  "version": "1.1.0",
+  "description": "Supercharge Claude Code with skills, commands, and workflows for agent-skill-driven development",
+  "bin": {
+    "claude-prime": "./bin/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "agent",
+    "skills",
+    "workflows"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/avibebuilder/claude-prime.git"
+  },
+  "author": "Peter Truong <peter.tr99@gmail.com>",
+  "homepage": "https://github.com/avibebuilder/claude-prime",
+  "dependencies": {
+    "@clack/prompts": "^1.1.0"
+  }
+}

package/src/init.js

@@ -0,0 +1,280 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { execSync } = require("node:child_process");
+const {
+  intro,
+  outro,
+  log,
+  text,
+  select,
+  confirm,
+  spinner,
+  cancel,
+  isCancel,
+} = require("@clack/prompts");
+const { banner } = require("./utils");
+
+const GITIGNORE_ENTRIES = [
+  "repomix-output.xml",
+  "plans/**/*",
+  "!plans/templates/*",
+  "screenshots/*",
+  "docs/screenshots/*",
+  "docs/assets/*",
+  "docs/research/*",
+  "docs/session-reports/*",
+  "claude-prime-*.zip",
+  ".mcp.json",
+];
+
+const CLAUDE_GITIGNORE_ENTRIES = [
+  "touch-skill",
+  "optimus-prime",
+  "convo-analysis",
+  "prime-sync",
+];
+
+function handleCancel(value) {
+  if (isCancel(value)) {
+    cancel("Initialization cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+
+function ensureGitignoreEntries(filePath, entries, label) {
+  const exists = fs.existsSync(filePath);
+  let content = exists ? fs.readFileSync(filePath, "utf-8") : "";
+  const lines = content.split("\n").map((l) => l.trim());
+  let added = 0;
+
+  if (exists && content.length > 0 && !content.endsWith("\n")) {
+    content += "\n";
+  }
+
+  for (const entry of entries) {
+    if (!lines.includes(entry)) {
+      content += entry + "\n";
+      added++;
+    }
+  }
+
+  if (added > 0) {
+    fs.writeFileSync(filePath, content);
+    log.success(`Updated ${label} (${added} entries added)`);
+  } else {
+    log.success(`${label} already configured`);
+  }
+}
+
+async function stageGitignore(installDir) {
+  log.step("Stage: .gitignore configuration");
+
+  const gitignorePath = path.join(installDir, ".gitignore");
+  ensureGitignoreEntries(gitignorePath, GITIGNORE_ENTRIES, ".gitignore");
+
+  const claudeGitignorePath = path.join(installDir, ".claude", ".gitignore");
+  if (fs.existsSync(path.join(installDir, ".claude"))) {
+    ensureGitignoreEntries(
+      claudeGitignorePath,
+      CLAUDE_GITIGNORE_ENTRIES,
+      ".claude/.gitignore"
+    );
+  }
+}
+
+async function stageSkillEnvFiles(installDir) {
+  log.step("Stage: Skill environment files");
+
+  const mediaProcessorDir = path.join(
+    installDir,
+    ".claude",
+    "skills",
+    "media-processor"
+  );
+  const envExample = path.join(mediaProcessorDir, ".env.example");
+  const envFile = path.join(mediaProcessorDir, ".env");
+
+  if (!fs.existsSync(envExample)) {
+    log.warn("media-processor skill not found (skipping)");
+    return;
+  }
+
+  if (fs.existsSync(envFile)) {
+    const action = handleCancel(
+      await select({
+        message: "media-processor .env already exists",
+        options: [
+          { value: "backup", label: "Backup and reconfigure", hint: "moves to .env.bk" },
+          { value: "override", label: "Override" },
+          { value: "skip", label: "Skip" },
+        ],
+      })
+    );
+    if (action === "skip") {
+      log.warn("Skipping media-processor configuration");
+      return;
+    }
+    if (action === "backup") {
+      fs.copyFileSync(envFile, envFile + ".bk");
+      log.success("Backed up .env → .env.bk");
+    }
+  }
+
+  log.info(
+    "Google Gemini API Configuration\n" +
+      " ◌ Used by media-processor skill for audio/video/image processing.\n" +
+      " ◌ Stored at: .claude/skills/media-processor/.env\n" +
+      " ◌ Get your API key: https://aistudio.google.com/apikey"
+  );
+
+  const apiKey = handleCancel(
+    await text({
+      message: "Enter Gemini API key (press Enter to skip)",
+      placeholder: "AIza...",
+      validate: () => undefined,
+    })
+  );
+
+  if (apiKey && apiKey.trim()) {
+    const template = fs.readFileSync(envExample, "utf-8");
+    fs.writeFileSync(
+      envFile,
+      template.replace("your_api_key_here", apiKey.trim())
+    );
+    log.success(`Created .env for media-processor\n  Stored at: ${envFile}`);
+  } else {
+    log.warn("Skipped - Gemini API key is required for this skill");
+  }
+}
+
+async function stageMcpServers(installDir) {
+  log.step("Stage: MCP servers");
+
+  const mcpExample = path.join(installDir, ".claude", ".mcp.json.example");
+  const mcpFile = path.join(installDir, ".mcp.json");
+
+  if (!fs.existsSync(mcpExample)) {
+    log.warn(".mcp.json.example not found (skipping)");
+    return;
+  }
+
+  if (fs.existsSync(mcpFile)) {
+    const action = handleCancel(
+      await select({
+        message: ".mcp.json already exists",
+        options: [
+          { value: "backup", label: "Backup and reconfigure", hint: "moves to .mcp.json.bk" },
+          { value: "override", label: "Override" },
+          { value: "skip", label: "Skip" },
+        ],
+      })
+    );
+    if (action === "skip") {
+      log.warn("Skipping .mcp.json configuration");
+      return;
+    }
+    if (action === "backup") {
+      fs.copyFileSync(mcpFile, mcpFile + ".bk");
+      log.success("Backed up .mcp.json → .mcp.json.bk");
+    }
+  }
+
+  log.info(
+    "Figma MCP Server Configuration (optional)\n" +
+      " ◌ Only needed if you use Figma for design-to-code workflows.\n" +
+      " ◌ Stored at: .mcp.json\n" +
+      " ◌ Get your API key: https://help.figma.com/hc/en-us/articles/8085703771159-Manage-personal-access-tokens"
+  );
+
+  const figmaKey = handleCancel(
+    await text({
+      message: "Enter Figma API key (press Enter to skip)",
+      placeholder: "figd_...",
+      validate: () => undefined,
+    })
+  );
+
+  const template = fs.readFileSync(mcpExample, "utf-8");
+
+  if (figmaKey && figmaKey.trim()) {
+    fs.writeFileSync(mcpFile, template.replace("YOUR-KEY", figmaKey.trim()));
+    log.success(`Created .mcp.json with Figma API key\n  Stored at: ${mcpFile}`);
+  } else {
+    fs.writeFileSync(mcpFile, template);
+    log.warn("Created .mcp.json with placeholder (configure later)");
+  }
+}
+
+async function stageBrowserAutomation() {
+  log.step("Stage: Browser automation");
+
+  let installed = false;
+  try {
+    execSync("command -v agent-browser", { stdio: "pipe" });
+    installed = true;
+  } catch {}
+
+  if (installed) {
+    log.success("agent-browser is already installed globally");
+    return;
+  }
+
+  const shouldInstall = handleCancel(
+    await confirm({
+      message: "Install agent-browser globally?",
+      initialValue: false,
+    })
+  );
+
+  if (!shouldInstall) {
+    log.warn("Skipped (use npx agent-browser instead)");
+    return;
+  }
+
+  const s = spinner();
+  s.start("Installing agent-browser...");
+  try {
+    execSync("npm install -g agent-browser", { stdio: "pipe" });
+    s.stop("agent-browser installed");
+
+    s.start("Downloading Chromium...");
+    execSync("agent-browser install", { stdio: "pipe" });
+    s.stop("Chromium downloaded");
+
+    log.success("agent-browser installed globally");
+  } catch (err) {
+    s.stop("Installation failed");
+    log.error(`Failed to install agent-browser: ${err.message}`);
+  }
+}
+
+async function init(installDir, opts = {}) {
+  const dir = installDir || process.cwd();
+  const standalone = opts.standalone !== false;
+
+  if (standalone) {
+    banner();
+    intro("Claude Prime - Project Initialization");
+  }
+
+  await stageGitignore(dir);
+  await stageSkillEnvFiles(dir);
+  await stageMcpServers(dir);
+  await stageBrowserAutomation();
+
+  if (standalone) {
+    const BLUE = "\x1b[0;34m";
+    const BOLD = "\x1b[1m";
+    const NC = "\x1b[0m";
+
+    outro("Initialization complete!");
+
+    console.log(`  ${BOLD}Next steps:${NC}`);
+    console.log(`    1. Review generated configuration files`);
+    console.log(`    2. Start using Claude Code with: ${BLUE}claude${NC}`);
+    console.log("");
+  }
+}
+
+module.exports = init;

package/src/install.js

@@ -0,0 +1,180 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const { execSync } = require("node:child_process");
+const {
+  intro,
+  outro,
+  spinner,
+  select,
+  log,
+  cancel,
+  isCancel,
+} = require("@clack/prompts");
+const { banner, resolveVersion } = require("./utils");
+
+async function checkExistingInstallation(installDir) {
+  const hasClaudeDir = fs.existsSync(path.join(installDir, ".claude"));
+  const hasClaudeMd = fs.existsSync(path.join(installDir, "CLAUDE.md"));
+
+  if (!hasClaudeDir && !hasClaudeMd) return;
+
+  const existing = [];
+  if (hasClaudeDir) existing.push(".claude/");
+  if (hasClaudeMd) existing.push("CLAUDE.md");
+  log.warn(`Existing configuration detected: ${existing.join(", ")}`);
+
+  if (!process.stdin.isTTY) {
+    log.error(
+      "Existing files found. Run interactively to choose backup/override, or remove them manually."
+    );
+    process.exit(1);
+  }
+
+  const action = await select({
+    message: "What would you like to do?",
+    options: [
+      {
+        value: "backup",
+        label: "Backup existing files and continue",
+        hint: "moves to .claude.bk / CLAUDE.md.bk",
+      },
+      {
+        value: "override",
+        label: "Override",
+        hint: "removes existing files",
+      },
+      { value: "cancel", label: "Cancel" },
+    ],
+  });
+
+  if (isCancel(action) || action === "cancel") {
+    cancel("Installation cancelled.");
+    process.exit(0);
+  }
+
+  if (action === "backup") {
+    if (hasClaudeDir) {
+      fs.rmSync(path.join(installDir, ".claude.bk"), {
+        recursive: true,
+        force: true,
+      });
+      fs.renameSync(
+        path.join(installDir, ".claude"),
+        path.join(installDir, ".claude.bk")
+      );
+      log.success("Backed up .claude/ → .claude.bk/");
+    }
+    if (hasClaudeMd) {
+      fs.rmSync(path.join(installDir, "CLAUDE.md.bk"), { force: true });
+      fs.renameSync(
+        path.join(installDir, "CLAUDE.md"),
+        path.join(installDir, "CLAUDE.md.bk")
+      );
+      log.success("Backed up CLAUDE.md → CLAUDE.md.bk");
+    }
+  }
+
+  if (action === "override") {
+    if (hasClaudeDir) {
+      fs.rmSync(path.join(installDir, ".claude"), {
+        recursive: true,
+        force: true,
+      });
+      log.success("Removed existing .claude/");
+    }
+    if (hasClaudeMd) {
+      fs.rmSync(path.join(installDir, "CLAUDE.md"), { force: true });
+      log.success("Removed existing CLAUDE.md");
+    }
+  }
+}
+
+async function downloadAndInstall(version, installDir) {
+  const tag = `v${version}`;
+  const assetUrl = `https://github.com/avibebuilder/claude-prime/releases/download/${tag}/claude-prime.zip`;
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-prime-"));
+  const zipPath = path.join(tmpDir, "claude-prime.zip");
+
+  const s = spinner();
+  s.start(`Downloading claude-prime ${tag}`);
+
+  try {
+    let response;
+    try {
+      response = await fetch(assetUrl, { redirect: "follow" });
+    } catch {
+      s.stop("Download failed");
+      log.error(
+        `Failed to download release asset for ${tag}.\nURL: ${assetUrl}\nMake sure this version has a release with the claude-prime.zip asset.`
+      );
+      process.exit(1);
+    }
+
+    if (!response.ok) {
+      s.stop("Download failed");
+      log.error(
+        `Failed to download release asset for ${tag}.\nURL: ${assetUrl}\nMake sure this version has a release with the claude-prime.zip asset.`
+      );
+      process.exit(1);
+    }
+
+    const buffer = Buffer.from(await response.arrayBuffer());
+    fs.writeFileSync(zipPath, buffer);
+
+    s.stop(`Downloaded ${tag}`);
+
+    execSync(`unzip -qo "${zipPath}" -d "${installDir}"`, {
+      stdio: "pipe",
+    });
+    log.success(`Installed .claude/ into ${installDir}`);
+
+    fs.writeFileSync(
+      path.join(installDir, ".claude", ".prime-version"),
+      version
+    );
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+async function runInit(installDir) {
+  const initModule = require("./init");
+  await initModule(installDir, { standalone: false });
+}
+
+async function init(args) {
+  const installDir = process.cwd();
+  const versionIdx = args.indexOf("--version");
+  const explicitVersion =
+    versionIdx !== -1 ? args[versionIdx + 1] : undefined;
+
+  if (versionIdx !== -1 && !explicitVersion) {
+    log.error("--version requires a version argument (e.g., --version 1.0.0)");
+    process.exit(1);
+  }
+
+  banner();
+  intro("Claude Prime Installer");
+
+  await checkExistingInstallation(installDir);
+
+  const version = await resolveVersion(explicitVersion);
+  await downloadAndInstall(version, installDir);
+
+  await runInit(installDir);
+
+  const BLUE = "\x1b[0;34m";
+  const BOLD = "\x1b[1m";
+  const NC = "\x1b[0m";
+
+  outro("Done!");
+
+  console.log(`  ${BOLD}Next steps:${NC}`);
+  console.log(`    1. Start Claude Code:  ${BLUE}claude${NC}`);
+  console.log(`    2. Prime your project: ${BLUE}/optimus-prime${NC}`);
+  console.log(`    3. Start building:     ${BLUE}/cook Add user authentication${NC}`);
+  console.log("");
+}
+
+module.exports = init;

package/src/utils.js

@@ -0,0 +1,70 @@
+const { spinner } = require("@clack/prompts");
+
+const YELLOW = "\x1b[1;33m";
+const NC = "\x1b[0m";
+
+function banner() {
+  const claude = [
+    " ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗",
+    "██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝",
+    "██║     ██║     ███████║██║   ██║██║  ██║█████╗  ",
+    "██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝  ",
+    "╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗",
+    " ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝",
+  ];
+  const prime = [
+    "██████╗ ██████╗ ██╗███╗   ███╗███████╗",
+    "██╔══██╗██╔══██╗██║████╗ ████║██╔════╝",
+    "██████╔╝██████╔╝██║██╔████╔██║█████╗  ",
+    "██╔═══╝ ██╔══██╗██║██║╚██╔╝██║██╔══╝  ",
+    "██║     ██║  ██║██║██║ ╚═╝ ██║███████╗",
+    "╚═╝     ╚═╝  ╚═╝╚═╝╚═╝     ╚═╝╚══════╝",
+  ];
+
+  console.log("");
+  for (let i = 0; i < claude.length; i++) {
+    console.log(`${claude[i]}  ${YELLOW}${prime[i]}${NC}`);
+  }
+  console.log("");
+}
+
+async function resolveVersion(explicitVersion) {
+  let version = explicitVersion || process.env.CLAUDE_PRIME_VERSION;
+
+  if (version) {
+    return version.replace(/^v/, "");
+  }
+
+  const s = spinner();
+  s.start("Fetching latest version from GitHub");
+
+  let response;
+  try {
+    response = await fetch(
+      "https://api.github.com/repos/avibebuilder/claude-prime/releases/latest",
+      { headers: { Accept: "application/vnd.github.v3+json" } }
+    );
+  } catch {
+    s.stop("Failed to fetch version");
+    process.exit(1);
+  }
+
+  if (!response.ok) {
+    s.stop("Failed to fetch version");
+    process.exit(1);
+  }
+
+  const data = await response.json();
+  version = data.tag_name;
+
+  if (!version) {
+    s.stop("Could not determine latest version");
+    process.exit(1);
+  }
+
+  version = version.replace(/^v/, "");
+  s.stop(`Resolved version: ${version}`);
+  return version;
+}
+
+module.exports = { banner, resolveVersion };