wogiflow 2.26.2 → 2.29.0

package/scripts/flow-repo-map.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Aider-style Repo Map (wf-f3707d2f / C1).
+ *
+ * Generates a compact, task-aware repo map that fits in a bounded token
+ * budget. Intended for injection at Step 1 Load Context (and refresh at each
+ * turn during exploring + coding phases) so the AI sees:
+ *   - TOUCHED  — files the current task modifies (summary + top-level symbols)
+ *   - ADJACENT — files that import or are imported by the touched set
+ *   - SHAPE    — compressed tree of the rest of the project (names only)
+ *
+ * This complements the existing registry maps (app-map, function-map, api-map)
+ * which are manually curated; the repo map is cheap, disposable, and always-fresh.
+ *
+ * Story: wf-f3707d2f (C1)
+ * Epic: wf-34290000
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const { PATHS } = require('./flow-paths');
+const { getConfig } = require('./flow-config-loader');
+
+const DEFAULT_BUDGET_BYTES = 16 * 1024; // ~4k tokens
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.workflow', '.worktrees', 'out']);
+const CODE_EXTS = new Set(['.js', '.ts', '.tsx', '.jsx', '.mjs', '.cjs']);
+const DOC_EXTS = new Set(['.md']);
+const STATE_EXTS = new Set(['.json', '.yaml', '.yml', '.toml']);
+
+function _getRepoMapConfig() {
+  const cfg = getConfig();
+  return cfg.repoMap || {};
+}
+
+/**
+ * Resolve changed-files list for a task.
+ * Priority: explicit opts.changedFiles → durable-session checkpoint → `git diff --name-only`.
+ *
+ * @param {object} opts
+ * @returns {string[]}
+ */
+function resolveChangedFiles(opts = {}) {
+  if (Array.isArray(opts.changedFiles)) return opts.changedFiles;
+
+  // Try task-checkpoint.json
+  const checkpointPath = path.join(PATHS.state, 'task-checkpoint.json');
+  if (fs.existsSync(checkpointPath)) {
+    try {
+      const cp = JSON.parse(fs.readFileSync(checkpointPath, 'utf8'));
+      if (Array.isArray(cp.changedFiles) && cp.changedFiles.length > 0) return cp.changedFiles;
+    } catch { /* fall through */ }
+  }
+
+  // Git diff
+  try {
+    const out = execFileSync('git', ['diff', '--name-only', 'HEAD'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const files = out.split('\n').filter(Boolean);
+    if (files.length > 0) return files;
+  } catch { /* no git */ }
+
+  try {
+    const out = execFileSync('git', ['status', '--porcelain'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return out.split('\n').map((l) => l.slice(3).trim()).filter(Boolean);
+  } catch { return []; }
+}
+
+/**
+ * Extract top-level symbol signatures from a file. Lightweight — regex only,
+ * no AST parser. Captures: function decls, class decls, const declarations,
+ * module.exports / export default, named exports.
+ *
+ * @param {string} filePath - absolute path
+ * @returns {{ symbols: string[], firstLine: string, loc: number }}
+ */
+function extractSymbols(filePath) {
+  const out = { symbols: [], firstLine: '', loc: 0 };
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch { return out; }
+
+  const lines = content.split('\n');
+  out.loc = lines.length;
+  // First docblock / comment line
+  for (const line of lines.slice(0, 5)) {
+    const t = line.trim().replace(/^[*/\s]+|[*/\s]+$/g, '');
+    if (t.length > 4 && !/^@|^#!\//.test(t)) { out.firstLine = t.slice(0, 100); break; }
+  }
+
+  const patterns = [
+    /^(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm,
+    /^(?:export\s+(?:default\s+)?)?class\s+(\w+)/gm,
+    /^(?:export\s+)?const\s+([A-Z][A-Z0-9_]+)\s*=/gm, // SCREAMING_SNAKE constants
+    /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?(?:function|\([^)]*\)\s*=>)/gm,
+  ];
+  for (const re of patterns) {
+    for (const m of content.matchAll(re)) {
+      const sig = m[2] !== undefined ? `${m[1]}(${m[2].length > 40 ? '...' : m[2]})` : m[1];
+      if (!out.symbols.includes(sig)) out.symbols.push(sig);
+      if (out.symbols.length >= 12) break;
+    }
+  }
+
+  // module.exports = {...} named-key extraction
+  const mexRe = /module\.exports\s*=\s*\{([^}]+)\}/;
+  const mex = content.match(mexRe);
+  if (mex) {
+    const keys = mex[1].split(',').map((s) => s.trim().split(/[:=\s]/)[0]).filter(Boolean);
+    for (const k of keys.slice(0, 8)) if (/^\w+$/.test(k) && !out.symbols.some((s) => s.startsWith(k))) out.symbols.push(k);
+  }
+
+  return out;
+}
+
+/**
+ * Find files that import or are imported by the given seed files.
+ * Strict depth=1 (direct neighbors only).
+ *
+ * @param {string[]} seedFiles - paths relative to repo root
+ * @param {string[]} allCodeFiles - paths to consider
+ * @returns {string[]} paths of adjacent files
+ */
+function findAdjacent(seedFiles, allCodeFiles) {
+  const seedSet = new Set(seedFiles);
+  const adjacent = new Set();
+  const seedBasenames = seedFiles.map((f) => path.basename(f, path.extname(f)));
+
+  for (const file of allCodeFiles) {
+    if (seedSet.has(file)) continue;
+    let content;
+    try { content = fs.readFileSync(file, 'utf8'); } catch { continue; }
+
+    // File imports something FROM the seed set
+    for (const base of seedBasenames) {
+      const re = new RegExp(`(?:require|import|from)\\s*\\(?[\`'"][^\`'"]*?${base}[^\`'"]*?[\`'"]\\)?`);
+      if (re.test(content)) { adjacent.add(file); break; }
+    }
+  }
+
+  // Reverse: what do seed files import?
+  for (const seed of seedFiles) {
+    let content;
+    try { content = fs.readFileSync(seed, 'utf8'); } catch { continue; }
+    const importRe = /(?:require|from)\s*\(?[`'"]([^`'"]+)[`'"]\)?/g;
+    for (const m of content.matchAll(importRe)) {
+      const resolved = _resolveImport(seed, m[1], allCodeFiles);
+      if (resolved && !seedSet.has(resolved)) adjacent.add(resolved);
+    }
+  }
+
+  return [...adjacent];
+}
+
+function _resolveImport(fromFile, spec, allFiles) {
+  if (!spec.startsWith('.')) return null; // external package
+  const dir = path.dirname(fromFile);
+  const base = path.resolve(dir, spec);
+  for (const ext of ['.js', '.ts', '.tsx', '.jsx', '.mjs', '.cjs', '/index.js', '/index.ts']) {
+    const candidate = base + ext;
+    const rel = path.relative(process.cwd(), candidate);
+    if (allFiles.includes(rel)) return rel;
+  }
+  return null;
+}
+
+/**
+ * Walk the repo collecting code file paths (relative to cwd).
+ * @returns {string[]}
+ */
+function collectCodeFiles() {
+  const root = process.cwd();
+  const out = [];
+  function walk(dir) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (e.name.startsWith('.') && e.name !== '.claude' && e.name !== '.workflow') continue;
+      if (IGNORED_DIRS.has(e.name)) continue;
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.isFile() && CODE_EXTS.has(path.extname(e.name))) out.push(path.relative(root, p));
+    }
+  }
+  walk(root);
+  return out;
+}
+
+/**
+ * Generate a compact shape-of-repo summary (file count per top-level dir).
+ */
+function generateShape(allCodeFiles) {
+  const buckets = {};
+  for (const f of allCodeFiles) {
+    const top = f.split('/')[0];
+    buckets[top] = (buckets[top] || 0) + 1;
+  }
+  return Object.entries(buckets)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 12)
+    .map(([k, v]) => `${k}/ (${v})`)
+    .join(', ');
+}
+
+/**
+ * Generate the repo map markdown.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.taskId]
+ * @param {string[]} [opts.changedFiles]
+ * @param {number} [opts.budgetBytes] - max output size
+ * @param {boolean} [opts.includeShape=true]
+ * @returns {{ markdown: string, stats: object }}
+ */
+function generateRepoMap(opts = {}) {
+  const cfg = _getRepoMapConfig();
+  if (cfg.enabled === false) {
+    return { markdown: '', stats: { skipped: true, reason: 'config-disabled' } };
+  }
+
+  const budget = opts.budgetBytes ?? cfg.budgetBytes ?? DEFAULT_BUDGET_BYTES;
+  const includeShape = opts.includeShape !== false;
+  const changed = resolveChangedFiles(opts).filter((f) => CODE_EXTS.has(path.extname(f)) || DOC_EXTS.has(path.extname(f)) || STATE_EXTS.has(path.extname(f)));
+
+  const allCode = collectCodeFiles();
+  const touched = changed.filter((f) => fs.existsSync(f));
+  const adjacent = touched.length > 0 ? findAdjacent(touched, allCode).slice(0, 20) : [];
+
+  const lines = [];
+  lines.push(`# Repo Map${opts.taskId ? ' — ' + opts.taskId : ''}`);
+  lines.push('');
+  lines.push(`Generated: ${new Date().toISOString()} | files-scanned: ${allCode.length} | touched: ${touched.length} | adjacent: ${adjacent.length}`);
+  lines.push('');
+
+  if (touched.length > 0) {
+    lines.push('## TOUCHED');
+    for (const f of touched.slice(0, 20)) {
+      const abs = path.resolve(f);
+      const info = extractSymbols(abs);
+      lines.push(`### ${f}`);
+      if (info.firstLine) lines.push(`_${info.firstLine}_`);
+      lines.push(`- LOC: ${info.loc}`);
+      if (info.symbols.length > 0) lines.push(`- Symbols: \`${info.symbols.slice(0, 10).join('`, `')}\``);
+      lines.push('');
+    }
+  } else {
+    lines.push('## TOUCHED\n_(no changed code files detected)_\n');
+  }
+
+  if (adjacent.length > 0) {
+    lines.push('## ADJACENT (depth=1 imports)');
+    for (const f of adjacent) {
+      const info = extractSymbols(path.resolve(f));
+      const sigs = info.symbols.slice(0, 5).join(', ');
+      lines.push(`- ${f}${sigs ? ` — \`${sigs}\`` : ''}`);
+    }
+    lines.push('');
+  }
+
+  if (includeShape) {
+    lines.push('## SHAPE');
+    lines.push(generateShape(allCode));
+    lines.push('');
+  }
+
+  let markdown = lines.join('\n');
+  const wasTruncated = markdown.length > budget;
+  if (wasTruncated) {
+    markdown = markdown.slice(0, budget - 40) + '\n\n_(repo map truncated at budget)_\n';
+  }
+
+  return {
+    markdown,
+    stats: {
+      touched: touched.length,
+      adjacent: adjacent.length,
+      filesScanned: allCode.length,
+      bytes: markdown.length,
+      budget,
+      truncated: wasTruncated,
+    },
+  };
+}
+
+module.exports = {
+  generateRepoMap,
+  resolveChangedFiles,
+  extractSymbols,
+  findAdjacent,
+  collectCodeFiles,
+  DEFAULT_BUDGET_BYTES,
+};
+
+// CLI
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+  if (cmd === 'generate' || !cmd) {
+    const taskId = args.find((a) => a.startsWith('--task='))?.split('=')[1];
+    const budgetArg = args.find((a) => a.startsWith('--budget='))?.split('=')[1];
+    const result = generateRepoMap({ taskId, budgetBytes: budgetArg ? parseInt(budgetArg, 10) : undefined });
+    process.stdout.write(result.markdown);
+    if (args.includes('--stats')) {
+      process.stderr.write('\n\nStats: ' + JSON.stringify(result.stats) + '\n');
+    }
+  } else {
+    console.error('usage: flow-repo-map generate [--task=<id>] [--budget=<bytes>] [--stats]');
+    process.exit(2);
+  }
+}

package/scripts/flow-review-passes/index.js

@@ -183,7 +183,7 @@ async function runMultiPassReview(context, options = {}) {
     passes = ['structure', 'logic', 'security', 'integration'],
     earlyExitOnCritical = reviewConfig.earlyExitOnCritical !== false,
     passForward = reviewConfig.passForward !== false,
-    parallel = false
+    _parallel = false
   } = options;
 
   const results = {

package/scripts/flow-review-passes/integration.js

@@ -502,7 +502,7 @@ function analyzeDependencyGraph(files) {
  * @returns {Promise<Object>} Pass results
  */
 async function run(context) {
-  const { files = [], previousResults = {} } = context;
+  const { files = [], _previousResults = {} } = context;
 
   const issues = [];
   const suggestions = [];

package/scripts/flow-review-passes/structure.js

@@ -287,7 +287,7 @@ function checkDirectoryStructure(files) {
  * @returns {Promise<Object>} Pass results
  */
 async function run(context) {
-  const { files = [], previousResults = {} } = context;
+  const { files = [], _previousResults = {} } = context;
   const config = getConfig();
   const namingConvention = config.componentReuse?.namingConvention || 'kebab-case';
 

package/scripts/flow-revision-tracker.js

@@ -19,7 +19,7 @@ const {
   PATHS,
   readJson: _readJson,
   fileExists: _fileExists,
-  getTodayDate
+  _getTodayDate
 } = require('./flow-utils');
 const { recordRevision, loadStats } = require('./flow-stats-collector');
 

package/scripts/flow-section-resolver.js

@@ -29,7 +29,7 @@ const {
   fileExists: _fileExists,
   readFile: _readFile,
   info,
-  warn
+  _warn
 } = require('./flow-utils');
 
 const {

package/scripts/flow-session-end.js

@@ -25,7 +25,7 @@ const {
   isGitRepo,
   getGitStatus,
   safeJsonParse,
-  getTodayDate
+  _getTodayDate
 } = require('./flow-utils')
 const { color, printSection, success, warn, error } = require('./flow-output');;
 
@@ -774,6 +774,64 @@ function showContextHealthSummary() {
   }
 }
 
+// B7 (wf-c3b5afab): Surface gate missRate telemetry at session-end so users
+// see rubber-stamping risk without running /wogi-gate-stats. Pulls from the
+// existing getGateStats() API — no duplicated computation or thresholds.
+const MISS_RATE_THRESHOLD = 0.10;
+const MISS_WATCH_WINDOW = '7d';
+const MISS_WATCH_TOP_N = 3;
+
+function loadGateStats() {
+  let getGateStats;
+  try {
+    ({ getGateStats } = require('./flow-gate-telemetry'));
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[DEBUG] Gate telemetry: ${err.message}`);
+    return null;
+  }
+  try {
+    return getGateStats({ since: MISS_WATCH_WINDOW });
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[DEBUG] Gate telemetry stats: ${err.message}`);
+    return null;
+  }
+}
+
+function printGateTelemetryWatch(stats = loadGateStats()) {
+  console.log('');
+  console.log(color('yellow', 'Gate Telemetry — Miss Rate Watch (7d):'));
+
+  const perGate = stats && stats.perGate ? stats.perGate : null;
+  const gates = perGate ? Object.keys(perGate) : [];
+  if (!perGate || gates.length === 0) {
+    console.log(`  ${color('dim', 'No telemetry yet (baseline)')}`);
+    return;
+  }
+
+  const ranked = gates
+    .map(id => ({ id, ...perGate[id] }))
+    .filter(g => g.verdicts && g.verdicts.PASS > 0)
+    .sort((a, b) => b.missRate - a.missRate)
+    .slice(0, MISS_WATCH_TOP_N);
+
+  if (ranked.length === 0) {
+    console.log(`  ${color('dim', 'No PASS events yet — miss rate unmeasurable')}`);
+    return;
+  }
+
+  for (const g of ranked) {
+    const pct = (g.missRate * 100).toFixed(1);
+    const flagged = g.missRate >= MISS_RATE_THRESHOLD;
+    const line = `  ${g.id}: miss ${pct}% (${g.missedAfterPass}/${g.verdicts.PASS} PASS events)`;
+    if (flagged) {
+      console.log(color('red', `${line}  ← rubber-stamping risk`));
+    } else {
+      console.log(line);
+    }
+  }
+  console.log(`  ${color('dim', 'Threshold: miss rate ≥ 10% flags a gate as rubber-stamping. See /wogi-gate-stats for full table.')}`);
+}
+
 /**
  * v1.8.0: Automatic memory management
  * Part of automatic memory management for teams
@@ -1346,6 +1404,9 @@ async function main() {
   // v1.7.0: Show context health
   showContextHealthSummary();
 
+  // B7 (wf-c3b5afab): Surface gate miss-rate watch — rubber-stamping visibility
+  printGateTelemetryWatch();
+
   // v1.8.0: Automatic memory management
   await automaticMemoryManagement();
 
@@ -1376,7 +1437,15 @@ async function main() {
   showSummary();
 }
 
-main().catch(err => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch(err => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  printGateTelemetryWatch,
+  MISS_RATE_THRESHOLD,
+  MISS_WATCH_TOP_N,
+};

package/scripts/flow-session-state.js

@@ -94,7 +94,11 @@ function getDefaultState() {
       count: 0,           // Number of bypasses in this session
       attempts: [],       // Array of bypass attempt details
       autoCreatedTasks: [] // Tasks that were auto-created (bypasses)
-    }
+    },
+    // Autonomous walk-away mode (Story C / wf-d712002e)
+    // active=true means the AI commits to running the queue without interrupting
+    // until it drains, the user sends "stop"/"pause", or the staleness threshold trips.
+    autonomousMode: null
   };
 }
 
@@ -915,6 +919,93 @@ if (require.main === module) {
   }
 }
 
+// ============================================================
+// Autonomous Mode (Story C / wf-d712002e)
+// ============================================================
+//
+// Disk is canonical (survives SIGTERM at task-boundary-reset); cache is read-hot.
+// Hot-path hooks (PreToolUse) MUST use the cache; never re-read the disk file.
+
+const DEFAULT_AUTONOMOUS_STALENESS_MS = 60 * 60 * 1000;
+
+let autonomousModeCache = undefined;
+
+function getAutonomousConfig() {
+  const cfg = getConfig().autonomousMode || {};
+  return {
+    stalenessThresholdMs: cfg.stalenessThresholdMs ?? DEFAULT_AUTONOMOUS_STALENESS_MS,
+    maxAdversaryInvocations: cfg.maxAdversaryInvocations ?? 30,
+    maxQueueSize: cfg.maxQueueSize ?? 100
+  };
+}
+
+function activateAutonomousMode({ trigger } = {}) {
+  const runId = `auto-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const record = {
+    active: true,
+    activatedAt: new Date().toISOString(),
+    trigger: trigger || 'unspecified',
+    runId,
+    adversaryInvocations: { used: 0, breakdown: { autonomousLowConfidence: 0, igrArchitect: 0, manual: 0 } }
+  };
+  saveSessionState({ autonomousMode: record });
+  autonomousModeCache = record;
+  return record;
+}
+
+function deactivateAutonomousMode() {
+  saveSessionState({ autonomousMode: null });
+  autonomousModeCache = null;
+}
+
+function getAutonomousMode() {
+  if (autonomousModeCache !== undefined) return autonomousModeCache;
+  const state = loadSessionState();
+  autonomousModeCache = state.autonomousMode || null;
+  return autonomousModeCache;
+}
+
+function isAutonomousActive() {
+  const mode = getAutonomousMode();
+  return Boolean(mode && mode.active);
+}
+
+function isAutonomousStale(mode = getAutonomousMode()) {
+  if (!mode || !mode.activatedAt) return false;
+  const ageMs = Date.now() - new Date(mode.activatedAt).getTime();
+  return ageMs > getAutonomousConfig().stalenessThresholdMs;
+}
+
+function rehydrateAutonomousFromDisk() {
+  autonomousModeCache = undefined;
+  const mode = getAutonomousMode();
+  if (mode && mode.active && isAutonomousStale(mode)) {
+    deactivateAutonomousMode();
+    return { hydrated: false, reason: 'stale', staleMode: mode };
+  }
+  return { hydrated: Boolean(mode && mode.active), mode };
+}
+
+function incrementAdversaryInvocation(source = 'manual') {
+  const mode = getAutonomousMode();
+  if (!mode || !mode.active) return { allowed: true, used: 0, cap: 0 };
+  const cap = getAutonomousConfig().maxAdversaryInvocations;
+  const used = (mode.adversaryInvocations?.used ?? 0) + 1;
+  const breakdown = { ...(mode.adversaryInvocations?.breakdown || {}) };
+  const key = source === 'igr' ? 'igrArchitect'
+    : source === 'lowConfidence' ? 'autonomousLowConfidence'
+    : 'manual';
+  breakdown[key] = (breakdown[key] || 0) + 1;
+  const updated = { ...mode, adversaryInvocations: { used, breakdown } };
+  saveSessionState({ autonomousMode: updated });
+  autonomousModeCache = updated;
+  return { allowed: used <= cap, used, cap };
+}
+
+function _resetAutonomousCacheForTests() {
+  autonomousModeCache = undefined;
+}
+
 // ============================================================
 // Exports
 // ============================================================
@@ -979,6 +1070,17 @@ module.exports = {
   getBypassSummary,
   clearBypassTracking,
 
+  // Autonomous mode (Story C / wf-d712002e)
+  activateAutonomousMode,
+  deactivateAutonomousMode,
+  getAutonomousMode,
+  isAutonomousActive,
+  isAutonomousStale,
+  rehydrateAutonomousFromDisk,
+  incrementAdversaryInvocation,
+  getAutonomousConfig,
+  _resetAutonomousCacheForTests,
+
   // Path
   SESSION_PATH
 };

package/scripts/flow-setup-hooks.js

@@ -18,7 +18,7 @@ const path = require('node:path');
 const {
   getProjectRoot: _getProjectRoot,
   getConfig, PATHS,
-  getTodayDate
+  _getTodayDate
 } = require('./flow-utils')
 const { color, success, warn, error } = require('./flow-output');;