claude-code-starter 0.0.9 → 0.1.0

package/README.md

@@ -2,487 +2,47 @@
 
 A lightweight starter kit for AI-assisted development with Claude Code.
 
-**Version:** 0.0.9
-
 ## Quick Start
 
 ```bash
-cd /path/to/your-project
-npx claude-code-starter
-claude
-```
-
-## CLI Options
-
-```bash
-npx claude-code-starter --help      # Show help message
-npx claude-code-starter --version   # Show version number
-npx claude-code-starter --force     # Force overwrite CLAUDE.md and settings.json
-```
-
----
-
-## Examples
-
-### Example 1: New Project
-
-```bash
-mkdir my-new-app
-cd my-new-app
-npx claude-code-starter
-```
-
-Output:
-```
-╔═══════════════════════════════════════╗
-║   Claude Code Starter v0.0.9        ║
-╚═══════════════════════════════════════╝
-
-Setting up framework files...
-  Created CLAUDE.md
-  Created .claude/settings.json
-  Updated .claude/commands/
-  Updated .claude/skills/
-
-New project detected
-
-What are you building?
-> A REST API for managing todo items
-
-Ready! Run claude to start working on: A REST API for managing todo items
-
-Tip: Add .claude/ to your global .gitignore
-```
-
-Then:
-```bash
-claude
-```
-
-Claude will start with context about your task and begin helping you build it.
-
----
-
-### Example 2: Existing Project
-
-```bash
-cd /path/to/my-express-app
+cd your-project
 npx claude-code-starter
-```
-
-Output:
-```
-╔═══════════════════════════════════════╗
-║   Claude Code Starter v0.0.9        ║
-╚═══════════════════════════════════════╝
-
-Setting up framework files...
-  Created CLAUDE.md
-  Created .claude/settings.json
-  Updated .claude/commands/
-  Updated .claude/skills/
-
-Detected existing project
-Tech stack: Node.js TypeScript
-
-Analyzing codebase...
-
-  Files: 47 source files
-  Directories: src/ lib/ tests/
-  Frameworks: Express
-
-Ready! Run claude to start.
-
-Tip: Add .claude/ to your global .gitignore
-```
-
----
-
-### Example 3: Starting a Task
-
-```
-You: /task Add user authentication with JWT
-
-Claude: I'll set up JWT authentication. Let me first understand your current
-        project structure...
-
-        [Claude reads files, creates a plan, updates .claude/state/task.md]
-
-        I've analyzed your project. Here's my plan:
-
-        1. Install dependencies (jsonwebtoken, bcrypt)
-        2. Create auth middleware in src/middleware/auth.ts
-        3. Add login/register endpoints
-        4. Protect existing routes
-
-        Starting with step 1...
-```
-
----
-
-### Example 4: Checking Status
-
-```
-You: /status
-
-Claude: ## Current Status
-
-        **Task:** Add user authentication with JWT
-        **Status:** In Progress
-
-        ### Progress
-        - [x] Installed dependencies
-        - [x] Created auth middleware
-        - [ ] Add login/register endpoints
-        - [ ] Protect existing routes
-
-        ### Decisions Made
-        - Using RS256 for JWT signing
-        - Storing refresh tokens in httpOnly cookies
-
-        ### Next Steps
-        Creating the login endpoint in src/routes/auth.ts
-```
-
----
-
-### Example 5: Completing a Task
-
-```
-You: /done
-
-Claude: ## Task Complete
-
-        **Task:** Add user authentication with JWT
-
-        ### Summary
-        Implemented full JWT authentication system with:
-        - Login/register endpoints
-        - Token refresh mechanism
-        - Protected route middleware
-
-        ### Files Changed
-        - src/middleware/auth.ts (new)
-        - src/routes/auth.ts (new)
-        - src/routes/index.ts (modified)
-        - package.json (modified)
-
-        ### Follow-up
-        - Consider adding rate limiting to auth endpoints
-        - Add password reset functionality
-
-        State cleared. Ready for next task.
-```
-
----
-
-### Example 6: Deep Analysis
-
-```
-You: /analyze authentication flow
-
-Claude: ## Analysis: Authentication Flow
-
-        ### Entry Points
-        - `POST /api/auth/login` → src/routes/auth.ts:23
-        - `POST /api/auth/register` → src/routes/auth.ts:45
-        - `POST /api/auth/refresh` → src/routes/auth.ts:67
-
-        ### Middleware Chain
-        1. `validateBody()` → src/middleware/validate.ts:12
-        2. `authMiddleware()` → src/middleware/auth.ts:8
-
-        ### Token Flow
-        ```
-        Login Request
-            ↓
-        Validate credentials (bcrypt.compare)
-            ↓
-        Generate access token (15min) + refresh token (7d)
-            ↓
-        Set refresh token as httpOnly cookie
-            ↓
-        Return access token in response body
-        ```
-
-        ### Potential Issues
-        - No rate limiting on login attempts
-        - Refresh tokens not stored in DB (can't revoke)
-
-        ### Recommendations
-        1. Add rate limiting with express-rate-limit
-        2. Store refresh tokens in Redis for revocation
-```
-
----
-
-### Example 7: Resuming Work
-
-When you close Claude and come back later:
-
-```bash
 claude
 ```
 
