cloving 1.2.0 → 1.4.0

package/dist/tools/workflow-candidate-shape.js

@@ -0,0 +1,90 @@
+import ts from "typescript";
+export function workflowShape(source) {
+    const exported = source.statements.filter((node) => ts.isFunctionDeclaration(node) &&
+        (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
+    const candidate = exported[0];
+    if (exported.length !== 1 ||
+        !candidate ||
+        !ts.isFunctionDeclaration(candidate))
+        return false;
+    if (!workflowFunction(candidate))
+        return false;
+    const directives = [];
+    function visit(node) {
+        if (ts.isStringLiteral(node) && node.text === "use workflow")
+            directives.push(node);
+        ts.forEachChild(node, visit);
+    }
+    visit(source);
+    return directives.length === 1;
+}
+function workflowFunction(candidate) {
+    if (!candidate.name || !candidate.body || candidate.asteriskToken)
+        return false;
+    const modifiers = ts.getModifiers(candidate) ?? [];
+    if (!modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ||
+        modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword))
+        return false;
+    const first = candidate.body.statements[0];
+    return first !== undefined && workflowDirective(first);
+}
+function workflowDirective(node) {
+    return (ts.isExpressionStatement(node) &&
+        ts.isStringLiteral(node.expression) &&
+        node.expression.text === "use workflow");
+}
+function unwrappedInitializer(node) {
+    if (ts.isParenthesizedExpression(node) ||
+        ts.isAsExpression(node) ||
+        ts.isSatisfiesExpression(node) ||
+        ts.isTypeAssertionExpression(node))
+        return node.expression;
+    return undefined;
+}
+function passiveCompound(node) {
+    if (ts.isArrayLiteralExpression(node))
+        return node.elements.every((element) => ts.isOmittedExpression(element) || passiveInitializer(element));
+    if (ts.isObjectLiteralExpression(node))
+        return node.properties.every((property) => ts.isPropertyAssignment(property) &&
+            !ts.isComputedPropertyName(property.name) &&
+            passiveInitializer(property.initializer));
+    return false;
+}
+function passiveInitializer(node) {
+    if (!node)
+        return false;
+    if (ts.isLiteralExpression(node))
+        return true;
+    if ([
+        ts.SyntaxKind.TrueKeyword,
+        ts.SyntaxKind.FalseKeyword,
+        ts.SyntaxKind.NullKeyword,
+    ].includes(node.kind))
+        return true;
+    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
+        return true;
+    if (ts.isPrefixUnaryExpression(node))
+        return ([ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(node.operator) && ts.isNumericLiteral(node.operand));
+    const inner = unwrappedInitializer(node);
+    return inner ? passiveInitializer(inner) : passiveCompound(node);
+}
+function passiveStatement(node, kind) {
+    if (ts.isVariableStatement(node))
+        return ((node.declarationList.flags & ts.NodeFlags.Const) !== 0 &&
+            node.declarationList.declarations.every((declaration) => (kind === "helper" ||
+                (ts.getCombinedModifierFlags(declaration) &
+                    ts.ModifierFlags.Export) ===
+                    0) &&
+                ts.isIdentifier(declaration.name) &&
+                passiveInitializer(declaration.initializer)));
+    if (ts.isExpressionStatement(node))
+        return ts.isStringLiteral(node.expression);
+    return (ts.isImportDeclaration(node) ||
+        ts.isTypeAliasDeclaration(node) ||
+        ts.isInterfaceDeclaration(node) ||
+        ts.isFunctionDeclaration(node) ||
+        ts.isEmptyStatement(node));
+}
+export function passiveCandidateModule(source, kind = "workflow") {
+    return source.statements.every((node) => passiveStatement(node, kind));
+}

package/dist/tools/workflow-candidate-source.js

@@ -1,8 +1,12 @@
+import { passiveCandidateModule, workflowShape, } from "./workflow-candidate-shape.js";
 import ts from "typescript";
+import { dirname, relative, sep } from "node:path";
 import { candidateProgram, resolvedSymbol, } from "./workflow-candidate-program.js";
-import { protectedEffectFact, passiveCandidateModule, unsupportedCandidateNode, workflowShape, } from "./workflow-candidate-syntax.js";
+import { protectedEffectFact, commandWaitCall, unsupportedCandidateNode, } from "./workflow-candidate-syntax.js";
+import { literalField } from "./workflow-candidate-fields.js";
 import { sourceEffectNodes } from "./workflow-source-effects.js";
 import { candidateEffectTotals } from "./workflow-candidate-counts.js";
+import { helperEffectTotals } from "./workflow-candidate-helper-counts.js";
 function exportSnapshot(modules, checker) {
     return Object.fromEntries([...modules].map(([name, declaration]) => {
         const symbol = checker.getSymbolAtLocation(declaration);
@@ -30,11 +34,14 @@ function sourceFacts(symbols) {
     const { source } = symbols;
     const imports = [];
     const effects = [];
+    const commandWaits = [];
     const unsupportedForms = [];
     function visit(node) {
         const imported = sourceImport(node);
         if (imported)
             imports.push(imported);
+        if (ts.isCallExpression(node) && commandWaitCall(node, symbols))
+            commandWaits.push(literalField(node.arguments[0], "name"));
         const effect = protectedEffectFact(node, symbols);
         if (effect)
             effects.push(effect);
@@ -45,6 +52,7 @@ function sourceFacts(symbols) {
     visit(source);
     return {
         imports,
+        ...(commandWaits.length === 0 ? {} : { commandWaits }),
         effects,
         directEffects: sourceEffectNodes(source, {
             checker: symbols.checker,
@@ -68,8 +76,21 @@ function sourceImport(node) {
             : [],
     };
 }
+function mergeHelpers(modules, checker) {
+    return [
+        ["merge-when-green", "mergeWhenGreen"],
+        ["merge-by-person", "mergeByPerson"],
+    ].flatMap(([module, name]) => {
+        const symbol = protectedHelper(modules, {
+            checker,
+            subpath: `cloving/workflows/steps/${String(module)}`,
+            name: String(name),
+        });
+        return symbol === undefined ? [] : [symbol];
+    });
+}
 export function analyzeWorkflowCandidate(text, installed = {}) {
-    const { program, source, modules } = candidateProgram(text, installed);
+    const { program, source, sources, modules } = candidateProgram(text, installed);
     const checker = program.getTypeChecker();
     const symbols = {
         checker,
@@ -84,24 +105,79 @@ export function analyzeWorkflowCandidate(text, installed = {}) {
             subpath: "cloving/workflows/steps/handoff",
             name: "handoff",
         }),
+        commandWaitSymbol: protectedHelper(modules, {
+            checker,
+            subpath: "cloving/workflows/steps/wait-for-command",
+            name: "waitForCommand",
+        }),
+        commandSymbol: protectedHelper(modules, {
+            checker,
+            subpath: "cloving/workflows/steps/run-command",
+            name: "runCommand",
+        }),
+        reviewSymbol: protectedHelper(modules, {
+            checker,
+            subpath: "cloving/workflows/steps/review-by-agent",
+            name: "reviewByAgent",
+        }),
+        mergeSymbols: mergeHelpers(modules, checker),
+    };
+    const facts = sources.map((entry) => analyzedSource({ ...symbols, source: entry }, { program, workflow: source }));
+    return {
+        analysis: combineFacts({
+            localSources: Object.keys(installed.helpers ?? {}),
+            facts,
+            expanded: helperEffectTotals({
+                symbols: { ...symbols, source },
+                sources,
+            }),
+        }),
+        installedExports: exportSnapshot(modules, checker),
     };
+}
+function analyzedSource(symbols, input) {
+    const { source } = symbols;
     const facts = sourceFacts(symbols);
-    const invalid = !workflowShape(source) ||
-        source.referencedFiles.length > 0 ||
+    const kind = source === input.workflow ? "workflow" : "helper";
+    const path = relative(dirname(input.workflow.fileName), source.fileName)
+        .split(sep)
+        .join("/");
+    const invalid = source.referencedFiles.length > 0 ||
         source.typeReferenceDirectives.length > 0 ||
         source.libReferenceDirectives.length > 0 ||
-        program.getSyntacticDiagnostics(source).length > 0;
+        input.program.getSyntacticDiagnostics(source).length > 0;
     return {
-        analysis: {
-            ...facts,
-            unsupportedForms: [
-                ...facts.unsupportedForms,
-                ...(invalid ? ["workflow-shape"] : []),
-                ...(facts.directEffects.length === 0 && !passiveCandidateModule(source)
-                    ? ["module-initialization"]
-                    : []),
-            ],
-        },
-        installedExports: exportSnapshot(modules, checker),
+        ...facts,
+        imports: facts.imports.map((entry) => kind === "workflow" ? entry : { ...entry, source: path }),
+        unsupportedForms: [
+            ...facts.unsupportedForms,
+            ...(invalid || (kind === "workflow" && !workflowShape(source))
+                ? ["workflow-shape"]
+                : []),
+            ...(facts.directEffects.length === 0 &&
+                !passiveCandidateModule(source, kind)
+                ? ["module-initialization"]
+                : []),
+        ],
+    };
+}
+function combineFacts(input) {
+    const { localSources, facts } = input;
+    return {
+        localSources,
+        ...(facts.some((entry) => entry.commandWaits !== undefined)
+            ? { commandWaits: facts.flatMap((entry) => entry.commandWaits ?? []) }
+            : {}),
+        imports: facts.flatMap((entry) => entry.imports),
+        effects: facts.flatMap((entry) => entry.effects),
+        directEffects: facts.flatMap((entry) => entry.directEffects),
+        unsupportedForms: [
+            ...facts.flatMap((entry) => entry.unsupportedForms),
+            ...input.expanded.unsupportedForms,
+        ],
+        knownCallCount: input.expanded.totals?.knownCallCount ??
+            facts.reduce((total, entry) => total + entry.knownCallCount, 0),
+        knownUnitTotal: input.expanded.totals?.knownUnitTotal ??
+            facts.reduce((total, entry) => total + entry.knownUnitTotal, 0),
     };
 }

package/dist/tools/workflow-candidate-syntax.d.ts

@@ -5,11 +5,17 @@ export interface CandidateSymbols {
     readonly source: ts.SourceFile;
     readonly protectedSymbol: ts.Symbol | undefined;
     readonly handoffSymbol: ts.Symbol | undefined;
+    readonly commandWaitSymbol?: ts.Symbol | undefined;
+    readonly commandSymbol: ts.Symbol | undefined;
+    readonly reviewSymbol: ts.Symbol | undefined;
+    readonly mergeSymbols: readonly ts.Symbol[];
 }
-export declare function propertyName(name: ts.PropertyName): string | undefined;
 export declare function protectedCall(node: ts.Node, symbols: CandidateSymbols): node is ts.CallExpression;
 export declare function handoffCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
+export declare function commandCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
+export declare function commandWaitCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
+export declare function reviewCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
+export declare function helperCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
+export declare function mergeCall(node: ts.CallExpression, symbols: CandidateSymbols): boolean;
 export declare function protectedEffectFact(node: ts.Node, symbols: CandidateSymbols): CandidateEffect | undefined;
 export declare function unsupportedCandidateNode(node: ts.Node, symbols: CandidateSymbols): boolean;
-export declare function workflowShape(source: ts.SourceFile): boolean;
-export declare function passiveCandidateModule(source: ts.SourceFile): boolean;

package/dist/tools/workflow-candidate-syntax.js

@@ -1,49 +1,95 @@
 import ts from "typescript";
 import { resolvedSymbol } from "./workflow-candidate-program.js";
 import { referenceSymbol } from "./workflow-source-effects.js";
-export function propertyName(name) {
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
-        return name.text;
-    return undefined;
-}
+import { invalidFields, literalField, propertyInitializer, propertyName, } from "./workflow-candidate-fields.js";
 export function protectedCall(node, symbols) {
     if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression))
         return false;
     const symbol = resolvedSymbol(symbols.checker, symbols.checker.getSymbolAtLocation(node.expression));
     return (symbol !== undefined &&
-        [symbols.protectedSymbol, symbols.handoffSymbol].includes(symbol));
+        [
+            symbols.protectedSymbol,
+            symbols.handoffSymbol,
+            symbols.commandSymbol,
+            symbols.commandWaitSymbol,
+            symbols.reviewSymbol,
+            ...symbols.mergeSymbols,
+        ].includes(symbol));
+}
+function calledSymbol(node, symbols) {
+    return resolvedSymbol(symbols.checker, symbols.checker.getSymbolAtLocation(node.expression));
 }
 export function handoffCall(node, symbols) {
-    return (symbols.handoffSymbol !== undefined &&
-        resolvedSymbol(symbols.checker, symbols.checker.getSymbolAtLocation(node.expression)) === symbols.handoffSymbol);
+    const symbol = symbols.handoffSymbol;
+    return symbol !== undefined && calledSymbol(node, symbols) === symbol;
+}
+export function commandCall(node, symbols) {
+    const symbol = symbols.commandSymbol;
+    return symbol !== undefined && calledSymbol(node, symbols) === symbol;
+}
+export function commandWaitCall(node, symbols) {
+    const symbol = symbols.commandWaitSymbol;
+    return symbol !== undefined && calledSymbol(node, symbols) === symbol;
+}
+export function reviewCall(node, symbols) {
+    const symbol = symbols.reviewSymbol;
+    return symbol !== undefined && calledSymbol(node, symbols) === symbol;
+}
+export function helperCall(node, symbols) {
+    return [handoffCall, commandCall, reviewCall, mergeCall].some((call) => call(node, symbols));
 }
-function literalField(node, field) {
-    const property = node.properties.find((entry) => entry.name && propertyName(entry.name) === field);
-    if (!property || !ts.isPropertyAssignment(property))
-        return null;
-    return ts.isStringLiteral(property.initializer)
-        ? property.initializer.text
-        : null;
+export function mergeCall(node, symbols) {
+    const symbol = calledSymbol(node, symbols);
+    return symbol !== undefined && symbols.mergeSymbols.includes(symbol);
 }
 export function protectedEffectFact(node, symbols) {
     if (!protectedCall(node, symbols))
         return undefined;
-    if (handoffCall(node, symbols))
+    if (handoffCall(node, symbols) || commandWaitCall(node, symbols))
         return undefined;
     const argument = node.arguments[0];
     if (!argument || !ts.isObjectLiteralExpression(argument))
         return undefined;
+    if (reviewCall(node, symbols))
+        return reviewEffectFact(propertyInitializer(argument, "reviewer"));
+    if (mergeCall(node, symbols))
+        return { capability: "github", method: "merge" };
+    if (commandCall(node, symbols)) {
+        const name = literalField(argument, "name");
+        return {
+            capability: "command",
+            method: name === null ? null : `run:${name}`,
+        };
+    }
     return {
         capability: literalField(argument, "capability"),
         method: literalField(argument, "method"),
     };
 }
+function reviewEffectFact(reviewer) {
+    const kind = literalField(reviewer, "kind");
+    if (kind === "greptile")
+        return { capability: "github", method: "wait-review" };
+    const profile = literalField(reviewer, "profile");
+    if (kind === "turn" &&
+        profile !== null &&
+        /^[A-Za-z0-9_-]{1,119}$/.test(profile))
+        return { capability: "claude", method: `run-turn:${profile}` };
+    return { capability: null, method: null };
+}
 function escapedHelper(node, symbols) {
     if (!ts.isIdentifier(node))
         return false;
     const symbol = resolvedSymbol(symbols.checker, referenceSymbol(node, { parent: node.parent, checker: symbols.checker }));
     if (symbol === undefined ||
-        ![symbols.protectedSymbol, symbols.handoffSymbol].includes(symbol))
+        ![
+            symbols.protectedSymbol,
+            symbols.handoffSymbol,
+            symbols.commandSymbol,
+            symbols.commandWaitSymbol,
+            symbols.reviewSymbol,
+            ...symbols.mergeSymbols,
+        ].includes(symbol))
         return false;
     if (ts.isImportSpecifier(node.parent))
         return false;
@@ -71,10 +117,26 @@ function invalidRequest(node, symbols) {
         !argument ||
         !ts.isObjectLiteralExpression(argument))
         return true;
-    const names = argument.properties.map((entry) => entry.name && propertyName(entry.name));
-    return (names.includes(undefined) ||
-        new Set(names).size !== names.length ||
-        argument.properties.some((entry) => !ts.isPropertyAssignment(entry)));
+    const reviewer = reviewCall(node, symbols)
+        ? propertyInitializer(argument, "reviewer")
+        : undefined;
+    return (invalidFields(argument) ||
+        invalidCommandWaitFields(node, symbols) ||
+        invalidReviewer(reviewer));
+}
+function invalidReviewer(reviewer) {
+    return (reviewer !== undefined &&
+        ts.isObjectLiteralExpression(reviewer) &&
+        invalidFields(reviewer));
+}
+function invalidCommandWaitFields(node, symbols) {
+    if (!commandWaitCall(node, symbols))
+        return false;
+    const argument = node.arguments[0];
+    return (!!argument &&
+        ts.isObjectLiteralExpression(argument) &&
+        argument.properties.some((entry) => entry.name &&
+            !["name", "input"].includes(propertyName(entry.name) ?? "")));
 }
 function workflowBodyCall(node) {
     let child = node;
@@ -129,91 +191,3 @@ export function unsupportedCandidateNode(node, symbols) {
     ];
     return checks.some(Boolean);
 }
-export function workflowShape(source) {
-    const exported = source.statements.filter((node) => ts.isFunctionDeclaration(node) &&
-        (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
-    const candidate = exported[0];
-    if (exported.length !== 1 ||
-        !candidate ||
-        !ts.isFunctionDeclaration(candidate))
-        return false;
-    if (!workflowFunction(candidate))
-        return false;
-    const directives = [];
-    function visit(node) {
-        if (ts.isStringLiteral(node) && node.text === "use workflow")
-            directives.push(node);
-        ts.forEachChild(node, visit);
-    }
-    visit(source);
-    return directives.length === 1;
-}
-function workflowFunction(candidate) {
-    if (!candidate.name || !candidate.body || candidate.asteriskToken)
-        return false;
-    const modifiers = ts.getModifiers(candidate) ?? [];
-    if (!modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ||
-        modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword))
-        return false;
-    const first = candidate.body.statements[0];
-    return first !== undefined && workflowDirective(first);
-}
-function workflowDirective(node) {
-    return (ts.isExpressionStatement(node) &&
-        ts.isStringLiteral(node.expression) &&
-        node.expression.text === "use workflow");
-}
-function unwrappedInitializer(node) {
-    if (ts.isParenthesizedExpression(node) ||
-        ts.isAsExpression(node) ||
-        ts.isSatisfiesExpression(node) ||
-        ts.isTypeAssertionExpression(node))
-        return node.expression;
-    return undefined;
-}
-function passiveCompound(node) {
-    if (ts.isArrayLiteralExpression(node))
-        return node.elements.every((element) => ts.isOmittedExpression(element) || passiveInitializer(element));
-    if (ts.isObjectLiteralExpression(node))
-        return node.properties.every((property) => ts.isPropertyAssignment(property) &&
-            !ts.isComputedPropertyName(property.name) &&
-            passiveInitializer(property.initializer));
-    return false;
-}
-function passiveInitializer(node) {
-    if (!node)
-        return false;
-    if (ts.isLiteralExpression(node))
-        return true;
-    if ([
-        ts.SyntaxKind.TrueKeyword,
-        ts.SyntaxKind.FalseKeyword,
-        ts.SyntaxKind.NullKeyword,
-    ].includes(node.kind))
-        return true;
-    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
-        return true;
-    if (ts.isPrefixUnaryExpression(node))
-        return ([ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(node.operator) && ts.isNumericLiteral(node.operand));
-    const inner = unwrappedInitializer(node);
-    return inner ? passiveInitializer(inner) : passiveCompound(node);
-}
-function passiveStatement(node) {
-    if (ts.isVariableStatement(node))
-        return ((node.declarationList.flags & ts.NodeFlags.Const) !== 0 &&
-            node.declarationList.declarations.every((declaration) => (ts.getCombinedModifierFlags(declaration) &
-                ts.ModifierFlags.Export) ===
-                0 &&
-                ts.isIdentifier(declaration.name) &&
-                passiveInitializer(declaration.initializer)));
-    if (ts.isExpressionStatement(node))
-        return ts.isStringLiteral(node.expression);
-    return (ts.isImportDeclaration(node) ||
-        ts.isTypeAliasDeclaration(node) ||
-        ts.isInterfaceDeclaration(node) ||
-        ts.isFunctionDeclaration(node) ||
-        ts.isEmptyStatement(node));
-}
-export function passiveCandidateModule(source) {
-    return source.statements.every(passiveStatement);
-}

package/dist/tools/workflow-command.d.ts

@@ -0,0 +1 @@
+export declare function workflowCommand(argumentsList: readonly string[]): Promise<number>;

package/dist/tools/workflow-command.js

@@ -0,0 +1,142 @@
+import { absoluteWorkflowFolder } from "../src/project-settings.js";
+import { projectConfiguration, projectRoot } from "./project-configuration.js";
+import { spawn } from "node:child_process";
+import { lstat, mkdtemp, rm } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { workflowTestLoader } from "./workflow-test-loader.js";
+import { preparedProject } from "./self-host-project.js";
+const usage = "Usage: cloving workflows list [--json] [--repository <directory>]\n       cloving workflows test [<id>] [--repository <directory>]\n";
+function invocation(argumentsList) {
+    const { values, positionals } = parseArgs({
+        args: [...argumentsList],
+        allowPositionals: true,
+        options: {
+            json: { type: "boolean" },
+            repository: { type: "string" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    const [command, id, ...extra] = positionals;
+    if (extra.length > 0 || (command === "list" && id !== undefined))
+        throw new Error("unexpected-argument");
+    if (command !== "list" && command !== "test")
+        throw new Error("unknown-command");
+    if (command === "test" && values.json)
+        throw new Error("unexpected-option");
+    return { ...values, command, id };
+}
+export async function workflowCommand(argumentsList) {
+    let selected;
+    try {
+        selected = invocation(argumentsList);
+    }
+    catch {
+        process.stderr.write("invalid-invocation: " + usage);
+        return 2;
+    }
+    if (selected.help) {
+        process.stdout.write(usage);
+        return 0;
+    }
+    const temporary = await mkdtemp(join(tmpdir(), "cloving-workflows-"));
+    try {
+        const repository = resolve(selected.repository ?? process.cwd());
+        const result = await preparedProject({
+            product: resolve(import.meta.dirname, ".."),
+            project: join(temporary, "project"),
+            repository,
+            home: homedir(),
+            xdgConfigHome: process.env["XDG_CONFIG_HOME"],
+            userFolder: absoluteWorkflowFolder((await projectConfiguration(await projectRoot(repository), process.env))
+                .environment["CLOVING_WORKFLOW_FOLDER"]),
+        });
+        if (selected.command === "test")
+            return await testWorkflows(result.workflows, {
+                id: selected.id,
+                repository,
+            });
+        presentWorkflows(result.workflows, { json: selected.json === true });
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write("workflow-inspection-failed: " +
+            (error instanceof Error ? error.message : "unavailable") +
+            "\n");
+        return 1;
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+function presentWorkflows(workflows, options) {
+    if (options.json) {
+        process.stdout.write(JSON.stringify(workflows) + "\n");
+        return;
+    }
+    for (const workflow of workflows)
+        process.stdout.write(`${workflow.workflowId ?? "unknown"} (${workflow.scope}, ${workflow.admitted ? "admitted" : "refused: " + workflow.codes.join(", ")}) ${JSON.stringify(workflow.file)}\n`);
+}
+async function testWorkflows(workflows, options) {
+    const { id, repository } = options;
+    const selected = workflows.filter((workflow) => id === undefined || workflow.workflowId === id);
+    if (id !== undefined &&
+        !workflows.some((workflow) => workflow.workflowId === id)) {
+        process.stderr.write("unknown-workflow: " + id + "\n");
+        return 1;
+    }
+    const files = [];
+    for (const workflow of selected) {
+        const file = workflow.file.replace(/\.ts$/, ".test.ts");
+        const exists = await lstat(file).catch((error) => {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                return undefined;
+            throw error;
+        });
+        if (exists?.isFile())
+            files.push(file);
+    }
+    if (files.length === 0) {
+        process.stderr.write("workflow-test-missing: " + (id ?? "no project or user tests") + "\n");
+        return 1;
+    }
+    return await runTests(files, repository);
+}
+function runTests(files, repository) {
+    return new Promise((settle, reject) => {
+        const child = spawn(process.execPath, [
+            "--experimental-strip-types",
+            "--import",
+            workflowTestLoader(),
+            "--test",
+            ...files,
+        ], {
+            cwd: repository,
+            stdio: "inherit",
+            env: { ...process.env, NODE_TEST_CONTEXT: undefined },
+        });
+        const interrupt = () => {
+            child.kill("SIGINT");
+        };
+        const terminate = () => {
+            child.kill("SIGTERM");
+        };
+        process.on("SIGINT", interrupt);
+        process.on("SIGTERM", terminate);
+        const cleanup = () => {
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", terminate);
+        };
+        child.once("error", (error) => {
+            cleanup();
+            reject(error);
+        });
+        child.once("close", (code) => {
+            cleanup();
+            settle(code ?? 1);
+        });
+    });
+}
+if (process.argv[1] === import.meta.filename)
+    process.exitCode = await workflowCommand(process.argv.slice(2));

package/dist/tools/workflow-folder-capture.d.ts

@@ -11,6 +11,7 @@ export declare function inspectWorkflowFolder(root: string, parts: readonly stri
 export declare function captureWorkflowCandidate(folder: WorkflowFolder, name: string): Promise<{
     source: string | undefined;
     declaration: string | undefined;
+    helpers: Record<string, string>;
     codes: WorkflowCaptureCode[];
 }>;
 export declare function workflowCaptureFailure(error: unknown): WorkflowCaptureCode;