wogiflow 1.9.3 → 1.9.4

package/.claude/commands/wogi-config.md

@@ -1,53 +1,177 @@
 ---
-description: "View or modify workflow configuration"
+description: "View or modify workflow configuration with natural language"
 ---
-View or modify workflow configuration.
+Smart configuration management for WogiFlow.
 
-**View config:** `/wogi-config`
-Shows current settings from `.workflow/config.json`
+## Usage
 
-**Toggle settings:** `/wogi-config [setting] [on/off]`
+`/wogi-config` — Show current configuration overview
+`/wogi-config [feature] [on/off]` — Toggle a feature
+`/wogi-config [preset]` — Apply a preset
+`/wogi-config show [key]` — Show specific config value
+`/wogi-config set [key] [value]` — Set a specific config key
 
-Available settings:
-- `storybook on/off` - Auto-generate Storybook stories for new components
-- `hooks on/off` - Enable/disable pre-commit git hooks
-- `tests-before-commit on/off` - Run tests before each commit
+## How It Works
 
-Examples:
-```
-/wogi-config
-→ Shows all current settings
+1. Read `.workflow/config-reference.json` for feature definitions, aliases, and presets
+2. Match the user's natural language to features or presets using aliases
+3. Apply all dependent config changes automatically
+4. Show what was changed with before/after values
+5. Save to `.workflow/config.json`
 
-/wogi-config storybook on
-→ Enables Storybook auto-generation
-→ Updates componentRules.autoGenerateStorybook: true
+## When the user says something like:
 
-/wogi-config hooks on
-→ Runs: ./scripts/flow setup-hooks install
+- "enable testing" → Match feature `testing`, set `testing.enabled: true`, prompt for mode
+- "make it strict" → Match preset `strict`, apply all enforcement settings
+- "turn on storybook" → Match feature `storybook`, set `componentReuse.autoGenerateStorybook: true`
+- "enable TDD" → Match preset `tdd`, enable testing + TDD enforcement
+- "I want full testing" → Match preset `full-testing`, enable all test modes
+- "relax the enforcement" → Match preset `relaxed`, disable strict enforcement
+- "enable parallel" → Match preset `parallel`, enable bulk orchestrator with worktrees
+- "turn off hooks" → Match feature `hooks`, set `hooks.enabled: false`
+- "enable research" → Match feature `research`, set `research.enabled: true`, prompt for depth
+- "enable security scanning" → Match feature `security-scan`, set scanning options
 
-/wogi-config tests-before-commit on
-→ Updates testing.runBeforeCommit: true
-```
+## Implementation Steps
+
+1. Load `.workflow/config-reference.json`
+2. Load current `.workflow/config.json`
+3. Parse user intent from ARGUMENTS
+4. Match against features (by name or aliases) and presets (by name or aliases)
+5. Determine if enabling (`on`, `enable`, `true`, no qualifier) or disabling (`off`, `disable`, `false`, `turn off`)
+6. For features being **enabled**: apply `dependencies.sets` and ask `dependencies.prompts` if present
+7. For features being **disabled**: set the `configPath` key to `false`
+8. For presets: apply all `sets` values directly
+9. Deep-merge changes into config.json (preserve existing keys, only change specified ones)
+10. Save config.json
+11. Display summary:
+    ```
+    Configuration updated:
+
+    testing.enabled: false → true
+    testing.mode: (not set) → "auto"
+    testing.discovery.enabled: false → true
+
+    3 settings changed.
+    ```
+
+## View Mode (no arguments)
+
+When invoked without arguments, display a grouped overview by reading current `.workflow/config.json` and cross-referencing with `.workflow/config-reference.json`:
 
