wogiflow 2.26.2 → 2.29.1

package/scripts/flow-question-queue.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Question Queue (Story C / wf-d712002e)
+ *
+ * Persistent queue for product/UX questions surfaced during autonomous mode.
+ * Questions blocking dependent tasks are recorded together with the skipped
+ * tasks so the completion summary can render them and the user can resolve
+ * them in one batch.
+ *
+ * Dependency classification is deliberately conservative — it is safer to
+ * over-flag (false positive: extra re-run) than to under-flag (false
+ * negative: dependent task ran on a stale assumption).
+ *
+ * File: .workflow/state/question-queue.json
+ *
+ * Programmatic:
+ *   const q = require('./flow-question-queue');
+ *   q.addQuestion({ text, classifiedBucket, taskContext, dependencies, runId });
+ *   q.skipTask({ taskId, reason });
+ *   q.loadQueue();
+ *   q.clearQueue();
+ *   q.classifyDependencies(questionText, pendingTaskIds);
+ */
+
+const path = require('node:path');
+const fs = require('node:fs');
+const { PATHS } = require('./flow-paths');
+const { readJson, writeJson } = require('./flow-io');
+
+const QUEUE_PATH = path.join(PATHS.state, 'question-queue.json');
+
+function emptyQueue() {
+  return { questions: [], skippedTasks: [] };
+}
+
+function loadQueue() {
+  try {
+    const data = readJson(QUEUE_PATH, null);
+    if (!data || typeof data !== 'object') return emptyQueue();
+    return {
+      questions: Array.isArray(data.questions) ? data.questions : [],
+      skippedTasks: Array.isArray(data.skippedTasks) ? data.skippedTasks : []
+    };
+  } catch (_err) {
+    return emptyQueue();
+  }
+}
+
+function saveQueue(data) {
+  writeJson(QUEUE_PATH, data);
+  return data;
+}
+
+function clearQueue() {
+  try {
+    if (fs.existsSync(QUEUE_PATH)) fs.unlinkSync(QUEUE_PATH);
+  } catch (_err) { /* ignore */ }
+  return emptyQueue();
+}
+
+function shortId() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+/**
+ * Append a question to the queue.
+ * @param {object} q
+ * @param {string} q.text - Question text
+ * @param {string} [q.classifiedBucket] - Original classifier bucket
+ * @param {string} [q.taskContext] - Task ID where the question arose
+ * @param {string[]} [q.dependencies] - Task IDs likely depending on the answer
+ * @param {string} [q.runId] - Autonomous run ID
+ */
+function addQuestion(q) {
+  if (!q || !q.text) throw new Error('addQuestion: text is required');
+  const queue = loadQueue();
+  const entry = {
+    id: `q-${shortId()}`,
+    text: q.text,
+    classifiedBucket: q.classifiedBucket || null,
+    taskContext: q.taskContext || null,
+    dependencies: Array.isArray(q.dependencies) ? q.dependencies : [],
+    createdAt: new Date().toISOString(),
+    runId: q.runId || null,
+    answered: false
+  };
+  queue.questions.push(entry);
+  saveQueue(queue);
+  return entry;
+}
+
+/**
+ * Mark a task as skipped, recording the reason and (optionally) the question
+ * blocking it.
+ */
+function skipTask({ taskId, reason, blockingQuestionId } = {}) {
+  if (!taskId) throw new Error('skipTask: taskId is required');
+  const queue = loadQueue();
+  const existing = queue.skippedTasks.find(s => s.taskId === taskId);
+  const record = {
+    taskId,
+    reason: reason || 'awaiting answer',
+    blockingQuestionId: blockingQuestionId || null,
+    skippedAt: new Date().toISOString()
+  };
+  if (existing) {
+    Object.assign(existing, record);
+  } else {
+    queue.skippedTasks.push(record);
+  }
+  saveQueue(queue);
+  return record;
+}
+
+/**
+ * Conservative dependency classifier — text-match only.
+ * AI classifier (Haiku) fallback is intentionally NOT inlined here; callers
+ * that have access to Haiku invoke `classifyDependenciesWithAi()` and merge
+ * results with `unionDependencies()`. This keeps the hot path classifier-free
+ * for tests and for environments without Anthropic credentials.
+ *
+ * Rules:
+ * 1. Exact task ID match (wf-XXXXXXXX) → flag dependency.
+ * 2. Title substring match (case-insensitive, ≥6 chars to avoid noise) → flag.
+ * 3. File-path match (anywhere in question text) → flag the task whose changed
+ *    files include that path.
+ *
+ * @param {string} questionText
+ * @param {Array<{id:string,title?:string,files?:string[]}>} pendingTasks
+ * @returns {string[]} task IDs flagged as dependent
+ */
+function classifyDependencies(questionText, pendingTasks = []) {
+  if (!questionText || !pendingTasks.length) return [];
+  const text = String(questionText);
+  const lower = text.toLowerCase();
+  const flagged = new Set();
+
+  const idRegex = /\bwf-[a-f0-9]{8}\b/gi;
+  const ids = text.match(idRegex) || [];
+  for (const id of ids) flagged.add(id.toLowerCase());
+
+  for (const task of pendingTasks) {
+    if (!task || !task.id) continue;
+    if (flagged.has(task.id.toLowerCase())) continue;
+    if (titleMatchesText(task.title, lower)) {
+      flagged.add(task.id);
+      continue;
+    }
+    if (Array.isArray(task.files)) {
+      for (const f of task.files) {
+        if (typeof f === 'string' && f.length >= 4 && lower.includes(f.toLowerCase())) {
+          flagged.add(task.id);
+          break;
+        }
+      }
+    }
+  }
+  return [...flagged];
+}
+
+function titleMatchesText(title, lowerText) {
+  if (!title || title.length < 6) return false;
+  const t = title.toLowerCase();
+  if (lowerText.includes(t)) return true;
+  const words = t.split(/\s+/).filter(w => w.length >= 4);
+  for (let i = 0; i < words.length - 1; i++) {
+    const bigram = `${words[i]} ${words[i + 1]}`;
+    if (bigram.length >= 6 && lowerText.includes(bigram)) return true;
+  }
+  return false;
+}
+
+/**
+ * Conservative union — combines text-match + AI classifier results, deduped.
+ */
+function unionDependencies(...lists) {
+  const out = new Set();
+  for (const list of lists) {
+    if (!Array.isArray(list)) continue;
+    for (const id of list) out.add(id);
+  }
+  return [...out];
+}
+
+/**
+ * Fail-safe wrapper: if the classifier is unavailable or throws, mark ALL
+ * pending tasks as dependent (the safest over-flag per the spec).
+ */
+function classifyDependenciesSafe(questionText, pendingTasks, aiClassifier = null) {
+  const textMatched = classifyDependencies(questionText, pendingTasks);
+  if (typeof aiClassifier !== 'function') {
+    if (textMatched.length === 0) {
+      return pendingTasks.map(t => t && t.id).filter(Boolean);
+    }
+    return textMatched;
+  }
+  try {
+    const aiResult = aiClassifier(questionText, pendingTasks);
+    if (!Array.isArray(aiResult)) {
+      return pendingTasks.map(t => t && t.id).filter(Boolean);
+    }
+    return unionDependencies(textMatched, aiResult);
+  } catch (_err) {
+    return pendingTasks.map(t => t && t.id).filter(Boolean);
+  }
+}
+
+function listOpenQuestions() {
+  return loadQueue().questions.filter(q => !q.answered);
+}
+
+function listSkippedTasks() {
+  return loadQueue().skippedTasks;
+}
+
+module.exports = {
+  QUEUE_PATH,
+  emptyQueue,
+  loadQueue,
+  saveQueue,
+  clearQueue,
+  addQuestion,
+  skipTask,
+  classifyDependencies,
+  classifyDependenciesSafe,
+  unionDependencies,
+  listOpenQuestions,
+  listSkippedTasks
+};
+
+if (require.main === module) {
+  const [,, cmd, ...args] = process.argv;
+  switch (cmd) {
+    case 'list': {
+      const q = loadQueue();
+      console.log(JSON.stringify(q, null, 2));
+      break;
+    }
+    case 'clear': {
+      clearQueue();
+      console.log('cleared');
+      break;
+    }
+    case 'add': {
+      const text = args.join(' ');
+      if (!text) { console.error('Usage: flow-question-queue add <text>'); process.exit(1); }
+      const entry = addQuestion({ text });
+      console.log(JSON.stringify(entry, null, 2));
+      break;
+    }
+    default:
+      console.log('Usage: flow-question-queue <list|add|clear>');
+  }
+}

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 {