vibe-coder-kit 6.0.0

package/.vibe/behaviors/assumption.md

@@ -0,0 +1,43 @@
+# Assumption Management Protocol
+
+## Core Rule
+Never make assumptions without stating them. If unsure, ask.
+
+## Confidence Threshold
+
+| Confidence | Action |
+|------------|--------|
+| ≥ 80% | Proceed, but state assumption |
+| 60-79% | Research first (codebase-memory, context7, websearch) |
+| 40-59% | Ask user |
+| < 40% | Stop, cannot proceed |
+
+## Research Order
+
+1. **Existing codebase** (codebase-memory)
+2. **Documentation** (context7)
+3. **Web research** (websearch)
+4. **Ask user** (question tool)
+
+## Assumption Documentation
+
+When making an assumption, document it:
+```
+Assumption: [what you're assuming]
+Basis: [why you think this]
+Risk: [what could go wrong]
+Mitigation: [how to handle if wrong]
+```
+
+## High-Risk Patterns to Watch
+
+- "It probably works like..." → VERIFY
+- "Everyone knows that..." → EXPLAIN
+- "Obviously..." → CHECK
+- "It must be..." → PROVE
+
+## Low-Risk Patterns
+
+- "Probably..." → State it
+- "I think..." → Note it
+- "If... then..." → Document as conditional

package/.vibe/behaviors/honesty.md

@@ -0,0 +1,49 @@
+# Honesty Protocol
+
+## Core Principles
+
+### Never Do
+- Don't say something is correct when you're not sure
+- Don't use empty praise ("great idea!", "perfect!")
+- Don't agree without considering alternatives
+- Don't give short/robotic answers
+- Don't hide uncertainty
+
+### Always Do
+- Explain what you did and why
+- Say "I don't know" or "I need to research" when appropriate
+- Present both pros and cons
+- State your assumptions clearly
+- Provide detailed explanations
+
+## Response Format
+
+Every response should include:
+1. **What I did**: [description]
+2. **Why**: [reasoning]
+3. **What went well**: [positive aspects]
+4. **What could be improved**: [critique]
+5. **Assumptions**: [list]
+
+## Anti-Sycophancy Rules
+
+- Never blindly agree with the user
+- Always present alternative viewpoints
+- Point out potential risks before implementation
+- Ask "Have you considered...?" when appropriate
+- Be honest about trade-offs
+
+## Uncertainty Handling
+
+| Confidence | Action |
+|------------|--------|
+| ≥ 80% | Proceed with explanation |
+| 60-79% | Research more, then decide |
+| 40-59% | Ask user for guidance |
+| < 40% | Stop, ask for help |
+
+## Example
+
+Bad: "This is a great idea! Let me implement it right away!"
+
+Good: "This approach has these advantages: [...]. However, there are some concerns: [...]. An alternative would be [...]. Which direction would you prefer?"

package/.vibe/behaviors/reflection.md

@@ -0,0 +1,56 @@
+# Self-Reflection Protocol
+
+## When to Reflect
+- At the end of each phase
+- After significant decisions
+- When facing uncertainty
+
+## Reflection Template
+
+```markdown
+## Self-Reflection
+
+**Phase:** [phase name]
+**Date:** [date]
+**Confidence:** [1-10]
+
+### What Went Well
+- [positive point 1]
+- [positive point 2]
+
+### What Could Be Improved
+- [improvement 1]
+- [improvement 2]
+
+### Assumptions Made
+- [assumption 1]
+- [assumption 2]
+
+### Scale Notes
+- How would this perform at 1M users?
+- What bottlenecks exist?
+
+### Production Risks
+- What could go wrong in production?
+- What monitoring is needed?
+```
+
+## Confidence Scale
+
+| Level | Meaning | Action |
+|-------|---------|--------|
+| 10 | Certain | Proceed confidently |
+| 8-9 | Very confident | Proceed with minor notes |
+| 6-7 | Confident | Note concerns |
+| 4-5 | Uncertain | Research more |
+| 2-3 | Very uncertain | Ask for help |
+| 1 | Clueless | Stop, cannot proceed |
+
+## Quality Checklist
+
+Before completing reflection:
+- [ ] Confidence level assigned
+- [ ] Pros and cons listed
+- [ ] Assumptions documented
+- [ ] Scale considerations noted
+- [ ] Production risks identified

package/.vibe/config.json