-Output for view:
 ```
-⚙️ Workflow Configuration
+WogiFlow Configuration
 
-Quality Gates:
-  feature: tests, appMapUpdate, requestLogEntry
-  bugfix: tests, requestLogEntry
+Enforcement:
+  strict mode .............. on
+  task gating .............. off
+  scope gating ............. off
+  routing gate ............. off
+  loop enforcement ......... off
 
 Testing:
-  Run after task: off
-  Run before commit: off
-  Browser tests: off
+  enabled .................. off
+  mode ..................... (not set)
+  TDD ...................... off
+  discovery ................ off
+  scenarios ................ off
+  generation ............... off
+  webmcp ................... off
+
+Research:
+  enabled .................. off
+  explore phase ............ off
+  research depth ........... (not set)
+  agents enabled ........... 0/5
+
+Execution:
+  parallel ................. off
+  bulk orchestrator ........ off
+  spec mode ................ off
 
 Components:
-  Auto Storybook: off
-  Require app-map entry: on
+  reuse checking ........... off
+  auto storybook ........... off
 
 Hooks:
-  Pre-commit: not installed
+  enabled .................. off
+  session context .......... off
+  validation ............... off
+  task completed ........... off
+
+Automation:
+  auto-log ................. on (default)
+  auto-update-app-map ...... on (default)
+
+Plugins:
+  enabled .................. off
+
+Security:
+  scan before commit ....... off
+
+Use /wogi-config [feature|preset] to change settings.
+Available presets: strict, relaxed, fast, research-heavy, full-testing, tdd, parallel
+```
+
+## Deep-Merge Logic
+
+When setting nested config keys:
+```javascript
+// Set "testing.discovery.enabled" to true
+// This should create the full path if it doesn't exist:
+// { testing: { discovery: { enabled: true } } }
+function deepSet(obj, path, value) {
+  const parts = path.split('.');
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current[parts[i]] === undefined || current[parts[i]] === null) {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+```
 
-Use /wogi-config [setting] on/off to change.
+When reading nested config values:
+```javascript
+function deepGet(obj, path) {
+  const parts = path.split('.');
+  let current = obj;
+  for (const part of parts) {
+    if (current === undefined || current === null) return undefined;
+    current = current[part];
+  }
+  return current;
+}
 ```
+
+## Matching Algorithm
+
+1. Normalize user input to lowercase, trim whitespace
+2. Check for exact feature name match (e.g., "testing", "storybook", "tdd")
+3. Check for exact preset name match (e.g., "strict", "relaxed", "fast")
+4. Check feature aliases for substring/fuzzy match
+5. Check preset aliases for substring/fuzzy match
+6. If multiple matches, prefer exact name matches over alias matches
+7. If still ambiguous, list all matches and ask user to clarify
+
+## Disable Logic
+
+When the user says "off", "disable", "turn off", or "false":
+- For features: set the `configPath` to `false`. Do NOT apply `dependencies.sets` (those are for enabling).
+- For presets: there is no "disable" — suggest the opposite preset (e.g., "strict" → suggest "relaxed")
+
+## Integration with Verification Profile
+
+When enabling testing features, check if a verification profile exists:
+- If yes: use detected values (framework, baseUrl, etc.) to auto-populate testing config
+- If no: suggest running `/wogi-test --setup` after enabling
+
+## Multiple Features
+
+The user can enable multiple features in one command:
+- "enable testing and hooks" → Match both, apply both sets of dependencies
+- "turn on storybook and tdd" → Match both features
+
+ARGUMENTS: {args}

package/.claude/commands/wogi-test.md

@@ -14,7 +14,8 @@ Run the WogiFlow Auto-Testing Suite — UI verification, API testing, data integ
 /wogi-test --ui                     # UI tests only
 /wogi-test --api                    # API tests only
 /wogi-test --integrity              # Data integrity chain only
-/wogi-test --setup                  # Configure testing (re-run detection)
+/wogi-test --setup                  # Configure testing (re-run detection + probe profile)
+/wogi-test --profile                # Display current verification profile
 /wogi-test --generate wf-XXXXXXXX  # Regenerate tests for a task
 ```
 
@@ -24,14 +25,14 @@ Run the WogiFlow Auto-Testing Suite — UI verification, API testing, data integ
 
 Parse `$ARGUMENTS` to extract:
 - **Task ID**: A `wf-XXXXXXXX` pattern → target task
-- **Flags**: `--ui`, `--api`, `--integrity`, `--all`, `--setup`, `--generate`
+- **Flags**: `--ui`, `--api`, `--integrity`, `--all`, `--setup`, `--profile`, `--generate`
 - **No args**: Use current in-progress task from `ready.json`
 
 ```javascript
 // Pseudo-logic for argument parsing
 const args = '$ARGUMENTS'.trim().split(/\s+/);
 let taskId = null;
