wogiflow 1.0.0

package/scripts/flow-status.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Project Status Overview
+ *
+ * Shows task counts, features, bugs, components, and config summary.
+ *
+ * Usage:
+ *   flow status           Human-readable status
+ *   flow status --json    JSON output for programmatic access
+ */
+
+const path = require('path');
+
+const {
+  PATHS,
+  PROJECT_ROOT,
+  fileExists,
+  dirExists,
+  getTaskCounts,
+  getConfig,
+  getReadyData,
+  countRequestLogEntries,
+  countAppMapComponents,
+  getGitStatus,
+  listDirs,
+  listFiles,
+  parseFlags,
+  outputJson,
+  printHeader,
+  printSection,
+  color
+} = require('./flow-utils');
+
+/**
+ * Collect all status data
+ */
+function collectStatus() {
+  const status = {
+    tasks: { ready: 0, inProgress: 0, blocked: 0, recentlyCompleted: 0 },
+    features: [],
+    bugs: [],
+    components: 0,
+    requestLog: 0,
+    git: { isRepo: false, branch: null, uncommitted: 0 },
+    cli: { type: 'claude-code', bridgeStatus: 'unknown' },
+    config: {},
+    recommendation: {}
+  };
+
+  // Task counts
+  if (fileExists(PATHS.ready)) {
+    status.tasks = getTaskCounts();
+  }
+
+  // Features
+  if (dirExists(PATHS.changes)) {
+    status.features = listDirs(PATHS.changes);
+  }
+
+  // Bugs
+  if (dirExists(PATHS.bugs)) {
+    status.bugs = listFiles(PATHS.bugs, '.md').filter(f => !f.startsWith('.'));
+  }
+
+  // Components
+  if (fileExists(PATHS.appMap)) {
+    status.components = countAppMapComponents();
+  }
+
+  // Request log
+  if (fileExists(PATHS.requestLog)) {
+    status.requestLog = countRequestLogEntries();
+  }
+
+  // Git
+  status.git = getGitStatus();
+
+  // CLI
+  if (fileExists(PATHS.config)) {
+    try {
+      const config = getConfig();
+      status.cli.type = config.cli?.type || 'claude-code';
+
+      // Check bridge status
+      const bridgesDir = path.join(PROJECT_ROOT, '.workflow', 'bridges');
+      const modelsDir = path.join(PROJECT_ROOT, '.workflow', 'models');
+
+      if (dirExists(bridgesDir) && dirExists(modelsDir)) {
+        status.cli.bridgeStatus = 'configured';
+      } else if (config.cli?.type) {
+        status.cli.bridgeStatus = 'partial';
+      } else {
+        status.cli.bridgeStatus = 'legacy';
+      }
+    } catch {
+      status.cli.bridgeStatus = 'error';
+    }
+  }
+
+  // Config
+  if (fileExists(PATHS.config)) {
+    const config = getConfig();
+    status.config = {
+      mandatoryAfterTask: config.mandatorySteps?.afterTask || [],
+      strictMode: config.enforcement?.strictMode || false,
+      priorities: config.priorities || {}
+    };
+  }
+
+  // Recommendation
+  status.recommendation = getRecommendation();
+
+  return status;
+}
+
+function main() {
+  const { flags } = parseFlags(process.argv.slice(2));
+
+  const status = collectStatus();
+
+  // JSON output - exit early to avoid human-readable output
+  if (flags.json) {
+    outputJson({
+      success: true,
+      ...status
+    });
+    return;
+  }
+
+  // Human-readable output - use already collected status data
+  printHeader('PROJECT STATUS');
+
+  // Task counts (use status.tasks from collectStatus)
+  if (status.tasks.ready > 0 || status.tasks.inProgress > 0 || status.tasks.blocked > 0 || status.tasks.recentlyCompleted > 0) {
+    printSection('Tasks');
+    console.log(`  Ready: ${status.tasks.ready}`);
+    console.log(`  In Progress: ${status.tasks.inProgress}`);
+    console.log(`  Blocked: ${status.tasks.blocked}`);
+    console.log(`  Recently Done: ${status.tasks.recentlyCompleted}`);
+    console.log('');
+  }
+
+  // Features (use status.features from collectStatus)
+  if (status.features.length > 0 || dirExists(PATHS.changes)) {
+    printSection('Features');
+    console.log(`  Active: ${status.features.length}`);
+    if (status.features.length > 0) {
+      for (const feature of status.features) {
+        console.log(`    • ${feature}`);
+      }
+    }
+    console.log('');
+  }
+
+  // Bugs (use status.bugs from collectStatus)
+  if (status.bugs.length > 0 || dirExists(PATHS.bugs)) {
+    printSection('Bugs');
+    console.log(`  Open: ${status.bugs.length}`);
+    console.log('');
+  }
+
+  // Components (use status.components from collectStatus)
+  if (status.components > 0) {
+    printSection('Components');
+    console.log(`  Mapped: ${status.components}`);
+    console.log('');
+  }
+
+  // Request log (use status.requestLog from collectStatus)
+  if (status.requestLog > 0) {
+    printSection('Request Log');
+    console.log(`  Entries: ${status.requestLog}`);
+    console.log('');
+  }
+
+  // Git status (use status.git from collectStatus)
+  if (status.git.isRepo) {
+    printSection('Git');
+    console.log(`  Branch: ${status.git.branch || 'unknown'}`);
+    console.log(`  Uncommitted: ${status.git.uncommitted || 0} files`);
+    console.log('');
+  }
+
+  // CLI status
+  printSection('CLI');
+  const cliNames = {
+    'claude-code': 'Claude Code',
+    'gemini-cli': 'Gemini CLI',
+    'opencode': 'OpenCode'
+  };
+  const bridgeColors = {
+    'configured': 'green',
+    'partial': 'yellow',
+    'legacy': 'yellow',
+    'error': 'red'
+  };
+  console.log(`  Type: ${cliNames[status.cli.type] || status.cli.type}`);
+  console.log(`  Bridge: ${color(bridgeColors[status.cli.bridgeStatus] || 'dim', status.cli.bridgeStatus)}`);
+  console.log('');
+
+  // Config summary (use status.config from collectStatus)
+  if (status.config.mandatoryAfterTask) {
+    printSection('Config');
+    const afterTask = status.config.mandatoryAfterTask;
+
+    if (afterTask.length > 0) {
+      console.log(`  After task: ${afterTask.join(', ')}`);
+    } else {
+      console.log('  After task: (none)');
+    }
+  }
+
+  // Action-oriented recommendation (use status.recommendation from collectStatus)
+  printSection('📌 Recommended Next Action');
+  console.log(`  ${status.recommendation.action}`);
+  if (status.recommendation.command) {
+    console.log(color('dim', `  Run: ${status.recommendation.command}`));
+  }
+
+  console.log('');
+  console.log(color('cyan', '═'.repeat(50)));
+}
+
+/**
+ * Get recommended next action based on current state
+ */
+function getRecommendation() {
+  const config = getConfig();
+
+  // Check for uncommitted changes first
+  const git = getGitStatus();
+  if (git.isRepo && git.uncommitted > 0) {
+    return {
+      action: `Commit ${git.uncommitted} uncommitted file(s)`,
+      command: 'git add -A && git commit -m "message"'
+    };
+  }
+
+  // Check task state
+  if (!fileExists(PATHS.ready)) {
+    return {
+      action: 'Initialize workflow to start tracking tasks',
+      command: 'flow install'
+    };
+  }
+
+  const data = getReadyData();
+
+  // Check in-progress tasks first
+  const inProgress = data.inProgress || [];
+  if (inProgress.length > 0) {
+    const task = inProgress[0];
+    const taskId = typeof task === 'string' ? task : task.id;
+    const taskTitle = typeof task === 'object' ? (task.title || task.description || '') : '';
+    return {
+      action: `Continue working on ${taskId}${taskTitle ? `: ${taskTitle.slice(0, 40)}` : ''}`,
+      command: null
+    };
+  }
+
+  // Check ready tasks
+  const ready = data.ready || [];
+  if (ready.length > 0) {
+    // Find highest priority task (P0=critical, P1=high, P2=medium, P3=low, P4=lowest)
+    const priorityOrder = { P0: 0, P1: 1, P2: 2, P3: 3, P4: 4 };
+    const sorted = [...ready].sort((a, b) => {
+      const aPriority = priorityOrder[a.priority] ?? 2;
+      const bPriority = priorityOrder[b.priority] ?? 2;
+      return aPriority - bPriority;
+    });
+
+    const task = sorted[0];
+    const taskId = typeof task === 'string' ? task : task.id;
+    const taskTitle = typeof task === 'object' ? (task.title || task.description || '') : '';
+    const priority = typeof task === 'object' && task.priority ? ` [${task.priority}]` : '';
+    return {
+      action: `Start ${taskId}${priority}${taskTitle ? `: ${taskTitle.slice(0, 35)}` : ''}`,
+      command: `flow start ${taskId}`
+    };
+  }
+
+  // Check blocked tasks
+  const blocked = data.blocked || [];
+  if (blocked.length > 0) {
+    return {
+      action: `${blocked.length} task(s) are blocked - resolve dependencies`,
+      command: 'flow ready'
+    };
+  }
+
+  // No tasks at all
+  return {
+    action: 'Create a new task to work on',
+    command: 'flow story "Your task title"'
+  };
+}
+
+if (require.main === module) {
+  main();
+}

