@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/cli/workflow-orchestrator.js

@@ -0,0 +1,478 @@
+/**
+ * Workflow Orchestrator
+ *
+ * Core orchestration engine that chains validation → optimization → re-validation.
+ * Supports batch processing, watch mode, auto-fix, and multiple output formats.
+ *
+ * @implements @.aiwg/requirements/use-cases/UC-001-validate-ai-generated-content.md
+ * @architecture @.aiwg/architecture/software-architecture-doc.md - Section 4.2 Core Orchestrator
+ * @tests @test/unit/cli/workflow-orchestrator.test.ts
+ * @depends @src/writing/validation-engine.ts
+ * @depends @src/writing/prompt-optimizer.ts
+ * @depends @src/cli/config-loader.ts
+ * @depends @src/cli/watch-service.ts
+ * @cli @docs/CLI_USAGE.md - workflow command
+ */
+import { readFile, writeFile, copyFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { basename } from 'path';
+import { glob } from 'glob';
+import { WritingValidationEngine } from '../writing/validation-engine.js';
+import { PromptOptimizer } from '../writing/prompt-optimizer.js';
+import { ConfigLoader } from './config-loader.js';
+import { WatchService } from './watch-service.js';
+/**
+ * Core Workflow Orchestrator
+ */
+export class WorkflowOrchestrator {
+    configLoader;
+    validator;
+    optimizer;
+    watchService;
+    config = null;
+    constructor(guideBasePath) {
+        this.configLoader = new ConfigLoader();
+        this.validator = new WritingValidationEngine(guideBasePath);
+        this.optimizer = new PromptOptimizer();
+        this.watchService = new WatchService();
+    }
+    /**
+     * Process a single file through the workflow
+     */
+    async processFile(filePath, config) {
+        const startTime = Date.now();
+        const cfg = config || await this.loadConfig();
+        const result = {
+            filePath,
+            validation: {
+                before: {}
+            },
+            applied: false,
+            duration: 0
+        };
+        try {
+            // Ensure file exists
+            if (!existsSync(filePath)) {
+                throw new Error(`File not found: ${filePath}`);
+            }
+            // Read file content
+            const content = await readFile(filePath, 'utf-8');
+            // Step 1: Validate
+            result.validation.before = await this.validateStep(content, cfg);
+            // Step 2: Optimize (if needed)
+            const needsOptimization = result.validation.before.score < cfg.validation.threshold ||
+                cfg.optimization.autoApply;
+            if (needsOptimization && cfg.optimization.enabled) {
+                result.optimization = await this.optimizeStep(content, cfg);
+                // Step 3: Re-validate (if optimization applied)
+                if (result.optimization) {
+                    result.validation.after = await this.revalidateStep(result.optimization.optimizedPrompt, cfg);
+                    // Step 4: Auto-apply (if configured)
+                    if (cfg.optimization.autoApply) {
+                        await this.applyOptimization(filePath, result.optimization, cfg);
+                        result.applied = true;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            result.error = error instanceof Error ? error.message : String(error);
+        }
+        result.duration = Date.now() - startTime;
+        return result;
+    }
+    /**
+     * Process multiple files in batch
+     */
+    async processBatch(files, config, onProgress) {
+        const cfg = config || await this.loadConfig();
+        const results = new Map();
+        const progress = {
+            total: files.length,
+            processed: 0,
+            passed: 0,
+            failed: 0,
+            errors: 0
+        };
+        // Process files sequentially to avoid overwhelming the system
+        for (const file of files) {
+            try {
+                const result = await this.processFile(file, cfg);
+                results.set(file, result);
+                // Update progress
+                progress.processed++;
+                if (result.error) {
+                    progress.errors++;
+                }
+                else if (result.validation.after) {
+                    if (result.validation.after.score >= cfg.validation.threshold) {
+                        progress.passed++;
+                    }
+                    else {
+                        progress.failed++;
+                    }
+                }
+                else if (result.validation.before.score >= cfg.validation.threshold) {
+                    progress.passed++;
+                }
+                else {
+                    progress.failed++;
+                }
+                // Call progress callback
+                if (onProgress) {
+                    onProgress(progress);
+                }
+            }
+            catch (error) {
+                console.error(`Failed to process ${file}:`, error);
+                progress.processed++;
+                progress.errors++;
+                if (onProgress) {
+                    onProgress(progress);
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Validate step
+     */
+    async validateStep(content, config) {
+        await this.validator.initialize();
+        if (config.validation.context) {
+            return this.validator.validateForContext(content, config.validation.context);
+        }
+        return this.validator.validate(content, config.validation.context);
+    }
+    /**
+     * Optimize step
+     */
+    async optimizeStep(content, config) {
+        const context = config.validation.context
+            ? {
+                voice: config.validation.context,
+                constraints: config.optimization.strategies
+            }
+            : undefined;
+        return this.optimizer.optimize(content, context);
+    }
+    /**
+     * Re-validate step
+     */
+    async revalidateStep(content, config) {
+        return this.validateStep(content, config);
+    }
+    /**
+     * Apply optimization to file
+     */
+    async applyOptimization(filePath, optimization, config) {
+        // Create backup if configured
+        if (config.optimization.createBackup) {
+            const backupPath = `${filePath}.original`;
+            await copyFile(filePath, backupPath);
+        }
+        // Write optimized content
+        await writeFile(filePath, optimization.optimizedPrompt, 'utf-8');
+    }
+    /**
+     * Start watch mode
+     */
+    async startWatchMode(config) {
+        const cfg = config || await this.loadConfig();
+        if (!cfg.watch.enabled) {
+            throw new Error('Watch mode is not enabled in configuration');
+        }
+        // Set up watch callback
+        this.watchService.onFileChange(async (event) => {
+            if (event.type === 'unlink') {
+                return; // Skip deleted files
+            }
+            console.log(`Processing ${event.path}...`);
+            const result = await this.processFile(event.path, cfg);
+            if (result.error) {
+                console.error(`Error: ${result.error}`);
+            }
+            else if (result.applied) {
+                console.log(`Applied optimization (score: ${result.validation.before.score} → ${result.validation.after?.score})`);
+            }
+            else {
+                console.log(`Validated (score: ${result.validation.before.score})`);
+            }
+        });
+        // Start watching
+        await this.watchService.start(cfg.watch.patterns, cfg.watch);
+        console.log(`Watching ${cfg.watch.patterns.join(', ')}...`);
+        console.log('Press Ctrl+C to stop');
+    }
+    /**
+     * Stop watch mode
+     */
+    async stopWatchMode() {
+        await this.watchService.stop();
+    }
+    /**
+     * Load configuration
+     */
+    async loadConfig(configPath) {
+        if (this.config) {
+            return this.config;
+        }
+        this.config = await this.configLoader.load(configPath);
+        return this.config;
+    }
+    /**
+     * Validate configuration
+     */
+    validateConfig(config) {
+        return this.configLoader.validate(config);
+    }
+    /**
+     * Generate report from results
+     */
+    generateReport(results, format) {
+        switch (format) {
+            case 'json':
+                return this.generateJsonReport(results);
+            case 'html':
+                return this.generateHtmlReport(results);
+            case 'junit':
+                return this.generateJunitReport(results);
+            case 'text':
+            default:
+                return this.generateTextReport(results);
+        }
+    }
+    /**
+     * Save report to file
+     */
+    async saveReport(report, destination) {
+        await writeFile(destination, report, 'utf-8');
+    }
+    /**
+     * Expand glob patterns to file list
+     */
+    async expandGlob(patterns) {
+        const files = [];
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**'],
+                nodir: true
+            });
+            files.push(...matches);
+        }
+        return [...new Set(files)]; // Remove duplicates
+    }
+    // Private report generation methods
+    generateTextReport(results) {
+        const lines = [];
+        lines.push('=== AIWG Workflow Report ===\n');
+        lines.push(`Total Files: ${results.size}`);
+        let passed = 0;
+        let failed = 0;
+        let errors = 0;
+        let optimized = 0;
+        results.forEach((result) => {
+            if (result.error) {
+                errors++;
+            }
+            else {
+                const finalScore = result.validation.after?.score || result.validation.before.score;
+                if (finalScore >= 70) {
+                    passed++;
+                }
+                else {
+                    failed++;
+                }
+                if (result.applied) {
+                    optimized++;
+                }
+            }
+        });
+        lines.push(`Passed: ${passed}`);
+        lines.push(`Failed: ${failed}`);
+        lines.push(`Errors: ${errors}`);
+        lines.push(`Optimized: ${optimized}\n`);
+        lines.push('=== File Results ===\n');
+        results.forEach((result, filePath) => {
+            if (result.error) {
+                lines.push(`[ERROR] ${filePath}`);
+                lines.push(`  ${result.error}\n`);
+            }
+            else {
+                const beforeScore = result.validation.before.score;
+                const afterScore = result.validation.after?.score;
+                if (afterScore !== undefined) {
+                    const delta = afterScore - beforeScore;
+                    const status = afterScore >= 70 ? 'PASS' : 'FAIL';
+                    lines.push(`[${status}] ${filePath}`);
+                    lines.push(`  Before: ${beforeScore}/100, After: ${afterScore}/100 (${delta > 0 ? '+' : ''}${delta})`);
+                    if (result.applied) {
+                        lines.push(`  Applied optimization`);
+                    }
+                }
+                else {
+                    const status = beforeScore >= 70 ? 'PASS' : 'FAIL';
+                    lines.push(`[${status}] ${filePath}`);
+                    lines.push(`  Score: ${beforeScore}/100`);
+                }
+                lines.push(`  Duration: ${result.duration}ms\n`);
+            }
+        });
+        return lines.join('\n');
+    }
+    generateJsonReport(results) {
+        const obj = {};
+        results.forEach((result, filePath) => {
+            obj[filePath] = result;
+        });
+        return JSON.stringify(obj, null, 2);
+    }
+    generateHtmlReport(results) {
+        let passed = 0;
+        let failed = 0;
+        let errors = 0;
+        const rows = [];
+        results.forEach((result, filePath) => {
+            const fileName = basename(filePath);
+            if (result.error) {
+                errors++;
+                rows.push(`
+          <tr class="error">
+            <td>${fileName}</td>
+            <td>ERROR</td>
+            <td>-</td>
+            <td>-</td>
+            <td>${result.error}</td>
+          </tr>
+        `);
+            }
+            else {
+                const beforeScore = result.validation.before.score;
+                const afterScore = result.validation.after?.score || beforeScore;
+                const status = afterScore >= 70 ? 'PASS' : 'FAIL';
+                if (afterScore >= 70) {
+                    passed++;
+                }
+                else {
+                    failed++;
+                }
+                const delta = result.validation.after ? afterScore - beforeScore : 0;
+                rows.push(`
+          <tr class="${status.toLowerCase()}">
+            <td>${fileName}</td>
+            <td>${status}</td>
+            <td>${beforeScore}</td>
+            <td>${afterScore}${delta !== 0 ? ` (${delta > 0 ? '+' : ''}${delta})` : ''}</td>
+            <td>${result.applied ? 'Yes' : 'No'}</td>
+          </tr>
+        `);
+            }
+        });
+        return `<!DOCTYPE html>
+<html>
+<head>
+  <title>AIWG Workflow Report</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 1200px; margin: 0 auto; padding: 2rem; }
+    .summary { display: grid; grid-template-columns: repeat(4, 1fr); gap: 1rem; margin: 2rem 0; }
+    .metric { background: #f3f4f6; padding: 1rem; border-radius: 0.5rem; text-align: center; }
+    .metric-value { font-size: 2rem; font-weight: bold; margin: 0.5rem 0; }
+    .metric.passed .metric-value { color: #22c55e; }
+    .metric.failed .metric-value { color: #ef4444; }
+    .metric.errors .metric-value { color: #f59e0b; }
+    table { width: 100%; border-collapse: collapse; margin: 2rem 0; }
+    th { background: #1f2937; color: white; padding: 0.75rem; text-align: left; }
+    td { padding: 0.75rem; border-bottom: 1px solid #e5e7eb; }
+    tr.pass { background: #f0fdf4; }
+    tr.fail { background: #fef2f2; }
+    tr.error { background: #fffbeb; }
+  </style>
+</head>
+<body>
+  <h1>AIWG Workflow Report</h1>
+
+  <div class="summary">
+    <div class="metric">
+      <div>Total Files</div>
+      <div class="metric-value">${results.size}</div>
+    </div>
+    <div class="metric passed">
+      <div>Passed</div>
+      <div class="metric-value">${passed}</div>
+    </div>
+    <div class="metric failed">
+      <div>Failed</div>
+      <div class="metric-value">${failed}</div>
+    </div>
+    <div class="metric errors">
+      <div>Errors</div>
+      <div class="metric-value">${errors}</div>
+    </div>
+  </div>
+
+  <table>
+    <thead>
+      <tr>
+        <th>File</th>
+        <th>Status</th>
+        <th>Before</th>
+        <th>After</th>
+        <th>Optimized</th>
+      </tr>
+    </thead>
+    <tbody>
+      ${rows.join('')}
+    </tbody>
+  </table>
+</body>
+</html>`;
+    }
+    generateJunitReport(results) {
+        let passed = 0;
+        let failed = 0;
+        let errors = 0;
+        let totalTime = 0;
+        const testCases = [];
+        results.forEach((result, filePath) => {
+            const fileName = basename(filePath);
+            totalTime += result.duration / 1000; // Convert to seconds
+            if (result.error) {
+                errors++;
+                testCases.push(`
+    <testcase name="${fileName}" classname="AIWG.Validation" time="${(result.duration / 1000).toFixed(3)}">
+      <error message="${this.escapeXml(result.error)}"/>
+    </testcase>`);
+            }
+            else {
+                const finalScore = result.validation.after?.score || result.validation.before.score;
+                if (finalScore >= 70) {
+                    passed++;
+                    testCases.push(`
+    <testcase name="${fileName}" classname="AIWG.Validation" time="${(result.duration / 1000).toFixed(3)}"/>`);
+                }
+                else {
+                    failed++;
+                    testCases.push(`
+    <testcase name="${fileName}" classname="AIWG.Validation" time="${(result.duration / 1000).toFixed(3)}">
+      <failure message="Score ${finalScore} below threshold 70"/>
+    </testcase>`);
+                }
+            }
+        });
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+  <testsuite name="AIWG Validation" tests="${results.size}" failures="${failed}" errors="${errors}" time="${totalTime.toFixed(3)}">
+${testCases.join('\n')}
+  </testsuite>
+</testsuites>`;
+    }
+    escapeXml(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+}
+//# sourceMappingURL=workflow-orchestrator.js.map