-let flags = { ui: false, api: false, integrity: false, all: false, setup: false, generate: false };
+let flags = { ui: false, api: false, integrity: false, all: false, setup: false, profile: false, generate: false };
 
 for (const arg of args) {
   if (/^wf-[a-f0-9]{8}$/i.test(arg)) {
@@ -41,6 +42,7 @@ for (const arg of args) {
   else if (arg === '--integrity') flags.integrity = true;
   else if (arg === '--all') flags.all = true;
   else if (arg === '--setup') flags.setup = true;
+  else if (arg === '--profile') flags.profile = true;
   else if (arg === '--generate') flags.generate = true;
 }
 ```
@@ -51,14 +53,14 @@ If no task ID provided, read `.workflow/state/ready.json` and use the first task
 
 Read config via:
 ```bash
-node -e "const { getConfig } = require('wogiflow/scripts/flow-utils'); const c = getConfig(); console.log(JSON.stringify(c.testing || {}))"
+node -e "const { getConfig } = require('./scripts/flow-utils'); const c = getConfig(); console.log(JSON.stringify(c.testing || {}))"
 ```
 
 If `config.testing.enabled` is `false` (or not set), **auto-trigger the setup flow** — do NOT just show info and stop. The user ran `/wogi-test` because they want to test. Guide them through setup seamlessly:
 
 **Step 2a: Detect project type**
 ```bash
-node -e "const { detectProjectType } = require('wogiflow/scripts/flow-project-analyzer'); const r = detectProjectType(); console.log(JSON.stringify(r))"
+node -e "const { detectProjectType } = require('./scripts/flow-project-analyzer'); const r = detectProjectType(); console.log(JSON.stringify(r))"
 ```
 
 **Step 2b: Show detection results and ask ONE question**
@@ -88,10 +90,11 @@ Shall I enable testing and install what's needed? [Y/n/customize]
 - **Yes (or enter)** → Proceed to auto-configure:
   1. Determine mode from detection: hasUI+hasAPI → `"full"`, hasUI only → `"ui"`, hasAPI only → `"api"`, neither → `"unit"`
   2. Update `.workflow/config.json`: set `testing.enabled: true`, `testing.mode`, and `testing.detected` fields
-  3. Check dependencies: `node -e "const d = require('wogiflow/scripts/flow-testing-deps'); console.log(JSON.stringify(d.checkDeps('[mode]')))"`
-  4. If deps missing → install them: `node -e "const d = require('wogiflow/scripts/flow-testing-deps'); console.log(JSON.stringify(d.installDeps('[mode]')))"`
+  3. Check dependencies: `node -e "const d = require('./scripts/flow-testing-deps'); console.log(JSON.stringify(d.checkDeps('[mode]')))"`
+  4. If deps missing → install them: `node -e "const d = require('./scripts/flow-testing-deps'); console.log(JSON.stringify(d.installDeps('[mode]')))"`
   5. If UI mode → also configure Playwright MCP in settings (show user the MCP config to add)
-  6. Show confirmation and **continue to Step 5 (run tests)**
+  6. Generate verification profile: `node -e "const { probeProject } = require('./scripts/flow-verification-profile'); probeProject().then(() => console.log('Profile generated')).catch(err => console.error(err.message))"`
+  7. Show confirmation and **continue to Step 5 (run tests)**
 
 - **Customize** → Ask for:
   - Preferred mode (ui/api/full/unit)
@@ -107,6 +110,24 @@ Shall I enable testing and install what's needed? [Y/n/customize]
 
 **IMPORTANT**: After successful setup, do NOT stop. Continue directly to Step 5 and run the tests the user originally asked for. The whole point is that `/wogi-test` works in one invocation even on first use.
 
+### Step 2.5: Handle `--profile` Flag (Display Verification Profile)
+
+If `--profile` was passed, display the current verification profile and **STOP**:
+
+```bash
+node -e "
+const { loadProfile } = require('./scripts/flow-verification-profile');
+const profile = loadProfile();
+if (!profile) {
+  console.log('No verification profile found. Run: /wogi-test --setup');
+} else {
+  console.log(JSON.stringify(profile, null, 2));
+}
+"
+```
+
+Format the output as a readable summary showing detected capabilities (test runner, E2E, API, Docker, database, CI, etc.) and the recommended verification strategy per task type.
+
 ### Step 3: Handle `--setup` Flag (Reconfigure)
 
 If `--setup` was passed, this is an explicit reconfiguration request. Use the same flow as Step 2 (auto-setup), but ALWAYS run it even if testing is already enabled. This lets users:
@@ -114,7 +135,22 @@ If `--setup` was passed, this is an explicit reconfiguration request. Use the sa
 - Re-detect after adding backend/frontend to their project
 - Install missing deps after a fresh `npm install` that lost node_modules
 
-After reconfiguration, show confirmation:
+After reconfiguration, also regenerate the verification profile:
+```bash
+node -e "
+const { probeProject } = require('./scripts/flow-verification-profile');
+probeProject().then(p => console.log(JSON.stringify({ success: true, detected: {
+  testRunner: p.testRunner.framework || 'none',
+  e2e: p.e2e.framework || 'none',
+  api: p.api.detected,
+  docker: p.docker.available,
+  database: p.database.type || 'none',
+  ci: p.ci.platform || 'none'
+}}))).catch(err => console.error(JSON.stringify({ error: err.message })));
+"
+```
+
+Show confirmation:
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   Testing Reconfigured ✓
@@ -124,6 +160,7 @@ Mode: [mode] (was: [old mode])
 UI provider: playwright-mcp
 API provider: direct-http (zero deps)
 Dependencies: all installed ✓
+Verification profile: regenerated ✓
 
 Run /wogi-test to execute tests.
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -135,7 +172,7 @@ If `--generate` was passed:
 
 ```bash
 node -e "
-const { generateTestScaffold } = require('wogiflow/scripts/flow-test-generate');
+const { generateTestScaffold } = require('./scripts/flow-test-generate');
 const result = generateTestScaffold('TASK_ID');
 console.log(JSON.stringify(result, null, 2));
 "
@@ -158,7 +195,7 @@ Determine which test types to run:
 #### Run UI Tests
 ```bash
 node -e "
-const { runUITests } = require('wogiflow/scripts/flow-test-ui');
+const { runUITests } = require('./scripts/flow-test-ui');
 runUITests('TASK_ID').then(r => console.log(JSON.stringify(r))).catch(err => console.error(JSON.stringify({error: err.message})));
 "
 ```
@@ -166,7 +203,7 @@ runUITests('TASK_ID').then(r => console.log(JSON.stringify(r))).catch(err => con
 #### Run API Tests
 ```bash
 node -e "
-const { runAPITests } = require('wogiflow/scripts/flow-test-api');
+const { runAPITests } = require('./scripts/flow-test-api');
 runAPITests('TASK_ID').then(r => console.log(JSON.stringify(r))).catch(err => console.error(JSON.stringify({error: err.message})));
 "
 ```
@@ -174,7 +211,7 @@ runAPITests('TASK_ID').then(r => console.log(JSON.stringify(r))).catch(err => co
 #### Run Integrity Tests
 ```bash
 node -e "
-const { runIntegrityTests } = require('wogiflow/scripts/flow-test-integrity');
+const { runIntegrityTests } = require('./scripts/flow-test-integrity');
 runIntegrityTests('TASK_ID').then(r => console.log(JSON.stringify(r))).catch(err => console.error(JSON.stringify({error: err.message})));
 "
 ```
@@ -241,3 +278,5 @@ Generated Tests: [passed]/[total] passed
 - All test scripts gracefully handle missing dependencies and report what's needed
 - Reports are saved to `.workflow/verifications/` for quality gate consumption
 - The quality gates `generatedTestsPass`, `uiVerification`, and `apiVerification` in `flow-done.js` will automatically run these same tests when closing a task via `/wogi-start`
+- **Verification Profile**: The `--setup` flag (and first-time auto-setup) generates a verification profile at `.workflow/state/verification-profile.json`. This profile auto-detects test runners, E2E frameworks, OpenAPI specs, Docker, databases, CI config, and more. Test scripts (`flow-test-api.js`, `flow-test-ui.js`, `flow-test-integrity.js`) read from this profile to provide smart defaults (base URLs, start commands, spec files) instead of using hardcoded values. Explicit `config.json` overrides always take precedence over profile-detected values.
+- Use `--profile` to display the current verification profile without running tests

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "1.9.3",
+  "version": "1.9.4",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

package/scripts/flow-done.js

@@ -36,6 +36,14 @@ const { autoArchiveIfNeeded } = require('./flow-log-manager');
 // v1.9.0 regression testing (legacy - now in workflow steps)
 const { runRegressionTests } = require('./flow-regression');
 
+// v1.10 smart test discovery + SWE-bench dual gate
+let testDiscovery;
+try {
+  testDiscovery = require('./flow-test-discovery');
+} catch (err) {
+  testDiscovery = null;
+}
+
 // v2.2 modular workflow steps
 const { runSteps, getAllSteps } = require('./flow-workflow-steps');
 
@@ -110,6 +118,9 @@ try {
   hypothesisGenerator = null;
 }
 
+// v5.2 verification profiles
+const { loadProfile: loadVerificationProfile } = require('./flow-verification-profile');
+
 // Path for last failure artifact
 const LAST_FAILURE_PATH = path.join(PATHS.state, 'last-failure.json');
 
@@ -197,6 +208,9 @@ function runQualityGates(taskId, taskType) {
   console.log(color('yellow', 'Running quality gates...'));
   console.log('');
 
+  // Load verification profile — warn if missing and testing gates are configured
+  const verificationProfile = loadVerificationProfile();
+
   const config = getConfig();
   // Use task-type-specific gates, fall back to feature gates, then empty
   const normalizedType = (taskType || 'feature').toLowerCase();
@@ -206,6 +220,15 @@ function runQualityGates(taskId, taskType) {
   const failed = [];
   const errors = {}; // Store error output for correction artifact
 
+  // Warn if testing gates are present but no verification profile exists
+  if (!verificationProfile) {
+    const hasTestingGates = gates.some(g => ['generatedTestsPass', 'uiVerification', 'apiVerification'].includes(g));
+    if (hasTestingGates && config.testing?.enabled) {
+      console.log(color('yellow', '  Note: No verification profile found. Run --setup to auto-detect project test infrastructure.'));
+      console.log('');
+    }
+  }
+
   // Cache outstanding findings result — used by both outstandingFindings and preRelease gates
   let cachedOutstandingFindings = null;
   function getOutstandingFindings() {
@@ -621,10 +644,63 @@ function runQualityGates(taskId, taskType) {
           } catch (err) {
             console.log(`  ${color('yellow', '⚠')} ${gate} (error: ${err.message})`);
           }
+
+          // Also check scenario verification results if available
+          if (!isUI && validateTaskId(taskId)) {
+            const scenarioReportPath = path.join(PATHS.workflow, 'verifications', `${taskId}-scenarios.json`);
+            if (fs.existsSync(scenarioReportPath)) {
+              try {
+                const scenarioReport = safeJsonParse(scenarioReportPath, null);
+                if (scenarioReport && scenarioReport.summary) {
+                  const ss = scenarioReport.summary;
+                  if (ss.failed === 0 && ss.total > 0) {
+                    console.log(`  ${color('green', '✓')} scenarioVerification (${ss.passed}/${ss.total} scenarios passed)`);
+                  } else if (ss.failed > 0) {
+                    console.log(`  ${color('red', '✗')} scenarioVerification (${ss.failed} scenarios failed)`);
+                    const failedScenarios = (scenarioReport.scenarios || []).filter(s => !s.passed);
+                    for (const sc of failedScenarios.slice(0, 5)) {
+                      console.log(color('dim', `    - ${sc.name || 'unnamed scenario'}: ${sc.error || 'assertions failed'}`));
+                    }
+                  }
+                }
+              } catch (err) {
+                // Non-fatal — scenario report parsing failed
+              }
+            }
+          }
         }
       } else {
         console.log(`  ${color('dim', '·')} ${gate} (testing disabled or mode excludes ${isUI ? 'UI' : 'API'})`);
       }
+    } else if (gate === 'testDiscovery') {
+      // v1.10: Smart test discovery + SWE-bench dual gate
+      const discoveryConfig = config.testing?.discovery || {};
+      if (discoveryConfig.enabled) {
+        if (testDiscovery && typeof testDiscovery.runTestDiscoveryGate === 'function') {
+          try {
+            console.log('  Running test discovery gate...');
+            const discoveryResult = testDiscovery.runTestDiscoveryGate(taskId, PATHS.root);
+            if (discoveryResult.passed) {
+              console.log(`  ${color('green', '✓')} testDiscovery (${discoveryResult.message})`);
+            } else {
+              console.log(`  ${color('red', '✗')} testDiscovery (${discoveryResult.message})`);
+              if (discoveryResult.report?.passToPass?.failed) {
+                for (const f of discoveryResult.report.passToPass.failed.slice(0, 5)) {
+                  console.log(color('dim', `    - ${f}`));
+                }
+              }
+              errors.testDiscovery = discoveryResult.message;
+              failed.push('testDiscovery');
+            }
+          } catch (err) {
+            console.log(`  ${color('yellow', '⚠')} testDiscovery (error: ${truncateOutput(err.message, 3, 200)})`);
+          }
+        } else {
+          console.log(`  ${color('yellow', '⚠')} testDiscovery (module not available — install flow-test-discovery.js)`);
+        }
+      } else {
+        console.log(`  ${color('dim', '·')} testDiscovery (disabled — set testing.discovery.enabled in config)`);
+      }
     } else {
       console.log(`  ${color('yellow', '○')} ${gate} (manual check)`);
     }