-Claude reads `.claude/state/task.md` (as instructed by CLAUDE.md) and continues:
-
-```
-Claude: Welcome back. I see you were working on:
-
-        **Task:** Add user authentication with JWT
-        **Status:** In Progress
-
-        Last time we completed the auth middleware. Next step is
-        creating the login endpoint.
-
-        Should I continue with that?
-```
-
----
-
-### Example 8: Using Skills
-
-Skills are referenced when relevant. You can also ask directly:
-
-```
-You: I'm debugging why login fails for some users. Help me use
-     the systematic debugging approach.
-
-Claude: I'll follow the systematic debugging methodology.
-
-        ### 1. Reproduce
-        First, let me understand the failure pattern...
-        - Which users fail? New users? Existing users?
-        - Any error messages in logs?
-
-        ### 2. Isolate
-        [Claude narrows down the issue]
-
-        ### 3. Trace
-        Looking at the code path:
-        - src/routes/auth.ts:23 → login handler
-        - src/services/auth.ts:15 → validatePassword
-        ...
-
-        ### 4. Root Cause
-        Found it: The password comparison fails for users migrated
-        from the old system because they use MD5 hashing, not bcrypt.
-
-        ### 5. Fix
-        I'll add a migration check in the login flow...
-```
-
----
-
-### Example 9: Pattern Discovery
-
-```
-You: I need to add a new API endpoint. What patterns does this
-     project use?
-
-Claude: Let me analyze the existing patterns...
-
-        ### API Endpoint Pattern
-        Based on src/routes/*.ts:
-
-        ```typescript
-        // Pattern: Route files export a router
-        import { Router } from 'express';
-        import { validateBody } from '../middleware/validate';
-        import { schema } from '../schemas/resourceSchema';
-
-        const router = Router();
-
-        router.post('/',
-          validateBody(schema),
-          async (req, res, next) => {
-            try {
-              const result = await service.create(req.body);
-              res.status(201).json(result);
-            } catch (error) {
-              next(error);
-            }
-          }
-        );
-
-        export default router;
-        ```
-
-        ### Conventions Found
-        - Validation middleware before handlers
-        - Async handlers with try/catch
-        - Services handle business logic
-        - 201 for creates, 200 for updates
-
-        Should I create your new endpoint following this pattern?
-```
-
----
-
-### Example 10: Multi-Step Feature
-
-```
-You: /task Build a complete user profile feature with avatar upload
-
-Claude: This is a multi-step feature. I'll break it down:
-
-        ## Plan
-
-        1. **Database**: Add profile fields to User model
-        2. **Storage**: Set up file upload for avatars
-        3. **API**: Create profile endpoints (GET/PATCH)
-        4. **Validation**: Add profile update schema
-        5. **Tests**: Write tests for new endpoints
-
-        I'll update state as we complete each step.
-
-        Starting with the database changes...
-
-        [After completing step 1]
-
-        ✓ Step 1 complete. Updated .claude/state/task.md
-
-        Moving to step 2: Setting up avatar uploads...
-```
-
----
-
-## Structure
+## What It Does
 
-After init, your project has:
-
-```
-your-project/
-├── CLAUDE.md              # Instructions for Claude
-└── .claude/
-    ├── .version           # Framework version
-    ├── settings.json      # Permissions
-    ├── commands/          # Slash commands
-    │   ├── task.md
-    │   ├── status.md
-    │   ├── done.md
-    │   └── analyze.md
-    ├── skills/            # Reference guides
-    │   ├── pattern-discovery.md
-    │   ├── systematic-debugging.md
-    │   └── testing-methodology.md
-    └── state/
-        └── task.md        # Current task state
-```
+Sets up your project with:
+- `CLAUDE.md` - Instructions for Claude
+- `.claude/commands/` - Slash commands (`/task`, `/status`, `/done`, `/analyze`)
+- `.claude/skills/` - Methodology guides (debugging, testing, patterns)
+- `.claude/state/task.md` - Task tracking
 
 ## Commands
 
-| Command | What it does |
+| Command | Description |
 |---------|-------------|
