claude-code-scanner 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 adnan-prompts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,306 @@
+# Claude Code Scanner
+
+> Scan any codebase and generate a complete Claude Code environment — 12 role-based agents, 13 skills, 12 hooks, rules, templates, full SDLC workflow with execution analytics.
+
+## Prerequisites
+
+This tool requires **Node.js >= 18**. `npx` is included with Node.js/npm.
+
+### Check if Node.js is installed:
+```bash
+node --version  # Should be >= 18.x.x
+npm --version   # Should be >= 8.x.x
+```
+
+### Install Node.js if needed:
+
+**macOS (using Homebrew):**
+```bash
+brew install node
+```
+
+**Ubuntu/Debian:**
+```bash
+curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
+sudo apt-get install -y nodejs
+```
+
+**Windows (using Chocolatey):**
+```bash
+choco install nodejs
+```
+
+**Or download from [nodejs.org](https://nodejs.org/)**
+
+## Installation
+
+### Method 1: npx (Recommended)
+```bash
+cd /path/to/your-project
+npx claude-code-scanner init
+```
+
+### Method 2: One-line install (macOS/Linux)
+```bash
+cd /path/to/your-project
+curl -fsSL https://raw.githubusercontent.com/adnan-prompts/claude-code-scanner/main/install.sh | bash
+```
+
+### Method 2b: One-line install (Windows PowerShell)
+```powershell
+cd C:\path\to\your-project
+irm https://raw.githubusercontent.com/adnan-prompts/claude-code-scanner/main/install.ps1 | iex
+```
+
+### Method 3: Git clone
+```bash
+git clone https://github.com/adnan-prompts/claude-code-scanner.git /tmp/scanner
+cp /tmp/scanner/template/CLAUDE.md ./CLAUDE.md
+cp -r /tmp/scanner/template/.claude ./.claude
+rm -rf /tmp/scanner
+```
+
+### Method 4: Global install
+```bash
+npm install -g claude-code-scanner
+cd /path/to/your-project
+claude-code-scanner init
+```
+
+### Cross-Platform Support
+
+Works on **Windows**, **macOS**, and **Linux**. All hooks and scripts use Node.js (no bash/jq dependency). The only requirement is Node.js >= 18.
+
+## Usage
+
+After installing, 3 commands set up everything:
+
+```bash
+claude                      # Start Claude Code session
+/scan-codebase              # Scan your tech stack (2-5 min)
+/generate-environment       # Generate all Claude Code files
+```
+
+That's it. Your project now has a complete AI-powered development environment.
+
+## What It Creates
+
+```
+your-project/
+├── CLAUDE.md                     <- Project instructions (auto-loaded)
+├── .claude/
+│   ├── settings.json             <- Permissions + 10 hook events
+│   ├── settings.local.json       <- Your env vars (gitignored)
+│   ├── rules/                    <- Path-specific coding rules
+│   ├── agents/                   <- 12 role-based AI agents
+│   │   ├── team-lead.md          <- Orchestrator, assigns work, tech sign-off
+│   │   ├── architect.md          <- Architecture design & review
+│   │   ├── product-owner.md      <- Acceptance criteria, business sign-off
+│   │   ├── qa-lead.md            <- QA planning, QA sign-off
+│   │   ├── explorer.md           <- Codebase navigation & impact analysis
+│   │   ├── reviewer.md           <- Code review & conventions
+│   │   ├── security.md           <- Security & vulnerability review
+│   │   ├── debugger.md           <- Root cause analysis & bug fixing
+│   │   ├── tester.md             <- Test writing & coverage
+│   │   ├── frontend.md           <- UI component development
+│   │   ├── api-builder.md        <- API endpoint development
+│   │   └── infra.md              <- Docker, CI/CD, deployment
+│   ├── skills/                   <- 13 slash commands
+│   │   ├── workflow/             <- /workflow — Full 13-phase SDLC
+│   │   ├── scan-codebase/        <- /scan-codebase
+│   │   ├── generate-environment/ <- /generate-environment
+│   │   ├── task-tracker/         <- /task-tracker
+│   │   ├── progress-report/      <- /progress-report
+│   │   ├── metrics/              <- /metrics
+│   │   ├── impact-analysis/      <- /impact-analysis
+│   │   ├── execution-report/     <- /execution-report — Post-execution analytics
+│   │   ├── context-check/        <- /context-check — Context budget enforcement
+│   │   ├── rollback/             <- /rollback — Deploy/code/phase rollback
+│   │   ├── sync/                 <- /sync — Drift detection & repair
+│   │   ├── setup-smithery/       <- /setup-smithery
+│   │   └── validate-setup/       <- /validate-setup
+│   ├── hooks/                    <- 12 automation scripts (10 events)
+│   ├── profiles/                 <- Developer role profiles
+│   ├── templates/                <- Code scaffolding (extracted from real code)
+│   ├── docs/                     <- 9 reference documents
+│   ├── scripts/                  <- Verification scripts
+│   ├── tasks/                    <- Task tracking (gitignored)
+│   └── reports/                  <- Progress & execution reports (gitignored)
+```
+
+## Agent Team (Role-Based)
+
+### SDLC Role Agents
+| Agent | Role | Access | Model |
+|-------|------|--------|-------|
+| `@team-lead` | Orchestrator — assigns work, resolves blockers, tech sign-off | Read/Write | opus |
+| `@architect` | Architecture design & review | Read-only | opus |
+| `@product-owner` | Acceptance criteria, business sign-off | Read-only | opus |
+| `@qa-lead` | QA planning, QA sign-off, bug triage | Read-only | sonnet |
+
+### Core Agents
+| Agent | Role | Access | Model |
+|-------|------|--------|-------|
+| `@explorer` | Codebase investigation & impact mapping | Read-only | sonnet |
+| `@reviewer` | Code quality & convention review | Read-only | sonnet |
+| `@security` | Vulnerability & OWASP review | Read-only | opus |
+| `@debugger` | Root cause analysis & bug fixes | Read/Write | opus |
+| `@tester` | Automated test writing & coverage | Read/Write | sonnet |
+
+### Dev Agents
+| Agent | Role | Access | Model |
+|-------|------|--------|-------|
+| `@api-builder` | Backend endpoints & services | Read/Write + worktree | sonnet |
+| `@frontend` | UI components & pages | Read/Write + worktree | sonnet |
+| `@infra` | Docker, CI/CD, deployment | Read/Write | sonnet |
+
+All agents include: structured handoff protocol with execution metrics, explicit limitations, cross-session memory, and self-check for hallucinations and regressions.
+
+## Commands After Setup
+
+### Built-in Skills
+```bash
+/scan-codebase                             # Scan your tech stack
+/generate-environment                      # Generate all Claude Code files
+/validate-setup                            # Verify everything works
+/workflow new "add user notifications"     # Full 13-phase SDLC lifecycle
+/workflow new --hotfix "fix login crash"   # Fast-track hotfix
+/workflow new --spike "evaluate Redis"     # Research only
+/workflow status                           # Dashboard
+/task-tracker status                       # Task dashboard
+/progress-report dev TASK-001             # Developer report
+/progress-report business                 # Business stakeholder report
+/metrics all                              # Velocity, quality, cycle-time
+/impact-analysis "replace auth"           # Blast radius check
+/execution-report TASK-001               # Post-execution analytics
+/context-check                            # Verify context under 60% budget
+/rollback deploy TASK-001                # Rollback failed deployment
+/sync --check                            # Detect environment drift
+/sync --fix                              # Auto-repair stale files
+/setup-smithery                           # Install community skills
+```
+
+### Generated Skills (created by /generate-environment based on your stack)
+```bash
+/add-feature "password reset"     # Scaffold feature
+/add-endpoint "POST /api/orders"  # Create API endpoint
+/add-component "UserAvatar"       # Create UI component
+/fix-bug "cart total wrong"       # Systematic debugging
+/migrate "add user roles"         # Database migration
+/review-pr 123                    # Code review
+/qa-plan                          # Generate QA test plan
+/signoff qa TASK-001              # Request sign-off
+/deploy staging 456               # Deploy to staging
+```
+
+## Workflow (13 Phases)
+
+```
+Phase 1:  Task Intake — classify, branch, create task record
+Phase 2:  Impact Analysis — @explorer + @security parallel scan
+Phase 3:  Architecture Review — @architect designs (skip if small + LOW risk)
+Phase 4:  Business Analysis — @product-owner writes acceptance criteria
+Phase 5:  Development — @api-builder / @frontend / @infra (parallel worktrees)
+Phase 6:  Dev Self-Testing — @tester + @debugger loop (max 5 iterations)
+Phase 7:  Code Review — @reviewer + @security loop (max 3 iterations)
+Phase 8:  PR + CI — create PR, fix CI failures
+Phase 9:  QA Testing — @qa-lead plans, @tester executes, bug loop
+Phase 10: Sign-offs — QA -> Business -> Tech (with rejection routing)
+Phase 11: Deployment — @infra deploys, health check, rollback on failure
+Phase 12: Post-Deploy — monitor, close issues, notify stakeholders
+Phase 13: Execution Report — success score, hallucination check, regression audit
+```
+
+Mandatory `/context-check` between every phase transition to enforce 60% context budget.
+
+## Hook Events (10 registered)
+
+| Event | Hook | Purpose |
+|-------|------|---------|
+| SessionStart | session-start.js | Re-inject active task context |
+| PreToolUse | protect-files.js, validate-bash.js | Block dangerous operations |
+| PostToolUse | post-edit-format.js, track-file-changes.js | Auto-format, log changes |
+| PostToolUseFailure | tool-failure-tracker.js | Track tool errors for debugging |
+| PreCompact | pre-compact-save.js | Save loop state before compaction |
+| PostCompact | post-compact-recovery.js | Restore workflow state after compaction |
+| Notification | notify-approval.js | OS notification on permission prompt |
+| SubagentStop | track-file-changes.js | Record subagent file changes |
+| Stop | execution-report.js + prompt | Mandatory execution report |
+| StopFailure | stop-failure-handler.js | Preserve state on failures |
+
+## Execution Reports
+
+Every phase generates a scored report:
+- **Success Score (0-100)** — completeness + quality + efficiency
+- **Hallucination Check (0-3)** — verifies file refs, function names, conventions
+- **Regression Impact (0-3)** — test suite, coverage delta, lint/type/build
+- **Agent Communication** — handoff count, loop iterations, parallel executions
+- **Token/Context Usage** — estimated consumption, peak context %
+
+## Context Budget
+
+Everything is designed to keep working context under 60%:
+
+| What | Context Cost | When Loaded |
+|------|-------------|-------------|
+| CLAUDE.md + rules | ~332 tokens | Always (startup) |
+| Agent descriptions | ~371 tokens | Always (metadata only) |
+| Skill descriptions | ~250 tokens | Always (metadata only) |
+| Agent full bodies | 0 on parent | Subagent context (isolated) |
+| Forked skills (11/13) | 0 on parent | Fork context (isolated) |
+| Templates/profiles/docs | 0 | Never auto-loaded |
+| **Total startup** | **~1,500 tokens** | **~1.2% of 128K** |
+
+Runtime enforcement: `/context-check` between phases, PreCompact hook saves state, PostCompact hook restores it.
+
+## Keeping In Sync
+
+The environment tracks its own state via `.claude/manifest.json`. When the codebase changes (new dependencies, new directories, team role changes), drift is detected automatically:
+
+- **On session start:** `drift-detector.js` hook checks for stale agents, modified dependencies, orphan hooks
+- **On workflow start:** Phase 1 runs `/sync --check` before intake
+- **Manually:** `/sync --check` (report) or `/sync --fix` (auto-repair)
+- **Full reset:** `/sync --full-rescan` re-scans and regenerates everything
+
+## CLI Commands
+
+```bash
+npx claude-code-scanner init       # Initialize in current directory
+npx claude-code-scanner status     # Check setup status
+npx claude-code-scanner verify     # Run verification checks (170+ checks)
+npx claude-code-scanner update     # Update to latest version
+npx claude-code-scanner help       # Show help
+
+# Flags
+npx claude-code-scanner init --force         # Overwrite existing files
+npx claude-code-scanner init --no-smithery   # Skip Smithery instructions
+```
+
+## How It Works
+
+1. **`/scan-codebase`** spawns 6 parallel agents that read your actual code:
+   - Technology fingerprinter (100+ framework markers)
+   - Directory structure mapper
+   - Backend deep scanner (API routes, DB, auth, logging)
+   - Frontend deep scanner (components, state, styling, routing)
+   - Architecture mapper (data flow, dependencies, security)
+   - Domain & convention extractor (naming, patterns, gotchas)
+
+2. **`/generate-environment`** uses scan results to create project-specific:
+   - CLAUDE.md with your exact commands, paths, and conventions
+   - Rules that enforce YOUR codebase patterns
+   - 12 agents configured for YOUR tech stack
+   - Skills with YOUR project's commands and file paths
+   - Templates extracted from YOUR existing code
+   - Profiles for backend, frontend, and devops roles
+
+3. **`/workflow`** orchestrates the full 13-phase SDLC with your agent team:
+   - Structured handoff protocol between every agent transition
+   - Loop limits with circuit breakers (dev-test 5x, review 3x, QA 3x)
+   - Rejection routing from sign-off gates back to correct phase
+   - Mandatory execution report with scoring after every phase
+   - Context budget enforcement between every phase transition
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Check prerequisites
+function checkPrerequisites() {
+  const { execSync } = require('child_process');
+
+  try {
+    // Check Node.js version
+    const nodeVersion = execSync('node --version', { encoding: 'utf-8' }).trim();
+    const nodeMajor = parseInt(nodeVersion.replace('v', '').split('.')[0]);
+    if (nodeMajor < 18) {
+      error(`Node.js ${nodeVersion} detected. This tool requires Node.js >= 18.`);
+      error('Please upgrade Node.js: https://nodejs.org/');
+      process.exit(1);
+    }
+  } catch (e) {
+    error('Node.js not found. Please install Node.js >= 18: https://nodejs.org/');
+    process.exit(1);
+  }
+
+  try {
+    // Check npm version (which includes npx)
+    const npmVersion = execSync('npm --version', { encoding: 'utf-8' }).trim();
+    const npmMajor = parseInt(npmVersion.split('.')[0]);
+    if (npmMajor < 8) {
+      error(`npm ${npmVersion} detected. This tool requires npm >= 8.`);
+      error('Please upgrade npm: npm install -g npm');
+      process.exit(1);
+    }
+  } catch (e) {
+    error('npm not found. Please install npm (comes with Node.js): https://nodejs.org/');
+    process.exit(1);
+  }
+}
+
+// Run prerequisite check
+checkPrerequisites();
+
+const COMMANDS = {
+  init: 'Initialize Claude Code environment in current directory',
+  status: 'Check if Claude Code environment is set up',
+  verify: 'Run verification checks on existing setup',
+  update: 'Update scanner skills/agents to latest version',
+  help: 'Show this help message',
+};
+
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+const flags = args.slice(1);
+
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+
+function log(msg) { console.log(msg); }
+function success(msg) { log(`${GREEN}✓${RESET} ${msg}`); }
+function warn(msg) { log(`${YELLOW}!${RESET} ${msg}`); }
+function error(msg) { log(`${RED}✗${RESET} ${msg}`); }
+function header(msg) { log(`\n${BOLD}${CYAN}${msg}${RESET}`); }
+
+function copyDir(src, dest, overwrite = false) {
+  if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  let copied = 0;
+  let skipped = 0;
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      const result = copyDir(srcPath, destPath, overwrite);
+      copied += result.copied;
+      skipped += result.skipped;
+    } else {
+      if (fs.existsSync(destPath) && !overwrite) {
+        skipped++;
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+        copied++;
+      }
+    }
+  }
+  return { copied, skipped };
+}
+
+function init() {
+  const cwd = process.cwd();
+  const templateDir = path.join(__dirname, '..', 'template');
+  const force = flags.includes('--force') || flags.includes('-f');
+  const skipSmithery = flags.includes('--no-smithery');
+
+  header('Claude Code Scanner — Environment Setup');
+  log(`Target: ${cwd}\n`);
+
+  // Check if already initialized
+  if (fs.existsSync(path.join(cwd, 'CLAUDE.md')) && !force) {
+    warn('CLAUDE.md already exists. Use --force to overwrite.');
+    log('  Or run: npx claude-code-scanner update');
+    process.exit(1);
+  }
+
+  // Copy CLAUDE.md to root
+  log('Installing files...\n');
+
+  const claudeMdSrc = path.join(templateDir, 'CLAUDE.md');
+  const claudeMdDest = path.join(cwd, 'CLAUDE.md');
+  fs.copyFileSync(claudeMdSrc, claudeMdDest);
+  success('CLAUDE.md');
+
+  // Copy .claude/ directory structure
+  const dirs = ['rules', 'agents', 'skills', 'hooks', 'scripts', 'docs', 'templates', 'profiles'];
+  for (const dir of dirs) {
+    const src = path.join(templateDir, '.claude', dir);
+    const dest = path.join(cwd, '.claude', dir);
+    if (fs.existsSync(src)) {
+      const result = copyDir(src, dest, force);
+      success(`.claude/${dir}/ (${result.copied} files${result.skipped ? `, ${result.skipped} skipped` : ''})`);
+    }
+  }
+
+  // Copy settings files
+  const settingsSrc = path.join(templateDir, '.claude', 'settings.json');
+  const settingsDest = path.join(cwd, '.claude', 'settings.json');
+  if (fs.existsSync(settingsSrc) && (!fs.existsSync(settingsDest) || force)) {
+    fs.copyFileSync(settingsSrc, settingsDest);
+    success('.claude/settings.json');
+  }
+
+  const localSettingsDest = path.join(cwd, '.claude', 'settings.local.json');
+  if (!fs.existsSync(localSettingsDest)) {
+    fs.writeFileSync(localSettingsDest, JSON.stringify({ env: {} }, null, 2));
+    success('.claude/settings.local.json (template)');
+  }
+
+  // Copy manifest.json for drift detection
+  const manifestSrc = path.join(templateDir, '.claude', 'manifest.json');
+  const manifestDest = path.join(cwd, '.claude', 'manifest.json');
+  if (fs.existsSync(manifestSrc) && (!fs.existsSync(manifestDest) || force)) {
+    fs.copyFileSync(manifestSrc, manifestDest);
+    success('.claude/manifest.json (drift tracking)');
+  }
+
+  // Create task/report/execution directories
+  fs.mkdirSync(path.join(cwd, '.claude', 'tasks'), { recursive: true });
+  fs.mkdirSync(path.join(cwd, '.claude', 'reports', 'daily'), { recursive: true });
+  fs.mkdirSync(path.join(cwd, '.claude', 'reports', 'executions'), { recursive: true });
+  // Ensure empty template dirs exist even if copyDir skips them
+  fs.mkdirSync(path.join(cwd, '.claude', 'profiles'), { recursive: true });
+  fs.mkdirSync(path.join(cwd, '.claude', 'templates'), { recursive: true });
+  success('.claude/tasks/, .claude/reports/, .claude/profiles/, .claude/templates/');
+
+  // Make hook scripts executable (handle both .js and legacy .sh)
+  const hooksDir = path.join(cwd, '.claude', 'hooks');
+  if (fs.existsSync(hooksDir)) {
+    for (const file of fs.readdirSync(hooksDir)) {
+      if (file.endsWith('.sh') || file.endsWith('.js')) {
+        const hookPath = path.join(hooksDir, file);
+        try { fs.chmodSync(hookPath, 0o755); } catch (e) { /* Windows — not needed for .js */ }
+      }
+    }
+    success('Hook scripts ready');
+  }
+
+  // Update .gitignore
+  const gitignorePath = path.join(cwd, '.gitignore');
+  const gitignoreEntries = [
+    '.claude/settings.local.json',
+    '.claude/agent-memory-local/',
+    '.claude/tasks/',
+    '.claude/reports/',
+  ];
+
+  let gitignoreContent = fs.existsSync(gitignorePath)
+    ? fs.readFileSync(gitignorePath, 'utf-8')
+    : '';
+
+  const newEntries = gitignoreEntries.filter(e => !gitignoreContent.includes(e));
+  if (newEntries.length > 0) {
+    gitignoreContent += '\n# Claude Code local files\n' + newEntries.join('\n') + '\n';
+    fs.writeFileSync(gitignorePath, gitignoreContent);
+    success(`.gitignore updated (${newEntries.length} entries)`);
+  }
+
+  // Summary
+  header('Setup Complete!\n');
+  log('Next steps:\n');
+  log(`  ${BOLD}1.${RESET} cd ${cwd}`);
+  log(`  ${BOLD}2.${RESET} claude`);
+  log(`  ${BOLD}3.${RESET} /scan-codebase          ${CYAN}# Scan your tech stack${RESET}`);
+  log(`  ${BOLD}4.${RESET} /generate-environment   ${CYAN}# Generate customized environment${RESET}`);
+  log(`  ${BOLD}5.${RESET} /validate-setup          ${CYAN}# Verify everything works${RESET}`);
+  if (!skipSmithery) {
+    log(`  ${BOLD}6.${RESET} /setup-smithery          ${CYAN}# Install community skills (optional)${RESET}`);
+  }
+  log('');
+  log(`Then start working:`);
+  log(`  /workflow new "your first task"`);
+  log('');
+}
+
+function status() {
+  const cwd = process.cwd();
+  header('Claude Code Environment Status\n');
+
+  const checks = [
+    ['CLAUDE.md', path.join(cwd, 'CLAUDE.md')],
+    ['.claude/rules/', path.join(cwd, '.claude', 'rules')],
+    ['.claude/agents/', path.join(cwd, '.claude', 'agents')],
+    ['.claude/skills/', path.join(cwd, '.claude', 'skills')],
+    ['.claude/settings.json', path.join(cwd, '.claude', 'settings.json')],
+    ['.claude/hooks/', path.join(cwd, '.claude', 'hooks')],
+    ['.claude/scripts/', path.join(cwd, '.claude', 'scripts')],
+    ['.claude/docs/', path.join(cwd, '.claude', 'docs')],
+  ];
+
+  let found = 0;
+  for (const [name, p] of checks) {
+    if (fs.existsSync(p)) { success(name); found++; }
+    else { error(`${name} — missing`); }
+  }
+
+  log('');
+  if (found === checks.length) {
+    log(`${GREEN}${BOLD}Environment is fully set up.${RESET}`);
+    log('Run: claude → /scan-codebase → /generate-environment');
+  } else if (found > 0) {
+    log(`${YELLOW}${BOLD}Partially set up (${found}/${checks.length}).${RESET}`);
+    log('Run: npx claude-code-scanner init --force');
+  } else {
+    log(`${RED}${BOLD}Not initialized.${RESET}`);
+    log('Run: npx claude-code-scanner init');
+  }
+}
+
+function verify() {
+  const cwd = process.cwd();
+  // Prefer cross-platform .js, fall back to legacy .sh
+  const jsPath = path.join(cwd, '.claude', 'scripts', 'verify-setup.js');
+  const shPath = path.join(cwd, '.claude', 'scripts', 'verify-setup.sh');
+  const scriptPath = fs.existsSync(jsPath) ? jsPath : shPath;
+  if (!fs.existsSync(scriptPath)) {
+    error('Verification script not found. Run: npx claude-code-scanner init');
+    process.exit(1);
+  }
+  const { execSync } = require('child_process');
+  try {
+    if (scriptPath.endsWith('.js')) {
+      execSync(`node "${scriptPath}"`, { stdio: 'inherit', cwd });
+    } else {
+      execSync(`bash "${scriptPath}"`, { stdio: 'inherit', cwd });
+    }
+  } catch (e) {
+    process.exit(1);
+  }
+}
+
+function update() {
+  flags.push('--force');
+  init();
+}
+
+function help() {
+  header('Claude Code Scanner\n');
+  log('Scan any codebase and generate a complete Claude Code environment.\n');
+  log(`${BOLD}Usage:${RESET}`);
+  log('  npx claude-code-scanner <command> [options]\n');
+  log(`${BOLD}Commands:${RESET}`);
+  for (const [cmd, desc] of Object.entries(COMMANDS)) {
+    log(`  ${CYAN}${cmd.padEnd(12)}${RESET} ${desc}`);
+  }
+  log(`\n${BOLD}Options:${RESET}`);
+  log(`  ${CYAN}--force, -f${RESET}      Overwrite existing files`);
+  log(`  ${CYAN}--no-smithery${RESET}    Skip Smithery setup step in instructions`);
+  log(`\n${BOLD}Quick Start:${RESET}`);
+  log('  cd /path/to/your-project');
+  log('  npx claude-code-scanner init');
+  log('  claude');
+  log('  /scan-codebase');
+  log('  /generate-environment');
+  log('');
+}
+
+// Route command
+switch (command) {
+  case 'init': init(); break;
+  case 'status': status(); break;
+  case 'verify': verify(); break;
+  case 'update': update(); break;
+  case 'help': case '--help': case '-h': help(); break;
+  case '--version': case '-v': case '-V': case 'version':
+    log(require('../package.json').version);
+    break;
+  default:
+    error(`Unknown command: ${command}`);
+    help();
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "claude-code-scanner",
+  "version": "1.0.0",
+  "description": "Scan any codebase and generate a complete Claude Code environment — agents, skills, hooks, rules, templates, and SDLC workflow",
+  "author": "adnan-prompts",
+  "license": "MIT",
+  "homepage": "https://github.com/adnan-prompts/claude-code-scanner#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adnan-prompts/claude-code-scanner.git"
+  },
+  "bugs": {
+    "url": "https://github.com/adnan-prompts/claude-code-scanner/issues"
+  },
+  "bin": {
+    "claude-code-scanner": "./bin/cli.js"
+  },
+  "scripts": {
+    "postinstall": "echo '✓ Run: npx claude-code-scanner init'"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "agents",
+    "skills",
+    "claude-code-scanner",
+    "sdlc",
+    "cli",
+    "generator",
+    "developer-tools"
+  ],
+  "files": [
+    "bin/",
+    "template/",
+    "README.md",
+    "DOCUMENTATION.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}