claudeforge-cli 1.0.0

package/src/commands/add.js

@@ -0,0 +1,205 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const logger = require('../logger');
+
+const TEMPLATES_DIR = path.join(__dirname, '../../templates');
+
+async function addAgent(name, options) {
+  const targetDir = path.resolve(options.dir || process.cwd());
+
+  if (!name || !name.trim()) {
+    logger.error('Please provide an agent name.');
+    console.log(chalk.dim('  Example: claudeforge add agent api-reviewer'));
+    process.exit(1);
+  }
+
+  const slug = toKebab(name);
+  const destPath = path.join(targetDir, '.claude/agents', `${slug}.md`);
+
+  await assertNotExists(destPath, options.force);
+
+  const description = options.description || `Use this agent to [describe when Claude should invoke ${slug}].`;
+  const model = options.model || 'sonnet';
+  const color = options.color || 'blue';
+
+  const content = `---
+name: ${slug}
+description: ${description}
+model: ${model}
+color: ${color}
+---
+
+# ${toTitle(name)} Agent
+
+<!-- Replace this with the agent's system prompt. Be specific about:
+  - What the agent specializes in
+  - What inputs it expects from the caller
+  - What output format it produces
+  - Any rules or constraints it follows
+-->
+
+You are a specialized agent for [task].
+
+## Instructions
+
+1. [Step 1]
+2. [Step 2]
+
+## Output Format
+
+[Describe the expected output]
+`;
+
+  await fs.ensureFile(destPath);
+  await fs.writeFile(destPath, content, 'utf8');
+
+  console.log('');
+  console.log(`  ${chalk.green('✓')} Created ${chalk.cyan(`.claude/agents/${slug}.md`)}`);
+  logger.hints('What to do next:', [
+    { cmd: `open .claude/agents/${slug}.md`,           note: 'edit the system prompt — be specific about what it reviews' },
+    { cmd: `/review-pr`,                               note: 'test the agent by having it review your current branch' },
+    { cmd: `claudeforge status`,                   note: 'confirm the agent appears in your project' },
+  ]);
+}
+
+async function addCommand(name, options) {
+  const targetDir = path.resolve(options.dir || process.cwd());
+
+  if (!name || !name.trim()) {
+    logger.error('Please provide a command name.');
+    console.log(chalk.dim('  Example: claudeforge add command deploy'));
+    process.exit(1);
+  }
+
+  const slug = toKebab(name);
+  const destPath = path.join(targetDir, '.claude/commands', `${slug}.md`);
+
+  await assertNotExists(destPath, options.force);
+
+  const description = options.description || `[Describe what /${slug} does]`;
+
+  const content = `---
+description: ${description}
+allowed-tools: Bash, Read, Edit
+---
+
+## Context
+
+<!-- Add dynamic context using !command syntax if needed -->
+<!-- Example: - Git status: !\`git status\` -->
+
+## Task
+
+<!-- Describe what Claude should do when this command is invoked. -->
+<!-- Be specific: what to read first, what to check, what to produce. -->
+
+[Instructions for Claude when /${slug} is invoked]
+
+## Rules
+
+- [Rule 1]
+- [Rule 2]
+`;
+
+  await fs.ensureFile(destPath);
+  await fs.writeFile(destPath, content, 'utf8');
+
+  console.log('');
+  console.log(`  ${chalk.green('✓')} Created ${chalk.cyan(`.claude/commands/${slug}.md`)}`);
+  logger.hints('What to do next:', [
+    { cmd: `open .claude/commands/${slug}.md`,         note: 'edit the ## Task section — add real instructions' },
+    { cmd: `/${slug}`,                                 note: 'run in Claude Code chat to test it' },
+    { cmd: `claudeforge add command <name>`,       note: 'add another command for your workflow' },
+  ]);
+}
+
+async function addSkill(name, options) {
+  const targetDir = path.resolve(options.dir || process.cwd());
+
+  if (!name || !name.trim()) {
+    logger.error('Please provide a skill name.');
+    console.log(chalk.dim('  Example: claudeforge add skill database-patterns'));
+    process.exit(1);
+  }
+
+  const slug = toKebab(name);
+  const skillDir = path.join(targetDir, '.claude/skills', slug);
+  const destPath = path.join(skillDir, 'SKILL.md');
+
+  await assertNotExists(destPath, options.force);
+
+  const description = options.description || `Apply ${toTitle(name)} patterns and conventions. Invoke when [specific trigger condition].`;
+  const userInvocable = options.userInvocable !== false;
+
+  const content = `---
+name: ${slug}
+description: ${description}
+user-invocable: ${userInvocable}
+---
+
+# ${toTitle(name)} Skill
+
+<!-- Define what Claude should know and do when this skill is active. -->
+<!-- Be specific: which files to read, patterns to follow, rules to apply. -->
+
+## When to Apply
+
+[Describe the exact conditions under which this skill should be active]
+
+## Instructions
+
+1. Read [relevant files or context first]
+2. Apply [specific patterns or conventions]
+3. [Additional steps]
+
+## Rules
+
+- [Rule 1 — specific to this skill]
+- [Rule 2]
+
+## Do Not
+
+- [Common mistake to avoid]
+`;
+
+  await fs.ensureDir(skillDir);
+  await fs.writeFile(destPath, content, 'utf8');
+
+  console.log('');
+  console.log(`  ${chalk.green('✓')} Created ${chalk.cyan(`.claude/skills/${slug}/SKILL.md`)}`);
+  logger.hints('What to do next:', [
+    { cmd: `open .claude/skills/${slug}/SKILL.md`,     note: 'fill in the Instructions section with specific conventions' },
+    { cmd: `claudeforge status`,                   note: 'verify the skill appears in your project summary' },
+    { cmd: `/project-health`,                          note: 'run in Claude Code chat to audit your full setup' },
+  ]);
+}
+
+// ── Shared helpers ────────────────────────────────────────────────────────────
+
+async function assertNotExists(filePath, force) {
+  if (!force && await fs.pathExists(filePath)) {
+    logger.error(`File already exists: ${path.relative(process.cwd(), filePath)}`);
+    console.log(chalk.dim('  Use --force to overwrite.'));
+    process.exit(1);
+  }
+}
+
+function toKebab(str) {
+  return str
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_]+/g, '-')
+    .replace(/[^a-z0-9-]/g, '');
+}
+
+function toTitle(str) {
+  return str
+    .split(/[-_\s]+/)
+    .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(' ');
+}
+
+module.exports = { addAgent, addCommand, addSkill };