-| `/task <desc>` | Start working on something |
+| `/task <desc>` | Start a new task |
 | `/status` | Show current task |
 | `/done` | Mark task complete |
 | `/analyze <area>` | Deep dive into code |
 
-## Skills
-
-The framework includes methodology guides in `.claude/skills/`:
-
-| Skill | Use When |
-|-------|----------|
-| **pattern-discovery.md** | Adding new code that should match existing patterns |
-| **systematic-debugging.md** | Investigating bugs or unexpected behavior |
-| **testing-methodology.md** | Writing tests or improving test coverage |
-
-Claude references these when the situation calls for it.
-
-## State Management
-
-All state lives in `.claude/state/task.md`. Example:
+## Options
 
-```markdown
-# Current Task
-
-## Status: In Progress
-
-**Task:** Add user authentication
-
-## Context
-
-Building JWT-based auth for the Express API.
-
-## Next Steps
-
-1. Create auth middleware
-2. Add login endpoint
-3. Test
-
-## Decisions
-
-- Using RS256 for JWT signing
-- Refresh tokens in httpOnly cookies
-- Access tokens expire in 15 minutes
+```bash
+npx claude-code-starter --help     # Show help
+npx claude-code-starter --force    # Overwrite existing files
 ```
 
-When you resume a session, Claude reads this file and continues where you left off.
+## Tip
 
-## Global .gitignore
-
-Add `.claude/` to your global gitignore so it's ignored in all projects:
+Add `.claude/` to your global gitignore:
 
 ```bash
 echo ".claude/" >> ~/.gitignore
 git config --global core.excludesfile ~/.gitignore
 ```
 
-## Permissions
-
-The `settings.json` pre-approves common dev commands:
-
-- **Git**: status, diff, log, add, commit, etc.
-- **Package managers**: npm, yarn, pnpm, bun, pip, cargo
-- **Build tools**: node, tsc, make, docker
-- **Test runners**: jest, vitest
-- **Linters**: eslint, prettier
-
-Edit `.claude/settings.json` to customize for your stack.
-
-## Troubleshooting
-
-### Init script fails on macOS
-
-The script is compatible with Bash 3.x (macOS default). If you see errors, check your bash version:
-
-```bash
-bash --version
-```
-
-### Commands not recognized
-
-If `/task`, `/status`, etc. don't work:
-
-1. Check that `.claude/commands/` exists in your project
-2. Verify files have YAML frontmatter (lines starting with `---`)
-3. Re-run init to refresh command files
-
-### Settings keep resetting
-
-The init script preserves your `settings.json` if it exists. If it's being overwritten:
-
-1. Check you're not running from inside the framework folder
-2. Verify `.claude/settings.json` exists before running init
-
-### Claude doesn't read task state
-
-Make sure `CLAUDE.md` exists in your project root. It tells Claude to check `.claude/state/task.md` on startup.
-
-### Framework version
-
-Check your installed version:
-
-```bash
-cat .claude/.version
-```
-
-## Tips
+## License
 
-1. **Be specific with tasks** - "Add login endpoint" is better than "work on auth"
-2. **Check status often** - `/status` helps you and Claude stay aligned
-3. **Let Claude update state** - Don't manually edit `.claude/state/task.md`
-4. **Use analyze for exploration** - `/analyze` before diving into unfamiliar code
-5. **Complete tasks properly** - `/done` creates a clean break for the next task
+MIT

package/dist/cli.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import prompts from "prompts";
+import pc from "picocolors";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var TEMPLATES_DIR = path.join(__dirname, "..", "templates");
+var VERSION = JSON.parse(
+  fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf-8")
+).version;
+function parseArgs(args) {
+  return {
+    help: args.includes("-h") || args.includes("--help"),
+    version: args.includes("-v") || args.includes("--version"),
+    force: args.includes("-f") || args.includes("--force")
+  };
+}
+function detectProject(projectDir) {
+  const techStack = [];
+  const frameworks = [];
+  const directories = [];
+  let isExisting = false;
+  const checks = [
+    ["package.json", "Node.js"],
+    ["tsconfig.json", "TypeScript"],
+    ["requirements.txt", "Python"],
+    ["pyproject.toml", "Python"],
+    ["Cargo.toml", "Rust"],
+    ["go.mod", "Go"],
+    ["pom.xml", "Java"],
+    ["build.gradle", "Java/Kotlin"],
+    ["Gemfile", "Ruby"]
+  ];
+  for (const [file, tech] of checks) {
+    if (fs.existsSync(path.join(projectDir, file))) {
+      if (!techStack.includes(tech)) techStack.push(tech);
+      isExisting = true;
+    }
+  }
+  const keyDirs = ["src", "lib", "app", "api", "components", "pages", "tests", "test"];
+  for (const dir of keyDirs) {
+    if (fs.existsSync(path.join(projectDir, dir))) {
+      directories.push(dir);
+      isExisting = true;
+    }
+  }
+  const pkgPath = path.join(projectDir, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = fs.readFileSync(pkgPath, "utf-8");
+      const frameworkChecks = [
+        ['"react"', "React"],
+        ['"next"', "Next.js"],
+        ['"vue"', "Vue"],
+        ['"express"', "Express"],
+        ['"fastify"', "Fastify"],
+        ['"@nestjs"', "NestJS"]
+      ];
+      for (const [pattern, name] of frameworkChecks) {
+        if (pkg.includes(pattern)) frameworks.push(name);
+      }
+    } catch {
+    }
+  }
+  let fileCount = 0;
+  const extensions = [".js", ".ts", ".tsx", ".py", ".go", ".rs", ".java", ".rb"];
+  const ignoreDirs = ["node_modules", ".git", "dist", "build", ".claude"];
+  function countFiles(dir, depth = 0) {
+    if (depth > 3) return;
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (ignoreDirs.includes(entry.name)) continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          countFiles(fullPath, depth + 1);
+        } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+          fileCount++;
+          isExisting = true;
+        }
+      }
+    } catch {
+    }
+  }
+  countFiles(projectDir);
+  return { isExisting, techStack, frameworks, directories, fileCount };
+}
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function copyFile(src, dest, force) {
+  const exists = fs.existsSync(dest);
+  if (!force && exists) {
+    return "skipped";
+  }
+  fs.copyFileSync(src, dest);
+  return exists ? "updated" : "created";
+}
+function getVersion() {
+  return VERSION;
+}
+function getTemplatesDir() {
+  return TEMPLATES_DIR;
+}
+function showHelp() {
+  console.log(`
+${pc.cyan("Claude Code Starter")} v${VERSION}
+
+A lightweight starter kit for AI-assisted development with Claude Code.
+
+${pc.bold("USAGE")}
+  npx claude-code-starter [OPTIONS]
+
+${pc.bold("OPTIONS")}
+  -h, --help      Show this help message
+  -v, --version   Show version number
+  -f, --force     Force overwrite of CLAUDE.md and settings.json
+
+${pc.bold("MORE INFO")}
+  https://github.com/cassmtnr/claude-code-starter
+`);
+}
+function showBanner() {
+  console.log(pc.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  console.log(pc.cyan(`\u2551   Claude Code Starter v${VERSION.padEnd(13)}\u2551`));
+  console.log(pc.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  console.log();
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    showHelp();
+    process.exit(0);
+  }
+  if (args.version) {
+    console.log(`claude-code-starter v${VERSION}`);
+    process.exit(0);
+  }
+  showBanner();
+  const projectDir = process.cwd();
+  if (!fs.existsSync(TEMPLATES_DIR)) {
+    console.error(pc.red("Error: Templates directory not found."));
+    console.error("The installation appears to be incomplete.");
+    process.exit(1);
+  }
+  fs.mkdirSync(path.join(projectDir, ".claude", "state"), { recursive: true });
+  fs.mkdirSync(path.join(projectDir, ".claude", "commands"), { recursive: true });
+  fs.mkdirSync(path.join(projectDir, ".claude", "skills"), { recursive: true });
+  console.log(pc.blue("Setting up framework files..."));
+  const claudeMdResult = copyFile(
+    path.join(TEMPLATES_DIR, "CLAUDE.md"),
+    path.join(projectDir, "CLAUDE.md"),
+    args.force
+  );
+  if (claudeMdResult === "skipped") {
+    console.log("  CLAUDE.md exists (use --force to overwrite)");
+  } else {
+    console.log(`  ${claudeMdResult === "updated" ? "Updated" : "Created"} CLAUDE.md`);
+  }
+  const settingsResult = copyFile(
+    path.join(TEMPLATES_DIR, "settings.json"),
+    path.join(projectDir, ".claude", "settings.json"),
+    args.force
+  );
+  if (settingsResult === "skipped") {
+    console.log("  settings.json exists (use --force to overwrite)");
+  } else {
+    console.log(`  ${settingsResult === "updated" ? "Updated" : "Created"} .claude/settings.json`);
+  }
+  copyDir(path.join(TEMPLATES_DIR, "commands"), path.join(projectDir, ".claude", "commands"));
+  console.log("  Updated .claude/commands/");
+  copyDir(path.join(TEMPLATES_DIR, "skills"), path.join(projectDir, ".claude", "skills"));
+  console.log("  Updated .claude/skills/");
+  fs.writeFileSync(path.join(projectDir, ".claude", ".version"), VERSION);
+  console.log();
+  const project = detectProject(projectDir);
+  if (project.isExisting) {
+    console.log(pc.green("Detected existing project"));
+    if (project.techStack.length > 0) {
+      console.log(`Tech stack: ${pc.cyan(project.techStack.join(" "))}`);
+    }
+    console.log();
+    console.log(pc.blue("Analyzing codebase..."));
+    console.log();
+    console.log(`  Files: ${project.fileCount} source files`);
+    if (project.directories.length > 0) {
+      console.log(`  Directories: ${project.directories.map((d) => d + "/").join(" ")}`);
+    }
+    if (project.frameworks.length > 0) {
+      console.log(`  Frameworks: ${project.frameworks.join(" ")}`);
+    }
+    console.log();
+    const taskPath = path.join(projectDir, ".claude", "state", "task.md");
+    if (!fs.existsSync(taskPath)) {
+      fs.writeFileSync(
+        taskPath,
+        `# Current Task
+
+## Status: Ready
+
+No active task. Start one with \`/task <description>\`.
+
+## Project Summary
+
+This is an existing codebase. Use \`/analyze\` to explore specific areas.
+
+## Quick Commands
+
+- \`/task\` - Start working on something
+- \`/status\` - See current state
+- \`/analyze\` - Deep dive into code
+- \`/done\` - Mark task complete
+`
+      );
+      console.log("  Created .claude/state/task.md");
+    } else {
+      console.log("  Task state preserved (.claude/state/task.md)");
+    }
+    console.log();
+    console.log(`${pc.green("Ready!")} Run ${pc.cyan("claude")} to start.`);
+  } else {
+    console.log(pc.yellow("New project detected"));
+    console.log();
+    const taskPath = path.join(projectDir, ".claude", "state", "task.md");
+    if (!fs.existsSync(taskPath)) {
+      const response = await prompts({
+        type: "text",
+        name: "task",
+        message: "What are you building?",
+        initial: "Explore and set up project"
+      });
+      const task = response.task || "Explore and set up project";
+      fs.writeFileSync(
+        taskPath,
+        `# Current Task
+
+## Status: In Progress
+
+**Task:** ${task}
+
+## Context
+
+New project - no existing code yet.
+
+## Next Steps
+
+1. Define project structure
+2. Set up development environment
+3. Start implementation
+
+## Decisions
+
+(None yet - starting fresh)
+`
+      );
+      console.log();
+      console.log(`${pc.green("Ready!")} Run ${pc.cyan("claude")} to start working on: ${task}`);
+    } else {
+      console.log("  Task state preserved (.claude/state/task.md)");
+      console.log();
+      console.log(`${pc.green("Ready!")} Run ${pc.cyan("claude")} to continue.`);
+    }
+  }
+  console.log();
+  console.log(`${pc.blue("Tip:")} Add ${pc.cyan(".claude/")} to your global .gitignore`);
+}
+main().catch((err) => {
+  console.error(pc.red("Error:"), err.message);
+  process.exit(1);
+});
+export {
+  copyDir,
+  copyFile,
+  detectProject,
+  getTemplatesDir,
+  getVersion,
+  parseArgs
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-code-starter",
-  "version": "0.0.9",
-  "description": "A lightweight framework for AI-assisted development with Claude Code",
+  "version": "0.1.0",
+  "description": "A lightweight starter kit for AI-assisted development with Claude Code",
   "keywords": [
     "claude",
     "ai",
@@ -13,24 +13,39 @@
   ],
   "author": "Cassiano Montanari",
   "license": "MIT",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cassmtnr/claude-code-starter.git"
   },
   "homepage": "https://github.com/cassmtnr/claude-code-starter#readme",
   "bin": {
-    "claude-code-starter": "./init"
+    "claude-code-starter": "./dist/cli.js"
   },
   "files": [
-    "init",
-    "CLAUDE.md",
-    ".claude/commands/",
-    ".claude/skills/",
-    ".claude/settings.json",
-    ".claude/state/task.md",
-    ".claude/.version"
+    "dist",
+    "templates"
   ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/cli.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^4.0.17"
+  },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   }
 }

