wogiflow 1.0.0

package/scripts/flow-bridge.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+/**
+ * flow-bridge.js - CLI Bridge Management
+ *
+ * Commands:
+ *   flow bridge sync     - Sync .workflow/ to CLI-specific folder
+ *   flow bridge status   - Show current bridge configuration
+ *   flow bridge list     - List available CLI bridges
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Colors
+const colors = {
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  bold: '\x1b[1m',
+  reset: '\x1b[0m'
+};
+
+const PROJECT_ROOT = process.cwd();
+const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
+const BRIDGES_DIR = path.join(WORKFLOW_DIR, 'bridges');
+const CONFIG_PATH = path.join(WORKFLOW_DIR, 'config.json');
+
+/**
+ * Read config file
+ */
+function getConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    console.error(`${colors.red}Error:${colors.reset} Config not found. Run 'flow install' first.`);
+    process.exit(1);
+  }
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch (err) {
+    console.error(`${colors.red}Error:${colors.reset} Invalid JSON in config.json: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Get CLI type from config
+ */
+function getCliType() {
+  const config = getConfig();
+  return config.cli?.type || 'claude-code';
+}
+
+/**
+ * List available bridges
+ */
+function listBridges() {
+  console.log(`${colors.bold}Available CLI Bridges:${colors.reset}`);
+  console.log('');
+
+  const availableBridges = [
+    {
+      id: 'claude-code',
+      name: 'Claude Code',
+      status: 'implemented',
+      folder: '.claude',
+      rulesFile: 'CLAUDE.md'
+    },
+    {
+      id: 'gemini-cli',
+      name: 'Gemini CLI',
+      status: 'planned',
+      folder: '.gemini',
+      rulesFile: 'GEMINI.md'
+    },
+    {
+      id: 'opencode',
+      name: 'OpenCode',
+      status: 'planned',
+      folder: '.opencode',
+      rulesFile: 'OPENCODE.md'
+    },
+    {
+      id: 'other',
+      name: 'Other / Manual',
+      status: 'manual',
+      folder: 'N/A',
+      rulesFile: 'N/A'
+    }
+  ];
+
+  const currentCli = getCliType();
+
+  for (const bridge of availableBridges) {
+    const isCurrent = bridge.id === currentCli;
+    const statusColor = bridge.status === 'implemented' ? colors.green :
+                        bridge.status === 'planned' ? colors.yellow : colors.cyan;
+    const indicator = isCurrent ? `${colors.green}→${colors.reset}` : ' ';
+
+    console.log(`  ${indicator} ${colors.bold}${bridge.name}${colors.reset} (${bridge.id})`);
+    console.log(`      Status: ${statusColor}${bridge.status}${colors.reset}`);
+    console.log(`      Folder: ${bridge.folder}`);
+    console.log(`      Rules:  ${bridge.rulesFile}`);
+    console.log('');
+  }
+}
+
+/**
+ * Show bridge status
+ */
+function showStatus() {
+  const config = getConfig();
+  const cliType = config.cli?.type || 'claude-code';
+  const bridgeConfig = config.cli?.bridge || {};
+
+  console.log(`${colors.bold}CLI Bridge Status${colors.reset}`);
+  console.log('');
+  console.log(`  CLI Type:        ${colors.cyan}${cliType}${colors.reset}`);
+  console.log(`  Auto Sync:       ${bridgeConfig.autoSync ? colors.green + 'enabled' : colors.yellow + 'disabled'}${colors.reset}`);
+  console.log(`  Sync on Change:  ${bridgeConfig.syncOnConfigChange ? colors.green + 'enabled' : colors.yellow + 'disabled'}${colors.reset}`);
+  console.log('');
+
+  // Check if bridge file exists
+  const bridgePath = path.join(BRIDGES_DIR, `${cliType.replace('-', '-')}-bridge.js`);
+  const bridgeFileMap = {
+    'claude-code': 'claude-bridge.js',
+    'gemini-cli': 'gemini-bridge.js',
+    'opencode': 'opencode-bridge.js'
+  };
+
+  const bridgeFile = bridgeFileMap[cliType];
+  if (bridgeFile) {
+    const bridgeExists = fs.existsSync(path.join(BRIDGES_DIR, bridgeFile));
+    console.log(`  Bridge File:     ${bridgeExists ? colors.green + '✓ ' + bridgeFile : colors.yellow + '○ not implemented'}${colors.reset}`);
+  }
+
+  // Check CLI folder status
+  const cliFolders = {
+    'claude-code': '.claude',
+    'gemini-cli': '.gemini',
+    'opencode': '.opencode'
+  };
+
+  const cliFolder = cliFolders[cliType];
+  if (cliFolder) {
+    const folderExists = fs.existsSync(path.join(PROJECT_ROOT, cliFolder));
+    console.log(`  CLI Folder:      ${folderExists ? colors.green + '✓ ' + cliFolder + '/' : colors.yellow + '○ ' + cliFolder + '/ (not created)'}${colors.reset}`);
+  }
+
+  console.log('');
+}
+
+/**
+ * Sync bridge
+ */
+async function syncBridge(options = {}) {
+  const verbose = options.verbose || process.argv.includes('--verbose') || process.argv.includes('-v');
+
+  console.log(`${colors.cyan}Syncing CLI bridge...${colors.reset}`);
+  console.log('');
+
+  try {
+    // Try to load the bridges module
+    let bridges;
+    try {
+      bridges = require(path.join(BRIDGES_DIR, 'index.js'));
+    } catch (err) {
+      console.error(`${colors.red}Error:${colors.reset} Bridges module not found.`);
+      console.error('Make sure .workflow/bridges/index.js exists.');
+      process.exit(1);
+    }
+
+    const result = await bridges.syncBridge({ verbose, projectDir: PROJECT_ROOT });
+
+    if (result.success) {
+      console.log(`${colors.green}✓ Bridge sync complete${colors.reset}`);
+      console.log('');
+      console.log(`  CLI Type: ${result.cliType}`);
+      console.log(`  Folder:   ${result.cliFolder}`);
+      console.log(`  Synced:   ${result.synced.join(', ')}`);
+      console.log(`  Duration: ${result.duration}ms`);
+    } else {
+      console.log(`${colors.yellow}⚠ Bridge sync completed with issues${colors.reset}`);
+      console.log('');
+      if (result.error) {
+        console.log(`  Error: ${result.error}`);
+      }
+      if (result.errors && result.errors.length > 0) {
+        for (const err of result.errors) {
+          console.log(`  ${colors.yellow}○${colors.reset} ${err.step}: ${err.error}`);
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`${colors.red}Error:${colors.reset} ${error.message}`);
+    process.exit(1);
+  }
+
+  console.log('');
+}
+
+// Main
+const command = process.argv[2] || 'status';
+
+switch (command) {
+  case 'sync':
+    syncBridge();
+    break;
+  case 'status':
+    showStatus();
+    break;
+  case 'list':
+    listBridges();
+    break;
+  default:
+    console.log('Usage: flow bridge [sync|status|list]');
+    console.log('');
+    console.log('Commands:');
+    console.log('  sync    Sync .workflow/ config to CLI-specific folder');
+    console.log('  status  Show current bridge configuration');
+    console.log('  list    List available CLI bridges');
+    process.exit(1);
+}

package/scripts/flow-browser-suggest.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Browser Test Suggestion
+ *
+ * Detects UI tasks and suggests relevant browser test flows.
+ * Integrates with /wogi-test-browser command.
+ *
+ * Usage:
+ *   Called automatically after task completion in flow-done.js
+ *   Or manually: flow browser-suggest <task-id>
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getProjectRoot, colors, getConfig } = require('./flow-utils');
+
+const PROJECT_ROOT = getProjectRoot();
+const WORKFLOW_DIR = path.join(PROJECT_ROOT, '.workflow');
+const FLOWS_DIR = path.join(WORKFLOW_DIR, 'tests', 'flows');
+const STATE_DIR = path.join(WORKFLOW_DIR, 'state');
+
+function log(color, ...args) {
+  console.log(colors[color] + args.join(' ') + colors.reset);
+}
+
+/**
+ * Check if a task is a UI task based on files it modified
+ */
+function isUITask(taskData) {
+  const files = taskData?.files || [];
+
+  // UI file patterns
+  const uiPatterns = [
+    /\.tsx$/,
+    /\.jsx$/,
+    /\/components\//,
+    /\/pages\//,
+    /\/views\//,
+    /\/screens\//,
+    /\/ui\//,
+    /\.css$/,
+    /\.scss$/,
+    /\.styled\./,
+  ];
+
+  return files.some(file =>
+    uiPatterns.some(pattern => pattern.test(file))
+  );
+}
+
+/**
+ * Get files changed by a task from various sources
+ */
+function getTaskFiles(taskId, taskData) {
+  const files = new Set(taskData?.files || []);
+
+  // Try to get files from request-log
+  const logPath = path.join(STATE_DIR, 'request-log.md');
+  if (fs.existsSync(logPath)) {
+    try {
+      const logContent = fs.readFileSync(logPath, 'utf8');
+      const escapedTaskId = taskId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const taskPattern = new RegExp(`### R-\\d+.*${escapedTaskId}[\\s\\S]*?Files:\\s*([^\\n]+)`, 'gi');
+
+      let match;
+      while ((match = taskPattern.exec(logContent)) !== null) {
+        const mentionedFiles = match[1].split(',').map(f => f.trim().replace(/`/g, ''));
+        mentionedFiles.forEach(f => files.add(f));
+      }
+    } catch (err) {
+      // Ignore errors reading log
+    }
+  }
+
+  // Try to get from git diff if task has branch info
+  if (taskData?.branch) {
+    try {
+      const { execSync } = require('child_process');
+      const diff = execSync(`git diff --name-only main...${taskData.branch}`, {
+        cwd: PROJECT_ROOT,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+      diff.split('\n').filter(Boolean).forEach(f => files.add(f));
+    } catch (err) {
+      // Git command failed, ignore
+    }
+  }
+
+  return Array.from(files);
+}
+
+/**
+ * Find browser test flows that match the task
+ */
+function findMatchingFlows(taskId, taskData) {
+  if (!fs.existsSync(FLOWS_DIR)) {
+    return [];
+  }
+
+  const matchingFlows = [];
+  const files = getTaskFiles(taskId, taskData);
+  const taskTitle = (taskData?.title || taskData?.name || '').toLowerCase();
+
+  try {
+    const flowFiles = fs.readdirSync(FLOWS_DIR).filter(f => f.endsWith('.json'));
+
+    for (const flowFile of flowFiles) {
+      const flowPath = path.join(FLOWS_DIR, flowFile);
+      try {
+        const flow = JSON.parse(fs.readFileSync(flowPath, 'utf8'));
+        const flowName = flowFile.replace('.json', '');
+
+        // Check if flow explicitly references this task
+        if (flow.relatedTasks?.includes(taskId)) {
+          matchingFlows.push(flowName);
+          continue;
+        }
+
+        // Check if flow name matches any component in task files
+        const flowNameLower = flowName.toLowerCase();
+        for (const file of files) {
+          const fileName = path.basename(file, path.extname(file)).toLowerCase();
+          if (flowNameLower.includes(fileName) || fileName.includes(flowNameLower)) {
+            matchingFlows.push(flowName);
+            break;
+          }
+        }
+
+        // Check if flow name matches task title keywords
+        if (taskTitle) {
+          const titleWords = taskTitle.split(/\s+/).filter(w => w.length > 3);
+          if (titleWords.some(word => flowNameLower.includes(word))) {
+            if (!matchingFlows.includes(flowName)) {
+              matchingFlows.push(flowName);
+            }
+          }
+        }
+
+        // Check if flow tests components that were modified
+        if (flow.components) {
+          const flowComponents = flow.components.map(c => c.toLowerCase());
+          for (const file of files) {
+            const fileName = path.basename(file, path.extname(file)).toLowerCase();
+            if (flowComponents.some(c => c.includes(fileName) || fileName.includes(c))) {
+              if (!matchingFlows.includes(flowName)) {
+                matchingFlows.push(flowName);
+              }
+              break;
+            }
+          }
+        }
+      } catch (err) {
+        // Invalid flow file, skip
+      }
+    }
+  } catch (err) {
+    // Can't read flows directory
+  }
+
+  return matchingFlows;
+}
+
+/**
+ * Main function to suggest browser tests for a task
+ */
+function suggestBrowserTests(taskId, taskData = {}) {
+  const config = getConfig();
+  const browserConfig = config.browserTesting || {};
+
+  // Check if browser testing is enabled
+  if (!browserConfig.enabled) {
+    return { suggested: false, reason: 'Browser testing disabled' };
+  }
+
+  // Get task files and check if UI task
+  const files = getTaskFiles(taskId, taskData);
+  taskData = { ...taskData, files };
+
+  const isUI = isUITask(taskData);
+
+  // If runForUITasks is true, only suggest for UI tasks
+  if (browserConfig.runForUITasks && !isUI) {
+    return { suggested: false, reason: 'Not a UI task', isUITask: false };
+  }
+
+  // Find matching flows
+  const flows = findMatchingFlows(taskId, taskData);
+
+  if (flows.length === 0) {
+    return {
+      suggested: false,
+      reason: 'No matching test flows found',
+      isUITask: isUI,
+      hint: isUI ? 'Consider creating a test flow for this component' : null
+    };
+  }
+
+  return {
+    suggested: true,
+    flows,
+    isUITask: isUI,
+    autoRun: browserConfig.autoRun || false
+  };
+}
+
+/**
+ * List all available browser test flows
+ */
+function listFlows() {
+  if (!fs.existsSync(FLOWS_DIR)) {
+    return [];
+  }
+
+  try {
+    return fs.readdirSync(FLOWS_DIR)
+      .filter(f => f.endsWith('.json'))
+      .map(f => f.replace('.json', ''));
+  } catch (err) {
+    return [];
+  }
+}
+
+// CLI handling
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+Wogi Flow - Browser Test Suggestion
+
+Usage:
+  flow browser-suggest <task-id>    Suggest browser tests for task
+  flow browser-suggest --list       List all available test flows
+
+Configuration (config.json):
+  "browserTesting": {
+    "enabled": true,
+    "runOnTaskComplete": true,
+    "runForUITasks": true,
+    "autoRun": false,
+    "timeout": 30000,
+    "screenshotOnFailure": true
+  }
+
+Test flows are stored in: .workflow/tests/flows/*.json
+`);
+    process.exit(0);
+  }
+
+  if (args.includes('--list')) {
+    const flows = listFlows();
+    if (flows.length === 0) {
+      log('yellow', 'No browser test flows found');
+      log('dim', `Create flows in: ${FLOWS_DIR}`);
+    } else {
+      log('cyan', 'Available browser test flows:');
+      flows.forEach(f => log('white', `  - ${f}`));
+    }
+    process.exit(0);
+  }
+
+  const taskId = args[0];
+  if (!taskId) {
+    console.log('Usage: flow browser-suggest <task-id>');
+    process.exit(1);
+  }
+
+  // Try to load task data from ready.json
+  let taskData = {};
+  const readyPath = path.join(STATE_DIR, 'ready.json');
+  if (fs.existsSync(readyPath)) {
+    try {
+      const ready = JSON.parse(fs.readFileSync(readyPath, 'utf8'));
+      const allTasks = [
+        ...(ready.ready || []),
+        ...(ready.inProgress || []),
+        ...(ready.recentlyCompleted || []),
+        ...(ready.blocked || [])
+      ];
+      const task = allTasks.find(t => t.id === taskId);
+      if (task) taskData = task;
+    } catch (err) {
+      // Ignore
+    }
+  }
+
+  const result = suggestBrowserTests(taskId, taskData);
+
+  console.log('');
+  if (result.suggested) {
+    log('green', `✓ Browser tests suggested for ${taskId}`);
+    log('cyan', '\nMatching test flows:');
+    result.flows.forEach(f => log('white', `  - ${f}`));
+    console.log('');
+    log('dim', `Run: /wogi-test-browser ${result.flows[0]}`);
+    if (result.flows.length > 1) {
+      log('dim', `Or run all: /wogi-test-browser all`);
+    }
+  } else {
+    log('yellow', `No browser tests suggested: ${result.reason}`);
+    if (result.hint) {
+      log('dim', result.hint);
+    }
+  }
+}
+
+// Export for use by other modules
+module.exports = {
+  suggestBrowserTests,
+  isUITask,
+  findMatchingFlows,
+  getTaskFiles,
+  listFlows
+};