wogiflow 2.17.0 → 2.18.0

package/scripts/flow-archive-runs.js

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Archive Runs (stale-cleanup)
+ *
+ * Manual-only archival for adversary-runs/*.json + gate-telemetry.jsonl.
+ *
+ * Story: wf-6a352aae (epic-episodic-memory). User-approved scope:
+ *   - archive.adversaryRunsDays: 30
+ *   - archive.telemetryMaxLines: 5000
+ *   - archive.autoAtSessionEnd: false (manual-only — destructive operations)
+ *
+ * Boundaries:
+ *   - Files referenced by the active task-checkpoint are NEVER archived.
+ *   - Original content is preserved in gzip form; nothing deleted.
+ *   - Idempotent: re-running on the same input writes no duplicate archives.
+ *
+ * Usage (programmatic):
+ *   const { archiveAdversaryRuns, archiveTelemetryLog, archiveAll } = require('./flow-archive-runs');
+ *   const result = await archiveAll({ dryRun: false });
+ *
+ * CLI:
+ *   node scripts/flow-archive-runs.js              # archive (writes + moves)
+ *   node scripts/flow-archive-runs.js --dry-run    # preview only
+ *   node scripts/flow-archive-runs.js status       # show what would archive
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const zlib = require('node:zlib');
+const { pipeline } = require('node:stream/promises');
+const { createReadStream, createWriteStream } = require('node:fs');
+
+const {
+  PATHS,
+  safeJsonParse,
+  writeJson,
+  ensureDir,
+  withLock,
+} = require('./flow-utils');
+const { getConfig } = require('./flow-config-loader');
+
+// ============================================================================
+// Constants & paths
+// ============================================================================
+
+const ADVERSARY_RUNS_DIR = path.join(PATHS.state, 'adversary-runs');
+const ADVERSARY_ARCHIVE_DIR = path.join(ADVERSARY_RUNS_DIR, '_archive');
+const ADVERSARY_INDEX_FILE = path.join(ADVERSARY_ARCHIVE_DIR, 'index.json');
+const TELEMETRY_LOG = path.join(PATHS.state, 'gate-telemetry.jsonl');
+const TELEMETRY_ARCHIVE_DIR = path.join(PATHS.state, '_archive');
+const TASK_CHECKPOINT_FILE = path.join(PATHS.state, 'task-checkpoint.json');
+
+const ARCHIVE_DEFAULTS = Object.freeze({
+  autoAtSessionEnd: false,
+  adversaryRunsDays: 30,
+  telemetryMaxLines: 5000,
+});
+
+// ============================================================================
+// Config
+// ============================================================================
+
+function getArchiveConfig() {
+  let cfg = {};
+  try {
+    cfg = getConfig() || {};
+  } catch (_err) {
+    cfg = {};
+  }
+  const a = cfg.archive || {};
+  return {
+    autoAtSessionEnd: a.autoAtSessionEnd === true,
+    adversaryRunsDays: Number.isFinite(a.adversaryRunsDays)
+      ? a.adversaryRunsDays
+      : ARCHIVE_DEFAULTS.adversaryRunsDays,
+    telemetryMaxLines: Number.isFinite(a.telemetryMaxLines)
+      ? a.telemetryMaxLines
+      : ARCHIVE_DEFAULTS.telemetryMaxLines,
+  };
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/**
+ * Read active taskId from task-checkpoint.json (used as do-not-archive guard).
+ */
+function getActiveTaskId() {
+  if (!fs.existsSync(TASK_CHECKPOINT_FILE)) return null;
+  const checkpoint = safeJsonParse(TASK_CHECKPOINT_FILE, null);
+  return checkpoint?.taskId || null;
+}
+
+function ageDays(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    const ageMs = Date.now() - stat.mtimeMs;
+    return ageMs / (1000 * 60 * 60 * 24);
+  } catch (_err) {
+    return 0;
+  }
+}
+
+function yyyyMm(date) {
+  const d = new Date(date);
+  const y = d.getUTCFullYear();
+  const m = String(d.getUTCMonth() + 1).padStart(2, '0');
+  return `${y}-${m}`;
+}
+
+function yyyyMmDd(date) {
+  const d = new Date(date);
+  const y = d.getUTCFullYear();
+  const m = String(d.getUTCMonth() + 1).padStart(2, '0');
+  const day = String(d.getUTCDate()).padStart(2, '0');
+  return `${y}-${m}-${day}`;
+}
+
+/**
+ * Stream-gzip a source file to a destination .gz. Cross-platform via Node zlib.
+ */
+async function gzipFile(srcPath, destPath) {
+  ensureDir(path.dirname(destPath));
+  await pipeline(createReadStream(srcPath), zlib.createGzip(), createWriteStream(destPath));
+}
+
+/**
+ * Cross-platform "move": copy then unlink. fs.rename can fail across volumes
+ * on Windows; copy+unlink is portable.
+ */
+function safeUnlink(filePath) {
+  try {
+    fs.unlinkSync(filePath);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+
+// ============================================================================
+// Adversary-runs archival
+// ============================================================================
+
+function loadAdversaryArchiveIndex() {
+  if (!fs.existsSync(ADVERSARY_INDEX_FILE)) return {};
+  const idx = safeJsonParse(ADVERSARY_INDEX_FILE, {});
+  return idx && typeof idx === 'object' ? idx : {};
+}
+
+async function saveAdversaryArchiveIndex(index) {
+  ensureDir(ADVERSARY_ARCHIVE_DIR);
+  await withLock(ADVERSARY_INDEX_FILE, async () => {
+    writeJson(ADVERSARY_INDEX_FILE, index);
+  });
+}
+
+/**
+ * List adversary-run files eligible for archival.
+ */
+function listEligibleAdversaryRuns(config, activeTaskId) {
+  if (!fs.existsSync(ADVERSARY_RUNS_DIR)) return [];
+  let entries;
+  try {
+    entries = fs.readdirSync(ADVERSARY_RUNS_DIR);
+  } catch (_err) {
+    return [];
+  }
+  const out = [];
+  for (const name of entries) {
+    if (!name.endsWith('.json')) continue;
+    // _archive is the archive subdirectory (no .json extension, won't reach here);
+    // index.json (under _archive) has a parent dir of _archive so won't appear here.
+    // We only filter individual run files now.
+    const full = path.join(ADVERSARY_RUNS_DIR, name);
+    try {
+      const stat = fs.statSync(full);
+      if (!stat.isFile()) continue;
+    } catch (_err) {
+      continue;
+    }
+    // Active-task guard: skip any file whose name contains the active task ID.
+    if (activeTaskId && name.includes(activeTaskId)) continue;
+    const age = ageDays(full);
+    if (age < config.adversaryRunsDays) continue;
+    out.push({ name, full, ageDays: Math.round(age * 10) / 10 });
+  }
+  return out;
+}
+
+/**
+ * Archive eligible adversary-runs.
+ * @returns {{ archived: number, skipped: number, failed: number, archives: Array }}
+ */
+async function archiveAdversaryRuns(opts = {}) {
+  const config = opts.config || getArchiveConfig();
+  const dryRun = !!opts.dryRun;
+  const activeTaskId = getActiveTaskId();
+  const eligible = listEligibleAdversaryRuns(config, activeTaskId);
+  const result = { archived: 0, skipped: 0, failed: 0, archives: [], dryRun, activeTaskId };
+  if (eligible.length === 0) return result;
+  if (dryRun) {
+    result.archives = eligible.map((e) => ({
+      name: e.name,
+      ageDays: e.ageDays,
+      destinationDir: path.join(ADVERSARY_ARCHIVE_DIR, yyyyMm(new Date())),
+    }));
+    return result;
+  }
+  const index = loadAdversaryArchiveIndex();
+  for (const f of eligible) {
+    const ymDir = yyyyMm(new Date());
+    const destPath = path.join(ADVERSARY_ARCHIVE_DIR, ymDir, `${f.name}.gz`);
+    // Idempotency: if archive already exists for this filename, skip.
+    if (index[f.name]) {
+      result.skipped += 1;
+      continue;
+    }
+    try {
+      await gzipFile(f.full, destPath);
+      // Read the run to extract metadata for the index. safeJsonParse handles
+      // file errors and prototype-pollution per security-patterns.md §2.
+      const meta = { taskId: null, round: null };
+      const parsed = safeJsonParse(f.full, null);
+      if (parsed && typeof parsed === 'object') {
+        meta.taskId = parsed.taskId || null;
+        meta.round = parsed.round || null;
+      }
+      const removed = safeUnlink(f.full);
+      if (!removed) {
+        // Source unlink failed → leave .gz in place; don't update index so
+        // a retry will skip (file already gzipped) and complete the unlink later.
+        result.failed += 1;
+        continue;
+      }
+      index[f.name] = {
+        archivedAt: new Date().toISOString(),
+        archivePath: path.relative(PATHS.state, destPath),
+        taskId: meta.taskId,
+        round: meta.round,
+        ageDaysAtArchive: f.ageDays,
+      };
+      result.archived += 1;
+      result.archives.push({ name: f.name, archivePath: index[f.name].archivePath });
+    } catch (err) {
+      result.failed += 1;
+      if (process.env.DEBUG) {
+        console.error(`[archive] gzip failed for ${f.name}: ${err.message}`);
+      }
+    }
+  }
+  if (result.archived > 0) {
+    await saveAdversaryArchiveIndex(index);
+  }
+  return result;
+}
+
+// ============================================================================
+// Telemetry-log rotation
+// ============================================================================
+
+/**
+ * Count lines in a file (streaming, no full-read).
+ */
+function countLines(filePath) {
+  return new Promise((resolve) => {
+    if (!fs.existsSync(filePath)) return resolve(0);
+    let count = 0;
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    let trailingNewline = false;
+    stream.on('data', (chunk) => {
+      for (let i = 0; i < chunk.length; i++) {
+        if (chunk[i] === '\n') count += 1;
+      }
+      trailingNewline = chunk[chunk.length - 1] === '\n';
+    });
+    stream.on('end', () => {
+      // If file doesn't end with \n, the last partial line still counts as a line.
+      // We're a JSONL log so most lines end with \n; keep the count as-is.
+      resolve(count + (trailingNewline ? 0 : (count > 0 || fs.existsSync(filePath) ? 1 : 0)));
+    });
+    stream.on('error', () => resolve(0));
+  });
+}
+
+/**
+ * Rotate gate-telemetry.jsonl when over the line cap.
+ * @returns {{ rotated: boolean, lineCount: number, archivePath?: string, dryRun: boolean }}
+ */
+async function archiveTelemetryLog(opts = {}) {
+  const config = opts.config || getArchiveConfig();
+  const dryRun = !!opts.dryRun;
+  const lineCount = await countLines(TELEMETRY_LOG);
+  if (lineCount <= config.telemetryMaxLines) {
+    return { rotated: false, lineCount, dryRun };
+  }
+  const archivePath = path.join(
+    TELEMETRY_ARCHIVE_DIR,
+    `gate-telemetry-${yyyyMmDd(new Date())}.jsonl.gz`
+  );
+  if (dryRun) {
+    return { rotated: false, lineCount, archivePath, dryRun: true };
+  }
+  await withLock(TELEMETRY_LOG, async () => {
+    await gzipFile(TELEMETRY_LOG, archivePath);
+    // Truncate live file (keeps existing FD-readers from breaking — file replaced).
+    fs.writeFileSync(TELEMETRY_LOG, '');
+  });
+  return { rotated: true, lineCount, archivePath: path.relative(PATHS.state, archivePath), dryRun };
+}
+
+// ============================================================================
+// Top-level archiveAll
+// ============================================================================
+
+async function archiveAll(opts = {}) {
+  const config = opts.config || getArchiveConfig();
+  const dryRun = !!opts.dryRun;
+  const adversary = await archiveAdversaryRuns({ config, dryRun });
+  const telemetry = await archiveTelemetryLog({ config, dryRun });
+  return { adversary, telemetry, dryRun };
+}
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+module.exports = {
+  archiveAll,
+  archiveAdversaryRuns,
+  archiveTelemetryLog,
+  loadAdversaryArchiveIndex,
+  listEligibleAdversaryRuns,
+  getActiveTaskId,
+  getArchiveConfig,
+  countLines,
+  yyyyMm,
+  yyyyMmDd,
+  ARCHIVE_DEFAULTS,
+};
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const cmd = args.find((a) => !a.startsWith('--')) || 'run';
+  (async () => {
+    if (cmd === 'status') {
+      const cfg = getArchiveConfig();
+      const eligible = listEligibleAdversaryRuns(cfg, getActiveTaskId());
+      const lineCount = await countLines(TELEMETRY_LOG);
+      console.log(JSON.stringify({
+        adversaryEligible: eligible.length,
+        adversaryFiles: eligible.map((e) => `${e.name} (${e.ageDays}d)`),
+        telemetryLineCount: lineCount,
+        telemetryMaxLines: cfg.telemetryMaxLines,
+        wouldRotateTelemetry: lineCount > cfg.telemetryMaxLines,
+        activeTaskId: getActiveTaskId(),
+      }, null, 2));
+      return;
+    }
+    const r = await archiveAll({ dryRun });
+    console.log(JSON.stringify(r, null, 2));
+  })().catch((err) => {
+    console.error(`[archive] error: ${err.message}`);
+    process.exit(1);
+  });
+}

package/scripts/flow-ask.js

@@ -80,7 +80,7 @@ function clearPendingQuestion() {
  * @returns {boolean}
  */
 function hasPendingQuestion() {
-  try { return fs.existsSync(getPendingQuestionPath()); } catch (_e) { return false; }
+  try { return fs.existsSync(getPendingQuestionPath()); } catch (_err) { return false; }
 }
 
 module.exports = {

package/scripts/flow-ast-grep.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - AST-Grep Integration
+ *
+ * Structural pattern search via the `sg` CLI (ast-grep). Extracted from
+ * flow-utils.js (wf-94cc3b72 epic — flow-utils decomposition) to keep the
+ * barrel thin. Re-exported from flow-utils.js for backwards compatibility.
+ */
+
+'use strict';
+
+const path = require('node:path');
+const { execSync, execFileSync } = require('node:child_process');
+const { PROJECT_ROOT } = require('./flow-paths');
+const { dirExists } = require('./flow-io');
+
+/**
+ * Common AST patterns for code discovery
+ */
+const AST_PATTERNS = {
+  // React patterns
+  reactComponent: 'function $NAME($PROPS) { return <$_>$$$</$_> }',
+  reactArrowComponent: 'const $NAME = ($PROPS) => { return <$_>$$$</$_> }',
+  useStateHook: 'const [$STATE, $SETTER] = useState($INIT)',
+  useEffectHook: 'useEffect($FN, [$$$DEPS])',
+  useCustomHook: 'const $RESULT = use$NAME($$$ARGS)',
+
+  // TypeScript patterns
+  interfaceDefinition: 'interface $NAME { $$$ }',
+  typeDefinition: 'type $NAME = $$$',
+  exportedFunction: 'export function $NAME($$$PARAMS) { $$$ }',
+  exportedConst: 'export const $NAME = $$$',
+
+  // Import patterns
+  namedImport: 'import { $$$IMPORTS } from "$PATH"',
+  defaultImport: 'import $NAME from "$PATH"',
+
+  // Class patterns
+  classDefinition: 'class $NAME { $$$ }',
+  classExtends: 'class $NAME extends $BASE { $$$ }'
+};
+
+/**
+ * Check if ast-grep CLI (sg) is available
+ */
+function isAstGrepAvailable() {
+  try {
+    execSync('which sg', { stdio: 'ignore' });
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+
+// Allowed languages for ast-grep to prevent command injection (Security Rule 8)
+const ALLOWED_AST_GREP_LANGUAGES = new Set([
+  'typescript', 'javascript', 'tsx', 'jsx', 'python', 'go', 'rust',
+  'java', 'c', 'cpp', 'csharp', 'ruby', 'swift', 'kotlin', 'html', 'css'
+]);
+
+/**
+ * Search codebase using ast-grep for structural patterns
+ * @param {string} pattern - AST pattern (e.g., "useState($INIT)")
+ * @param {object} options - { lang, cwd, maxResults }
+ * @returns {Array|null} Array of matches or null if ast-grep unavailable
+ */
+function astGrepSearch(pattern, options = {}) {
+  const {
+    lang = 'typescript',
+    cwd = PROJECT_ROOT,
+    maxResults = 20,
+    searchDir = 'src'
+  } = options;
+
+  // Validate lang parameter to prevent command injection (Security Rule 8)
+  if (!ALLOWED_AST_GREP_LANGUAGES.has(lang)) {
+    if (process.env.DEBUG) {
+      console.error(`[ast-grep] Invalid language: ${lang}. Allowed: ${[...ALLOWED_AST_GREP_LANGUAGES].join(', ')}`);
+    }
+    return null;
+  }
+
+  // Check if ast-grep is available
+  if (!isAstGrepAvailable()) {
+    return null;
+  }
+
+  const searchPath = path.join(cwd, searchDir);
+  if (!dirExists(searchPath)) {
+    return [];
+  }
+
+  try {
+    // Use execFileSync with array args to prevent shell injection (Security Rule 8)
+    const result = execFileSync('sg', [
+      '--pattern', pattern,
+      '--lang', lang,
+      '--json', searchPath
+    ], {
+      encoding: 'utf-8',
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 30000
+    });
+
+    const matches = JSON.parse(result || '[]');
+    return matches.slice(0, maxResults).map(m => ({
+      file: path.relative(cwd, m.file || m.path),
+      line: m.range?.start?.line ?? m.startLine ?? 0,
+      endLine: m.range?.end?.line ?? m.endLine ?? 0,
+      content: m.text || m.match,
+      meta: m.metaVariables || {}  // Captured $VARS
+    }));
+  } catch (err) {
+    // Parse error, timeout, or no matches
+    if (err.stdout) {
+      try {
+        const matches = JSON.parse(err.stdout);
+        return matches.slice(0, maxResults).map(m => ({
+          file: path.relative(cwd, m.file || m.path),
+          line: m.range?.start?.line ?? 0,
+          content: m.text || m.match,
+          meta: m.metaVariables || {}
+        }));
+      } catch (_err) {
+        // Ignore parse errors
+      }
+    }
+    return [];
+  }
+}
+
+/**
+ * Search for React components in the codebase
+ * @param {object} options - Search options
+ */
+function findReactComponents(options = {}) {
+  const { maxResults = 10 } = options;
+
+  // Try function components first
+  let results = astGrepSearch(AST_PATTERNS.reactComponent, { ...options, maxResults });
+
+  // If ast-grep not available, return null
+  if (results === null) return null;
+
+  // Also search arrow function components
+  const arrowResults = astGrepSearch(AST_PATTERNS.reactArrowComponent, { ...options, maxResults });
+  if (arrowResults) {
+    results = [...results, ...arrowResults];
+  }
+
+  // Dedupe by file
+  const seen = new Set();
+  return results.filter(r => {
+    if (seen.has(r.file)) return false;
+    seen.add(r.file);
+    return true;
+  }).slice(0, maxResults);
+}
+
+/**
+ * Search for custom hooks in the codebase
+ * @param {object} options - Search options
+ */
+function findCustomHooks(options = {}) {
+  const { maxResults = 10 } = options;
+
+  // Search for function use* pattern
+  const results = astGrepSearch('function use$NAME($$$) { $$$ }', { ...options, maxResults });
+
+  if (results === null) return null;
+
+  return results.filter(r => {
+    // Filter to only actual hook files
+    const fileName = path.basename(r.file).toLowerCase();
+    return fileName.startsWith('use') || fileName.includes('hook');
+  });
+}
+
+/**
+ * Search for TypeScript interfaces/types
+ * @param {string} namePattern - Optional name pattern to filter by
+ * @param {object} options - Search options
+ */
+function findTypeDefinitions(namePattern = null, options = {}) {
+  const { maxResults = 10 } = options;
+
+  // Search interfaces
+  let results = astGrepSearch(AST_PATTERNS.interfaceDefinition, { ...options, maxResults });
+
+  if (results === null) return null;
+
+  // Also search type aliases
+  const typeResults = astGrepSearch(AST_PATTERNS.typeDefinition, { ...options, maxResults });
+  if (typeResults) {
+    results = [...results, ...typeResults];
+  }
+
+  // Filter by name pattern if provided
+  if (namePattern) {
+    const regex = new RegExp(namePattern, 'i');
+    results = results.filter(r => regex.test(r.content));
+  }
+
+  return results.slice(0, maxResults);
+}
+
+module.exports = {
+  AST_PATTERNS,
+  ALLOWED_AST_GREP_LANGUAGES,
+  isAstGrepAvailable,
+  astGrepSearch,
+  findReactComponents,
+  findCustomHooks,
+  findTypeDefinitions,
+};

package/scripts/flow-audit-gates.js

@@ -29,7 +29,7 @@
 
 'use strict';
 
-const { execFileSync } = require('node:child_process');
+const { execFileSync, execSync } = require('node:child_process');
 const fs = require('node:fs');
 const path = require('node:path');
 

package/scripts/flow-auto-learn.js

@@ -15,13 +15,13 @@ const fs = require('node:fs');
 const path = require('node:path');
 const {
   PATHS,
-  PROJECT_ROOT,
   fileExists,
   getConfig,
   color,
   success,
   info,
-  warn
+  warn,
+  getTodayDate
 } = require('./flow-utils');
 
 // ============================================================
@@ -142,15 +142,9 @@ function normalizeIssueToPattern(issue) {
  * @param {string} str - Input string
  * @returns {string} Kebab-case string
  */
-function slugify(str) {
-  return str
-    .toLowerCase()
-    .replace(/[^a-z0-9\s-]/g, '')
-    .replace(/\s+/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '')
-    .slice(0, 50);
-}
+// Local slugify removed in favor of canonical flow-output slugify (wf-7072d3ac).
+const { slugify: _slugify } = require('./flow-output');
+const slugify = (str) => _slugify(str, { maxLength: 50 });
 
 // ============================================================
 // Feedback Patterns File Management
@@ -608,6 +602,9 @@ module.exports = {
   getAutoLearnConfig,
   loadAutoPatterns,
   saveAutoPatterns,
+  // Promotion API exposed for wf-6a352aae callers (adversary-promotion + pattern-phrase-promotion)
+  handlePromotion,
+  promoteToDecisions,
   showStatus
 };
 

package/scripts/flow-bug.js

@@ -42,10 +42,10 @@ let loadSessionState;
 try {
   const sessionModule = require('./flow-session-state');
   loadSessionState = sessionModule.loadSessionState;
-} catch (importError) {
+} catch (err) {
   // Log in debug mode - don't silently hide potential syntax errors
   if (process.env.DEBUG) {
-    console.warn(`[DEBUG] Could not load flow-session-state: ${importError.message}`);
+    console.warn(`[DEBUG] Could not load flow-session-state: ${err.message}`);
   }
   loadSessionState = () => ({});
 }