package/scripts/flow-step-browser.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Browser Test Step
+ *
+ * Workflow step wrapper for browser test suggestions.
+ * Suggests running browser tests for UI changes.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getProjectRoot, colors, getConfig } = require('./flow-utils');
+
+const PROJECT_ROOT = getProjectRoot();
+const TESTS_DIR = path.join(PROJECT_ROOT, '.workflow', 'tests', 'flows');
+
+/**
+ * Run browser test step
+ *
+ * @param {object} options
+ * @param {string[]} options.files - Files modified in this task
+ * @param {string} options.taskId - Current task ID
+ * @param {object} options.stepConfig - Step configuration
+ * @param {string} options.mode - Step mode (block/warn/prompt/auto)
+ * @returns {object} - { passed: boolean, message: string, suggestion?: string }
+ */
+async function run(options = {}) {
+  const { files = [], mode, stepConfig = {} } = options;
+
+  // Check if we have any UI files
+  const uiExtensions = ['.tsx', '.jsx', '.vue', '.svelte'];
+  const uiFiles = files.filter(f => uiExtensions.some(ext => f.endsWith(ext)));
+
+  if (uiFiles.length === 0) {
+    return { passed: true, message: 'No UI files modified' };
+  }
+
+  // Check if browser tests exist
+  if (!fs.existsSync(TESTS_DIR)) {
+    return {
+      passed: true,
+      message: 'No browser test flows configured',
+      suggestion: 'Consider adding browser tests in .workflow/tests/flows/',
+    };
+  }
+
+  // Find available test flows
+  const testFlows = fs.readdirSync(TESTS_DIR)
+    .filter(f => f.endsWith('.json') || f.endsWith('.yaml') || f.endsWith('.yml'));
+
+  if (testFlows.length === 0) {
+    return {
+      passed: true,
+      message: 'No browser test flows found',
+      suggestion: 'Add test flows to .workflow/tests/flows/',
+    };
+  }
+
+  // In prompt mode, suggest tests
+  if (mode === 'prompt') {
+    console.log(colors.yellow + '\n  UI files modified:' + colors.reset);
+    uiFiles.forEach(f => console.log(`    - ${f}`));
+    console.log(colors.yellow + '\n  Available browser tests:' + colors.reset);
+    testFlows.forEach(f => console.log(`    - ${f.replace(/\.(json|ya?ml)$/, '')}`));
+    console.log(colors.cyan + '\n  Run with: /wogi-test-browser <flow-name>' + colors.reset);
+
+    return {
+      passed: true,
+      message: 'Browser tests suggested',
+      suggestion: `/wogi-test-browser ${testFlows[0].replace(/\.(json|ya?ml)$/, '')}`,
+    };
+  }
+
+  // In auto mode, we could run tests automatically
+  // For now, just mark as passed with suggestion
+  return {
+    passed: true,
+    message: `${uiFiles.length} UI file(s) modified, browser tests available`,
+    suggestion: 'Run browser tests to verify UI changes',
+  };
+}
+
+module.exports = { run };