package/.claude/.version

@@ -1 +0,0 @@
-0.0.8

package/init

@@ -1,352 +0,0 @@
-#!/usr/bin/env bash
-#
-# Claude Code Starter - Init Script
-#
-
-set -e
-
-# Colors
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[1;33m'
-CYAN='\033[0;36m'
-RED='\033[0;31m'
-NC='\033[0m'
-
-# Default options
-FORCE=false
-
-# Get framework directory (resolve symlinks for npm global install)
-SCRIPT_PATH="$0"
-if [ -L "$SCRIPT_PATH" ]; then
-    # Resolve symlink
-    if command -v readlink >/dev/null 2>&1; then
-        SCRIPT_PATH="$(readlink "$SCRIPT_PATH")"
-        # Handle relative symlinks
-        if [[ "$SCRIPT_PATH" != /* ]]; then
-            SCRIPT_PATH="$(dirname "$0")/$SCRIPT_PATH"
-        fi
-    fi
-fi
-FRAMEWORK_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
-
-# Get version from package.json (single source of truth)
-VERSION=$(node -p "require('$FRAMEWORK_DIR/package.json').version")
-
-# Help message
-show_help() {
-    cat << EOF
-Claude Code Starter v${VERSION}
-
-A lightweight starter kit for AI-assisted development with Claude Code.
-
-USAGE:
-    npx claude-code-starter [OPTIONS]
-    claude-code-starter [OPTIONS]
-
-OPTIONS:
-    -h, --help      Show this help message
-    -v, --version   Show version number
-    -f, --force     Force overwrite of CLAUDE.md and settings.json
-
-EXAMPLES:
-    # Initialize in current directory (no install required)
-    cd /path/to/your-project
-    npx claude-code-starter
-
-    # Force overwrite existing files
-    npx claude-code-starter --force
-
-    # If installed globally
-    claude-code-starter
-
-WHAT IT DOES:
-    1. Creates .claude/ directory structure
-    2. Copies CLAUDE.md (instructions for Claude)
-    3. Sets up slash commands (/task, /status, /done, /analyze)
-    4. Installs skill files for patterns, debugging, testing
-    5. Creates initial task state
-
-MORE INFO:
-    https://github.com/cassmtnr/claude-code-starter
-EOF
-}
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        -h|--help)
-            show_help
-            exit 0
-            ;;
-        -v|--version)
-            echo "claude-code-starter v${VERSION}"
-            exit 0
-            ;;
-        -f|--force)
-            FORCE=true
-            shift
-            ;;
-        *)
-            echo -e "${RED}Unknown option: $1${NC}"
-            echo "Use --help for usage information"
-            exit 1
-            ;;
-    esac
-done
-
-# Get project directory (current working directory)
-PROJECT_DIR="$(pwd)"
-
-# Prevent running init inside the framework folder itself
-if [ "$PROJECT_DIR" = "$FRAMEWORK_DIR" ]; then
-    echo -e "${YELLOW}Run this from your project directory, not the framework folder.${NC}"
-    echo ""
-    echo "Usage:"
-    echo "  cd /path/to/your-project"
-    echo "  npx claude-code-starter"
-    exit 1
-fi
-
-# Validate framework files exist
-validate_framework() {
-    local missing=()
-
-    [ ! -f "$FRAMEWORK_DIR/CLAUDE.md" ] && missing+=("CLAUDE.md")
-    [ ! -f "$FRAMEWORK_DIR/.claude/settings.json" ] && missing+=(".claude/settings.json")
-    [ ! -d "$FRAMEWORK_DIR/.claude/commands" ] && missing+=(".claude/commands/")
-    [ ! -d "$FRAMEWORK_DIR/.claude/skills" ] && missing+=(".claude/skills/")
-
-    if [ ${#missing[@]} -gt 0 ]; then
-        echo -e "${RED}Error: Framework files missing:${NC}"
-        for file in "${missing[@]}"; do
-            echo "  - $file"
-        done
-        echo ""
-        echo "The framework installation appears to be incomplete."
-        echo "Try reinstalling: npm install -g claude-code-starter"
-        exit 1
-    fi
-}
-
-validate_framework
-
-# Show banner
-echo -e "${CYAN}╔═════════════════════════════════════╗${NC}"
-echo -e "${CYAN}║   Claude Code Starter v${VERSION}        ║${NC}"
-echo -e "${CYAN}╚═════════════════════════════════════╝${NC}"
-echo ""
-
-# Create .claude directory structure
-mkdir -p "$PROJECT_DIR/.claude/state"
-mkdir -p "$PROJECT_DIR/.claude/commands"
-mkdir -p "$PROJECT_DIR/.claude/skills"
-
-# Copy framework files to project
-echo -e "${BLUE}Setting up framework files...${NC}"
-
-# Copy CLAUDE.md
-if [ ! -f "$PROJECT_DIR/CLAUDE.md" ] || [ "$FORCE" = true ]; then
-    cp -- "$FRAMEWORK_DIR/CLAUDE.md" "$PROJECT_DIR/CLAUDE.md" 2>/dev/null || true
-    if [ "$FORCE" = true ] && [ -f "$PROJECT_DIR/CLAUDE.md" ]; then
-        echo "  Updated CLAUDE.md (forced)"
-    else
-        echo "  Created CLAUDE.md"
-    fi
-else
-    echo "  CLAUDE.md exists (use --force to overwrite)"
-fi
-
-# Copy settings.json
-if [ ! -f "$PROJECT_DIR/.claude/settings.json" ] || [ "$FORCE" = true ]; then
-    cp -- "$FRAMEWORK_DIR/.claude/settings.json" "$PROJECT_DIR/.claude/settings.json" 2>/dev/null || true
-    if [ "$FORCE" = true ] && [ -f "$PROJECT_DIR/.claude/settings.json" ]; then
-        echo "  Updated .claude/settings.json (forced)"
-    else
-        echo "  Created .claude/settings.json"
-    fi
-else
-    echo "  settings.json exists (use --force to overwrite)"
-fi
-
-# Copy commands (always update - these are framework-managed)
-cp -r -- "$FRAMEWORK_DIR/.claude/commands/"* "$PROJECT_DIR/.claude/commands/" 2>/dev/null || true
-echo "  Updated .claude/commands/"
-
-# Copy skills (always update - these are framework-managed)
-cp -r -- "$FRAMEWORK_DIR/.claude/skills/"* "$PROJECT_DIR/.claude/skills/" 2>/dev/null || true
-echo "  Updated .claude/skills/"
-
-# Write version file
-echo "$VERSION" > "$PROJECT_DIR/.claude/.version"
-
-echo ""
-
-# Detect project type (bash 3.x compatible - no mapfile)
-detect_project() {
-    local has_code=false
-    local tech_stack=""
-
-    # Check for various project indicators
-    [ -f "$PROJECT_DIR/package.json" ] && tech_stack+="Node.js " && has_code=true
-    [ -f "$PROJECT_DIR/tsconfig.json" ] && tech_stack+="TypeScript " && has_code=true
-    [ -f "$PROJECT_DIR/requirements.txt" ] && tech_stack+="Python " && has_code=true
-    [ -f "$PROJECT_DIR/pyproject.toml" ] && tech_stack+="Python " && has_code=true
-    [ -f "$PROJECT_DIR/Cargo.toml" ] && tech_stack+="Rust " && has_code=true
-    [ -f "$PROJECT_DIR/go.mod" ] && tech_stack+="Go " && has_code=true
-    [ -f "$PROJECT_DIR/pom.xml" ] && tech_stack+="Java " && has_code=true
-    [ -f "$PROJECT_DIR/build.gradle" ] && tech_stack+="Java/Kotlin " && has_code=true
-    [ -f "$PROJECT_DIR/Gemfile" ] && tech_stack+="Ruby " && has_code=true
-    [ -d "$PROJECT_DIR/src" ] && has_code=true
-    [ -d "$PROJECT_DIR/lib" ] && has_code=true
-    [ -d "$PROJECT_DIR/app" ] && has_code=true
-
-    # Check for source files (optimized with -prune)
-    if [ "$has_code" = false ]; then
-        local file_count
-        file_count=$(find "$PROJECT_DIR" -maxdepth 3 \
-            \( -name "node_modules" -o -name ".git" -o -name "dist" -o -name "build" \) -prune -o \
-            \( -name "*.js" -o -name "*.ts" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.java" -o -name "*.rb" \) -print 2>/dev/null | head -20 | wc -l | tr -d ' ')
-        [ "$file_count" -gt 0 ] && has_code=true
-    fi
-
-    # Return values via global variables (bash 3.x compatible)
-    PROJECT_TYPE="new"
-    TECH_STACK=""
-    if [ "$has_code" = true ]; then
-        PROJECT_TYPE="existing"
-        TECH_STACK="$tech_stack"
-    fi
-}
-
-# Run detection
-detect_project
-
-if [ "$PROJECT_TYPE" = "existing" ]; then
-    echo -e "${GREEN}Detected existing project${NC}"
-    [ -n "$TECH_STACK" ] && echo -e "Tech stack: ${CYAN}$TECH_STACK${NC}"
-    echo ""
-
-    # Run analysis
-    echo -e "${BLUE}Analyzing codebase...${NC}"
-
-    # Count files (optimized with -prune)
-    total_files=$(find "$PROJECT_DIR" \
-        \( -name "node_modules" -o -name ".git" -o -name "dist" -o -name "build" -o -name ".claude" \) -prune -o \
-        -type f \( -name "*.js" -o -name "*.ts" -o -name "*.tsx" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.java" -o -name "*.rb" -o -name "*.php" \) -print 2>/dev/null | wc -l | tr -d ' ')
-
-    # Detect key directories
-    key_dirs=""
-    [ -d "$PROJECT_DIR/src" ] && key_dirs+="src/ "
-    [ -d "$PROJECT_DIR/lib" ] && key_dirs+="lib/ "
-    [ -d "$PROJECT_DIR/app" ] && key_dirs+="app/ "
-    [ -d "$PROJECT_DIR/api" ] && key_dirs+="api/ "
-    [ -d "$PROJECT_DIR/components" ] && key_dirs+="components/ "
-    [ -d "$PROJECT_DIR/pages" ] && key_dirs+="pages/ "
-    [ -d "$PROJECT_DIR/tests" ] && key_dirs+="tests/ "
-    [ -d "$PROJECT_DIR/test" ] && key_dirs+="test/ "
-    [ -d "$PROJECT_DIR/__tests__" ] && key_dirs+="__tests__/ "
-
-    # Detect frameworks
-    frameworks=""
-    if [ -f "$PROJECT_DIR/package.json" ]; then
-        grep -q '"react"' "$PROJECT_DIR/package.json" 2>/dev/null && frameworks+="React "
-        grep -q '"next"' "$PROJECT_DIR/package.json" 2>/dev/null && frameworks+="Next.js "
-        grep -q '"vue"' "$PROJECT_DIR/package.json" 2>/dev/null && frameworks+="Vue "
-        grep -q '"express"' "$PROJECT_DIR/package.json" 2>/dev/null && frameworks+="Express "
-        grep -q '"fastify"' "$PROJECT_DIR/package.json" 2>/dev/null && frameworks+="Fastify "
-        grep -q '"@nestjs"' "$PROJECT_DIR/package.json" 2>/dev/null && frameworks+="NestJS "
-    fi
-    if [ -f "$PROJECT_DIR/requirements.txt" ]; then
-        grep -qi 'django' "$PROJECT_DIR/requirements.txt" 2>/dev/null && frameworks+="Django "
-        grep -qi 'flask' "$PROJECT_DIR/requirements.txt" 2>/dev/null && frameworks+="Flask "
-        grep -qi 'fastapi' "$PROJECT_DIR/requirements.txt" 2>/dev/null && frameworks+="FastAPI "
-    fi
-
-    echo ""
-    echo "  Files: $total_files source files"
-    [ -n "$key_dirs" ] && echo "  Directories: $key_dirs"
-    [ -n "$frameworks" ] && echo "  Frameworks: $frameworks"
-    echo ""
-
-    # Only create task file if it doesn't exist (preserve existing state)
-    if [ ! -f "$PROJECT_DIR/.claude/state/task.md" ]; then
-        cat > "$PROJECT_DIR/.claude/state/task.md" << 'EOF'
-# Current Task
-
-## Status: Ready
-
-No active task. Start one with `/task <description>`.
-
-## Project Summary
-
-This is an existing codebase. Use `/analyze` to explore specific areas.
-
-## Quick Commands
-
-- `/task` - Start working on something
-- `/status` - See current state
-- `/analyze` - Deep dive into code
-- `/done` - Mark task complete
-EOF
-        echo "  Created .claude/state/task.md"
-    else
-        echo "  Task state preserved (.claude/state/task.md)"
-    fi
-
-    echo ""
-    echo -e "${GREEN}Ready!${NC} Run ${CYAN}claude${NC} to start."
-
-else
-    echo -e "${YELLOW}New project detected${NC}"
-    echo ""
-
-    # Only ask for task if state doesn't exist
-    if [ ! -f "$PROJECT_DIR/.claude/state/task.md" ]; then
-        echo "What are you building?"
-        echo -n "> "
-        read -r initial_task
-
-        # Sanitize input - remove characters that could break heredoc
-        initial_task="${initial_task//\$/}"
-        initial_task="${initial_task//\`/}"
-        initial_task="${initial_task//\\/}"
-
-        if [ -z "$initial_task" ]; then
-            initial_task="Explore and set up project"
-        fi
-
-        # Create initial task file for new project
-        cat > "$PROJECT_DIR/.claude/state/task.md" << TASKEOF
-# Current Task
-
-## Status: In Progress
-
-**Task:** $initial_task
-
-## Context
-
-New project - no existing code yet.
-
-## Next Steps
-
-1. Define project structure
-2. Set up development environment
-3. Start implementation
-
-## Decisions
-
-(None yet - starting fresh)
-TASKEOF
-
-        echo ""
-        echo -e "${GREEN}Ready!${NC} Run ${CYAN}claude${NC} to start working on: $initial_task"
-    else
-        echo "  Task state preserved (.claude/state/task.md)"
-        echo ""
-        echo -e "${GREEN}Ready!${NC} Run ${CYAN}claude${NC} to continue."
-    fi
-fi
-
-echo ""
-echo -e "${BLUE}Tip:${NC} Add ${CYAN}.claude/${NC} to your global .gitignore"