wogiflow 2.1.2 → 2.2.0

package/scripts/flow-audit.js

@@ -254,6 +254,134 @@ function calculateHealthScore(scores) {
   };
 }
 
+// ============================================================
+// Pattern Promotion (Audit → Learning Pipeline)
+// ============================================================
+
+// Severity classification thresholds for audit patterns
+const SYSTEMIC_THRESHOLD = 5;   // 5+ files = HIGH severity / systemic
+const MEDIUM_THRESHOLD = 3;     // 3-4 files = MEDIUM severity
+
+/**
+ * Process AI-clustered audit findings through the learning pipeline.
+ *
+ * For each clustered pattern:
+ * 1. Check if a rule already exists in decisions.md → ENFORCEMENT_GAP
+ * 2. Record/increment in feedback-patterns.md
+ * 3. Check promotion threshold → auto-promote if met
+ * 4. Check last-audit.json → detect RECURRING patterns
+ *
+ * @param {Object[]} clusters - AI-clustered patterns from audit
+ * @param {Object} [previousAudit] - Previous audit data for recurrence detection
+ * @returns {Object} Promotion results per pattern
+ */
+function promoteAuditPatterns(clusters, previousAudit) {
+  const {
+    recordAuditPattern,
+    checkEnforcementGap,
+    promoteToDecisions,
+    syncToRulesDir,
+    mapAuditCategoryToLearnerCategory,
+    buildAuditRuleTemplate
+  } = require('./flow-standards-learner');
+
+  const previousPatternIds = new Set(
+    (previousAudit?.patterns || []).map(p => p.patternId)
+  );
+
+  const results = {
+    patterns: [],
+    summary: {
+      total: clusters.length,
+      promoted: 0,
+      promotionFailed: 0,
+      tracking: 0,
+      enforcementGaps: 0,
+      newPatterns: 0,
+      recurring: 0
+    }
+  };
+
+  for (const cluster of clusters) {
+    const patternResult = {
+      patternId: cluster.patternId,
+      category: cluster.category,
+      description: cluster.description,
+      instanceCount: cluster.instanceCount,
+      severity: cluster.severity || (cluster.instanceCount >= SYSTEMIC_THRESHOLD ? 'HIGH' : cluster.instanceCount >= MEDIUM_THRESHOLD ? 'MEDIUM' : 'LOW'),
+      isSystemic: cluster.isSystemic || cluster.instanceCount >= SYSTEMIC_THRESHOLD,
+      status: 'NEW',
+      count: 0,
+      rootCause: null,
+      recommendation: null
+    };
+
+    // Step 1: Check for enforcement gap
+    const gapCheck = checkEnforcementGap(cluster.patternId, cluster.description);
+    if (gapCheck.exists) {
+      patternResult.status = 'ENFORCEMENT_GAP';
+      patternResult.ruleLocation = gapCheck.section;
+      patternResult.ruleText = gapCheck.ruleText;
+      results.summary.enforcementGaps++;
+    } else {
+      // Step 2: Record/increment in feedback-patterns
+      const recordResult = recordAuditPattern(cluster);
+
+      if (recordResult.recorded) {
+        patternResult.count = recordResult.newCount;
+
+        // Step 3: Check promotion threshold
+        if (recordResult.shouldPromote) {
+          // Build a learning object for promotion (reuse learner functions)
+          const learning = {
+            canLearn: true,
+            violationType: cluster.category,
+            category: mapAuditCategoryToLearnerCategory(cluster.category),
+            patternName: cluster.description.slice(0, 100),
+            message: `${cluster.instanceCount} instances found (audit source, ${recordResult.newCount} occurrences)`,
+            ruleTemplate: buildAuditRuleTemplate(cluster)
+          };
+
+          const promoteResult = promoteToDecisions(learning, recordResult.newCount);
+          if (promoteResult.promoted) {
+            patternResult.status = 'PROMOTED';
+            results.summary.promoted++;
+
+            // Also sync to rules dir
+            const syncLearning = {
+              ...learning,
+              subcategory: cluster.patternId
+            };
+            syncToRulesDir(syncLearning);
+          } else {
+            // Distinguish "not yet at threshold" from "promotion failed"
+            patternResult.status = 'PROMOTION_FAILED';
+            patternResult.failureReason = promoteResult.reason || 'Unknown promotion failure';
+            results.summary.promotionFailed++;
+          }
+        } else {
+          patternResult.status = `TRACKING (${recordResult.newCount}/${recordResult.threshold})`;
+          results.summary.tracking++;
+        }
+      }
+    }
+
+    // Step 4: Check recurrence
+    if (previousPatternIds.has(cluster.patternId)) {
+      if (patternResult.status !== 'ENFORCEMENT_GAP' && patternResult.status !== 'PROMOTED') {
+        patternResult.status = `RECURRING — ${patternResult.status}`;
+      }
+      results.summary.recurring++;
+    } else if (patternResult.status === 'NEW' || patternResult.status.startsWith('TRACKING')) {
+      results.summary.newPatterns++;
+    }
+
+    results.patterns.push(patternResult);
+  }
+
+  return results;
+}
+
 // ============================================================
 // CLI Interface
 // ============================================================