@@ -0,0 +1,25 @@
+{
+  "version": "1.0.0",
+  "projectType": "web",
+  "teamSize": "solo",
+  "painPoint": "consistency",
+  "experienceLevel": "beginner",
+  "activePhases": ["init", "clarify", "code", "review", "learn"],
+  "activeRules": 12,
+  "subagentsRequired": false,
+  "selfReflectionRequired": false,
+  "telemetry": {
+    "enabled": true,
+    "exportInterval": 300000
+  },
+  "healthChecks": {
+    "enabled": true,
+    "interval": 30000,
+    "timeout": 5000
+  },
+  "costTracking": {
+    "enabled": true,
+    "budgetPerSession": 100000,
+    "alertThreshold": 80
+  }
+}

package/.vibe/core/circuit-breaker.ts

@@ -0,0 +1,113 @@
+// Circuit Breaker Pattern
+// Protects against cascading failures in agent operations
+
+export type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+
+export interface CircuitBreakerConfig {
+  failureThreshold: number;
+  resetTimeoutMs: number;
+  halfOpenMaxAttempts: number;
+}
+
+export class CircuitBreaker {
+  private state: CircuitState = 'CLOSED';
+  private failures = 0;
+  private lastFailureTime = 0;
+  private halfOpenAttempts = 0;
+  private config: CircuitBreakerConfig;
+
+  constructor(config?: Partial<CircuitBreakerConfig>) {
+    this.config = {
+      failureThreshold: config?.failureThreshold ?? 3,
+      resetTimeoutMs: config?.resetTimeoutMs ?? 60000,
+      halfOpenMaxAttempts: config?.halfOpenMaxAttempts ?? 1,
+    };
+  }
+
+  getState(): CircuitState {
+    return this.state;
+  }
+
+  private checkTransition(): void {
+    if (this.state === 'OPEN') {
+      if (Date.now() - this.lastFailureTime >= this.config.resetTimeoutMs) {
+        this.state = 'HALF_OPEN';
+        this.halfOpenAttempts = 0;
+      }
+    }
+  }
+
+  async execute<T>(operation: () => Promise<T>): Promise<T> {
+    this.checkTransition();
+    const currentState = this.getState();
+    
+    if (currentState === 'OPEN') {
+      throw new CircuitOpenError(
+        `Circuit breaker is OPEN. Retry after ${this.config.resetTimeoutMs}ms`
+      );
+    }
+
+    if (currentState === 'HALF_OPEN' && this.halfOpenAttempts >= this.config.halfOpenMaxAttempts) {
+      throw new CircuitOpenError(
+        `Circuit breaker is HALF_OPEN. Max attempts reached.`
+      );
+    }
+
+    try {
+      const result = await operation();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+
+  private onSuccess(): void {
+    if (this.state === 'HALF_OPEN') {
+      this.state = 'CLOSED';
+      this.failures = 0;
+      this.halfOpenAttempts = 0;
+      console.log('[CircuitBreaker] State: HALF_OPEN -> CLOSED');
+    }
+  }
+
+  private onFailure(): void {
+    this.failures++;
+    this.lastFailureTime = Date.now();
+
+    if (this.state === 'HALF_OPEN') {
+      this.halfOpenAttempts++;
+      if (this.halfOpenAttempts >= this.config.halfOpenMaxAttempts) {
+        this.state = 'OPEN';
+        console.log('[CircuitBreaker] State: HALF_OPEN -> OPEN');
+      }
+    } else if (this.failures >= this.config.failureThreshold) {
+      this.state = 'OPEN';
+      console.log(`[CircuitBreaker] State: CLOSED -> OPEN (${this.failures} failures)`);
+    }
+  }
+
+  reset(): void {
+    this.state = 'CLOSED';
+    this.failures = 0;
+    this.halfOpenAttempts = 0;
+  }
+
+  getStats(): { state: CircuitState; failures: number; lastFailure: string | null } {
+    return {
+      state: this.getState(),
+      failures: this.failures,
+      lastFailure: this.lastFailureTime
+        ? new Date(this.lastFailureTime).toISOString()
+        : null,
+    };
+  }
+}
+
+export class CircuitOpenError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'CircuitOpenError';
+  }
+}

package/.vibe/core/cli.ts