package/scripts/flow-step-changelog.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Update Changelog Step
+ *
+ * Prompts or auto-generates changelog entries.
+ * Follows Keep a Changelog format.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getProjectRoot, colors, getConfig } = require('./flow-utils');
+
+const PROJECT_ROOT = getProjectRoot();
+const CHANGELOG_PATH = path.join(PROJECT_ROOT, 'CHANGELOG.md');
+
+/**
+ * Run update changelog step
+ *
+ * @param {object} options
+ * @param {string} options.taskId - Current task ID
+ * @param {string} options.taskTitle - Task title/description
+ * @param {string} options.taskType - Task type (feature/bugfix/refactor)
+ * @param {string[]} options.files - Files modified
+ * @param {object} options.stepConfig - Step configuration
+ * @param {string} options.mode - Step mode (block/warn/prompt/auto)
+ * @returns {object} - { passed: boolean, message: string, entry?: string }
+ */
+async function run(options = {}) {
+  const { taskId, taskTitle, taskType, files = [], mode, stepConfig = {} } = options;
+
+  // Determine changelog category
+  const category = getChangelogCategory(taskType, taskTitle, files);
+
+  // Generate suggested entry
+  const entry = generateEntry(taskId, taskTitle, category, files);
+
+  // In prompt mode, show suggestion
+  if (mode === 'prompt') {
+    console.log(colors.yellow + '\n  Suggested changelog entry:' + colors.reset);
+    console.log(colors.gray + `  ### ${category}` + colors.reset);
+    console.log(`  - ${entry}`);
+
+    if (!fs.existsSync(CHANGELOG_PATH)) {
+      console.log(colors.yellow + '\n  CHANGELOG.md does not exist - will create if approved' + colors.reset);
+    }
+
+    return {
+      passed: true,
+      message: 'Changelog entry suggested',
+      entry,
+      category,
+      suggestion: `Add to CHANGELOG.md under ${category}`,
+    };
+  }
+
+  // In auto mode, add the entry
+  if (mode === 'auto') {
+    const result = addToChangelog(entry, category);
+    if (result.success) {
+      return {
+        passed: true,
+        message: 'Changelog entry added',
+        entry,
+        category,
+      };
+    } else {
+      return {
+        passed: false,
+        message: result.error,
+      };
+    }
+  }
+
+  // In warn mode, just report
+  return {
+    passed: true,
+    message: `Changelog entry ready: ${entry}`,
+    entry,
+    category,
+  };
+}
+
+/**
+ * Determine changelog category from task type
+ */
+function getChangelogCategory(taskType, taskTitle, files) {
+  // Explicit type mapping
+  const typeMap = {
+    feature: 'Added',
+    feat: 'Added',
+    add: 'Added',
+    bugfix: 'Fixed',
+    fix: 'Fixed',
+    refactor: 'Changed',
+    change: 'Changed',
+    update: 'Changed',
+    remove: 'Removed',
+    delete: 'Removed',
+    deprecate: 'Deprecated',
+    security: 'Security',
+  };
+
+  if (taskType && typeMap[taskType.toLowerCase()]) {
+    return typeMap[taskType.toLowerCase()];
+  }
+
+  // Infer from title
+  const titleLower = (taskTitle || '').toLowerCase();
+
+  if (titleLower.includes('add') || titleLower.includes('implement') || titleLower.includes('create')) {
+    return 'Added';
+  }
+  if (titleLower.includes('fix') || titleLower.includes('bug') || titleLower.includes('resolve')) {
+    return 'Fixed';
+  }
+  if (titleLower.includes('remove') || titleLower.includes('delete')) {
+    return 'Removed';
+  }
+  if (titleLower.includes('refactor') || titleLower.includes('update') || titleLower.includes('change')) {
+    return 'Changed';
+  }
+  if (titleLower.includes('deprecate')) {
+    return 'Deprecated';
+  }
+  if (titleLower.includes('security') || titleLower.includes('vulnerability')) {
+    return 'Security';
+  }
+
+  // Default to Changed
+  return 'Changed';
+}
+
+/**
+ * Generate a changelog entry
+ */
+function generateEntry(taskId, taskTitle, category, files) {
+  // Clean up title
+  let entry = taskTitle || 'Update';
+
+  // Remove task ID prefix if present
+  entry = entry.replace(/^(TASK-\d+:?\s*)/i, '');
+
+  // Capitalize first letter
+  entry = entry.charAt(0).toUpperCase() + entry.slice(1);
+
+  // Add task reference
+  if (taskId) {
+    entry += ` (${taskId})`;
+  }
+
+  return entry;
+}
+
+/**
+ * Add entry to CHANGELOG.md
+ */
+function addToChangelog(entry, category) {
+  try {
+    let content;
+
+    if (fs.existsSync(CHANGELOG_PATH)) {
+      content = fs.readFileSync(CHANGELOG_PATH, 'utf8');
+    } else {
+      // Create new changelog
+      content = `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+`;
+    }
+
+    // Find or create [Unreleased] section
+    const unreleasedMatch = content.match(/## \[Unreleased\]\n/);
+    if (!unreleasedMatch) {
+      // Add unreleased section after header
+      const headerEnd = content.indexOf('\n\n') + 2;
+      content = content.slice(0, headerEnd) + '## [Unreleased]\n\n' + content.slice(headerEnd);
+    }
+
+    // Find or create category under Unreleased
+    const unreleasedIndex = content.indexOf('## [Unreleased]');
+    const nextVersionMatch = content.slice(unreleasedIndex + 15).match(/\n## \[/);
+    const unreleasedEnd = nextVersionMatch
+      ? unreleasedIndex + 15 + nextVersionMatch.index
+      : content.length;
+
+    const unreleasedSection = content.slice(unreleasedIndex, unreleasedEnd);
+
+    // Check if category exists
+    const categoryRegex = new RegExp(`### ${category}\\n`);
+    const categoryMatch = unreleasedSection.match(categoryRegex);
+
+    if (categoryMatch) {
+      // Add under existing category
+      const categoryIndex = unreleasedIndex + categoryMatch.index + categoryMatch[0].length;
+      content = content.slice(0, categoryIndex) + `- ${entry}\n` + content.slice(categoryIndex);
+    } else {
+      // Add new category section
+      const insertIndex = unreleasedIndex + 16; // After "## [Unreleased]\n"
+      content = content.slice(0, insertIndex) + `\n### ${category}\n- ${entry}\n` + content.slice(insertIndex);
+    }
+
+    fs.writeFileSync(CHANGELOG_PATH, content);
+    return { success: true };
+
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = { run, getChangelogCategory, generateEntry, addToChangelog };