@@ -307,6 +435,30 @@ function main() {
       break;
     }
 
+    case 'promote': {
+      // Process AI-clustered findings through the learning pipeline
+      // Usage: node scripts/flow-audit.js promote '<clusters-json>'
+      const clustersArg = process.argv[3];
+      if (!clustersArg) {
+        console.error('Usage: flow-audit.js promote \'[{patternId, category, description, instanceCount, instances}]\'');
+        process.exit(1);
+      }
+
+      const clusters = safeJsonParseString(clustersArg, null);
+      if (!Array.isArray(clusters)) {
+        console.error('Invalid JSON clusters argument — expected an array');
+        process.exit(1);
+      }
+
+      // Load previous audit for recurrence detection
+      const lastAuditPath = path.join(PATHS.state, 'last-audit.json');
+      const previousAudit = safeJsonParse(lastAuditPath, {});
+
+      const promoteResults = promoteAuditPatterns(clusters, previousAudit);
+      console.log(JSON.stringify(promoteResults, null, 2));
+      break;
+    }
+
     default: {
       console.log(`
 Wogi Flow - Project Audit Helpers
@@ -319,9 +471,13 @@ Commands:
   outdated   Run npm outdated (structured JSON output)
   audit      Run npm audit (structured JSON output)
   score      Calculate weighted health score from agent grades
+  promote    Process AI-clustered findings through learning pipeline
 
 Score usage:
   node scripts/flow-audit.js score '{"architecture":"B+","dependencies":"A-"}'
+
+Promote usage:
+  node scripts/flow-audit.js promote '[{"patternId":"missing-error-handling","category":"security","description":"...","instanceCount":7}]'
 `);
       break;
     }