package/src/commands/create.js

@@ -0,0 +1,218 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const readline = require('readline');
+const initCommand = require('./init');
+const projectCommand = require('./project');
+const logger = require('../logger');
+
+// ── Readline helpers ──────────────────────────────────────────────────────────
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, answer => resolve(answer.trim())));
+}
+
+async function askDefault(rl, question, defaultVal) {
+  const answer = await ask(rl, question);
+  return answer || defaultVal;
+}
+
+async function askChoice(rl, question, choices, defaultIdx = 0) {
+  const labels = choices.map((c, i) => `${chalk.dim(`${i + 1}.`)} ${c.label}`).join('\n  ');
+  const answer = await ask(rl, `${question}\n\n  ${labels}\n\n  ${chalk.dim('Enter number')} [${defaultIdx + 1}]: `);
+  const idx = parseInt(answer, 10) - 1;
+  if (idx >= 0 && idx < choices.length) return choices[idx].value;
+  return choices[defaultIdx].value;
+}
+
+async function askMultiChoice(rl, question, choices) {
+  const labels = choices.map((c, i) => `${chalk.dim(`${i + 1}.`)} ${c.label}`).join('\n  ');
+  const answer = await ask(rl, `${question}\n\n  ${labels}\n\n  ${chalk.dim('Enter numbers separated by commas, or press Enter to skip')}: `);
+  if (!answer) return [];
+  const indices = answer.split(',').map(s => parseInt(s.trim(), 10) - 1).filter(i => i >= 0 && i < choices.length);
+  return indices.map(i => choices[i].value);
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+async function create(name, options) {
+  const parentDir = path.resolve(options.dir || process.cwd());
+
+  console.log('');
+  console.log(chalk.bold.cyan('  claudeforge') + chalk.dim('  —  Create New Project'));
+  console.log(chalk.dim('  ─────────────────────────────────────────'));
+  console.log('');
+  console.log(chalk.dim('  Answer a few questions and claudeforge will scaffold a fully configured'));
+  console.log(chalk.dim('  Claude Code project ready for AI-assisted development.'));
+  console.log('');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    // 1. Project name
+    const defaultName = name || 'my-project';
+    const projectName = await askDefault(rl, '  ' + chalk.bold('Project name') + ' ' + chalk.dim('[' + defaultName + ']') + ': ', defaultName);
+
+    // 2. Description
+    const description = await askDefault(
+      rl,
+      `\n  ${chalk.bold('Describe your project')} ${chalk.dim('(used to AI-configure everything)')}:\n  `,
+      `${projectName} — a new project`
+    );
+
+    // 3. Stack
+    const stack = await askChoice(rl, `\n  ${chalk.bold('Primary tech stack')}:`, [
+      { label: 'Node.js / TypeScript',     value: 'node' },
+      { label: 'Python (FastAPI / Django)', value: 'python' },
+      { label: 'Go',                        value: 'go' },
+      { label: 'Rust',                      value: 'rust' },
+      { label: 'Other / Mixed',             value: 'generic' },
+    ], 0);
+
+    // 4. Optional features
+    const features = await askMultiChoice(rl, `\n  ${chalk.bold('Optional features')} ${chalk.dim('(select all that apply)')}:`, [
+      { label: 'GitHub Actions CI/CD + PR templates',   value: 'github' },
+      { label: 'VS Code devcontainer',                  value: 'devcontainer' },
+      { label: 'Docker + docker-compose',               value: 'docker' },
+    ]);
+
+    rl.close();
+
+    // ── Scaffold ────────────────────────────────────────────────────────────
+    const targetDir = path.join(parentDir, projectName);
+    await fs.ensureDir(targetDir);
+
+    console.log('');
+    console.log(chalk.dim('  ─────────────────────────────────────────'));
+    console.log('');
+    console.log(`  ${chalk.green('✓')} Creating project at ${chalk.cyan(targetDir)}`);
+    console.log('');
+
+    // Run init
+    await initCommand({ dir: targetDir, force: false, dryRun: false });
+
+    // Run project
+    await projectCommand(description, { dir: targetDir });
+
+    // Optional: GitHub
+    if (features.includes('github')) {
+      const githubCommand = require('./github');
+      await githubCommand({ dir: targetDir, dryRun: false, stack, devcontainer: features.includes('devcontainer'), prTemplate: true, issueTemplates: true });
+    } else if (features.includes('devcontainer')) {
+      const githubCommand = require('./github');
+      await githubCommand({ dir: targetDir, dryRun: false, stack, devcontainer: true, prTemplate: false, issueTemplates: false });
+    }
+
+    // Optional: Docker stubs
+    if (features.includes('docker')) {
+      await writeDockerFiles(targetDir, stack, projectName);
+    }
+
+    // Final summary
+    console.log('');
+    console.log(chalk.dim('  ─────────────────────────────────────────'));
+    console.log('');
+    console.log(chalk.green.bold(`  ✓ Project "${projectName}" is ready!`));
+    console.log('');
+    console.log(chalk.bold('  What to do next:'));
+    console.log('');
+    console.log(`  ${chalk.dim('1.')} ${chalk.cyan(`cd ${projectName}`)}`);
+    console.log(`  ${chalk.dim('2.')} Open in VS Code / your IDE with Claude Code`);
+    console.log(`  ${chalk.dim('3.')} In the Claude Code chat, run:`);
+    console.log(`     ${chalk.cyan.bold(`/setup-project "${truncate(description, 50)}"`)}`);
+    console.log(`     ${chalk.dim('— Claude will fill in CLAUDE.md, agents, commands, and more')}`);
+    console.log(`  ${chalk.dim('4.')} Then run ${chalk.cyan('/scaffold-structure')} to create src/, tests/, etc.`);
+    console.log('');
+
+  } catch (err) {
+    if (!rl.closed) rl.close();
+    logger.error(err.message || String(err));
+    process.exit(1);
+  }
+}
+
+async function writeDockerFiles(targetDir, stack, projectName) {
+  const dockerfile = buildDockerfile(stack, projectName);
+  const compose = buildDockerCompose(stack, projectName);
+  await fs.writeFile(path.join(targetDir, 'Dockerfile'), dockerfile, 'utf8');
+  await fs.writeFile(path.join(targetDir, 'docker-compose.yml'), compose, 'utf8');
+  console.log(`  ${chalk.green('✓')} Written ${chalk.cyan('Dockerfile')}`);
+  console.log(`  ${chalk.green('✓')} Written ${chalk.cyan('docker-compose.yml')}`);
+}
+
+function buildDockerfile(stack, name) {
+  if (stack === 'node') {
+    return `FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --production
+COPY . .
+EXPOSE 3000
+CMD ["node", "src/index.js"]
+`;
+  }
+  if (stack === 'python') {
+    return `FROM python:3.12-slim
+WORKDIR /app
+COPY requirements*.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8000
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000"]
+`;
+  }
+  if (stack === 'go') {
+    return `FROM golang:1.22-alpine AS builder
+WORKDIR /app
+COPY go.* ./
+RUN go mod download
+COPY . .
+RUN go build -o /app/server ./cmd/server
+
+FROM alpine:3.19
+COPY --from=builder /app/server /server
+EXPOSE 8080
+CMD ["/server"]
+`;
+  }
+  if (stack === 'rust') {
+    return `FROM rust:1.77-slim AS builder
+WORKDIR /app
+COPY Cargo.* ./
+COPY src ./src
+RUN cargo build --release
+
+FROM debian:bookworm-slim
+COPY --from=builder /app/target/release/${name} /${name}
+EXPOSE 8080
+CMD ["/${name}"]
+`;
+  }
+  return `FROM ubuntu:22.04
+WORKDIR /app
+COPY . .
+`;
+}
+
+function buildDockerCompose(stack, name) {
+  const port = stack === 'node' ? '3000' : stack === 'python' ? '8000' : '8080';
+  return `services:
+  app:
+    build: .
+    ports:
+      - "${port}:${port}"
+    environment:
+      - NODE_ENV=development
+    volumes:
+      - .:/app
+      - /app/node_modules
+`;
+}
+
+function truncate(str, max) {
+  return str.length > max ? str.slice(0, max - 1) + '…' : str;
+}
+
+module.exports = create;