claudeforge-cli 1.0.5 → 1.0.7

package/README.md

@@ -61,6 +61,7 @@ node --version   # should print v18 or higher
   - [github](#github--cicd--devcontainer)
   - [status](#status--show-whats-configured)
   - [upgrade](#upgrade--update-built-in-templates)
+- [clear](#clear--remove-all-claudeforge-files)
 - [Slash Commands (in IDE chat)](#slash-commands-in-ide-chat)
 - [What Gets Scaffolded](#what-gets-scaffolded)
 - [How It Works](#how-it-works)
@@ -337,6 +338,29 @@ By default, only **infrastructure files** are updated (hook scripts, rules, buil
 
 ---
 
+### `clear` — Remove all claudeforge files
+
+```bash
+claudeforge clear             # interactive confirmation
+claudeforge clear --dry-run   # preview what would be deleted
+claudeforge clear --force     # skip confirmation prompt
+```
+
+Wipes everything claudeforge created so you can start fresh:
+
+| Removed | Kept |
+|---------|------|
+| `.claude/` (agents, commands, hooks, rules, skills) | Your source code |
+| `memory/` | Git history |
+| `CLAUDE.md`, `CLAUDE.local.md` | `.github/` CI/CD files |
+| `.mcp.json`, `SETUP_CONTEXT.md` | All other project files |
+
+Requires typing `yes` to confirm unless `--force` is passed.
+
+After clearing, run `claudeforge init` to scaffold fresh or `claudeforge create` to start over with the wizard.
+
+---
+
 ## Slash Commands (in IDE chat)
 
 Run these in the Claude Code chat window in VS Code, JetBrains, or any Claude Code IDE. Works with any Claude model — no separate API key.

package/bin/cli.js

@@ -10,6 +10,7 @@ const statusCommand = require('../src/commands/status');
 const upgradeCommand = require('../src/commands/upgrade');
 const createCommand = require('../src/commands/create');
 const githubCommand = require('../src/commands/github');
+const clearCommand = require('../src/commands/clear');
 
 program
   .name('claudeforge')
@@ -152,4 +153,28 @@ Examples:
   `)
   .action(githubCommand);
 
+// ── clear ─────────────────────────────────────────────────────────────────────
+program
+  .command('clear')
+  .description('Remove all claudeforge-generated files and start fresh (.claude/, memory/, CLAUDE.md, etc.)')
+  .option('-d, --dir <path>', 'Target directory (defaults to current directory)')
+  .option('-n, --dry-run',    'Preview what would be deleted without removing anything')
+  .option('-f, --force',      'Skip confirmation prompt')
+  .addHelpText('after', `
+Removes everything claudeforge created:
+  .claude/        — settings, agents, commands, hooks, rules, skills
+  memory/         — all memory files
+  CLAUDE.md       — project context file
+  CLAUDE.local.md — personal context file
+  .mcp.json       — MCP server config
+
+Your source code, git history, and other project files are never touched.
+
+Examples:
+  $ claudeforge clear             # interactive confirmation
+  $ claudeforge clear --dry-run   # preview what would be deleted
+  $ claudeforge clear --force     # skip confirmation prompt
+  `)
+  .action(clearCommand);
+
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeforge-cli",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Forge production-ready AI agent projects — agents, slash commands, memory, CI/CD, and devcontainers in one command",
   "bin": {
     "claudeforge": "bin/cli.js"

package/src/commands/clear.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const path = require('path');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const readline = require('readline');
+
+// Everything claudeforge creates — safe to wipe
+const CLAUDEFORGE_PATHS = [
+  '.claude',
+  'memory',
+  'CLAUDE.md',
+  'CLAUDE.local.md',
+  '.mcp.json',
+  'SETUP_CONTEXT.md',
+  'SETUP_SUMMARY.md',
+];
+
+async function clear(options) {
+  const targetDir = path.resolve(options.dir || process.cwd());
+  const dryRun = options.dryRun || false;
+  const force = options.force || false;
+
+  console.log('');
+  console.log(chalk.bold.cyan('  claudeforge') + chalk.dim('  —  Clear Project Structure'));
+  console.log(chalk.dim('  ─────────────────────────────────────────'));
+  if (dryRun) console.log(chalk.bold.yellow('  [DRY RUN] No files will be deleted'));
+  console.log('');
+
+  // Check which paths actually exist
+  const existing = [];
+  for (const p of CLAUDEFORGE_PATHS) {
+    const abs = path.join(targetDir, p);
+    if (await fs.pathExists(abs)) existing.push(p);
+  }
+
+  if (existing.length === 0) {
+    console.log(chalk.dim('  Nothing to clear — no claudeforge files found.'));
+    console.log('');
+    return;
+  }
+
+  // Show what will be removed
+  console.log(chalk.bold('  The following will be permanently deleted:'));
+  console.log('');
+  for (const p of existing) {
+    const abs = path.join(targetDir, p);
+    const stat = await fs.stat(abs);
+    const label = stat.isDirectory() ? chalk.yellow(p + '/') : chalk.yellow(p);
+    console.log(`  ${chalk.red('✗')}  ${label}`);
+  }
+  console.log('');
+
+  if (dryRun) {
+    console.log(chalk.cyan(`  Dry run: ${existing.length} item(s) would be deleted.`));
+    console.log(chalk.dim('  Run without --dry-run to actually delete them.'));
+    console.log('');
+    return;
+  }
+
+  // Confirm unless --force
+  if (!force) {
+    const answer = await prompt(
+      chalk.red('  ⚠  This cannot be undone. Type ') +
+      chalk.bold.red('yes') +
+      chalk.red(' to confirm: ')
+    );
+    console.log('');
+    if (answer.trim().toLowerCase() !== 'yes') {
+      console.log(chalk.dim('  Aborted — nothing was deleted.'));
+      console.log('');
+      return;
+    }
+  }
+
+  // Delete
+  for (const p of existing) {
+    const abs = path.join(targetDir, p);
+    await fs.remove(abs);
+    console.log(`  ${chalk.red('✗')}  ${chalk.dim(p)}  ${chalk.red('deleted')}`);
+  }
+
+  console.log('');
+  console.log(chalk.dim('  ─────────────────────────────────────────'));
+  console.log(chalk.green(`  ✓ ${existing.length} item(s) removed.`));
+  console.log('');
+  console.log(chalk.bold('  Start fresh:'));
+  console.log('');
+  console.log(`  ${chalk.dim('›')} ${chalk.cyan('claudeforge init')}     ${chalk.dim('re-scaffold the full structure')}`);
+  console.log(`  ${chalk.dim('›')} ${chalk.cyan('claudeforge create')}   ${chalk.dim('start a new project from scratch with the wizard')}`);
+  console.log('');
+}
+
+function prompt(question) {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+module.exports = clear;

package/templates/claude/commands/analyze-project.md.tpl

@@ -1,6 +1,6 @@
 ---
 description: Analyze an existing codebase and auto-generate the full Claude Code setup — CLAUDE.md, skills, agents, commands, and memory — by reading actual code, patterns, and conventions already in the project. No description required.
-allowed-tools: Read, Write, Edit, MultiEdit, Bash(git log:*), Bash(git diff:*), Bash(ls:*), Bash(find:*), Bash(cat:*), Bash(wc:*)
+allowed-tools: Read, Write, Edit, MultiEdit, Bash(git log:*), Bash(git diff:*), Bash(ls:*), Bash(find:*), Bash(cat:*), Bash(wc:*), Bash(head:*), Bash(sort:*), Bash(uniq:*), Bash(xargs:*), Bash(test:*)
 ---
 
 ## Step 1 — Deep Codebase Scan
@@ -10,17 +10,21 @@ Do not ask the user for a description. Read the codebase directly to infer every
 ### 1a. Project identity
 
 !`ls -la`
-!`test -f package.json && cat package.json || test -f pyproject.toml && cat pyproject.toml || test -f go.mod && cat go.mod || test -f Cargo.toml && cat Cargo.toml || echo "(no manifest found)"`
-!`test -f README.md && head -60 README.md || echo "(no README)"`
+!`git log --oneline -20`
 
 ### 1b. Full dependency map
 
-!`test -f package.json && cat package.json || echo "(no package.json)"`
-!`test -f requirements.txt && cat requirements.txt || test -f pyproject.toml && cat pyproject.toml || echo "(no python deps)"`
-!`test -f go.mod && cat go.mod || echo "(no go.mod)"`
-!`test -f Cargo.toml && cat Cargo.toml || echo "(no Cargo.toml)"`
-!`test -f pom.xml && head -80 pom.xml || echo "(no pom.xml)"`
-!`test -f Gemfile && cat Gemfile || echo "(no Gemfile)"`
+Use the Read tool to attempt reading each of these files. Skip silently if a file doesn't exist — do not error:
+
+- `package.json`
+- `requirements.txt`
+- `pyproject.toml`
+- `go.mod`
+- `Cargo.toml`
+- `pom.xml`
+- `Gemfile`
+- `composer.json`
+- `README.md`
 
 ### 1c. Project structure
 
@@ -29,36 +33,32 @@ Do not ask the user for a description. Read the codebase directly to infer every
 
 ### 1d. Read actual source code — infer real patterns
 
-Read the most representative files in each layer of the project. For each category below, find and read 2–3 real files:
+Use the Read tool to open the most representative files in each layer. Try each location — skip if it doesn't exist:
 
-- **Entry points**: `main.py`, `index.ts`, `main.go`, `app.py`, `server.js`, etc.
-- **Route/controller layer**: files in `routes/`, `controllers/`, `handlers/`, `api/`, `pages/api/`
-- **Service/business logic layer**: files in `services/`, `lib/`, `internal/`, `core/`
-- **Data/database layer**: files in `models/`, `db/`, `prisma/`, `migrations/`, `schema/`
-- **UI components** (if frontend): files in `components/`, `pages/`, `views/`, `screens/`
-- **Tests**: files in `tests/`, `__tests__/`, `spec/`, `test/`
-- **Config**: `tsconfig.json`, `eslint.config.*`, `.prettierrc`, `pytest.ini`, `ruff.toml`, etc.
+- **Entry points**: `main.py`, `index.ts`, `main.go`, `app.py`, `server.js`, `app.js`
+- **Routes/controllers**: look inside `routes/`, `controllers/`, `handlers/`, `api/`, `pages/api/`
+- **Services/business logic**: look inside `services/`, `lib/`, `internal/`, `core/`
+- **Data/database**: look inside `models/`, `db/`, `prisma/schema.prisma`, `migrations/`
+- **UI components**: look inside `components/`, `pages/`, `views/`, `screens/`
+- **Tests**: look inside `tests/`, `__tests__/`, `spec/`, `test/`
+- **Config files**: `tsconfig.json`, `.eslintrc*`, `.prettierrc`, `pytest.ini`, `ruff.toml`
 
-Read enough code to answer:
-- What frameworks and libraries are actually used (not just listed in deps)?
+Read enough real code to answer:
+- What frameworks and libraries are actually used?
 - How are files structured and named?
-- What patterns repeat across files (error handling, auth checks, response format, logging)?
-- What conventions are enforced (naming, imports, exports)?
+- What patterns repeat across files (error handling, auth, response format, logging)?
 - How are tests written?
 
-### 1e. Git history — understand how the project evolved
-
-!`git log --oneline -20 || echo "(no git history)"`
-!`git log --pretty=format:"%s" -50 | sort | uniq -c | sort -rn | head -20 || echo "(no commits)"`
-
-What do the commit messages reveal about the team's workflow and focus areas?
+### 1e. CI/CD and infrastructure
 
-### 1f. Existing CI/CD and infrastructure
+Use the Read tool to attempt reading each — skip silently if missing:
 
-!`test -d .github/workflows && find .github/workflows -name "*.yml" | head -5 | xargs head -100 || echo "(no GitHub Actions)"`
-!`test -f Dockerfile && head -40 Dockerfile || echo "(no Dockerfile)"`
-!`test -f docker-compose.yml && cat docker-compose.yml || echo "(no docker-compose)"`
-!`test -f .env.example && cat .env.example || test -f .env.sample && cat .env.sample || echo "(no .env.example)"`
+- `.github/workflows/` — use find to list yml files then read them
+- `Dockerfile`
+- `docker-compose.yml`
+- `.env.example`
+- `.env.sample`
+- `Makefile`
 
 ---