@diff-review-system/drs 3.3.0 → 4.0.0-rc.4

package/dist/cli/workflow.js

@@ -0,0 +1,1229 @@
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import { dirname } from 'path';
+import simpleGit from 'simple-git';
+import chalk from 'chalk';
+import { getDescriberModelOverride, loadWorkflowSourceInfo, normalizeAgentConfig, resolveAgentRunConfig, } from '../lib/config.js';
+import { resolveWithinWorkingDir } from '../lib/path-utils.js';
+import { parseDiff, getChangedFiles, getFilesWithDiffs } from '../lib/diff-parser.js';
+import { parseValidLinesFromPatch } from '../lib/diff-lines.js';
+import { connectToRuntime, executeReview, filterIgnoredFiles, } from '../lib/review-orchestrator.js';
+import { ExitError, setExitHandler } from '../lib/exit.js';
+import { postReviewComments } from '../lib/comment-poster.js';
+import { findExistingCommentById } from '../lib/comment-manager.js';
+import { removeErrorComment } from '../lib/error-comment-poster.js';
+import { runDescribeIfEnabled } from '../lib/description-executor.js';
+import { buildBaseInstructions } from '../lib/review-core.js';
+import { resolveCursorFixLinkOptions } from '../lib/cursor-fix-link.js';
+import { enforceRepoBranchMatch, getCanonicalDiffCommand, resolveBaseBranch, } from '../lib/repository-validator.js';
+import { formatCodeQualityReport, generateCodeQualityReport } from '../lib/code-quality-report.js';
+import { createGitHubClient } from '../github/client.js';
+import { GitHubPlatformAdapter } from '../github/platform-adapter.js';
+import { createGitLabClient } from '../gitlab/client.js';
+import { GitLabPlatformAdapter } from '../gitlab/platform-adapter.js';
+import { runAgent } from './run-agent.js';
+function createWorkflowLock() {
+    return { current: Promise.resolve() };
+}
+async function withWorkflowLock(lock, run) {
+    const previousLock = lock.current;
+    let releaseLock;
+    lock.current = new Promise((resolve) => {
+        releaseLock = resolve;
+    });
+    await previousLock;
+    try {
+        return await run();
+    }
+    finally {
+        releaseLock();
+    }
+}
+async function withWorkflowConsoleSuppressed(executionContext, suppress, run) {
+    if (!suppress) {
+        return run();
+    }
+    return withWorkflowLock(executionContext.locks.console, async () => {
+        const originalLog = console.log;
+        const originalWarn = console.warn;
+        console.log = () => undefined;
+        console.warn = () => undefined;
+        try {
+            return await run();
+        }
+        finally {
+            console.log = originalLog;
+            console.warn = originalWarn;
+        }
+    });
+}
+function getWorkflowGitClient(executionContext, workingDir) {
+    const existing = executionContext.gitClients.get(workingDir);
+    if (existing) {
+        return existing;
+    }
+    const git = simpleGit({ baseDir: workingDir });
+    executionContext.gitClients.set(workingDir, git);
+    return git;
+}
+function getWorkflowPlatformClient(executionContext, platform) {
+    const existing = executionContext.platformClients[platform];
+    if (existing) {
+        return existing;
+    }
+    const client = platform === 'github'
+        ? new GitHubPlatformAdapter(createGitHubClient())
+        : new GitLabPlatformAdapter(createGitLabClient());
+    executionContext.platformClients[platform] = client;
+    return client;
+}
+function getNodeNeeds(node) {
+    if (node.needs === undefined) {
+        return [];
+    }
+    if (!Array.isArray(node.needs)) {
+        throw new Error('Workflow node "needs" must be an array of node ids.');
+    }
+    return node.needs;
+}
+function getWorkflowExecutionOrder(nodes) {
+    const nodeIds = Object.keys(nodes);
+    const visiting = new Set();
+    const visited = new Set();
+    const order = [];
+    function visit(nodeId) {
+        if (visited.has(nodeId)) {
+            return;
+        }
+        if (visiting.has(nodeId)) {
+            throw new Error(`Workflow contains a dependency cycle at node "${nodeId}".`);
+        }
+        const node = nodes[nodeId];
+        if (!node) {
+            throw new Error(`Workflow references unknown node "${nodeId}".`);
+        }
+        visiting.add(nodeId);
+        for (const dependency of getNodeNeeds(node)) {
+            if (!nodes[dependency]) {
+                throw new Error(`Workflow node "${nodeId}" needs unknown node "${dependency}".`);
+            }
+            visit(dependency);
+        }
+        visiting.delete(nodeId);
+        visited.add(nodeId);
+        order.push(nodeId);
+    }
+    for (const nodeId of nodeIds) {
+        visit(nodeId);
+    }
+    return order;
+}
+function getWorkflowNodes(workflowName, workflow) {
+    const nodes = workflow.nodes;
+    if (typeof nodes !== 'object' ||
+        nodes === null ||
+        Array.isArray(nodes) ||
+        Object.keys(nodes).length === 0) {
+        throw new Error(`Workflow "${workflowName}" must define at least one node.`);
+    }
+    return nodes;
+}
+function getWorkflowExecutionWaves(nodes, executionOrder) {
+    const depthByNode = new Map();
+    const waves = [];
+    for (const nodeId of executionOrder) {
+        const node = nodes[nodeId];
+        if (!node) {
+            throw new Error(`Workflow references unknown node "${nodeId}".`);
+        }
+        const depth = getNodeNeeds(node).reduce((maxDepth, dependency) => {
+            return Math.max(maxDepth, (depthByNode.get(dependency) ?? 0) + 1);
+        }, 0);
+        depthByNode.set(nodeId, depth);
+        waves[depth] = waves[depth] ?? [];
+        waves[depth].push(nodeId);
+    }
+    return waves;
+}
+function getPathValue(root, path) {
+    return path.split('.').reduce((current, part) => {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        return current[part];
+    }, root);
+}
+function stringifyTemplateValue(value) {
+    if (value === undefined) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    return JSON.stringify(value, null, 2);
+}
+function renderTemplate(template, context) {
+    return template.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_match, rawPath) => {
+        const path = rawPath.trim();
+        const value = getPathValue(context, path);
+        if (value === undefined) {
+            throw new Error(`Unknown workflow template value "{{${path}}}".`);
+        }
+        return stringifyTemplateValue(value);
+    });
+}
+async function resolveWorkflowInput(key, input, workingDir) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    const hasValue = input.value !== undefined;
+    const hasFile = input.file !== undefined;
+    if (hasValue && hasFile) {
+        throw new Error(`Workflow input "${key}" cannot define both value and file.`);
+    }
+    if (hasValue) {
+        return input.value ?? '';
+    }
+    if (hasFile) {
+        const inputPath = resolveWithinWorkingDir(workingDir, input.file ?? '', 'read');
+        return readFile(inputPath, 'utf-8');
+    }
+    throw new Error(`Workflow input "${key}" must define value or file.`);
+}
+async function resolveWorkflowInputs(workflow, options, workingDir) {
+    const values = {};
+    for (const [key, input] of Object.entries(workflow.inputs ?? {})) {
+        values[key] = await resolveWorkflowInput(key, input, workingDir);
+    }
+    for (const [key, value] of Object.entries(options.inputs ?? {})) {
+        values[key] = value;
+    }
+    for (const [key, filePath] of Object.entries(options.inputFiles ?? {})) {
+        const resolvedPath = resolveWithinWorkingDir(workingDir, filePath, 'read');
+        values[key] = await readFile(resolvedPath, 'utf-8');
+    }
+    return values;
+}
+function resolveAgentsFrom(config, agentsFrom) {
+    if (agentsFrom === 'review.agents') {
+        return normalizeAgentConfig(config.review.agents).map((agent) => agent.name);
+    }
+    throw new Error(`Unsupported workflow agentsFrom "${agentsFrom}". ` + 'Currently supported: review.agents.');
+}
+function getNodeKind(node) {
+    const configuredKinds = [node.agent, node.agentsFrom, node.action].filter((value) => value !== undefined).length;
+    if (configuredKinds !== 1) {
+        throw new Error('Workflow node must define exactly one of agent, agentsFrom, or action.');
+    }
+    if (node.agent !== undefined)
+        return 'agent';
+    if (node.agentsFrom !== undefined)
+        return 'agents';
+    return 'action';
+}
+function hasConfiguredAgentPrompt(config, agentId) {
+    const runConfig = resolveAgentRunConfig(config, agentId);
+    return runConfig.prompt !== undefined || runConfig.promptFile !== undefined;
+}
+function createAgentOptions(prompt, options, workingDir) {
+    return {
+        prompt,
+        jsonOutput: false,
+        debug: options.debug,
+        thinkingLevel: options.thinkingLevel,
+        workingDir,
+        quiet: true,
+        allowImplicitStdin: false,
+        ignoreConfiguredOutput: true,
+    };
+}
+async function writeWorkflowFile(workingDir, relativeOutputPath, content) {
+    if (!relativeOutputPath.trim()) {
+        throw new Error('Workflow output path cannot be empty.');
+    }
+    const outputPath = resolveWithinWorkingDir(workingDir, relativeOutputPath, 'write');
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, content, 'utf-8');
+}
+function renderNodeWritesPath(nodeId, node, context) {
+    if (!node.writes) {
+        return undefined;
+    }
+    const writes = renderTemplate(node.writes, context);
+    if (!writes.trim()) {
+        throw new Error(`Workflow node "${nodeId}" writes resolved to an empty path.`);
+    }
+    return writes;
+}
+async function runAgentWorkflowNode(config, nodeId, node, options, workingDir, context) {
+    const agentId = node.agent;
+    if (!agentId) {
+        throw new Error(`Workflow node "${nodeId}" is missing agent.`);
+    }
+    const prompt = node.input === undefined ? undefined : renderTemplate(node.input, context);
+    if (prompt === undefined && !hasConfiguredAgentPrompt(config, agentId)) {
+        throw new Error(`Workflow agent node "${nodeId}" must define input or configure ` +
+            `agents.overrides.${agentId}.run.prompt/promptFile.`);
+    }
+    const result = await runAgent(config, agentId, createAgentOptions(prompt, options, workingDir));
+    const writes = renderNodeWritesPath(nodeId, node, context);
+    if (writes) {
+        await writeWorkflowFile(workingDir, writes, node.json === true ? JSON.stringify(result, null, 2) : result.response);
+    }
+    return {
+        id: nodeId,
+        type: 'agent',
+        agent: agentId,
+        response: result.response,
+        output: result.response,
+        writes,
+    };
+}
+async function runAgentsWorkflowNode(config, nodeId, node, options, workingDir, context) {
+    const agentsFrom = node.agentsFrom;
+    if (!agentsFrom) {
+        throw new Error(`Workflow node "${nodeId}" is missing agentsFrom.`);
+    }
+    const agentIds = resolveAgentsFrom(config, agentsFrom);
+    const prompt = node.input === undefined ? undefined : renderTemplate(node.input, context);
+    if (prompt === undefined) {
+        const missingPromptAgent = agentIds.find((agentId) => !hasConfiguredAgentPrompt(config, agentId));
+        if (missingPromptAgent) {
+            throw new Error(`Workflow agentsFrom node "${nodeId}" must define input or configure ` +
+                `agents.overrides.${missingPromptAgent}.run.prompt/promptFile.`);
+        }
+    }
+    const responses = await Promise.all(agentIds.map((agentId) => runAgent(config, agentId, createAgentOptions(prompt, options, workingDir))));
+    const response = responses
+        .map((result) => `## ${result.agent}\n\n${result.response.trim()}`.trim())
+        .join('\n\n');
+    const writes = renderNodeWritesPath(nodeId, node, context);
+    if (writes) {
+        await writeWorkflowFile(workingDir, writes, node.json === true ? JSON.stringify(responses, null, 2) : response);
+    }
+    return {
+        id: nodeId,
+        type: 'agents',
+        agents: agentIds,
+        response,
+        responses,
+        output: response,
+        writes,
+    };
+}
+async function runActionWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext) {
+    if (node.action === 'write') {
+        return runWriteWorkflowNode(nodeId, node, workingDir, context);
+    }
+    if (node.action === 'git-diff') {
+        return runGitDiffWorkflowNode(nodeId, node, workingDir, context, executionContext);
+    }
+    if (node.action === 'git-add') {
+        return runGitAddWorkflowNode(nodeId, node, workingDir, context, executionContext);
+    }
+    if (node.action === 'git-commit') {
+        return runGitCommitWorkflowNode(nodeId, node, workingDir, context, executionContext);
+    }
+    if (node.action === 'change-source') {
+        return runChangeSourceWorkflowNode(nodeId, node, workingDir, context, executionContext);
+    }
+    if (node.action === 'review') {
+        return runReviewWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext);
+    }
+    if (node.action === 'review-context') {
+        return runReviewContextWorkflowNode(config, nodeId, node, workingDir, context);
+    }
+    if (node.action === 'describe') {
+        return runDescribeWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext);
+    }
+    if (node.action === 'code-quality-report') {
+        return runCodeQualityReportWorkflowNode(nodeId, node, workingDir, context);
+    }
+    if (node.action === 'post-comment') {
+        return runPostCommentWorkflowNode(nodeId, node, options, workingDir, context, executionContext);
+    }
+    if (node.action === 'post-review-comments') {
+        return runPostReviewCommentsWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext);
+    }
+    throw new Error(`Unsupported workflow action "${node.action}" in node "${nodeId}".`);
+}
+async function runWriteWorkflowNode(nodeId, node, workingDir, context) {
+    if (!node.writes) {
+        throw new Error(`Workflow write node "${nodeId}" must define writes.`);
+    }
+    if (node.input === undefined) {
+        throw new Error(`Workflow write node "${nodeId}" must define input.`);
+    }
+    const content = renderTemplate(node.input, context);
+    const relativeOutputPath = renderNodeWritesPath(nodeId, node, context);
+    if (!relativeOutputPath) {
+        throw new Error(`Workflow write node "${nodeId}" must define writes.`);
+    }
+    await writeWorkflowFile(workingDir, relativeOutputPath, content);
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: content,
+        output: content,
+        writes: relativeOutputPath,
+    };
+}
+function getBooleanActionOption(node, key) {
+    const value = node.with?.[key];
+    return value === true || value === 'true';
+}
+function getStringActionOption(node, key, context) {
+    const value = node.with?.[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return renderTemplate(value, context);
+    }
+    return String(value);
+}
+function hasActionOption(node, key) {
+    return Object.prototype.hasOwnProperty.call(node.with ?? {}, key);
+}
+function requireStringActionOption(nodeId, node, key, context) {
+    const value = getStringActionOption(node, key, context)?.trim();
+    if (!value) {
+        throw new Error(`Workflow node "${nodeId}" must define with.${key}.`);
+    }
+    return value;
+}
+function requireNumberActionOption(nodeId, node, key, context) {
+    const value = requireStringActionOption(nodeId, node, key, context);
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Workflow node "${nodeId}" with.${key} must be a positive number.`);
+    }
+    return parsed;
+}
+function getPathActionOption(nodeId, node, context, workingDir) {
+    const rawPaths = hasActionOption(node, 'paths')
+        ? requireStringActionOption(nodeId, node, 'paths', context)
+        : requireStringActionOption(nodeId, node, 'path', context);
+    const paths = rawPaths
+        .split(/[\n,]/)
+        .map((path) => path.trim())
+        .filter(Boolean);
+    if (paths.length === 0) {
+        throw new Error(`Workflow node "${nodeId}" must define at least one path.`);
+    }
+    for (const path of paths) {
+        resolveWithinWorkingDir(workingDir, path, 'access');
+    }
+    return paths;
+}
+async function requireWorkflowGitRepo(nodeId, workingDir, executionContext) {
+    const git = getWorkflowGitClient(executionContext, workingDir);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        throw new Error(`Workflow git node "${nodeId}" must run from a git repository.`);
+    }
+    return git;
+}
+async function runGitDiffWorkflowNode(nodeId, node, workingDir, context, executionContext) {
+    const git = getWorkflowGitClient(executionContext, workingDir);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        throw new Error(`Workflow git-diff node "${nodeId}" must run from a git repository.`);
+    }
+    const staged = getBooleanActionOption(node, 'staged');
+    const diff = staged ? await git.diff(['--cached']) : await git.diff();
+    const writes = renderNodeWritesPath(nodeId, node, context);
+    if (writes) {
+        await writeWorkflowFile(workingDir, writes, diff);
+    }
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: diff,
+        output: diff,
+        writes,
+    };
+}
+async function runGitAddWorkflowNode(nodeId, node, workingDir, context, executionContext) {
+    const git = await requireWorkflowGitRepo(nodeId, workingDir, executionContext);
+    const paths = getPathActionOption(nodeId, node, context, workingDir);
+    await git.add(paths);
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: paths.join('\n'),
+        output: paths,
+    };
+}
+async function runGitCommitWorkflowNode(nodeId, node, workingDir, context, executionContext) {
+    const git = await requireWorkflowGitRepo(nodeId, workingDir, executionContext);
+    const message = requireStringActionOption(nodeId, node, 'message', context);
+    const paths = hasActionOption(node, 'paths') || hasActionOption(node, 'path')
+        ? getPathActionOption(nodeId, node, context, workingDir)
+        : undefined;
+    if (paths) {
+        await git.add(paths);
+    }
+    const commit = paths ? await git.commit(message, paths) : await git.commit(message);
+    const output = {
+        commit: commit.commit,
+        message,
+        paths,
+        summary: commit.summary,
+    };
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: commit.commit ? `Created commit ${commit.commit}` : 'Created git commit',
+        output,
+    };
+}
+async function loadLocalChangeSource(nodeId, node, workingDir) {
+    const git = simpleGit({ baseDir: workingDir });
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+        throw new Error(`Workflow change-source node "${nodeId}" must run from a git repository.`);
+    }
+    const staged = getBooleanActionOption(node, 'staged');
+    const diffText = staged ? await git.diff(['--cached']) : await git.diff();
+    const diffs = parseDiff(diffText);
+    const changedFiles = getChangedFiles(diffs);
+    return {
+        name: `Local ${staged ? 'staged' : 'unstaged'} diff`,
+        files: changedFiles,
+        filesWithDiffs: getFilesWithDiffs(diffs),
+        context: {},
+        workingDir,
+        staged,
+    };
+}
+function parseGitRangeCommits(logOutput) {
+    return logOutput
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const [sha = '', author = '', date = '', subject = ''] = line.split('\x1f');
+        return { sha, author, date, subject };
+    })
+        .filter((commit) => commit.sha.length > 0);
+}
+async function resolveGitRangeToRef(git) {
+    if (process.env.GITHUB_REF_TYPE === 'tag' && process.env.GITHUB_REF_NAME) {
+        return process.env.GITHUB_REF_NAME;
+    }
+    const tag = (await git.raw(['describe', '--tags', '--exact-match', 'HEAD'])).trim();
+    if (!tag) {
+        throw new Error('Workflow git-range change-source could not infer the current tag. ' +
+            'Run from a tag checkout or provide with.to.');
+    }
+    return tag;
+}
+function isStableSemverTag(tag) {
+    return /^v?\d+\.\d+\.\d+$/.test(tag);
+}
+async function resolvePreviousGitRangeTag(nodeId, node, git, toRef) {
+    const includePrerelease = getBooleanActionOption(node, 'includePrereleaseFrom');
+    const tagOutput = await git.raw(['tag', '--merged', toRef, '--sort=-v:refname']);
+    const tags = tagOutput
+        .split('\n')
+        .map((tag) => tag.trim())
+        .filter((tag) => tag.length > 0 && tag !== toRef);
+    const previousTag = tags.find((tag) => includePrerelease || isStableSemverTag(tag)) ?? tags[0];
+    if (!previousTag) {
+        throw new Error(`Workflow node "${nodeId}" could not infer the previous tag for ${toRef}. ` +
+            'Provide with.from explicitly.');
+    }
+    return previousTag;
+}
+async function resolveGitRangeRefs(nodeId, node, context, git) {
+    const configuredToRef = getStringActionOption(node, 'to', context)?.trim();
+    const toRef = configuredToRef ? configuredToRef : await resolveGitRangeToRef(git);
+    const configuredFromRef = getStringActionOption(node, 'from', context)?.trim();
+    const fromRef = configuredFromRef
+        ? configuredFromRef
+        : await resolvePreviousGitRangeTag(nodeId, node, git, toRef);
+    if (!fromRef) {
+        throw new Error(`Workflow node "${nodeId}" could not infer the previous tag for ${toRef}. ` +
+            'Provide with.from explicitly.');
+    }
+    return { fromRef, toRef };
+}
+async function loadGitRangeChangeSource(nodeId, node, workingDir, context, executionContext) {
+    const git = await requireWorkflowGitRepo(nodeId, workingDir, executionContext);
+    const { fromRef, toRef } = await resolveGitRangeRefs(nodeId, node, context, git);
+    const range = `${fromRef}..${toRef}`;
+    const diffText = await git.diff([range]);
+    const logOutput = await git.raw(['log', '--format=%H%x1f%an%x1f%aI%x1f%s', '--no-merges', range]);
+    const diffs = parseDiff(diffText);
+    const changedFiles = getChangedFiles(diffs);
+    return {
+        name: `Git range ${range}`,
+        files: changedFiles,
+        filesWithDiffs: getFilesWithDiffs(diffs),
+        context: {
+            sourceType: 'git-range',
+            fromRef,
+            toRef,
+            range,
+            commits: parseGitRangeCommits(logOutput),
+        },
+        workingDir,
+    };
+}
+function createPlatformChangeSource(platform, name, projectId, pullRequest, changedFiles, workingDir) {
+    return {
+        name,
+        files: changedFiles.map((file) => file.filename),
+        filesWithDiffs: changedFiles
+            .filter((file) => file.patch && file.patch.length > 0)
+            .map((file) => ({ filename: file.filename, patch: file.patch ?? '' })),
+        context: {
+            platform,
+            projectId,
+            pullRequest,
+            changedFiles,
+        },
+        workingDir,
+    };
+}
+async function loadGitHubChangeSource(nodeId, node, workingDir, context, executionContext) {
+    const owner = requireStringActionOption(nodeId, node, 'owner', context);
+    const repo = requireStringActionOption(nodeId, node, 'repo', context);
+    const prNumber = requireNumberActionOption(nodeId, node, 'pr', context);
+    const projectId = `${owner}/${repo}`;
+    const platformClient = getWorkflowPlatformClient(executionContext, 'github');
+    const [pullRequest, changedFiles] = await Promise.all([
+        platformClient.getPullRequest(projectId, prNumber),
+        platformClient.getChangedFiles(projectId, prNumber),
+    ]);
+    return createPlatformChangeSource('github', `GitHub PR ${projectId}#${prNumber}`, projectId, pullRequest, changedFiles, workingDir);
+}
+async function loadGitLabChangeSource(nodeId, node, workingDir, context, executionContext) {
+    const projectId = hasActionOption(node, 'project')
+        ? requireStringActionOption(nodeId, node, 'project', context)
+        : requireStringActionOption(nodeId, node, 'projectId', context);
+    const mrIid = hasActionOption(node, 'mr')
+        ? requireNumberActionOption(nodeId, node, 'mr', context)
+        : requireNumberActionOption(nodeId, node, 'mrIid', context);
+    const platformClient = getWorkflowPlatformClient(executionContext, 'gitlab');
+    const [pullRequest, changedFiles] = await Promise.all([
+        platformClient.getPullRequest(projectId, mrIid),
+        platformClient.getChangedFiles(projectId, mrIid),
+    ]);
+    return createPlatformChangeSource('gitlab', `GitLab MR ${projectId}!${mrIid}`, projectId, pullRequest, changedFiles, workingDir);
+}
+async function runChangeSourceWorkflowNode(nodeId, node, workingDir, context, executionContext) {
+    const type = getStringActionOption(node, 'type', context) ?? 'local';
+    let source;
+    if (type === 'local') {
+        source = await loadLocalChangeSource(nodeId, node, workingDir);
+    }
+    else if (type === 'git-range') {
+        source = await loadGitRangeChangeSource(nodeId, node, workingDir, context, executionContext);
+    }
+    else if (type === 'github-pr') {
+        source = await loadGitHubChangeSource(nodeId, node, workingDir, context, executionContext);
+    }
+    else if (type === 'gitlab-mr') {
+        source = await loadGitLabChangeSource(nodeId, node, workingDir, context, executionContext);
+    }
+    else {
+        throw new Error(`Unsupported workflow change-source type "${type}" in node "${nodeId}". ` +
+            'Currently supported: local, git-range, github-pr, gitlab-mr.');
+    }
+    const writes = renderNodeWritesPath(nodeId, node, context);
+    if (writes) {
+        await writeWorkflowFile(workingDir, writes, JSON.stringify(source, null, 2));
+    }
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: source.name,
+        output: source,
+        writes,
+    };
+}
+function isWorkflowPlatform(value) {
+    return value === 'github' || value === 'gitlab';
+}
+function readSourcePostTarget(source) {
+    if (!source) {
+        return {};
+    }
+    const platform = typeof source.context.platform === 'string' ? source.context.platform : undefined;
+    const projectId = typeof source.context.projectId === 'string' ? source.context.projectId : undefined;
+    const pullRequest = isPullRequest(source.context.pullRequest)
+        ? source.context.pullRequest
+        : undefined;
+    const changedFiles = Array.isArray(source.context.changedFiles)
+        ? source.context.changedFiles.filter(isFileChange)
+        : undefined;
+    return {
+        platform: isWorkflowPlatform(platform) ? platform : undefined,
+        projectId,
+        prNumber: pullRequest?.number,
+        pullRequest,
+        changedFiles,
+    };
+}
+function resolvePostProjectId(nodeId, node, context, sourceTarget) {
+    if (hasActionOption(node, 'owner') || hasActionOption(node, 'repo')) {
+        const owner = requireStringActionOption(nodeId, node, 'owner', context);
+        const repo = requireStringActionOption(nodeId, node, 'repo', context);
+        return `${owner}/${repo}`;
+    }
+    const projectId = getStringActionOption(node, 'project', context) ??
+        getStringActionOption(node, 'projectId', context) ??
+        sourceTarget.projectId;
+    if (!projectId) {
+        throw new Error(`Workflow post node "${nodeId}" must define a project target.`);
+    }
+    return projectId;
+}
+function resolvePostPrNumber(nodeId, node, context, sourceTarget) {
+    if (hasActionOption(node, 'pr')) {
+        return requireNumberActionOption(nodeId, node, 'pr', context);
+    }
+    if (hasActionOption(node, 'mr')) {
+        return requireNumberActionOption(nodeId, node, 'mr', context);
+    }
+    if (hasActionOption(node, 'prNumber')) {
+        return requireNumberActionOption(nodeId, node, 'prNumber', context);
+    }
+    if (hasActionOption(node, 'mrIid')) {
+        return requireNumberActionOption(nodeId, node, 'mrIid', context);
+    }
+    if (sourceTarget.prNumber) {
+        return sourceTarget.prNumber;
+    }
+    throw new Error(`Workflow post node "${nodeId}" must define a PR/MR number.`);
+}
+function resolvePostTarget(nodeId, node, context, executionContext, source) {
+    const sourceTarget = readSourcePostTarget(source);
+    const explicitPlatform = getStringActionOption(node, 'platform', context);
+    const platform = explicitPlatform ?? sourceTarget.platform;
+    if (!isWorkflowPlatform(platform)) {
+        throw new Error(`Workflow post node "${nodeId}" must resolve with.platform to github or gitlab.`);
+    }
+    const projectId = resolvePostProjectId(nodeId, node, context, sourceTarget);
+    const prNumber = resolvePostPrNumber(nodeId, node, context, sourceTarget);
+    return {
+        platform,
+        platformClient: getWorkflowPlatformClient(executionContext, platform),
+        projectId,
+        prNumber,
+        pullRequest: sourceTarget.pullRequest,
+        changedFiles: sourceTarget.changedFiles,
+    };
+}
+function isPullRequest(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.number === 'number' &&
+        typeof candidate.title === 'string' &&
+        typeof candidate.author === 'string' &&
+        typeof candidate.sourceBranch === 'string' &&
+        typeof candidate.targetBranch === 'string' &&
+        typeof candidate.headSha === 'string');
+}
+function isFileChange(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.filename === 'string' && typeof candidate.status === 'string';
+}
+function createWorkflowLineValidator(platform, source) {
+    const pullRequest = isPullRequest(source.context.pullRequest) ? source.context.pullRequest : null;
+    const platformData = pullRequest?.platformData;
+    const diffRefs = platformData?.diff_refs;
+    if (platform === 'gitlab' && (!diffRefs?.base_sha || !diffRefs.head_sha || !diffRefs.start_sha)) {
+        return undefined;
+    }
+    const fileChanges = Array.isArray(source.context.changedFiles)
+        ? source.context.changedFiles.filter(isFileChange)
+        : [];
+    const patchSources = fileChanges.length > 0 ? fileChanges : (source.filesWithDiffs ?? []);
+    const validLinesMap = new Map();
+    for (const file of patchSources) {
+        if ('status' in file && file.status === 'removed') {
+            continue;
+        }
+        const patch = file.patch;
+        if (patch) {
+            validLinesMap.set(file.filename, parseValidLinesFromPatch(patch));
+        }
+    }
+    return {
+        isValidLine(file, line) {
+            const validLines = validLinesMap.get(file);
+            return validLines !== undefined && validLines.has(line);
+        },
+    };
+}
+function createWorkflowInlinePosition(platform, source) {
+    const pullRequest = isPullRequest(source.context.pullRequest) ? source.context.pullRequest : null;
+    if (!pullRequest) {
+        return undefined;
+    }
+    if (platform === 'github') {
+        return (issue) => ({
+            path: issue.file,
+            line: issue.line,
+            commitSha: pullRequest.headSha,
+        });
+    }
+    return (issue, platformData) => {
+        const data = platformData;
+        const refs = data?.diff_refs;
+        return {
+            path: issue.file,
+            line: issue.line,
+            baseSha: refs?.base_sha,
+            headSha: refs?.head_sha,
+            startSha: refs?.start_sha,
+        };
+    };
+}
+function isReviewResult(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return Array.isArray(candidate.issues) && typeof candidate.summary === 'object';
+}
+function getReviewSourceDiffCommand(source, baseBranch) {
+    const pullRequest = isPullRequest(source.context.pullRequest) ? source.context.pullRequest : null;
+    if (pullRequest) {
+        return getCanonicalDiffCommand(pullRequest, resolveBaseBranch(baseBranch, pullRequest.targetBranch));
+    }
+    return source.staged ? 'git diff --cached -- <file>' : 'git diff -- <file>';
+}
+function getReviewContextFiles(config, source, fileFilter) {
+    const filteredFiles = filterIgnoredFiles(source.files, config);
+    const patchByFile = new Map((source.filesWithDiffs ?? []).map((file) => [file.filename, file.patch]));
+    const files = filteredFiles.map((filename) => ({
+        filename,
+        patch: patchByFile.get(filename),
+    }));
+    if (!fileFilter) {
+        return files;
+    }
+    const matches = files.filter((file) => file.filename === fileFilter);
+    if (matches.length === 0) {
+        throw new Error(`No matching file "${fileFilter}" found in review source.`);
+    }
+    return matches;
+}
+async function runReviewContextWorkflowNode(config, nodeId, node, workingDir, context) {
+    const sourceArtifact = getStringActionOption(node, 'source', context) ?? 'change';
+    const source = context.artifacts[sourceArtifact];
+    if (!isReviewSource(source)) {
+        throw new Error(`Workflow review-context node "${nodeId}" needs a ReviewSource artifact. ` +
+            'Set with.source to a change-source output.');
+    }
+    const rawFileFilter = getStringActionOption(node, 'file', context)?.trim();
+    const rawBaseBranch = getStringActionOption(node, 'baseBranch', context)?.trim();
+    const fileFilter = rawFileFilter === '' ? undefined : rawFileFilter;
+    const baseBranch = rawBaseBranch === '' ? undefined : rawBaseBranch;
+    const files = getReviewContextFiles(config, source, fileFilter);
+    const instructions = buildBaseInstructions(source.name, files, getReviewSourceDiffCommand(source, baseBranch));
+    const writes = renderNodeWritesPath(nodeId, node, context);
+    if (writes) {
+        await writeWorkflowFile(workingDir, writes, instructions);
+    }
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: instructions,
+        output: instructions,
+        writes,
+    };
+}
+function getDescribeFiles(source, target) {
+    if (source.filesWithDiffs && source.filesWithDiffs.length > 0) {
+        return source.filesWithDiffs;
+    }
+    return (target.changedFiles ?? [])
+        .filter((file) => file.status !== 'removed')
+        .map((file) => ({ filename: file.filename, patch: file.patch }));
+}
+async function runCodeQualityReportWorkflowNode(nodeId, node, workingDir, context) {
+    const reviewArtifact = getStringActionOption(node, 'review', context) ?? 'review';
+    const reviewResult = context.artifacts[reviewArtifact];
+    if (!isReviewResult(reviewResult)) {
+        throw new Error(`Workflow code-quality-report node "${nodeId}" needs a ReviewResult artifact.`);
+    }
+    const reportPath = hasActionOption(node, 'path')
+        ? requireStringActionOption(nodeId, node, 'path', context)
+        : renderNodeWritesPath(nodeId, node, context);
+    if (!reportPath) {
+        throw new Error(`Workflow code-quality-report node "${nodeId}" must define with.path or writes.`);
+    }
+    const report = generateCodeQualityReport(reviewResult.issues);
+    await writeWorkflowFile(workingDir, reportPath, formatCodeQualityReport(report));
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: `wrote GitLab code quality report to ${reportPath}`,
+        output: {
+            path: reportPath,
+            issues: report.length,
+        },
+        writes: reportPath,
+    };
+}
+async function runDescribeWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext) {
+    const sourceArtifact = getStringActionOption(node, 'source', context) ?? 'change';
+    const source = context.artifacts[sourceArtifact];
+    if (!isReviewSource(source)) {
+        throw new Error(`Workflow describe node "${nodeId}" needs a ReviewSource artifact. ` +
+            'Set with.source to a change-source output.');
+    }
+    const target = resolvePostTarget(nodeId, node, context, executionContext, source);
+    if (!target.pullRequest) {
+        throw new Error(`Workflow describe node "${nodeId}" needs a platform change-source target.`);
+    }
+    const shouldPostDescription = getBooleanActionOption(node, 'post') || getBooleanActionOption(node, 'postDescription');
+    const runtimeClient = await connectToRuntime(config, source.workingDir ?? workingDir, {
+        debug: options.debug,
+        modelOverrides: getDescriberModelOverride(config),
+        thinkingLevel: options.thinkingLevel,
+    });
+    let description = null;
+    try {
+        description = await runDescribeIfEnabled(runtimeClient, config, target.platformClient, target.projectId, target.pullRequest, getDescribeFiles(source, target), shouldPostDescription, source.workingDir ?? workingDir, options.debug);
+    }
+    finally {
+        await runtimeClient.shutdown();
+    }
+    const writes = renderNodeWritesPath(nodeId, node, context);
+    if (writes) {
+        await writeWorkflowFile(workingDir, writes, JSON.stringify(description, null, 2));
+    }
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: description ? JSON.stringify(description, null, 2) : 'description generation skipped',
+        output: description,
+        writes,
+    };
+}
+function formatMarkedComment(body, marker) {
+    if (!marker) {
+        return body;
+    }
+    const markerComment = `<!-- drs-comment-id: ${marker} -->`;
+    return body.includes(markerComment) ? body : `${markerComment}\n${body}`;
+}
+async function runPostCommentWorkflowNode(nodeId, node, options, workingDir, context, executionContext) {
+    const sourceArtifact = getStringActionOption(node, 'source', context) ?? 'change';
+    const source = isReviewSource(context.artifacts[sourceArtifact])
+        ? context.artifacts[sourceArtifact]
+        : undefined;
+    const target = resolvePostTarget(nodeId, node, context, executionContext, source);
+    const rawBody = node.input === undefined
+        ? requireStringActionOption(nodeId, node, 'body', context)
+        : renderTemplate(node.input, context);
+    const marker = getStringActionOption(node, 'marker', context)?.trim();
+    const body = formatMarkedComment(rawBody, marker);
+    let operation = 'created';
+    if (marker) {
+        const comments = await target.platformClient.getComments(target.projectId, target.prNumber);
+        const existingComment = findExistingCommentById(comments, marker);
+        if (existingComment) {
+            await withWorkflowConsoleSuppressed(executionContext, options.jsonOutput === true, () => target.platformClient.updateComment(target.projectId, target.prNumber, existingComment.id, body));
+            operation = 'updated';
+        }
+        else {
+            await withWorkflowConsoleSuppressed(executionContext, options.jsonOutput === true, () => target.platformClient.createComment(target.projectId, target.prNumber, body));
+        }
+    }
+    else {
+        await withWorkflowConsoleSuppressed(executionContext, options.jsonOutput === true, () => target.platformClient.createComment(target.projectId, target.prNumber, body));
+    }
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: `${operation} comment on ${target.platform} ${target.projectId}#${target.prNumber}`,
+        output: {
+            platform: target.platform,
+            projectId: target.projectId,
+            prNumber: target.prNumber,
+            marker,
+            operation,
+        },
+    };
+}
+async function runPostReviewCommentsWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext) {
+    const sourceArtifact = getStringActionOption(node, 'source', context) ?? 'change';
+    const reviewArtifact = getStringActionOption(node, 'review', context) ?? 'review';
+    const source = context.artifacts[sourceArtifact];
+    const reviewResult = context.artifacts[reviewArtifact];
+    if (!isReviewSource(source)) {
+        throw new Error(`Workflow post-review-comments node "${nodeId}" needs a ReviewSource artifact.`);
+    }
+    if (!isReviewResult(reviewResult)) {
+        throw new Error(`Workflow post-review-comments node "${nodeId}" needs a ReviewResult artifact.`);
+    }
+    const target = resolvePostTarget(nodeId, node, context, executionContext, source);
+    const pullRequest = target.pullRequest;
+    const platformData = pullRequest?.platformData;
+    const lineValidator = createWorkflowLineValidator(target.platform, source);
+    const createInlinePosition = lineValidator
+        ? createWorkflowInlinePosition(target.platform, source)
+        : undefined;
+    const shouldRemoveErrorComment = !hasActionOption(node, 'removeErrorComment') ||
+        getBooleanActionOption(node, 'removeErrorComment');
+    await withWorkflowConsoleSuppressed(executionContext, options.jsonOutput === true, async () => {
+        if (shouldRemoveErrorComment) {
+            await removeErrorComment(target.platformClient, target.projectId, target.prNumber);
+        }
+        const cursorFixLinks = resolveCursorFixLinkOptions(config, target.projectId, workingDir);
+        await postReviewComments(target.platformClient, target.projectId, target.prNumber, reviewResult.summary, reviewResult.issues, reviewResult.changeSummary, reviewResult.usage, platformData, lineValidator, createInlinePosition, cursorFixLinks, pullRequest
+            ? {
+                headSha: pullRequest.headSha,
+                sourceBranch: pullRequest.sourceBranch,
+                targetBranch: pullRequest.targetBranch,
+            }
+            : undefined);
+    });
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: `posted review comments on ${target.platform} ${target.projectId}#${target.prNumber}`,
+        output: {
+            platform: target.platform,
+            projectId: target.projectId,
+            prNumber: target.prNumber,
+            issues: reviewResult.issues.length,
+        },
+    };
+}
+function isReviewSource(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.name === 'string' &&
+        Array.isArray(candidate.files) &&
+        typeof candidate.context === 'object' &&
+        candidate.context !== null);
+}
+async function enforceWorkflowReviewTarget(config, source, workingDir) {
+    const platform = typeof source.context.platform === 'string' ? source.context.platform : undefined;
+    if (!isWorkflowPlatform(platform)) {
+        return;
+    }
+    const projectId = typeof source.context.projectId === 'string' ? source.context.projectId : undefined;
+    const pullRequest = isPullRequest(source.context.pullRequest)
+        ? source.context.pullRequest
+        : undefined;
+    if (!projectId || !pullRequest) {
+        throw new Error('Workflow platform review source is missing project or PR/MR metadata.');
+    }
+    await enforceRepoBranchMatch(workingDir, projectId, pullRequest, {
+        skipRepoCheck: config.review.skipRepoCheck,
+        skipBranchCheck: config.review.skipBranchCheck,
+    });
+}
+async function runReviewWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext) {
+    const sourceArtifact = getStringActionOption(node, 'source', context) ?? 'change';
+    const source = context.artifacts[sourceArtifact];
+    if (!isReviewSource(source)) {
+        throw new Error(`Workflow review node "${nodeId}" needs a ReviewSource artifact. ` +
+            'Set with.source to a change-source output.');
+    }
+    const reviewResult = await withWorkflowLock(executionContext.locks.exit, async () => {
+        const restoreExit = setExitHandler((code) => {
+            throw new ExitError(code);
+        });
+        const originalLog = console.log;
+        const originalWarn = console.warn;
+        if (options.jsonOutput) {
+            console.log = () => undefined;
+            console.warn = () => undefined;
+        }
+        try {
+            await enforceWorkflowReviewTarget(config, source, source.workingDir ?? workingDir);
+            return await executeReview(config, {
+                ...source,
+                workingDir: source.workingDir ?? workingDir,
+                debug: options.debug,
+                thinkingLevel: options.thinkingLevel,
+            });
+        }
+        catch (error) {
+            if (error instanceof ExitError) {
+                throw new Error(`Workflow review node "${nodeId}" failed: all review agents failed.`);
+            }
+            throw error;
+        }
+        finally {
+            if (options.jsonOutput) {
+                console.log = originalLog;
+                console.warn = originalWarn;
+            }
+            restoreExit();
+        }
+    });
+    const writes = renderNodeWritesPath(nodeId, node, context);
+    if (writes) {
+        await writeWorkflowFile(workingDir, writes, JSON.stringify(reviewResult, null, 2));
+    }
+    return {
+        id: nodeId,
+        type: 'action',
+        action: node.action,
+        response: JSON.stringify(reviewResult.summary, null, 2),
+        output: reviewResult,
+        writes,
+    };
+}
+function recordNodeArtifact(nodeId, node, result, artifacts) {
+    const artifactValue = result.output ?? result.response ?? result.responses;
+    artifacts[nodeId] = artifactValue;
+    if (node.output) {
+        artifacts[node.output] = artifactValue;
+    }
+}
+function formatWorkflowJson(result) {
+    return JSON.stringify(result, null, 2);
+}
+async function runSingleWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext) {
+    const kind = getNodeKind(node);
+    if (kind === 'agent') {
+        return runAgentWorkflowNode(config, nodeId, node, options, workingDir, context);
+    }
+    if (kind === 'agents') {
+        return runAgentsWorkflowNode(config, nodeId, node, options, workingDir, context);
+    }
+    return runActionWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext);
+}
+export async function runWorkflow(config, workflowName, options = {}) {
+    const workflow = config.workflows?.[workflowName];
+    if (!workflow) {
+        throw new Error(`Unknown workflow "${workflowName}".`);
+    }
+    const workflowNodes = getWorkflowNodes(workflowName, workflow);
+    const workingDir = options.workingDir ?? process.cwd();
+    const inputs = await resolveWorkflowInputs(workflow, options, workingDir);
+    const nodes = {};
+    const artifacts = {};
+    const context = { inputs, nodes, artifacts };
+    const executionContext = {
+        gitClients: new Map(),
+        platformClients: {},
+        locks: {
+            exit: createWorkflowLock(),
+            console: createWorkflowLock(),
+        },
+    };
+    const executionOrder = getWorkflowExecutionOrder(workflowNodes);
+    const executionWaves = getWorkflowExecutionWaves(workflowNodes, executionOrder);
+    if (!options.jsonOutput) {
+        console.log(chalk.gray(`Running workflow ${workflowName}...\n`));
+    }
+    for (const wave of executionWaves) {
+        const results = await Promise.all(wave.map(async (nodeId) => {
+            const node = workflowNodes[nodeId];
+            if (!node) {
+                throw new Error(`Workflow references unknown node "${nodeId}".`);
+            }
+            if (!options.jsonOutput) {
+                console.log(chalk.gray(`Running node ${nodeId}...`));
+            }
+            const result = await runSingleWorkflowNode(config, nodeId, node, options, workingDir, context, executionContext);
+            return { nodeId, node, result };
+        }));
+        for (const { nodeId, node, result } of results) {
+            nodes[nodeId] = result;
+            recordNodeArtifact(nodeId, node, result, artifacts);
+        }
+    }
+    const lastNodeId = executionOrder[executionOrder.length - 1];
+    const lastNode = workflowNodes[lastNodeId];
+    const outputKey = lastNode.output ?? lastNodeId;
+    const result = {
+        timestamp: new Date().toISOString(),
+        workflow: workflowName,
+        inputs,
+        nodes,
+        artifacts,
+        output: artifacts[outputKey],
+    };
+    if (options.outputPath) {
+        await writeWorkflowFile(workingDir, options.outputPath, formatWorkflowJson(result));
+        if (!options.jsonOutput) {
+            console.log(chalk.green(`\n✓ Workflow output saved to ${options.outputPath}`));
+        }
+    }
+    if (options.jsonOutput) {
+        console.log(formatWorkflowJson(result));
+    }
+    else if (typeof result.output === 'string' && result.output.trim()) {
+        console.log(`\n${result.output}`);
+    }
+    return result;
+}
+/**
+ * List available workflows and their source origin.
+ *
+ * Packaged workflows are always returned. Project-defined workflows
+ * appear as 'project' and mark any packaged workflow they replace
+ * as overridden.
+ */
+export function listWorkflows(config, options = {}) {
+    const workingDir = options.workingDir ?? process.cwd();
+    const sourceInfo = loadWorkflowSourceInfo(workingDir);
+    const workflows = config.workflows ?? {};
+    const entries = Object.entries(workflows)
+        .map(([name, workflow]) => {
+        const info = sourceInfo[name] ?? {
+            source: 'packaged',
+            overridesPackaged: false,
+        };
+        return {
+            name,
+            source: info.source,
+            overridden: info.overridesPackaged,
+            description: workflow.description,
+        };
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
+    if (options.json) {
+        console.log(JSON.stringify(entries, null, 2));
+    }
+    else {
+        const sourceLabel = (source, overridden) => {
+            const label = source === 'packaged' ? chalk.gray('packaged') : chalk.cyan('project');
+            return overridden ? `${label} ${chalk.yellow('(overrides packaged)')}` : label;
+        };
+        console.log(chalk.bold('\n📋 Available Workflows:\n'));
+        for (const entry of entries) {
+            console.log(`  ${chalk.white(entry.name)}`);
+            console.log(`    Source: ${sourceLabel(entry.source, entry.overridden)}`);
+            if (entry.description) {
+                console.log(`    ${chalk.gray(entry.description)}`);
+            }
+        }
+        console.log('');
+    }
+    return entries;
+}
+//# sourceMappingURL=workflow.js.map