vibe-coder-kit 6.0.0

package/.vibe/core/knowledge-store.ts

@@ -0,0 +1,199 @@
+// Knowledge Store
+// Semantic search and knowledge management
+
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
+import { join, resolve, normalize } from 'path';
+
+export interface KnowledgeEntry {
+  id: string;
+  title: string;
+  date: string;
+  tags: string[];
+  context: string;
+  solution: string;
+  phase?: string;
+  relatedEntries?: string[];
+  embedding?: number[];
+}
+
+export interface SearchResult {
+  entry: KnowledgeEntry;
+  score: number;
+}
+
+export class KnowledgeStore {
+  private knowledgeDir: string;
+  private indexPath: string;
+  private entries: KnowledgeEntry[] = [];
+
+  constructor(knowledgeDir: string) {
+    // Normalize and validate path to prevent path traversal
+    this.knowledgeDir = resolve(normalize(knowledgeDir));
+    this.indexPath = join(this.knowledgeDir, 'INDEX.md');
+    this.loadEntries();
+  }
+
+  private isPathSafe(filePath: string): boolean {
+    const resolved = resolve(normalize(filePath));
+    return resolved.startsWith(this.knowledgeDir);
+  }
+
+  private loadEntries(): void {
+    if (!existsSync(this.knowledgeDir)) {
+      console.warn(`[KnowledgeStore] Directory not found: ${this.knowledgeDir}`);
+      return;
+    }
+    
+    try {
+      const files = readdirSync(this.knowledgeDir).filter(f => f.endsWith('.md') && f !== 'INDEX.md');
+      
+      for (const file of files) {
+        const filePath = join(this.knowledgeDir, file);
+        
+        // Path traversal check
+        if (!this.isPathSafe(filePath)) {
+          console.warn(`[KnowledgeStore] Skipping potentially unsafe path: ${file}`);
+          continue;
+        }
+        
+        try {
+          const content = readFileSync(filePath, 'utf-8');
+          const entry = this.parseEntry(content, file);
+          if (entry) this.entries.push(entry);
+        } catch (e) {
+          console.error(`[KnowledgeStore] Failed to read ${file}: ${(e as Error).message}`);
+        }
+      }
+    } catch (e) {
+      console.error(`[KnowledgeStore] Failed to load entries: ${(e as Error).message}`);
+    }
+  }
+
+  private parseEntry(content: string, filename: string): KnowledgeEntry | null {
+    const titleMatch = content.match(/^#\s+(.+)/m);
+    const dateMatch = content.match(/\*\*Date:\*\*\s*(.+)/);
+    const tagsMatch = content.match(/\*\*Tags:\*\*\s*(.+)/);
+    const contextMatch = content.match(/## Context\n([\s\S]*?)(?=\n##|$)/);
+    const solutionMatch = content.match(/## Solution\n([\s\S]*?)(?=\n##|$)/);
+    const phaseMatch = content.match(/\*\*Phase:\*\*\s*(.+)/);
+
+    if (!titleMatch) return null;
+
+    return {
+      id: filename.replace('.md', ''),
+      title: titleMatch[1].trim(),
+      date: dateMatch?.[1]?.trim() || new Date().toISOString().split('T')[0],
+      tags: tagsMatch?.[1]?.split(',').map(t => t.trim()) || [],
+      context: contextMatch?.[1]?.trim() || '',
+      solution: solutionMatch?.[1]?.trim() || '',
+      phase: phaseMatch?.[1]?.trim(),
+    };
+  }
+
+  addEntry(entry: Omit<KnowledgeEntry, 'id'>): KnowledgeEntry {
+    const id = `knowledge-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const newEntry: KnowledgeEntry = { ...entry, id };
+    this.entries.push(newEntry);
+    this.saveEntry(newEntry);
+    this.updateIndex();
+    return newEntry;
+  }
+
+  private saveEntry(entry: KnowledgeEntry): void {
+    const filePath = join(this.knowledgeDir, `${entry.id}.md`);
+    
+    // Path traversal check
+    if (!this.isPathSafe(filePath)) {
+      throw new Error(`Invalid file path: ${entry.id}.md`);
+    }
+    
+    const content = `# ${entry.title}
+
+**Date:** ${entry.date}
+**Tags:** ${entry.tags.join(', ')}
+${entry.phase ? `**Phase:** ${entry.phase}` : ''}
+
+## Context
+
+${entry.context}
+
+## Solution
+
+${entry.solution}
+
+${entry.relatedEntries?.length ? `## Related\n\n${entry.relatedEntries.map(r => `- ${r}`).join('\n')}` : ''}
+`;
+    writeFileSync(filePath, content);
+  }
+
+  private updateIndex(): void {
+    let index = '# Knowledge Index\n\n';
+    index += '| # | Date | Title | Tags | File |\n';
+    index += '|---|------|-------|------|------|\n';
+    
+    this.entries
+      .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
+      .forEach((entry, i) => {
+        index += `| ${i + 1} | ${entry.date} | ${entry.title} | ${entry.tags.join(', ')} | ${entry.id}.md |\n`;
+      });
+    
+    writeFileSync(this.indexPath, index);
+  }
+
+  search(query: string): SearchResult[] {
+    // Limit query length to prevent ReDoS
+    const sanitizedQuery = query.substring(0, 100);
+    const queryLower = sanitizedQuery.toLowerCase();
+    const queryWords = queryLower.split(/\s+/).filter(w => w.length > 0);
+
+    return this.entries
+      .map(entry => {
+        let score = 0;
+        const entryText = `${entry.title} ${entry.tags.join(' ')} ${entry.context} ${entry.solution}`.toLowerCase();
+
+        for (const word of queryWords) {
+          // Escape regex special characters
+          const escapedWord = word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+          const regex = new RegExp(escapedWord, 'gi');
+          
+          if (entryText.includes(word)) score += 1;
+          if (entry.title.toLowerCase().includes(word)) score += 2;
+          if (entry.tags.some(t => t.toLowerCase().includes(word))) score += 1.5;
+        }
+
+        return { entry, score };
+      })
+      .filter(r => r.score > 0)
+      .sort((a, b) => b.score - a.score);
+  }
+
+  getByTag(tag: string): KnowledgeEntry[] {
+    return this.entries.filter(e => e.tags.includes(tag));
+  }
+
+  getByPhase(phase: string): KnowledgeEntry[] {
+    return this.entries.filter(e => e.phase === phase);
+  }
+
+  getRecent(count: number = 10): KnowledgeEntry[] {
+    return [...this.entries]
+      .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
+      .slice(0, count);
+  }
+
+  getStats(): { total: number; byTag: Record<string, number>; byPhase: Record<string, number> } {
+    const byTag: Record<string, number> = {};
+    const byPhase: Record<string, number> = {};
+
+    for (const entry of this.entries) {
+      for (const tag of entry.tags) {
+        byTag[tag] = (byTag[tag] || 0) + 1;
+      }
+      if (entry.phase) {
+        byPhase[entry.phase] = (byPhase[entry.phase] || 0) + 1;
+      }
+    }
+
+    return { total: this.entries.length, byTag, byPhase };
+  }
+}

package/.vibe/core/plugin-registry.ts

@@ -0,0 +1,174 @@
+// Plugin Registry
+// Hot-reloadable plugin system for rules and hooks
+
+import { readFileSync, readdirSync, existsSync, watchFile } from 'fs';
+import { join, extname } from 'path';
+import { parse as parseYaml } from 'yaml';
+
+export interface Rule {
+  id: string;
+  name: string;
+  pattern?: string;
+  action: 'block' | 'warn' | 'info';
+  message: string;
+  severity: 'critical' | 'high' | 'medium' | 'low';
+  category: string;
+}
+
+export interface Hook {
+  phase: string;
+  action: string;
+  priority: number;
+  timing: 'pre' | 'post';
+}
+
+export interface Plugin {
+  name: string;
+  version: string;
+  description: string;
+  author: string;
+  rules: Rule[];
+  hooks: Hook[];
+  config: Record<string, unknown>;
+  enabled: boolean;
+}
+
+export class PluginRegistry {
+  private plugins: Map<string, Plugin> = new Map();
+  private pluginsDir: string;
+
+  constructor(pluginsDir: string) {
+    this.pluginsDir = pluginsDir;
+    this.loadPlugins();
+  }
+
+  private loadPlugins(): void {
+    const coreDir = join(this.pluginsDir, 'core');
+    const customDir = join(this.pluginsDir, 'custom');
+
+    if (existsSync(coreDir)) this.loadFromDir(coreDir);
+    if (existsSync(customDir)) this.loadFromDir(customDir);
+  }
+
+  private loadFromDir(dir: string): void {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const pluginDir = join(dir, entry.name);
+        const manifestPath = join(pluginDir, 'plugin.yaml');
+        
+        if (existsSync(manifestPath)) {
+          try {
+            const content = readFileSync(manifestPath, 'utf-8');
+            const manifest = parseYaml(content);
+            const rules = this.loadRules(pluginDir);
+            const hooks = this.loadHooks(pluginDir);
+            
+            const plugin: Plugin = {
+              name: manifest.name || entry.name,
+              version: manifest.version || '1.0.0',
+              description: manifest.description || '',
+              author: manifest.author || 'unknown',
+              rules,
+              hooks,
+              config: manifest.config || {},
+              enabled: manifest.enabled !== false,
+            };
+            
+            this.plugins.set(plugin.name, plugin);
+            console.log(`[PluginRegistry] Loaded: ${plugin.name} v${plugin.version} (${rules.length} rules, ${hooks.length} hooks)`);
+          } catch (err) {
+            console.error(`[PluginRegistry] Failed to load ${entry.name}:`, err);
+          }
+        }
+      }
+    }
+  }
+
+  private loadRules(pluginDir: string): Rule[] {
+    const rulesFile = join(pluginDir, 'rules.yaml');
+    if (!existsSync(rulesFile)) return [];
+    
+    try {
+      const content = readFileSync(rulesFile, 'utf-8');
+      const data = parseYaml(content);
+      return data.rules || [];
+    } catch {
+      return [];
+    }
+  }
+
+  private loadHooks(pluginDir: string): Hook[] {
+    const hooksFile = join(pluginDir, 'hooks.yaml');
+    if (!existsSync(hooksFile)) return [];
+    
+    try {
+      const content = readFileSync(hooksFile, 'utf-8');
+      const data = parseYaml(content);
+      return data.hooks || [];
+    } catch {
+      return [];
+    }
+  }
+
+  getPlugin(name: string): Plugin | undefined {
+    return this.plugins.get(name);
+  }
+
+  getAllPlugins(): Plugin[] {
+    return Array.from(this.plugins.values());
+  }
+
+  getEnabledPlugins(): Plugin[] {
+    return this.getAllPlugins().filter(p => p.enabled);
+  }
+
+  getAllRules(): Rule[] {
+    return this.getEnabledPlugins().flatMap(p => p.rules);
+  }
+
+  getHooksForPhase(phase: string, timing: 'pre' | 'post'): Hook[] {
+    return this.getEnabledPlugins()
+      .flatMap(p => p.hooks)
+      .filter(h => h.phase === phase && h.timing === timing)
+      .sort((a, b) => a.priority - b.priority);
+  }
+
+  validateRule(code: string): Array<{ rule: Rule; matched: boolean; line?: number }> {
+    const rules = this.getAllRules();
+    const results: Array<{ rule: Rule; matched: boolean; line?: number }> = [];
+    
+    for (const rule of rules) {
+      if (rule.pattern) {
+        try {
+          const regex = new RegExp(rule.pattern, 'gm');
+          const match = regex.exec(code);
+          results.push({
+            rule,
+            matched: match !== null,
+            line: match ? this.getLineNumber(code, match.index) : undefined,
+          });
+        } catch {
+          results.push({ rule, matched: false });
+        }
+      }
+    }
+    
+    return results;
+  }
+
+  private getLineNumber(code: string, index: number): number {
+    return code.substring(0, index).split('\n').length;
+  }
+
+  enablePlugin(name: string): void {
+    const plugin = this.plugins.get(name);
+    if (plugin) plugin.enabled = true;
+  }
+
+  disablePlugin(name: string): void {
+    const plugin = this.plugins.get(name);
+    if (plugin) plugin.enabled = false;
+  }
+}

package/.vibe/core/saga.ts

@@ -0,0 +1,141 @@
+// Saga Pattern
+// Compensating transactions for workflow rollback
+
+export interface SagaStep<T = unknown> {
+  name: string;
+  execute: () => Promise<T>;
+  compensate: (result: T) => Promise<void>;
+}
+
+export interface SagaConfig {
+  maxRetries: number;
+  retryDelayMs: number;
+  maxRetryDelayMs: number;
+  stepTimeoutMs: number;
+}
+
+export interface SagaResult {
+  success: boolean;
+  completedSteps: string[];
+  failedCompensations: string[];
+  error?: string;
+}
+
+export class Saga {
+  private steps: SagaStep[] = [];
+  private config: SagaConfig;
+
+  constructor(config?: Partial<SagaConfig>) {
+    this.config = {
+      maxRetries: Math.min(config?.maxRetries ?? 3, 10), // Cap at 10
+      retryDelayMs: config?.retryDelayMs ?? 1000,
+      maxRetryDelayMs: config?.maxRetryDelayMs ?? 30000, // 30s max
+      stepTimeoutMs: config?.stepTimeoutMs ?? 60000, // 60s per step
+    };
+  }
+
+  addStep<T>(step: SagaStep<T>): void {
+    this.steps.push(step as SagaStep);
+  }
+
+  async execute(): Promise<SagaResult> {
+    const completedSteps: Array<{ name: string; result: unknown }> = [];
+
+    for (const step of this.steps) {
+      let retries = 0;
+      let lastError: Error | undefined;
+
+      while (retries < this.config.maxRetries) {
+        try {
+          console.log(`[Saga] Executing: ${step.name} (attempt ${retries + 1})`);
+          
+          // Add timeout to step execution
+          const result = await this.executeWithTimeout(
+            () => step.execute(),
+            this.config.stepTimeoutMs
+          );
+          
+          completedSteps.push({ name: step.name, result });
+          break;
+        } catch (error) {
+          lastError = error as Error;
+          retries++;
+          
+          if (retries < this.config.maxRetries) {
+            const delayMs = Math.min(
+              this.config.retryDelayMs * retries,
+              this.config.maxRetryDelayMs
+            );
+            console.log(`[Saga] Retrying ${step.name} (${retries}/${this.config.maxRetries}) after ${delayMs}ms`);
+            await this.delay(delayMs);
+          }
+        }
+      }
+
+      if (lastError && retries >= this.config.maxRetries) {
+        console.log(`[Saga] Step ${step.name} failed after ${retries} retries`);
+        const failedCompensations = await this.compensate([...completedSteps].reverse());
+        return {
+          success: false,
+          completedSteps: completedSteps.map(s => s.name),
+          failedCompensations,
+          error: `Step ${step.name} failed: ${lastError.message}`,
+        };
+      }
+    }
+
+    return {
+      success: true,
+      completedSteps: completedSteps.map(s => s.name),
+      failedCompensations: [],
+    };
+  }
+
+  private async executeWithTimeout<T>(
+    operation: () => Promise<T>,
+    timeoutMs: number
+  ): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error(`Operation timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      operation()
+        .then(result => {
+          clearTimeout(timeoutId);
+          resolve(result);
+        })
+        .catch(error => {
+          clearTimeout(timeoutId);
+          reject(error);
+        });
+    });
+  }
+
+  private async compensate(completedSteps: Array<{ name: string; result: unknown }>): Promise<string[]> {
+    console.log('[Saga] Compensating completed steps...');
+    const failedCompensations: string[] = [];
+    
+    for (const { name, result } of completedSteps) {
+      const step = this.steps.find(s => s.name === name);
+      if (step) {
+        try {
+          console.log(`[Saga] Compensating: ${name}`);
+          await this.executeWithTimeout(
+            () => step.compensate(result),
+            this.config.stepTimeoutMs
+          );
+        } catch (error) {
+          console.error(`[Saga] Compensation failed for ${name}:`, (error as Error).message);
+          failedCompensations.push(name);
+        }
+      }
+    }
+    return failedCompensations;
+  }
+
+  private delay(ms: number): Promise<void> {
+    const delayMs = Math.max(0, Math.min(ms, this.config.maxRetryDelayMs));
+    return new Promise(resolve => setTimeout(resolve, delayMs));
+  }
+}