wogiflow 1.0.0

package/scripts/flow-step-coverage.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Coverage Check Step
+ *
+ * Checks test coverage meets threshold.
+ * Supports Jest, Vitest, NYC/Istanbul coverage formats.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { getProjectRoot, colors, getConfig } = require('./flow-utils');
+
+const PROJECT_ROOT = getProjectRoot();
+
+// Common coverage output locations
+const COVERAGE_PATHS = [
+  'coverage/coverage-summary.json',   // Jest/Vitest JSON summary
+  'coverage/coverage-final.json',     // Istanbul/NYC
+  'coverage/lcov-report/index.html',  // LCOV HTML
+  '.nyc_output/coverage.json',        // NYC output
+];
+
+/**
+ * Run coverage check step
+ *
+ * @param {object} options
+ * @param {string[]} options.files - Files modified
+ * @param {object} options.stepConfig - Step configuration
+ * @param {string} options.mode - Step mode (block/warn/prompt/auto)
+ * @returns {object} - { passed: boolean, message: string, coverage?: object }
+ */
+async function run(options = {}) {
+  const { files = [], stepConfig = {}, mode } = options;
+  const minCoverage = stepConfig.minCoverage || 80;
+  const checkFiles = stepConfig.checkModifiedOnly ?? true;
+
+  // Try to find existing coverage data
+  let coverage = findExistingCoverage();
+
+  // If no coverage found, try to run tests with coverage
+  if (!coverage && stepConfig.runTests !== false) {
+    coverage = await runCoverageTests();
+  }
+
+  if (!coverage) {
+    return {
+      passed: true,
+      message: 'No coverage data available',
+      suggestion: 'Run tests with coverage: npm test -- --coverage',
+    };
+  }
+
+  // Check overall coverage
+  const overall = coverage.total || coverage;
+  const metrics = ['lines', 'statements', 'branches', 'functions'];
+
+  const results = {};
+  let allPassing = true;
+
+  for (const metric of metrics) {
+    if (overall[metric]) {
+      const pct = overall[metric].pct ?? overall[metric].percent ?? overall[metric];
+      if (typeof pct === 'number') {
+        results[metric] = pct;
+        if (pct < minCoverage) {
+          allPassing = false;
+        }
+      }
+    }
+  }
+
+  // Check coverage for modified files specifically
+  let modifiedFileCoverage = null;
+  if (checkFiles && files.length > 0 && coverage.files) {
+    modifiedFileCoverage = checkModifiedFilesCoverage(files, coverage.files, minCoverage);
+  }
+
+  // Report results
+  if (Object.keys(results).length > 0) {
+    console.log(colors.yellow + `\n  Coverage (threshold: ${minCoverage}%):` + colors.reset);
+    for (const [metric, pct] of Object.entries(results)) {
+      const color = pct >= minCoverage ? colors.green : colors.red;
+      const icon = pct >= minCoverage ? '✓' : '✗';
+      console.log(`    ${color}${icon}${colors.reset} ${metric}: ${pct.toFixed(1)}%`);
+    }
+  }
+
+  if (modifiedFileCoverage && modifiedFileCoverage.uncovered.length > 0) {
+    console.log(colors.yellow + '\n  Modified files with low coverage:' + colors.reset);
+    for (const file of modifiedFileCoverage.uncovered) {
+      console.log(colors.red + `    ✗ ${file.name}: ${file.coverage.toFixed(1)}%` + colors.reset);
+    }
+  }
+
+  if (!allPassing) {
+    return {
+      passed: false,
+      message: `Coverage below ${minCoverage}% threshold`,
+      coverage: results,
+      modifiedFileCoverage,
+    };
+  }
+
+  return {
+    passed: true,
+    message: `Coverage meets ${minCoverage}% threshold`,
+    coverage: results,
+  };
+}
+
+/**
+ * Find existing coverage data
+ */
+function findExistingCoverage() {
+  for (const coveragePath of COVERAGE_PATHS) {
+    const fullPath = path.join(PROJECT_ROOT, coveragePath);
+    if (fs.existsSync(fullPath)) {
+      try {
+        if (coveragePath.endsWith('.json')) {
+          return JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+        }
+        // For HTML reports, try to find accompanying JSON
+        const jsonPath = fullPath.replace('.html', '.json');
+        if (fs.existsSync(jsonPath)) {
+          return JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+        }
+      } catch (err) {
+        // Continue to next path
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Run tests with coverage
+ */
+async function runCoverageTests() {
+  // Check package.json for test script
+  const packagePath = path.join(PROJECT_ROOT, 'package.json');
+  if (!fs.existsSync(packagePath)) return null;
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    const scripts = pkg.scripts || {};
+
+    // Try to find coverage command
+    let coverageCmd = null;
+
+    if (scripts['test:coverage']) {
+      coverageCmd = 'npm run test:coverage';
+    } else if (scripts.coverage) {
+      coverageCmd = 'npm run coverage';
+    } else if (scripts.test) {
+      // Try to add --coverage flag
+      if (scripts.test.includes('jest') || scripts.test.includes('vitest')) {
+        coverageCmd = 'npm test -- --coverage --json --outputFile=coverage/coverage-summary.json';
+      }
+    }
+
+    if (!coverageCmd) return null;
+
+    // Run coverage
+    execSync(coverageCmd, {
+      cwd: PROJECT_ROOT,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 300000, // 5 minute timeout
+    });
+
+    // Try to read the output
+    return findExistingCoverage();
+
+  } catch (err) {
+    // Test run failed or timed out
+    return null;
+  }
+}
+
+/**
+ * Check coverage for specific modified files
+ */
+function checkModifiedFilesCoverage(files, coverageFiles, threshold) {
+  const covered = [];
+  const uncovered = [];
+
+  for (const file of files) {
+    // Skip test files
+    if (file.includes('.test.') || file.includes('.spec.')) continue;
+
+    // Skip non-code files
+    if (!file.match(/\.(js|ts|jsx|tsx)$/)) continue;
+
+    // Find in coverage data
+    const coverageKey = Object.keys(coverageFiles).find(k =>
+      k.endsWith(file) || k.includes(file)
+    );
+
+    if (coverageKey) {
+      const fileCov = coverageFiles[coverageKey];
+      const pct = fileCov.lines?.pct ?? fileCov.statements?.pct ?? 0;
+
+      if (pct >= threshold) {
+        covered.push({ name: file, coverage: pct });
+      } else {
+        uncovered.push({ name: file, coverage: pct });
+      }
+    } else {
+      // File not in coverage - might be new or not tested
+      uncovered.push({ name: file, coverage: 0, notFound: true });
+    }
+  }
+
+  return { covered, uncovered };
+}
+
+module.exports = { run, findExistingCoverage };

package/scripts/flow-step-knowledge.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Update Knowledge Base Step
+ *
+ * Prompts to document learnings in the knowledge base.
+ * Helps capture institutional knowledge automatically.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getProjectRoot, colors, getConfig } = require('./flow-utils');
+
+const PROJECT_ROOT = getProjectRoot();
+const KNOWLEDGE_DIR = path.join(PROJECT_ROOT, '.claude', 'docs', 'knowledge-base');
+
+/**
+ * Run update knowledge base step
+ *
+ * @param {object} options
+ * @param {string} options.taskId - Current task ID
+ * @param {string} options.taskTitle - Task title/description
+ * @param {string[]} options.files - Files modified
+ * @param {object} options.stepConfig - Step configuration
+ * @param {string} options.mode - Step mode (block/warn/prompt/auto)
+ * @param {object} options.learnings - Any learnings discovered during task
+ * @returns {object} - { passed: boolean, message: string, suggestion?: string }
+ */
+async function run(options = {}) {
+  const { taskId, taskTitle, files = [], mode, stepConfig = {}, learnings } = options;
+
+  // Ensure knowledge base directory exists
+  if (!fs.existsSync(KNOWLEDGE_DIR)) {
+    fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+  }
+
+  // Detect potential learnings based on task
+  const detectedLearnings = detectLearnings(files, taskTitle);
+
+  if (detectedLearnings.length === 0 && !learnings) {
+    return { passed: true, message: 'No learnings detected to document' };
+  }
+
+  // In prompt mode, suggest documentation
+  if (mode === 'prompt') {
+    console.log(colors.yellow + '\n  Potential learnings to document:' + colors.reset);
+
+    if (learnings) {
+      console.log(`    - ${learnings}`);
+    }
+
+    detectedLearnings.forEach(l => {
+      console.log(`    - ${l.type}: ${l.description}`);
+    });
+
+    console.log(colors.cyan + '\n  Knowledge base location: .claude/docs/knowledge-base/' + colors.reset);
+
+    // Suggest where to document
+    const suggestion = suggestKnowledgeFile(detectedLearnings, taskTitle);
+    if (suggestion) {
+      console.log(colors.cyan + `  Suggested file: ${suggestion}` + colors.reset);
+    }
+
+    return {
+      passed: true,
+      message: 'Documentation prompt shown',
+      suggestion: `Document learnings in ${suggestion || 'knowledge-base'}`,
+      detectedLearnings,
+    };
+  }
+
+  // In auto mode, we could auto-create entries (future enhancement)
+  return {
+    passed: true,
+    message: `${detectedLearnings.length} potential learning(s) detected`,
+    suggestion: 'Consider documenting these patterns',
+    detectedLearnings,
+  };
+}
+
+/**
+ * Detect potential learnings based on files and task
+ */
+function detectLearnings(files, taskTitle) {
+  const learnings = [];
+
+  // Check for new patterns
+  const hasNewComponent = files.some(f =>
+    f.includes('/components/') && !f.includes('.test.') && !f.includes('.spec.')
+  );
+  if (hasNewComponent) {
+    learnings.push({
+      type: 'component',
+      description: 'New component created - document usage patterns',
+      category: 'components',
+    });
+  }
+
+  // Check for new hooks
+  const hasNewHook = files.some(f =>
+    f.includes('/hooks/') || (f.includes('use') && f.endsWith('.ts'))
+  );
+  if (hasNewHook) {
+    learnings.push({
+      type: 'hook',
+      description: 'Custom hook created - document API and usage',
+      category: 'hooks',
+    });
+  }
+
+  // Check for API endpoints
+  const hasApiChange = files.some(f =>
+    f.includes('/api/') || f.includes('.controller.') || f.includes('.routes.')
+  );
+  if (hasApiChange) {
+    learnings.push({
+      type: 'api',
+      description: 'API endpoint modified - document request/response format',
+      category: 'api',
+    });
+  }
+
+  // Check for configuration changes
+  const hasConfigChange = files.some(f =>
+    f.includes('config') || f.endsWith('.env.example') || f.includes('settings')
+  );
+  if (hasConfigChange) {
+    learnings.push({
+      type: 'configuration',
+      description: 'Configuration changed - document options',
+      category: 'configuration',
+    });
+  }
+
+  // Check for database/model changes
+  const hasModelChange = files.some(f =>
+    f.includes('/models/') || f.includes('/entities/') || f.includes('.schema.')
+  );
+  if (hasModelChange) {
+    learnings.push({
+      type: 'data-model',
+      description: 'Data model changed - document schema',
+      category: 'data-models',
+    });
+  }
+
+  // Check task title for patterns
+  const titleLower = (taskTitle || '').toLowerCase();
+  if (titleLower.includes('fix') || titleLower.includes('bug')) {
+    learnings.push({
+      type: 'bugfix',
+      description: 'Bug fixed - document root cause and solution',
+      category: 'troubleshooting',
+    });
+  }
+
+  if (titleLower.includes('performance') || titleLower.includes('optim')) {
+    learnings.push({
+      type: 'performance',
+      description: 'Performance improvement - document technique',
+      category: 'performance',
+    });
+  }
+
+  return learnings;
+}
+
+/**
+ * Suggest knowledge base file based on learnings
+ */
+function suggestKnowledgeFile(learnings, taskTitle) {
+  if (learnings.length === 0) return null;
+
+  const primary = learnings[0];
+  const category = primary.category || 'general';
+
+  // Check if category file exists
+  const categoryFile = path.join(KNOWLEDGE_DIR, `${category}.md`);
+  if (fs.existsSync(categoryFile)) {
+    return `knowledge-base/${category}.md`;
+  }
+
+  // Check subdirectories
+  const categoryDir = path.join(KNOWLEDGE_DIR, category);
+  if (fs.existsSync(categoryDir)) {
+    return `knowledge-base/${category}/`;
+  }
+
+  // Suggest new file
+  return `knowledge-base/${category}.md (new)`;
+}
+
+module.exports = { run, detectLearnings };