@exaudeus/workrail 3.38.0 → 3.40.0

package/dist/cli-worktrain.js

@@ -702,4 +702,235 @@ function runHealthSummary(sessionId, raw) {
     }
     process.stdout.write('\n');
 }
+const runCommand = program
+    .command('run')
+    .description('Run a coordinator script');
+runCommand
+    .command('pr-review')
+    .description('Review open PRs autonomously: dispatch review sessions, route by findings, merge or escalate')
+    .requiredOption('-W, --workspace <path>', 'Absolute path to the git workspace')
+    .option('-r, --pr <number>', 'Review a specific PR number (repeatable)', (val, prev) => [...prev, parseInt(val, 10)], [])
+    .option('--dry-run', 'Print actions without dispatching sessions or merging')
+    .option('-p, --port <n>', 'Console HTTP server port (default: auto-discover from lock file, then 3456)', parseInt)
+    .action(async (options) => {
+    const { runPrReviewCoordinator, discoverConsolePort, } = await Promise.resolve().then(() => __importStar(require('./coordinators/pr-review.js')));
+    const { execFile: execFileRaw } = await Promise.resolve().then(() => __importStar(require('child_process')));
+    const execFilePromise = (0, util_1.promisify)(execFileRaw);
+    if (!path_1.default.isAbsolute(options.workspace)) {
+        process.stderr.write(`Error: --workspace must be an absolute path, got: ${options.workspace}\n`);
+        process.exit(1);
+    }
+    try {
+        const stat = await fs_1.default.promises.stat(options.workspace);
+        if (!stat.isDirectory()) {
+            process.stderr.write(`Error: --workspace must be an existing directory: ${options.workspace}\n`);
+            process.exit(1);
+        }
+    }
+    catch {
+        process.stderr.write(`Error: --workspace does not exist: ${options.workspace}\n`);
+        process.exit(1);
+    }
+    const port = await discoverConsolePort({
+        readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+        homedir: os_1.default.homedir,
+        joinPath: path_1.default.join,
+    }, options.port);
+    const deps = {
+        spawnSession: async (workflowId, goal, workspace) => {
+            const url = `http://127.0.0.1:${port}/api/v2/auto/dispatch`;
+            try {
+                const response = await globalThis.fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ workflowId, goal, workspacePath: workspace }),
+                    signal: AbortSignal.timeout(30000),
+                });
+                const body = await response.json();
+                if (!response.ok) {
+                    const errMsg = typeof body['error'] === 'string' ? body['error'] : `HTTP ${response.status}`;
+                    if (response.status === 503) {
+                        return { kind: 'err', error: `WorkTrain daemon is not ready: ${errMsg}` };
+                    }
+                    return { kind: 'err', error: `Dispatch failed: ${errMsg}` };
+                }
+                if (body['success'] !== true || typeof body['data'] !== 'object') {
+                    return { kind: 'err', error: 'Unexpected response from dispatch endpoint' };
+                }
+                const data = body['data'];
+                const handle = typeof data['sessionHandle'] === 'string' ? data['sessionHandle'] : '';
+                if (!handle) {
+                    return { kind: 'err', error: 'Dispatch succeeded but no session handle returned' };
+                }
+                return { kind: 'ok', value: handle };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                const isConnRefused = msg.includes('ECONNREFUSED') || msg.includes('fetch failed');
+                if (isConnRefused) {
+                    return { kind: 'err', error: `Could not connect to WorkTrain daemon on port ${port}. Ensure the daemon is running with: worktrain daemon` };
+                }
+                if (e instanceof Error && e.name === 'TimeoutError') {
+                    return { kind: 'err', error: `Daemon request timed out after 30s` };
+                }
+                return { kind: 'err', error: `Dispatch request failed: ${msg}` };
+            }
+        },
+        awaitSessions: async (handles, timeoutMs) => {
+            const { executeWorktrainAwaitCommand } = await Promise.resolve().then(() => __importStar(require('./cli/commands/worktrain-await.js')));
+            let resolvedResult = null;
+            await executeWorktrainAwaitCommand({
+                fetch: (url) => globalThis.fetch(url),
+                readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+                stdout: (line) => {
+                    try {
+                        resolvedResult = JSON.parse(line);
+                    }
+                    catch { }
+                },
+                stderr: (line) => process.stderr.write(line + '\n'),
+                homedir: os_1.default.homedir,
+                joinPath: path_1.default.join,
+                sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+                now: () => Date.now(),
+            }, {
+                sessions: [...handles].join(','),
+                mode: 'all',
+                timeout: `${Math.round(timeoutMs / 1000)}s`,
+                port,
+            });
+            if (resolvedResult === null) {
+                process.stderr.write(`[WARN coord:reason=await_failed] awaitSessions: could not get session results -- daemon may be unreachable or timed out. Returning all ${handles.length} session(s) as failed.\n`);
+            }
+            return resolvedResult ?? { results: [...handles].map((h) => ({
+                    handle: h,
+                    outcome: 'failed',
+                    status: null,
+                    durationMs: 0,
+                })), allSucceeded: false };
+        },
+        getAgentResult: async (sessionHandle) => {
+            const emptyResult = { recapMarkdown: null, artifacts: [] };
+            try {
+                const sessionUrl = `http://127.0.0.1:${port}/api/v2/sessions/${encodeURIComponent(sessionHandle)}`;
+                const sessionRes = await globalThis.fetch(sessionUrl, { signal: AbortSignal.timeout(30000) });
+                if (!sessionRes.ok) {
+                    process.stderr.write(`[WARN coord:reason=http_error status=${sessionRes.status} handle=${sessionHandle.slice(0, 16)}] getAgentResult: session fetch returned HTTP ${sessionRes.status}\n`);
+                    return emptyResult;
+                }
+                const sessionBody = await sessionRes.json();
+                if (sessionBody['success'] !== true) {
+                    process.stderr.write(`[WARN coord:reason=api_error handle=${sessionHandle.slice(0, 16)}] getAgentResult: session API returned success=false\n`);
+                    return emptyResult;
+                }
+                const data = sessionBody['data'];
+                if (!data) {
+                    process.stderr.write(`[WARN coord:reason=no_data handle=${sessionHandle.slice(0, 16)}] getAgentResult: session response missing data field\n`);
+                    return emptyResult;
+                }
+                const runs = data['runs'];
+                if (!Array.isArray(runs) || runs.length === 0) {
+                    process.stderr.write(`[WARN coord:reason=no_runs handle=${sessionHandle.slice(0, 16)}] getAgentResult: session has no runs\n`);
+                    return emptyResult;
+                }
+                const firstRun = runs[0];
+                const tipNodeId = typeof firstRun['preferredTipNodeId'] === 'string'
+                    ? firstRun['preferredTipNodeId']
+                    : null;
+                if (!tipNodeId) {
+                    process.stderr.write(`[WARN coord:reason=no_tip_node handle=${sessionHandle.slice(0, 16)}] getAgentResult: session run has no preferredTipNodeId\n`);
+                    return emptyResult;
+                }
+                const allNodes = Array.isArray(firstRun['nodes'])
+                    ? firstRun['nodes']
+                    : [];
+                const allNodeIds = allNodes
+                    .map((n) => (typeof n['nodeId'] === 'string' ? n['nodeId'] : null))
+                    .filter((id) => id !== null);
+                const nodeIdsToFetch = allNodeIds.length > 0
+                    ? allNodeIds
+                    : [tipNodeId];
+                const baseNodeUrl = `http://127.0.0.1:${port}/api/v2/sessions/${encodeURIComponent(sessionHandle)}/nodes/`;
+                let recap = null;
+                const collectedArtifacts = [];
+                for (const nodeId of nodeIdsToFetch) {
+                    try {
+                        const nodeRes = await globalThis.fetch(baseNodeUrl + encodeURIComponent(nodeId), { signal: AbortSignal.timeout(30000) });
+                        if (!nodeRes.ok) {
+                            process.stderr.write(`[WARN coord:reason=node_http_error status=${nodeRes.status} handle=${sessionHandle.slice(0, 16)} node=${nodeId.slice(0, 16)}] getAgentResult: node fetch returned HTTP ${nodeRes.status}\n`);
+                            continue;
+                        }
+                        const nodeBody = await nodeRes.json();
+                        if (nodeBody['success'] !== true) {
+                            process.stderr.write(`[WARN coord:reason=node_api_error handle=${sessionHandle.slice(0, 16)} node=${nodeId.slice(0, 16)}] getAgentResult: node API returned success=false\n`);
+                            continue;
+                        }
+                        const nodeData = nodeBody['data'];
+                        if (!nodeData)
+                            continue;
+                        if (nodeId === tipNodeId) {
+                            recap = typeof nodeData['recapMarkdown'] === 'string' ? nodeData['recapMarkdown'] : null;
+                            if (recap === null) {
+                                process.stderr.write(`[WARN coord:reason=no_recap handle=${sessionHandle.slice(0, 16)} node=${nodeId.slice(0, 16)}] getAgentResult: tip node has no recapMarkdown\n`);
+                            }
+                        }
+                        const nodeArtifacts = nodeData['artifacts'];
+                        if (Array.isArray(nodeArtifacts) && nodeArtifacts.length > 0) {
+                            collectedArtifacts.push(...nodeArtifacts);
+                        }
+                    }
+                    catch (nodeErr) {
+                        const msg = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
+                        process.stderr.write(`[WARN coord:reason=node_exception handle=${sessionHandle.slice(0, 16)} node=${nodeId.slice(0, 16)}] getAgentResult: ${msg}\n`);
+                    }
+                }
+                return { recapMarkdown: recap, artifacts: collectedArtifacts };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                process.stderr.write(`[WARN coord:reason=exception handle=${sessionHandle.slice(0, 16)}] getAgentResult: ${msg}\n`);
+                return emptyResult;
+            }
+        },
+        listOpenPRs: async (workspace) => {
+            try {
+                const { stdout } = await execFilePromise('gh', ['pr', 'list', '--json', 'number,title,headRefName'], {
+                    cwd: workspace,
+                    timeout: 30000,
+                });
+                const parsed = JSON.parse(stdout);
+                return parsed.map((p) => ({ number: p.number, title: p.title, headRef: p.headRefName }));
+            }
+            catch {
+                return [];
+            }
+        },
+        mergePR: async (prNumber, workspace) => {
+            try {
+                await execFilePromise('gh', ['pr', 'merge', String(prNumber), '--squash', '--auto'], {
+                    cwd: workspace,
+                    timeout: 60000,
+                });
+                return { kind: 'ok', value: undefined };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { kind: 'err', error: msg };
+            }
+        },
+        writeFile: async (filePath, content) => {
+            await fs_1.default.promises.writeFile(filePath, content, 'utf-8');
+        },
+        stderr: (line) => process.stderr.write(line + '\n'),
+        now: () => Date.now(),
+        port,
+    };
+    const result = await runPrReviewCoordinator(deps, {
+        workspace: options.workspace,
+        prs: options.pr.length > 0 ? options.pr : undefined,
+        dryRun: options.dryRun ?? false,
+        port: options.port,
+    });
+    process.exit(result.hasErrors ? 1 : 0);
+});
 program.parse();