start-vibing 2.0.47 → 2.0.49

package/dist/cli.js

@@ -765,6 +765,163 @@ async function installMcps() {
   return { installed, failed, skipped };
 }
 
+// src/plugins.ts
+import { spawn as spawn3, spawnSync as spawnSync3 } from "child_process";
+var RECOMMENDED_PLUGINS = [
+  {
+    name: "typescript-lsp",
+    marketplace: "claude-plugins-official",
+    description: "TypeScript code intelligence (go-to-definition, diagnostics)"
+  },
+  {
+    name: "code-review",
+    marketplace: "claude-plugins-official",
+    description: "Code review workflows and PR analysis"
+  },
+  {
+    name: "security-guidance",
+    marketplace: "claude-plugins-official",
+    description: "Security best practices and vulnerability detection"
+  },
+  {
+    name: "commit-commands",
+    marketplace: "claude-plugins-official",
+    description: "Git commit, push, and PR workflows"
+  }
+];
+var c2 = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  red: "\x1B[31m",
+  magenta: "\x1B[35m"
+};
+function isClaudePluginReady() {
+  if (!commandExists("claude"))
+    return false;
+  try {
+    const result = spawnSync3("claude", ["plugin", "--help"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: true,
+      timeout: 1e4
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function isPluginInstalled(name, marketplace) {
+  try {
+    const result = spawnSync3("claude", ["plugin", "list"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: true,
+      timeout: 1e4
+    });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.includes(`${name}@${marketplace}`);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function installPlugin(plugin) {
+  const pluginId = `${plugin.name}@${plugin.marketplace}`;
+  if (isPluginInstalled(plugin.name, plugin.marketplace)) {
+    return {
+      plugin: pluginId,
+      success: true,
+      message: "Already installed",
+      skipped: true
+    };
+  }
+  return new Promise((resolve) => {
+    const args = ["plugin", "install", pluginId, "--scope", "user"];
+    const proc = spawn3("claude", args, {
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve({
+          plugin: pluginId,
+          success: true,
+          message: "Installed"
+        });
+      } else {
+        resolve({
+          plugin: pluginId,
+          success: false,
+          message: stderr || stdout || `Exit code: ${code}`
+        });
+      }
+    });
+    proc.on("error", (err) => {
+      resolve({
+        plugin: pluginId,
+        success: false,
+        message: err.message
+      });
+    });
+    setTimeout(() => {
+      proc.kill();
+      resolve({
+        plugin: pluginId,
+        success: false,
+        message: "Installation timed out"
+      });
+    }, 30000);
+  });
+}
+async function installPlugins() {
+  console.log("");
+  console.log(`  ${c2.bright}${c2.magenta}Installing Plugins...${c2.reset}`);
+  console.log(`  ${c2.dim}(Also pre-configured in .claude/settings.json as fallback)${c2.reset}`);
+  console.log("");
+  if (!isClaudePluginReady()) {
+    console.log(`  ${c2.yellow}Plugin commands not available. Skipping CLI installation.${c2.reset}`);
+    console.log(`  ${c2.dim}Plugins will auto-prompt when Claude Code opens the project.${c2.reset}`);
+    return { installed: 0, failed: 0, skipped: RECOMMENDED_PLUGINS.length };
+  }
+  const results = [];
+  for (const plugin of RECOMMENDED_PLUGINS) {
+    process.stdout.write(`    ${c2.dim}Installing ${plugin.name}...${c2.reset}`);
+    const result = await installPlugin(plugin);
+    process.stdout.clearLine?.(0);
+    process.stdout.cursorTo?.(0);
+    const icon = result.success ? `${c2.green}\u2713${c2.reset}` : `${c2.red}\u2717${c2.reset}`;
+    const status = result.skipped ? `${c2.dim}(already installed)${c2.reset}` : result.success ? `${c2.green}OK${c2.reset}` : `${c2.yellow}skipped (will auto-prompt)${c2.reset}`;
+    console.log(`    ${icon} ${c2.cyan}${plugin.name}${c2.reset}: ${plugin.description} ${status}`);
+    results.push(result);
+  }
+  const installed = results.filter((r) => r.success && !r.skipped).length;
+  const failed = results.filter((r) => !r.success).length;
+  const skipped = results.filter((r) => r.skipped).length;
+  console.log("");
+  console.log(`  ${c2.bright}Plugin Summary:${c2.reset}`);
+  console.log(`    ${c2.green}Installed: ${installed}${c2.reset}`);
+  if (skipped > 0)
+    console.log(`    ${c2.dim}Already installed: ${skipped}${c2.reset}`);
+  if (failed > 0) {
+    console.log(`    ${c2.yellow}Deferred: ${failed} (will auto-prompt on project open)${c2.reset}`);
+  }
+  return { installed, failed, skipped };
+}
+
 // src/cli.ts
 var __filename3 = fileURLToPath2(import.meta.url);
 var __dirname3 = dirname2(__filename3);
@@ -849,7 +1006,8 @@ ${BANNER}
     2. Creates .claude/ folder with agents, skills, hooks, config
     3. Installs Claude Code if not found on system
     4. Installs recommended MCP servers (Context7, Playwright, etc.)
-    5. Launches Claude Code with --dangerously-skip-permissions
+    5. Installs recommended plugins (TypeScript LSP, Code Review, etc.)
+    6. Launches Claude Code with --dangerously-skip-permissions
 
   Smart Copy Behavior:
     - ALWAYS overwrites: agents/*.md, hooks/*.py, settings.json
@@ -985,6 +1143,13 @@ async function main() {
         console.log("  MCP installation skipped (Claude CLI not ready).");
         console.log('  Run "claude mcp list" after restart to verify.');
       }
+      if (!skipMcp && isClaudePluginReady()) {
+        console.log("");
+        console.log("  ========================================");
+        console.log("  Plugin Setup");
+        console.log("  ========================================");
+        await installPlugins();
+      }
       console.log("");
       launchClaude(targetDir);
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "start-vibing",
-	"version": "2.0.47",
+	"version": "2.0.49",
 	"description": "Setup Claude Code agents, skills, and hooks in your project. Smart copy that preserves your custom domains and configurations.",
 	"type": "module",
 	"bin": {

package/template/.claude/agents/claude-md-compactor.md

@@ -0,0 +1,214 @@
+---
+name: claude-md-compactor
+description: "AUTOMATICALLY invoke when CLAUDE.md exceeds 40k chars. Triggers: stop hook CLAUDE_MD_SIZE_EXCEEDED, 'compact CLAUDE.md'. Compacts while preserving critical knowledge per Anthropic best practices."
+model: sonnet
+tools: Read, Write, Edit, Bash, Grep, Glob, WebSearch
+skills: codebase-knowledge, docs-tracker
+---
+
+# Claude MD Compactor Agent
+
+Intelligently compact CLAUDE.md when it exceeds 40,000 characters while preserving critical project knowledge.
+
+## Research-Based Best Practices (Sources)
+
+Per [Anthropic Engineering Blog](https://www.anthropic.com/engineering/claude-code-best-practices):
+- Keep CLAUDE.md concise and human-readable
+- Treat it like a frequently-used prompt - iterate on effectiveness
+- Use emphasis ("IMPORTANT", "YOU MUST") for critical rules
+
+Per [HumanLayer Research](https://www.humanlayer.dev/blog/writing-a-good-claude-md):
+- **Target: <60 lines** (their production CLAUDE.md)
+- **Maximum: <300 lines** (general consensus)
+- LLMs can follow ~150-200 instructions max, Claude Code uses ~50 already
+- Only include **universally applicable** content
+
+Per [Context Management Research](https://mcpcat.io/guides/managing-claude-code-context/):
+- Performance degrades as file grows ("fading memory" phenomenon)
+- Move task-specific content to separate files (Progressive Disclosure)
+- Use external docs/ folder for ad-hoc content
+
+## Execution Steps
+
+### Step 1: Analyze Current State
+
+```bash
+wc -m CLAUDE.md              # Current size
+grep -n "^## " CLAUDE.md     # Section breakdown
+```
+
+### Step 2: Apply Compaction Rules
+
+#### MUST KEEP (Critical Sections)
+
+| Section              | Max Size | Notes                        |
+| -------------------- | -------- | ---------------------------- |
+| # Project Title      | 1 line   | Just the name                |
+| ## Last Change       | 200 char | ONLY latest, no history      |
+| ## 30 Seconds        | 300 char | 2-3 sentences max            |
+| ## Stack             | 500 char | Table format only            |
+| ## Architecture      | 800 char | Tree structure, no prose     |
+| ## Critical Rules    | 2000 char | Bullet points only          |
+| ## FORBIDDEN Actions | 1000 char | Table format                 |
+| ## Quality Gates     | 500 char | Commands only                |
+
+#### MUST REMOVE/CONDENSE
+
+| Remove                      | Why                                  |
+| --------------------------- | ------------------------------------ |
+| Verbose explanations        | Use bullet points instead            |
+| Code examples > 5 lines     | Reference file paths instead         |
+| Duplicate information       | Keep only in most relevant section   |
+| Old "Last Change" entries   | Git history has this                 |
+| Long tables with examples   | Keep headers + 1-2 rows max          |
+| Commented-out sections      | Delete completely                    |
+| Multiple H1 headers         | Only one allowed                     |
+| Nested sub-sub-sections     | Flatten to H2 max                    |
+
+#### CONDENSE TECHNIQUES
+
+```markdown
+# BAD (verbose)
+## Authentication
+The authentication system uses JWT tokens for secure session management.
+When a user logs in, the server generates a token that contains...
+[50 more lines of explanation]
+
+# GOOD (compact)
+## Auth
+- JWT tokens via `lib/auth.ts`
+- Session: 7 days, refresh: 30 days
+- Middleware: `middleware/auth.ts`
+```
+
+### Step 5: Rewrite File
+
+Create new CLAUDE.md with:
+
+1. **Header** - Project name only
+2. **Last Change** - Latest only (branch, date, 1-line summary)
+3. **30 Seconds** - What it does in 2 sentences
+4. **Stack** - Technology table (no descriptions)
+5. **Architecture** - Tree only, no explanations
+6. **Workflow** - Numbered steps, no prose
+7. **Critical Rules** - Bullets, max 10 rules
+8. **FORBIDDEN** - Table format
+9. **Quality Gates** - Commands only
+
+### Step 6: Validate Size
+
+```bash
+# Must be under 40,000
+wc -m CLAUDE.md
+
+# If still over, remove more:
+# 1. Reduce examples
+# 2. Shorten rule descriptions
+# 3. Remove optional sections
+```
+
+---
+
+## Compaction Template
+
+```markdown
+# {Project Name}
+
+> Max 40k chars. Validate: `wc -m CLAUDE.md`
+
+---
+
+## Last Change
+
+**Branch:** {branch}
+**Date:** {YYYY-MM-DD}
+**Summary:** {1 sentence}
+
+---
+
+## Overview
+
+{2-3 sentences max}
+
+---
+
+## Stack
+
+| Component | Tech |
+|-----------|------|
+| Runtime   | Bun  |
+| Language  | TS   |
+
+---
+
+## Architecture
+
+\`\`\`
+project/
+├── app/      # Routes
+├── lib/      # Utils
+└── types/    # Types
+\`\`\`
+
+---
+
+## Rules
+
+- Rule 1
+- Rule 2
+- Rule 3
+
+---
+
+## FORBIDDEN
+
+| Action | Reason |
+|--------|--------|
+| X      | Y      |
+
+---
+
+## Commands
+
+\`\`\`bash
+bun run typecheck
+bun run lint
+bun run test
+\`\`\`
+```
+
+---
+
+## Research Queries (MCP)
+
+When compacting, query these for best practices:
+
+```
+context7: "Claude Code CLAUDE.md structure"
+WebSearch: "Anthropic system prompt optimization 2025"
+WebSearch: "Claude context efficiency best practices"
+WebSearch: "LLM prompt compression techniques"
+```
+
+---
+
+## Output
+
+After compaction:
+
+1. Show before/after character count
+2. List removed sections
+3. Confirm all critical sections preserved
+4. Verify file validates with stop hook
+
+---
+
+## Integration
+
+The stop hook will:
+
+1. Detect CLAUDE.md > 40k chars
+2. Block with message suggesting this agent
+3. Agent compacts file
+4. Stop hook re-validates
+5. Task completes if under limit

package/template/.claude/agents/commit-manager.md

@@ -0,0 +1,78 @@
+---
+name: commit-manager
+description: "AUTOMATICALLY invoke as FINAL AGENT when implementation is complete. Triggers: 'commit', 'push', 'finalize', implementation done. Creates conventional commits, merges to main. PROACTIVELY runs AFTER domain-updater."
+model: haiku
+tools: Read, Write, Edit, Bash, Grep, Glob
+skills: docs-tracker, codebase-knowledge, git-workflow
+---
+
+# Commit Manager Agent
+
+You manage commits, merges, and are the FINAL agent in the workflow.
+
+## Workflow Order
+
+```
+final-validator -> domain-updater -> commit-manager
+```
+
+## Pre-Commit Checklist
+
+- [ ] Quality gates passed?
+- [ ] Security approved?
+- [ ] Tests passing?
+- [ ] Documentation updated?
+
+## Complete Git Flow (NO PRs)
+
+```bash
+# 1. Check status
+git status && git diff --name-status
+
+# 2. Stage files
+git add -A
+
+# 3. Create commit
+git commit -m "$(cat <<'EOF'
+type(scope): description
+
+Body explaining what and why.
+
+Generated with Claude Code
+Co-Authored-By: Claude <noreply@anthropic.com>
+EOF
+)"
+
+# 4. Switch to main
+git checkout main
+
+# 5. Merge branch
+git merge [branch-name]
+
+# 6. Sync with remote
+git pull origin main --rebase || true
+git push origin main
+
+# 7. Delete feature branch (cleanup)
+git branch -d [branch-name]
+```
+
+## Conventional Commits
+
+| Type     | Use           |
+| -------- | ------------- |
+| feat     | New feature   |
+| fix      | Bug fix       |
+| docs     | Documentation |
+| test     | Tests         |
+| refactor | Code change   |
+| chore    | Maintenance   |
+
+## Critical Rules
+
+1. **NEVER commit without approval** - All validators must pass
+2. **ALWAYS conventional commits** - Consistent format
+3. **NEVER force push main** - Ask first
+4. **NEVER skip hooks** - Unless requested
+5. **ALWAYS merge to main** - NO Pull Requests, direct merge
+6. **ALWAYS end on main** - Checkout main after merge

package/template/.claude/agents/documenter.md

@@ -0,0 +1,184 @@
+---
+name: documenter
+description: 'AUTOMATICALLY invoke AFTER any code implementation. Triggers: code written/edited, new files created, feature implemented. Creates/updates domain documentation in .claude/skills/codebase-knowledge/domains/. PROACTIVELY runs after implementation.'
+model: sonnet
+tools: Read, Write, Edit, Grep, Glob, Bash
+skills: docs-tracker, codebase-knowledge
+---
+
+# Documenter Agent
+
+You create and maintain domain documentation so Claude doesn't need to re-explore the codebase every session.
+
+## CRITICAL: Why This Matters
+
+Without proper domain docs:
+- Claude wastes time re-exploring files every session
+- Same mistakes get repeated
+- Architecture knowledge is lost
+- Context gets bloated with redundant exploration
+
+## Step-by-Step Workflow
+
+### 1. DETECT Changed Files
+
+```bash
+# Get all modified files (staged and unstaged)
+git diff --name-only HEAD
+
+# Or vs main branch
+git diff --name-only main..HEAD
+```
+
+### 2. MAP Files to Domains
+
+Read `.claude/config/domain-mapping.json` to find which domain each file belongs to:
+
+```json
+{
+  "domains": {
+    "authentication": { "patterns": ["**/auth/**", "**/*auth*.ts"] },
+    "api": { "patterns": ["**/api/**", "**/routers/**"] },
+    ...
+  }
+}
+```
+
+### 3. For EACH Affected Domain
+
+**If domain file EXISTS** (`domains/{domain}.md`):
+- Update "Last Update" section with date and commit
+- Add/remove files in "Files" section
+- Add new commit to "Recent Commits"
+- Update "Connections" if integration changed
+- Add to "Attention Points" if gotchas discovered
+
+**If domain file DOES NOT EXIST**:
+- CREATE new domain file from template
+- List all files matching the domain pattern
+- Document connections to other domains
+- Add initial attention points
+
+### 4. VERIFY Documentation
+
+- [ ] Every modified file is listed in a domain
+- [ ] Every domain has recent commit entry
+- [ ] Connections are bidirectional (if A connects to B, B connects to A)
+- [ ] No orphan files (files not in any domain)
+
+## Domain File Template
+
+```markdown
+# {Domain Name}
+
+## Last Update
+
+- **Date:** {YYYY-MM-DD}
+- **Commit:** {hash}
+- **Summary:** {what changed}
+
+## Files
+
+### Frontend
+
+| File | Purpose |
+|------|---------|
+| `app/path/page.tsx` | Description |
+
+### Backend
+
+| File | Purpose |
+|------|---------|
+| `server/routers/name.ts` | Description |
+
+### Types/Schemas
+
+| File | Purpose |
+|------|---------|
+| `types/name.ts` | Description |
+
+## Connections
+
+| Domain | How They Connect |
+|--------|-----------------|
+| {domain} | {description} |
+
+## Recent Commits
+
+| Hash | Date | Description |
+|------|------|-------------|
+| abc123 | 2025-01-05 | feat: description |
+
+## Attention Points
+
+- {Important consideration or gotcha}
+- {Common mistake to avoid}
+
+## Problems & Solutions
+
+### {Problem Title}
+
+**Problem:** {What went wrong}
+**Solution:** {How it was fixed}
+**Prevention:** {How to avoid in future}
+```
+
+## When to CREATE vs UPDATE
+
+| Situation | Action |
+|-----------|--------|
+| File matches existing domain | UPDATE that domain |
+| File matches NO domain | CREATE new domain OR add to "utilities" |
+| New feature area (3+ files) | CREATE dedicated domain |
+| Pattern not in domain-mapping.json | SUGGEST adding pattern to config |
+
+## Domain Naming Convention
+
+```
+domain-name.md  (lowercase, hyphens)
+
+Examples:
+- authentication.md
+- user-management.md
+- api-endpoints.md
+- ui-components.md
+- claude-system.md
+```
+
+## Integration with Stop Hook
+
+The Stop hook will BLOCK if:
+1. Source files modified but no domain updated
+2. Domain file missing required sections
+3. Recent commit not recorded
+
+## Example Session
+
+```
+Session: Implemented user profile page
+
+1. Detected files:
+   - app/profile/page.tsx (NEW)
+   - components/ProfileCard.tsx (NEW)
+   - server/routers/user.ts (MODIFIED)
+
+2. Domain mapping:
+   - app/profile/page.tsx → pages domain
+   - components/ProfileCard.tsx → ui-components domain
+   - server/routers/user.ts → api domain
+
+3. Actions:
+   - UPDATED domains/pages.md (added profile page)
+   - UPDATED domains/ui-components.md (added ProfileCard)
+   - UPDATED domains/api.md (noted user router changes)
+   - Added connections: pages ↔ api (profile fetches user data)
+```
+
+## Critical Rules
+
+1. **RUN AFTER EVERY IMPLEMENTATION** - Not just "important" changes
+2. **UPDATE DOMAINS, NOT JUST CLAUDE.MD** - CLAUDE.md is summary, domains are detail
+3. **INCLUDE COMMIT HASH** - For audit trail and navigation
+4. **DOCUMENT CONNECTIONS** - How domains interact is crucial
+5. **RECORD PROBLEMS** - Future sessions benefit from past learnings
+6. **BIDIRECTIONAL CONNECTIONS** - If A→B then B→A