@acmeacmeio/setup-sh 0.2.6

package/src/cli.mjs

@@ -0,0 +1,614 @@
+#!/usr/bin/env node
+
+import { execSync, spawn } from "node:child_process";
+import {
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  cpSync,
+} from "node:fs";
+import { join, dirname, resolve, isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATES_DIR = join(__dirname, "..", "templates");
+
+// ============================================================================
+// ANSI Colors (no dependencies)
+// ============================================================================
+const colors = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+};
+
+const log = {
+  info: (msg) => console.log(`${colors.blue}info${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}done${colors.reset} ${msg}`),
+  warn: (msg) => console.log(`${colors.yellow}warn${colors.reset} ${msg}`),
+  error: (msg) => console.log(`${colors.red}error${colors.reset} ${msg}`),
+  step: (msg) => console.log(`${colors.cyan}  -> ${colors.reset}${msg}`),
+  title: (msg) =>
+    console.log(`\n${colors.bold}${colors.magenta}${msg}${colors.reset}\n`),
+};
+
+// ============================================================================
+// Platform Detection
+// ============================================================================
+function detectPlatform() {
+  const platform = process.platform;
+
+  if (platform === "darwin") {
+    return { os: "macos", pm: "brew" };
+  }
+
+  if (platform === "linux") {
+    try {
+      const osRelease = readFileSync("/etc/os-release", "utf8");
+      if (osRelease.includes("Ubuntu") || osRelease.includes("Debian")) {
+        return { os: "debian", pm: "apt" };
+      }
+      if (
+        osRelease.includes("Fedora") ||
+        osRelease.includes("RHEL") ||
+        osRelease.includes("CentOS")
+      ) {
+        return { os: "fedora", pm: "dnf" };
+      }
+      if (osRelease.includes("Arch")) {
+        return { os: "arch", pm: "pacman" };
+      }
+    } catch {
+      // ignore
+    }
+    return { os: "linux", pm: "unknown" };
+  }
+
+  if (platform === "win32") {
+    return { os: "windows", pm: "winget" };
+  }
+
+  return { os: "unknown", pm: "unknown" };
+}
+
+// ============================================================================
+// Command Execution Helpers
+// ============================================================================
+function commandExists(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function exec(cmd, options = {}) {
+  try {
+    return execSync(cmd, {
+      encoding: "utf8",
+      stdio: options.silent ? "pipe" : "inherit",
+      ...options,
+    });
+  } catch (error) {
+    if (!options.ignoreError) {
+      throw error;
+    }
+    return null;
+  }
+}
+
+// ============================================================================
+// Interactive Prompts
+// ============================================================================
+function createPrompt(autoYes = false) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return {
+    ask: (question) =>
+      new Promise((resolve) => {
+        rl.question(question, (answer) => resolve(answer));
+      }),
+    confirm: async (question, defaultYes = true) => {
+      if (autoYes) {
+        console.log(`${question} [Y/n] y (auto)`);
+        return true;
+      }
+      const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+      const answer = await new Promise((resolve) => {
+        rl.question(`${question} ${suffix} `, resolve);
+      });
+      if (answer === "") return defaultYes;
+      return answer.toLowerCase() === "y";
+    },
+    select: async (question, options) => {
+      console.log(`\n${question}`);
+      options.forEach((opt, i) => {
+        console.log(
+          `  ${colors.cyan}${i + 1}${colors.reset}) ${opt.label}${opt.default ? ` ${colors.dim}(default)${colors.reset}` : ""}`,
+        );
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(`\nSelect [1-${options.length}]: `, resolve);
+      });
+      const idx = parseInt(answer, 10) - 1;
+      if (isNaN(idx) || idx < 0 || idx >= options.length) {
+        const defaultOpt = options.find((o) => o.default);
+        return defaultOpt ? defaultOpt.value : options[0].value;
+      }
+      return options[idx].value;
+    },
+    close: () => rl.close(),
+  };
+}
+
+// ============================================================================
+// Tool Installation
+// ============================================================================
+const TOOLS = {
+  gh: {
+    name: "GitHub CLI",
+    check: () => commandExists("gh"),
+    install: {
+      macos: "brew install gh",
+      debian: "sudo apt install -y gh",
+      fedora: "sudo dnf install -y gh",
+      arch: "sudo pacman -S --noconfirm github-cli",
+      windows: "winget install GitHub.cli",
+    },
+  },
+  node: {
+    name: "Node.js",
+    check: () => commandExists("node"),
+    install: {
+      macos: "brew install node",
+      debian:
+        "curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash - && sudo apt install -y nodejs",
+      fedora: "sudo dnf install -y nodejs",
+      arch: "sudo pacman -S --noconfirm nodejs npm",
+      windows: "winget install OpenJS.NodeJS.LTS",
+    },
+  },
+  pnpm: {
+    name: "pnpm",
+    check: () => commandExists("pnpm"),
+    install: {
+      macos: "brew install pnpm",
+      debian: "npm install -g pnpm",
+      fedora: "npm install -g pnpm",
+      arch: "npm install -g pnpm",
+      windows: "npm install -g pnpm",
+    },
+  },
+  python: {
+    name: "Python 3.11+",
+    check: () => commandExists("python3.11") || commandExists("python3"),
+    install: {
+      macos: "brew install python@3.11",
+      debian: "sudo apt install -y python3.11 python3.11-venv",
+      fedora: "sudo dnf install -y python3.11",
+      arch: "sudo pacman -S --noconfirm python",
+      windows: "winget install Python.Python.3.11",
+    },
+  },
+  uv: {
+    name: "uv (Python package manager)",
+    check: () => commandExists("uv"),
+    install: {
+      macos: "curl -LsSf https://astral.sh/uv/install.sh | sh",
+      debian: "curl -LsSf https://astral.sh/uv/install.sh | sh",
+      fedora: "curl -LsSf https://astral.sh/uv/install.sh | sh",
+      arch: "curl -LsSf https://astral.sh/uv/install.sh | sh",
+      windows: 'powershell -c "irm https://astral.sh/uv/install.ps1 | iex"',
+    },
+  },
+  "browser-use": {
+    name: "browser-use (Browser automation)",
+    check: () => commandExists("browser-use"),
+    install: {
+      macos: "uv tool install browser-use && uvx browser-use install",
+      debian: "uv tool install browser-use && uvx browser-use install",
+      fedora: "uv tool install browser-use && uvx browser-use install",
+      arch: "uv tool install browser-use && uvx browser-use install",
+      windows: "uv tool install browser-use && uvx browser-use install",
+    },
+  },
+};
+
+async function installTools(platform, prompt) {
+  log.title("Checking Required Tools");
+
+  const missing = [];
+
+  for (const [key, tool] of Object.entries(TOOLS)) {
+    if (tool.check()) {
+      log.success(`${tool.name} is installed`);
+    } else {
+      log.warn(`${tool.name} is not installed`);
+      missing.push(key);
+    }
+  }
+
+  if (missing.length === 0) {
+    return true;
+  }
+
+  const install = await prompt.confirm(
+    `\nInstall missing tools (${missing.join(", ")})?`,
+  );
+
+  if (!install) {
+    log.warn("Skipping tool installation. Some features may not work.");
+    return false;
+  }
+
+  for (const key of missing) {
+    const tool = TOOLS[key];
+    const cmd = tool.install[platform.os];
+
+    if (!cmd) {
+      log.error(`No install command for ${tool.name} on ${platform.os}`);
+      continue;
+    }
+
+    log.step(`Installing ${tool.name}...`);
+    try {
+      exec(cmd);
+      log.success(`${tool.name} installed`);
+    } catch (error) {
+      log.error(`Failed to install ${tool.name}: ${error.message}`);
+    }
+  }
+
+  return true;
+}
+
+// ============================================================================
+// Skills Installation
+// ============================================================================
+const SKILL_SOURCES = [
+  // Official Anthropic skills
+  { repo: "anthropics/anthropic-skills", skills: ["frontend-design"] },
+  // Browser automation
+  { repo: "browser-use/browser-use", skills: ["browser-use"] },
+  // TDD workflow
+  { repo: "obra/superpowers", skills: ["test-driven-development"] },
+  // Supabase Postgres
+  { repo: "supabase/agent-skills", skills: ["supabase-postgres-best-practices"] },
+];
+
+async function installSkills(prompt, agentChoice) {
+  // Skills installation only applies to Claude Code
+  // Codex uses the bundled skills from .codex/skills/
+  // Cursor uses MDC rules bundled in .cursor/rules/
+  if (agentChoice === "codex") {
+    log.info("Codex skills are bundled in .codex/skills/ directory");
+    return;
+  }
+
+  if (agentChoice === "cursor") {
+    log.info("Cursor rules are bundled in .cursor/rules/ directory");
+    return;
+  }
+
+  log.title("Installing Claude Code Skills");
+
+  const install = await prompt.confirm("Install recommended external skills?");
+
+  if (!install) {
+    log.warn("Skipping skill installation. Bundled skills in .claude/skills/ are ready to use.");
+    return;
+  }
+
+  for (const source of SKILL_SOURCES) {
+    for (const skill of source.skills) {
+      log.step(`Installing ${skill} from ${source.repo}...`);
+      try {
+        exec(`npx add-skill ${source.repo} ${skill}`, {
+          silent: true,
+          ignoreError: true,
+        });
+        log.success(`Installed ${skill}`);
+      } catch {
+        log.warn(`Could not install ${skill} (may require manual setup)`);
+      }
+    }
+  }
+}
+
+// ============================================================================
+// Template Files
+// ============================================================================
+function copyTemplates(targetDir, agentChoice) {
+  log.title("Setting Up Workspace");
+
+  const shouldCopyClaude = agentChoice === "claude" || agentChoice === "all";
+  const shouldCopyCodex = agentChoice === "codex" || agentChoice === "all";
+  const shouldCopyCursor = agentChoice === "cursor" || agentChoice === "all";
+
+  // Copy Claude Code templates
+  if (shouldCopyClaude) {
+    const claudeDir = join(targetDir, ".claude");
+    if (!existsSync(claudeDir)) {
+      mkdirSync(claudeDir, { recursive: true });
+    }
+    cpSync(join(TEMPLATES_DIR, ".claude"), claudeDir, { recursive: true });
+    log.step("Created .claude/ directory with settings, commands, skills, and agents");
+
+    // Copy CLAUDE.md
+    cpSync(
+      join(TEMPLATES_DIR, "CLAUDE.md"),
+      join(targetDir, "CLAUDE.md"),
+    );
+    log.step("Created CLAUDE.md");
+
+    // Copy .mcp.json (Claude Code MCP config)
+    cpSync(
+      join(TEMPLATES_DIR, ".mcp.json"),
+      join(targetDir, ".mcp.json"),
+    );
+    log.step("Created .mcp.json");
+  }
+
+  // Copy Codex templates
+  if (shouldCopyCodex) {
+    const codexDir = join(targetDir, ".codex");
+    if (!existsSync(codexDir)) {
+      mkdirSync(codexDir, { recursive: true });
+    }
+    cpSync(join(TEMPLATES_DIR, ".codex"), codexDir, { recursive: true });
+    log.step("Created .codex/ directory with config and skills");
+
+    // Copy AGENTS.md
+    cpSync(
+      join(TEMPLATES_DIR, "AGENTS.md"),
+      join(targetDir, "AGENTS.md"),
+    );
+    log.step("Created AGENTS.md");
+  }
+
+  // Copy Cursor templates
+  if (shouldCopyCursor) {
+    const cursorDir = join(targetDir, ".cursor");
+    if (!existsSync(cursorDir)) {
+      mkdirSync(cursorDir, { recursive: true });
+    }
+    cpSync(join(TEMPLATES_DIR, ".cursor"), cursorDir, { recursive: true });
+    log.step("Created .cursor/ directory with rules, commands, and hooks");
+
+    // Copy .cursorignore
+    if (existsSync(join(TEMPLATES_DIR, ".cursorignore.template"))) {
+      cpSync(
+        join(TEMPLATES_DIR, ".cursorignore.template"),
+        join(targetDir, ".cursorignore"),
+      );
+      log.step("Created .cursorignore");
+    }
+
+    // Cursor reads CLAUDE.md natively - copy if not already present
+    const claudeMdPath = join(targetDir, "CLAUDE.md");
+    if (!existsSync(claudeMdPath) && !shouldCopyClaude) {
+      cpSync(
+        join(TEMPLATES_DIR, "CLAUDE.md"),
+        claudeMdPath,
+      );
+      log.step("Created CLAUDE.md (Cursor reads this natively)");
+    }
+
+    // Copy AGENTS.md if not already present (Cursor reads this too)
+    const agentsMdPath = join(targetDir, "AGENTS.md");
+    if (!existsSync(agentsMdPath) && !shouldCopyCodex) {
+      cpSync(
+        join(TEMPLATES_DIR, "AGENTS.md"),
+        agentsMdPath,
+      );
+      log.step("Created AGENTS.md (Cursor reads this natively)");
+    }
+  }
+
+  // Copy shared templates (.gitignore)
+  if (existsSync(join(TEMPLATES_DIR, ".gitignore.template"))) {
+    const gitignorePath = join(targetDir, ".gitignore");
+    const gitignoreContent = existsSync(gitignorePath)
+      ? readFileSync(gitignorePath, "utf8")
+      : "";
+
+    const templateContent = readFileSync(
+      join(TEMPLATES_DIR, ".gitignore.template"),
+      "utf8",
+    );
+
+    // Add new entries that don't already exist
+    const additions = templateContent
+      .split("\n")
+      .filter((line) => line.trim() && !gitignoreContent.includes(line.trim()));
+
+    if (additions.length > 0) {
+      writeFileSync(
+        gitignorePath,
+        gitignoreContent + (gitignoreContent.endsWith("\n") ? "" : "\n") + additions.join("\n") + "\n",
+      );
+      log.step("Updated .gitignore");
+    }
+  }
+
+  log.success("Workspace templates copied");
+}
+
+// ============================================================================
+// Main CLI
+// ============================================================================
+function parseArgs(argv) {
+  const args = { flags: {}, positional: [] };
+  for (const arg of argv) {
+    if (arg === "--yes" || arg === "-y") {
+      args.flags.yes = true;
+    } else if (arg.startsWith("--agent=")) {
+      const agent = arg.split("=")[1];
+      if (["claude", "codex", "cursor", "all"].includes(agent)) {
+        args.flags.agent = agent;
+      } else {
+        log.warn(`Unknown agent "${agent}". Valid options: claude, codex, cursor, all`);
+      }
+    } else if (arg === "--help" || arg === "-h") {
+      args.flags.help = true;
+    } else if (arg.startsWith("-")) {
+      // ignore unknown flags
+    } else {
+      args.positional.push(arg);
+    }
+  }
+  return args;
+}
+
+function showHelp() {
+  console.log(`
+${colors.bold}Usage:${colors.reset}
+  npx @acmeacmeio/setup-sh [directory] [options]
+
+${colors.bold}Options:${colors.reset}
+  --agent=<agent>  Select AI coding agent (claude, codex, cursor, all)
+  -y, --yes        Auto-confirm all prompts
+  -h, --help       Show this help message
+
+${colors.bold}Examples:${colors.reset}
+  npx @acmeacmeio/setup-sh                    # Current directory, interactive
+  npx @acmeacmeio/setup-sh my-project         # New directory, interactive
+  npx @acmeacmeio/setup-sh . --agent=claude   # Claude Code only
+  npx @acmeacmeio/setup-sh . --agent=codex    # Codex only
+  npx @acmeacmeio/setup-sh . --agent=cursor   # Cursor IDE only
+  npx @acmeacmeio/setup-sh . --agent=all      # All agents
+`);
+}
+
+async function main() {
+  const { flags, positional } = parseArgs(process.argv.slice(2));
+
+  if (flags.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  const autoYes = flags.yes;
+  const targetDir = positional[0]
+    ? isAbsolute(positional[0])
+      ? positional[0]
+      : resolve(process.cwd(), positional[0])
+    : process.cwd();
+
+  console.log(`
+${colors.bold}${colors.magenta}
+███████╗███████╗████████╗██╗   ██╗██████╗        ███████╗██╗  ██╗
+██╔════╝██╔════╝╚══██╔══╝██║   ██║██╔══██╗       ██╔════╝██║  ██║
+███████╗█████╗     ██║   ██║   ██║██████╔╝ █████╗███████╗███████║
+╚════██║██╔══╝     ██║   ██║   ██║██╔═══╝  ╚════╝╚════██║██╔══██║
+███████║███████╗   ██║   ╚██████╔╝██║            ███████║██║  ██║
+╚══════╝╚══════╝   ╚═╝    ╚═════╝ ╚═╝            ╚══════╝╚═╝  ╚═╝
+${colors.reset}
+${colors.dim}Multi-Agent Workspace Initializer${colors.reset}
+`);
+
+  // Ensure target directory exists
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  const platform = detectPlatform();
+  log.info(`Detected platform: ${platform.os} (${platform.pm})`);
+  log.info(`Target directory: ${targetDir}`);
+
+  const prompt = createPrompt(autoYes);
+
+  try {
+    // Step 0: Select AI coding agent
+    let agentChoice = flags.agent;
+    if (!agentChoice) {
+      agentChoice = await prompt.select(
+        "Which AI coding agent are you using?",
+        [
+          { value: "claude", label: "Claude Code (Anthropic)", default: true },
+          { value: "codex", label: "Codex (OpenAI)" },
+          { value: "cursor", label: "Cursor IDE" },
+          { value: "all", label: "All agents (generate all configs)" },
+        ],
+      );
+    }
+    log.info(`Selected agent: ${agentChoice}`);
+
+    // Step 1: Install system tools
+    await installTools(platform, prompt);
+
+    // Step 2: Copy/create workspace files based on agent selection
+    copyTemplates(targetDir, agentChoice);
+
+    // Step 3: Install external skills (Claude Code only)
+    await installSkills(prompt, agentChoice);
+
+    // Done! Show appropriate next steps based on agent choice
+    const nextSteps = getNextSteps(agentChoice);
+    console.log(`
+${colors.green}${colors.bold}
+Workspace is ready!${colors.reset}
+
+${colors.cyan}Next steps:${colors.reset}
+${nextSteps}
+
+${colors.dim}Tips:${colors.reset}
+${getTips(agentChoice)}
+`);
+  } catch (error) {
+    log.error(`Setup failed: ${error.message}`);
+    process.exit(1);
+  } finally {
+    prompt.close();
+  }
+}
+
+function getNextSteps(agentChoice) {
+  const claudeSteps = `  - Review and customize ${colors.bold}CLAUDE.md${colors.reset} for your project
+  - Run ${colors.bold}claude${colors.reset} to start coding with AI assistance`;
+
+  const codexSteps = `  - Review and customize ${colors.bold}AGENTS.md${colors.reset} for your project
+  - Run ${colors.bold}codex${colors.reset} to start coding with AI assistance`;
+
+  const cursorSteps = `  - Review and customize ${colors.bold}CLAUDE.md${colors.reset} for your project (Cursor reads this)
+  - Add custom rules in ${colors.bold}.cursor/rules/${colors.reset}
+  - Open the project in Cursor IDE`;
+
+  if (agentChoice === "claude") return claudeSteps;
+  if (agentChoice === "codex") return codexSteps;
+  if (agentChoice === "cursor") return cursorSteps;
+  return claudeSteps + "\n" + codexSteps + "\n" + cursorSteps;
+}
+
+function getTips(agentChoice) {
+  const claudeTips = `  - Create ${colors.bold}CLAUDE.local.md${colors.reset} for personal preferences (gitignored)
+  - Edit ${colors.bold}.claude/settings.local.json${colors.reset} for local overrides`;
+
+  const codexTips = `  - Create ${colors.bold}AGENTS.local.md${colors.reset} for personal preferences (gitignored)
+  - Edit ${colors.bold}.codex/config.local.toml${colors.reset} for local overrides`;
+
+  const cursorTips = `  - Add ${colors.bold}alwaysApply: true${colors.reset} to rules that should always be active
+  - Use ${colors.bold}globs${colors.reset} in rules for file-specific context`;
+
+  const sharedTips = `  - Run ${colors.bold}gh auth login${colors.reset} if GitHub CLI needs authentication`;
+
+  if (agentChoice === "claude") return claudeTips + "\n" + sharedTips;
+  if (agentChoice === "codex") return codexTips + "\n" + sharedTips;
+  if (agentChoice === "cursor") return cursorTips + "\n" + sharedTips;
+  return claudeTips + "\n" + codexTips + "\n" + cursorTips + "\n" + sharedTips;
+}
+
+main();

package/templates/.claude/agents/code-simplifier.md

@@ -0,0 +1,52 @@
+---
+name: code-simplifier
+description: Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code unless instructed otherwise.
+model: opus
+---
+
+You are an expert code simplification specialist focused on enhancing code clarity, consistency, and maintainability while preserving exact functionality. Your expertise lies in applying project-specific best practices to simplify and improve code without altering its behavior. You prioritize readable, explicit code over overly compact solutions. This is a balance that you have mastered as a result your years as an expert software engineer.
+
+You will analyze recently modified code and apply refinements that:
+
+1. **Preserve Functionality**: Never change what the code does - only how it does it. All original features, outputs, and behaviors must remain intact.
+
+2. **Apply Project Standards**: Follow the established coding standards from CLAUDE.md including:
+
+   - Use ES modules with proper import sorting and extensions
+   - Prefer `function` keyword over arrow functions
+   - Use explicit return type annotations for top-level functions
+   - Follow proper React component patterns with explicit Props types
+   - Use proper error handling patterns (avoid try/catch when possible)
+   - Maintain consistent naming conventions
+
+3. **Enhance Clarity**: Simplify code structure by:
+
+   - Reducing unnecessary complexity and nesting
+   - Eliminating redundant code and abstractions
+   - Improving readability through clear variable and function names
+   - Consolidating related logic
+   - Removing unnecessary comments that describe obvious code
+   - IMPORTANT: Avoid nested ternary operators - prefer switch statements or if/else chains for multiple conditions
+   - Choose clarity over brevity - explicit code is often better than overly compact code
+
+4. **Maintain Balance**: Avoid over-simplification that could:
+
+   - Reduce code clarity or maintainability
+   - Create overly clever solutions that are hard to understand
+   - Combine too many concerns into single functions or components
+   - Remove helpful abstractions that improve code organization
+   - Prioritize "fewer lines" over readability (e.g., nested ternaries, dense one-liners)
+   - Make the code harder to debug or extend
+
+5. **Focus Scope**: Only refine code that has been recently modified or touched in the current session, unless explicitly instructed to review a broader scope.
+
+Your refinement process:
+
+1. Identify the recently modified code sections
+2. Analyze for opportunities to improve elegance and consistency
+3. Apply project-specific best practices and coding standards
+4. Ensure all functionality remains unchanged
+5. Verify the refined code is simpler and more maintainable
+6. Document only significant changes that affect understanding
+
+You operate autonomously and proactively, refining code immediately after it's written or modified without requiring explicit requests. Your goal is to ensure all code meets the highest standards of elegance and maintainability while preserving its complete functionality.