@@ -333,7 +489,8 @@ module.exports = {
   findTodos,
   getOutdatedDeps,
   getAuditResults,
-  calculateHealthScore
+  calculateHealthScore,
+  promoteAuditPatterns
 };
 
 if (require.main === module) {

package/scripts/flow-context-compact/index.js

@@ -291,7 +291,7 @@ function clearAll() {
 function getSerializedTree(level = 1) {
   const tree = summaryTree.loadTree();
   if (!tree) {
-    return '# No Context Saved\n\nRun /wogi-compact to save session context.';
+    return '# No Context Saved\n\nRun /wogi-pre-compact to save session context.';
   }
 
   return summaryTree.serializeTree(tree, level);

package/scripts/flow-context-monitor.js

@@ -271,10 +271,10 @@ function checkContextHealth() {
 
   if (usage >= config.criticalAt) {
     status = 'critical';
-    recommendation = 'Run /wogi-compact NOW to avoid context overflow';
+    recommendation = 'Run /wogi-pre-compact NOW to avoid context overflow';
   } else if (usage >= config.warnAt) {
     status = 'warning';
-    recommendation = 'Consider running /wogi-compact soon';
+    recommendation = 'Consider running /wogi-pre-compact soon';
   } else {
     status = 'healthy';
     recommendation = null;

package/scripts/flow-loop-retry-learning.js

@@ -99,7 +99,7 @@ const ROOT_CAUSE_CATEGORIES = {
   },
   CONTEXT_OVERFLOW: {
     ...FailureCategory.CONTEXT_OVERFLOW,
-    suggestion: 'Use /wogi-compact before large tasks',
+    suggestion: 'Use /wogi-pre-compact before large tasks',
     targetFile: 'config.json'
   },
   CAPABILITY_MISMATCH: {

package/scripts/flow-proactive-compact.js

@@ -68,7 +68,7 @@ function getProactiveCompactionConfig() {
  * Check whether proactive compaction should trigger at a phase boundary.
  *
  * This is called by /wogi-start at each phase transition.
- * The actual compaction is performed by the AI agent using /wogi-compact.
+ * The actual compaction is performed by the AI agent using /wogi-pre-compact.
  *
  * @param {Object} params - Check parameters
  * @param {string} params.phase - The phase that just completed
@@ -161,7 +161,7 @@ async function handlePhaseBoundary(params) {
 
 /**
  * Generate a compaction summary for the current task state.
- * Used by /wogi-compact when proactive compaction triggers.
+ * Used by /wogi-pre-compact when proactive compaction triggers.
  *
  * @param {Object} checkpoint - Current checkpoint data
  * @returns {string} Formatted compaction summary
@@ -253,7 +253,7 @@ function formatCompactionMessage(result, contextPercent) {
   lines.push(`Context at ${pct}%. Compacting before next phase...`);
   lines.push(`Reason: ${result.reason}`);
   lines.push('');
-  lines.push('Task state has been checkpointed. Run /wogi-compact to compact now.');
+  lines.push('Task state has been checkpointed. Run /wogi-pre-compact to compact now.');
   lines.push('After compaction, read task-checkpoint.json to restore context.');
 
   return lines.join('\n');

package/scripts/flow-progress-tracker.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Progress Tracker
+ *
+ * Manages progress state for long-running tasks (reviews, audits, multi-criteria).
+ * Writes to .workflow/state/task-progress.json for hook/status line consumption.
+ * Optionally updates task title in ready.json with progress prefix for status line.
+ *
+ * Usage:
+ *   flow-progress-tracker.js update <json>   Update progress state
+ *   flow-progress-tracker.js get             Get current progress
+ *   flow-progress-tracker.js clear           Clear progress state
+ *   flow-progress-tracker.js format <json>   Format a progress bar string
+ *
+ * The AI calls this at natural checkpoints during execution.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { PATHS, safeJsonParse, safeJsonParseString, getReadyData, saveReadyData } = require('./flow-utils');
+
+const PROGRESS_PATH = path.join(PATHS.state, 'task-progress.json');
+
+// ============================================================
+// Progress State Management
+// ============================================================
+
+/**
+ * Update the progress state file.
+ *
+ * @param {Object} progress
+ * @param {string} progress.taskId - Current task ID
+ * @param {string} progress.command - Command running (e.g., "/wogi-review")
+ * @param {string} progress.phase - Current phase name
+ * @param {number} progress.phaseNum - Current phase number (1-based)
+ * @param {number} progress.totalPhases - Total phases
+ * @param {string} [progress.step] - Current sub-step description
+ * @param {number} [progress.stepNum] - Current sub-step number
+ * @param {number} [progress.totalSteps] - Total sub-steps in this phase
+ * @param {boolean} [progress.updateTitle] - Update task title in ready.json
+ * @returns {{ saved: boolean }}
+ */
+function updateProgress(progress) {
+  const state = {
+    taskId: progress.taskId,
+    command: progress.command,
+    phase: progress.phase,
+    phaseNum: progress.phaseNum || 0,
+    totalPhases: progress.totalPhases || 0,
+    step: progress.step || null,
+    stepNum: progress.stepNum || 0,
+    totalSteps: progress.totalSteps || 0,
+    percentage: calculatePercentage(progress),
+    startedAt: getExistingStartTime() || new Date().toISOString(),
+    lastUpdate: new Date().toISOString()
+  };
+
+  try {
+    fs.mkdirSync(path.dirname(PROGRESS_PATH), { recursive: true });
+    fs.writeFileSync(PROGRESS_PATH, JSON.stringify(state, null, 2));
+  } catch (err) {
+    return { saved: false, reason: err.message };
+  }
+
+  // Update task title in ready.json for status line visibility (opt-in)
+  if (progress.updateTitle === true && state.taskId) {
+    updateTaskTitle(state);
+  }
+
+  return { saved: true, state };
+}
+
+/**
+ * Calculate progress percentage from phase/step numbers.
+ */
+function calculatePercentage(progress) {
+  const { phaseNum, totalPhases, stepNum, totalSteps } = progress;
+  if (!totalPhases || !phaseNum) return 0;
+
+  // Phase-level progress
+  const phaseProgress = ((phaseNum - 1) / totalPhases) * 100;
+
+  // Step-level progress within the current phase
+  const phaseWeight = 100 / totalPhases;
+  const stepProgress = (totalSteps && stepNum)
+    ? (stepNum / totalSteps) * phaseWeight
+    : 0;
+
+  return Math.min(100, Math.round(phaseProgress + stepProgress));
+}
+
+/**
+ * Get existing start time to preserve across updates.
+ */
+function getExistingStartTime() {
+  try {
+    const existing = safeJsonParse(PROGRESS_PATH, null);
+    return existing?.startedAt || null;
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Update task title in ready.json with progress prefix.
+ * Format: "[2/5] Original title"
+ */
+function updateTaskTitle(state) {
+  try {
+    const data = getReadyData();
+    const task = data.inProgress.find(t => t.id === state.taskId);
+    if (!task) return;
+
+    // Strip any existing progress prefix
+    const cleanTitle = task.title.replace(/^\[\d+\/\d+\]\s*/, '');
+
+    // Add new prefix
+    task.title = `[${state.phaseNum}/${state.totalPhases}] ${cleanTitle}`;
+    saveReadyData(data);
+  } catch (err) {
+    // Non-fatal — title update is cosmetic
+    if (process.env.DEBUG) {
+      console.error(`[progress-tracker] Title update failed: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Get current progress state.
+ * @returns {Object|null}
+ */
+function getProgress() {
+  return safeJsonParse(PROGRESS_PATH, null);
+}
+
+/**
+ * Clear progress state (called on task completion).
+ *
+ * NOTE: Title restoration (stripping [N/M] prefix) is handled inside the
+ * task-completed hook's withLock() callback to avoid race conditions on ready.json.
+ * This function only deletes the progress state file.
+ */
+function clearProgress() {
+  try {
+    fs.unlinkSync(PROGRESS_PATH);
+    return { cleared: true };
+  } catch (err) {
+    if (err.code === 'ENOENT') return { cleared: true };
+    return { cleared: false, reason: err.message };
+  }
+}
+
+/**
+ * Format a progress bar string for conversation output.
+ *
+ * @param {Object} opts
+ * @param {number} opts.current - Current step
+ * @param {number} opts.total - Total steps
+ * @param {string} opts.label - Label text
+ * @param {number} [opts.width=20] - Bar width
+ * @returns {string} Formatted progress line
+ */
+function formatProgressBar(opts) {
+  const { current, total, label, width = 20 } = opts;
+  const pct = total > 0 ? Math.round((current / total) * 100) : 0;
+  const filled = total > 0 ? Math.round((current / total) * width) : 0;
+  const empty = width - filled;
+
+  const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(empty);
+  return `[${bar}] ${pct}% ${label} (${current}/${total})`;
+}
+
+/**
+ * Format a multi-level progress display for conversation output.
+ *
+ * @param {Object} opts
+ * @param {string} opts.command - Command name
+ * @param {string} opts.phase - Current phase
+ * @param {number} opts.phaseNum
+ * @param {number} opts.totalPhases
+ * @param {string} [opts.step] - Current step within phase
+ * @param {number} [opts.stepNum]
+ * @param {number} [opts.totalSteps]
+ * @returns {string} Multi-line progress display
+ */
+function formatProgress(opts) {
+  const lines = [];
+  const pct = calculatePercentage(opts);
+
+  // Phase-level bar
+  lines.push(formatProgressBar({
+    current: opts.phaseNum,
+    total: opts.totalPhases,
+    label: opts.phase
+  }));
+
+  // Step-level detail (if applicable)
+  if (opts.step && opts.totalSteps) {
+    lines.push(`  ${opts.step} (${opts.stepNum}/${opts.totalSteps})`);
+  }
+
+  return lines.join('\n');
+}
+
+// ============================================================
+// CLI Interface
+// ============================================================
+
+function main() {
+  const command = process.argv[2];
+  const arg = process.argv[3];
+
+  switch (command) {
+    case 'update': {
+      if (!arg) {
+        console.error('Usage: flow-progress-tracker.js update \'{"taskId":"...","phase":"...","phaseNum":1,"totalPhases":5}\'');
+        process.exit(1);
+      }
+      const progress = safeJsonParseString(arg, null);
+      if (!progress) {
+        console.error('Invalid JSON argument');
+        process.exit(1);
+      }
+      const result = updateProgress(progress);
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    case 'get': {
+      const state = getProgress();
+      if (state) {
+        console.log(JSON.stringify(state, null, 2));
+      } else {
+        console.log(JSON.stringify({ active: false }));
+      }
+      break;
+    }
+
+    case 'clear': {
+      const result = clearProgress();
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    case 'format': {
+      if (!arg) {
+        console.error('Usage: flow-progress-tracker.js format \'{"current":2,"total":5,"label":"Phase"}\'');
+        process.exit(1);
+      }
+      const opts = safeJsonParseString(arg, null);
+      if (!opts) {
+        console.error('Invalid JSON argument');
+        process.exit(1);
+      }
+      console.log(formatProgressBar(opts));
+      break;
+    }
+
+    default:
+      console.log(`
+Wogi Flow - Progress Tracker
+
+Usage: flow-progress-tracker.js <command> [args]
+
+Commands:
+  update <json>   Update progress state + task title
+  get             Get current progress state
+  clear           Clear progress state
+  format <json>   Format a progress bar string
+
+Update format:
+  {"taskId":"wf-xxx","command":"/wogi-review","phase":"AI Review","phaseNum":2,"totalPhases":5}
+`);
+  }
+}
+
+module.exports = {
+  updateProgress,
+  getProgress,
+  clearProgress,
+  formatProgressBar,
+  formatProgress,
+  calculatePercentage
+};
+
+if (require.main === module) {
+  main();
+}