@@ -0,0 +1,280 @@
+// CLI Interface
+// vibe init, vibe status, vibe run, vibe doctor, vibe rollback
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+export interface CLIConfig {
+  projectType: 'web' | 'api' | 'mobile' | 'data' | 'unknown';
+  teamSize: 'solo' | 'small' | 'medium' | 'large';
+  painPoint: 'consistency' | 'review' | 'onboarding' | 'debt';
+}
+
+export interface StatusReport {
+  currentPhase: string;
+  progress: number;
+  activeAgent: string | null;
+  contextUsage: { used: number; total: number };
+  duration: string;
+  recentEvents: Array<{ phase: string; type: string; time: string }>;
+}
+
+export class VibeCLI {
+  private rootDir: string;
+  private configPath: string;
+
+  constructor(rootDir: string) {
+    this.rootDir = rootDir;
+    this.configPath = join(rootDir, '.vibe', 'config.json');
+  }
+
+  async init(options?: { template?: string; interactive?: boolean }): Promise<void> {
+    console.log('🚀 Vibe Coder Kit — Initial Setup\n');
+
+    // Auto-detect project type
+    const detected = this.detectProject();
+    console.log(`✓ Proje tespit edildi: ${detected.type} (${detected.stack})`);
+    
+    // Load or create config
+    const config: CLIConfig = {
+      projectType: detected.type as CLIConfig['projectType'],
+      teamSize: 'solo',
+      painPoint: 'consistency',
+    };
+
+    // Write config
+    writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+    console.log('✓ Yapılandırma kaydedildi');
+
+    // Initialize directories
+    this.ensureDirectories();
+    console.log('✓ Dizinler hazırlandı');
+
+    // Initialize state
+    this.initializeState();
+    console.log('✓ State başlatıldı');
+
+    // Initialize knowledge base
+    this.initializeKnowledge();
+    console.log('✓ Knowledge base başlatıldı');
+
+    console.log('\n🚀 Hazır! "vibe status" ile durumu kontrol edin.\n');
+  }
+
+  private detectProject(): { type: string; stack: string } {
+    const packageJsonPath = join(this.rootDir, 'package.json');
+    const cargoTomlPath = join(this.rootDir, 'Cargo.toml');
+    const requirementsPath = join(this.rootDir, 'requirements.txt');
+    const pubspecPath = join(this.rootDir, 'pubspec.yaml');
+
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        
+        if (deps['next'] || deps['react'] || deps['vue']) {
+          return { type: 'web', stack: 'Node.js' };
+        }
+        if (deps['express'] || deps['fastify'] || deps['nestjs']) {
+          return { type: 'api', stack: 'Node.js' };
+        }
+        return { type: 'unknown', stack: 'Node.js' };
+      } catch {
+        return { type: 'unknown', stack: 'Node.js' };
+      }
+    }
+
+    if (existsSync(cargoTomlPath)) return { type: 'api', stack: 'Rust' };
+    if (existsSync(requirementsPath)) return { type: 'data', stack: 'Python' };
+    if (existsSync(pubspecPath)) return { type: 'mobile', stack: 'Flutter' };
+
+    return { type: 'unknown', stack: 'Unknown' };
+  }
+
+  private ensureDirectories(): void {
+    const dirs = [
+      '.vibe/state', '.vibe/state/snapshots',
+      '.vibe/memory/knowledge', '.vibe/memory/decisions',
+      '.vibe/memory/gotchas', '.vibe/memory/conventions',
+      '.vibe/workspace/plans', '.vibe/workspace/reports',
+      '.vibe/workspace/archive',
+    ];
+    for (const dir of dirs) {
+      const fullPath = join(this.rootDir, dir);
+      if (!existsSync(fullPath)) {
+        mkdirSync(fullPath, { recursive: true });
+      }
+    }
+  }
+
+  private initializeState(): void {
+    const eventsPath = join(this.rootDir, '.vibe/state/events.jsonl');
+    if (!existsSync(eventsPath)) {
+      writeFileSync(eventsPath, '');
+    }
+  }
+
+  private initializeKnowledge(): void {
+    const indexPath = join(this.rootDir, '.vibe/memory/INDEX.md');
+    if (!existsSync(indexPath)) {
+      writeFileSync(indexPath, '# Knowledge Index\n\n| # | Date | Title | Tags | File |\n|---|------|-------|------|------|\n');
+    }
+  }
+
+  status(): StatusReport {
+    const eventsPath = join(this.rootDir, '.vibe/state/events.jsonl');
+    let events: Array<{ phase: string; type: string; timestamp: string }> = [];
+    
+    if (existsSync(eventsPath)) {
+      try {
+        const content = readFileSync(eventsPath, 'utf-8');
+        events = content.split('\n').filter(l => l.trim()).map(l => {
+          try {
+            return JSON.parse(l);
+          } catch {
+            return null;
+          }
+        }).filter((e): e is { phase: string; type: string; timestamp: string } => e !== null);
+      } catch {
+        events = [];
+      }
+    }
+
+    const lastEvent = events[events.length - 1];
+    const currentPhase = lastEvent?.phase || 'init';
+    
+    const phaseProgress: Record<string, number> = {
+      init: 10, clarify: 20, brainstorm: 30, plan: 40,
+      approve: 50, code: 70, review: 85, fix: 85,
+      learn: 95, deploy: 98, done: 100,
+    };
+
+    return {
+      currentPhase,
+      progress: phaseProgress[currentPhase] || 0,
+      activeAgent: lastEvent?.type === 'STARTED' ? 'running' : null,
+      contextUsage: { used: 0, total: 8000 },
+      duration: this.calculateDuration(events),
+      recentEvents: events.slice(-5).map(e => ({
+        phase: e.phase,
+        type: e.type,
+        time: e.timestamp,
+      })),
+    };
+  }
+
+  private calculateDuration(events: Array<{ timestamp: string }>): string {
+    if (events.length < 2) return '0m';
+    const first = new Date(events[0].timestamp);
+    const last = new Date(events[events.length - 1].timestamp);
+    const diffMs = last.getTime() - first.getTime();
+    const minutes = Math.floor(diffMs / 60000);
+    if (minutes < 60) return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+  }
+
+  doctor(): Array<{ check: string; status: 'ok' | 'warning' | 'error'; message: string }> {
+    const results: Array<{ check: string; status: 'ok' | 'warning' | 'error'; message: string }> = [];
+
+    // Check CLI version
+    results.push({ check: 'CLI Version', status: 'ok', message: '1.0.0 (latest)' });
+
+    // Check Node.js
+    const nodeVersion = process.version;
+    results.push({
+      check: 'Node.js',
+      status: parseInt(nodeVersion.slice(1)) >= 18 ? 'ok' : 'error',
+      message: `${nodeVersion} (required: >=18)`,
+    });
+
+    // Check config
+    results.push({
+      check: 'Config',
+      status: existsSync(this.configPath) ? 'ok' : 'error',
+      message: existsSync(this.configPath) ? 'Loaded' : 'Not found',
+    });
+
+    // Check state
+    const eventsPath = join(this.rootDir, '.vibe/state/events.jsonl');
+    results.push({
+      check: 'State',
+      status: existsSync(eventsPath) ? 'ok' : 'warning',
+      message: existsSync(eventsPath) ? 'Clean' : 'No events yet',
+    });
+
+    // Check knowledge base
+    const indexPath = join(this.rootDir, '.vibe/memory/INDEX.md');
+    results.push({
+      check: 'Knowledge Base',
+      status: existsSync(indexPath) ? 'ok' : 'warning',
+      message: existsSync(indexPath) ? 'Initialized' : 'Not initialized',
+    });
+
+    return results;
+  }
+
+  displayStatus(): void {
+    const status = this.status();
+    const bar = '█'.repeat(Math.floor(status.progress / 5)) + '░'.repeat(20 - Math.floor(status.progress / 5));
+    
+    console.log('┌────────────────────────────────────────────┐');
+    console.log(`│ Phase: ${status.currentPhase.padEnd(20)} [${bar}] ${status.progress}% │`);
+    console.log(`│ Agent: ${(status.activeAgent || 'idle').padEnd(29)} │`);
+    console.log(`│ Context: ${status.contextUsage.used} / ${status.contextUsage.total} tokens${' '.repeat(Math.max(0, 16 - String(status.contextUsage.used).length - String(status.contextUsage.total).length))}│`);
+    console.log(`│ Duration: ${status.duration.padEnd(28)} │`);
+    console.log('└────────────────────────────────────────────┘');
+    
+    if (status.recentEvents.length > 0) {
+      console.log('\nRecent events:');
+      for (const event of status.recentEvents) {
+        const icon = event.type === 'COMPLETED' ? '✓' : event.type === 'FAILED' ? '✗' : '→';
+        console.log(`  ${icon} ${event.phase} — ${event.type} (${new Date(event.time).toLocaleTimeString()})`);
+      }
+    }
+  }
+
+  displayDoctor(): void {
+    const results = this.doctor();
+    console.log('\nVibe Coder Kit — Health Check\n');
+    
+    for (const r of results) {
+      const icon = r.status === 'ok' ? '✓' : r.status === 'warning' ? '⚠' : '✗';
+      console.log(`${icon} ${r.check}: ${r.message}`);
+    }
+    
+    const errors = results.filter(r => r.status === 'error');
+    if (errors.length > 0) {
+      console.log(`\n${errors.length} error(s) found. Run 'vibe doctor --fix' to resolve.`);
+    } else {
+      console.log('\n✓ All checks passed.');
+    }
+  }
+}
+
+// CLI Entry Point
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const rootDir = process.cwd();
+  
+  const cli = new VibeCLI(rootDir);
+  
+  switch (command) {
+    case 'init':
+      cli.init().catch(console.error);
+      break;
+    case 'status':
+      cli.displayStatus();
+      break;
+    case 'doctor':
+      cli.displayDoctor();
+      break;
+    default:
+      console.log('Vibe Coder Kit v6.0.0\n');
+      console.log('Commands:');
+      console.log('  vibe init     — Initialize project');
+      console.log('  vibe status   — Show current status');
+      console.log('  vibe doctor   — Health check');
+  }
+}