cloving 1.2.0 → 1.3.0

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

@@ -1,8 +1,10 @@
 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 { 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);
@@ -68,8 +70,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 +99,71 @@ export function analyzeWorkflowCandidate(text, installed = {}) {
             subpath: "cloving/workflows/steps/handoff",
             name: "handoff",
         }),
+        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,
+        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 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 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;
+export declare function passiveCandidateModule(source: ts.SourceFile, kind?: "workflow" | "helper"): boolean;

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

@@ -1,29 +1,41 @@
 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, } 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.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;
 }
-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 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));
+}
+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))
@@ -33,17 +45,45 @@ export function protectedEffectFact(node, symbols) {
     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.reviewSymbol,
+            ...symbols.mergeSymbols,
+        ].includes(symbol))
         return false;
     if (ts.isImportSpecifier(node.parent))
         return false;
@@ -71,10 +111,13 @@ 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) ||
+        (reviewer !== undefined &&
+            ts.isObjectLiteralExpression(reviewer) &&
+            invalidFields(reviewer)));
 }
 function workflowBodyCall(node) {
     let child = node;
@@ -198,12 +241,13 @@ function passiveInitializer(node) {
     const inner = unwrappedInitializer(node);
     return inner ? passiveInitializer(inner) : passiveCompound(node);
 }
-function passiveStatement(node) {
+function passiveStatement(node, kind) {
     if (ts.isVariableStatement(node))
         return ((node.declarationList.flags & ts.NodeFlags.Const) !== 0 &&
-            node.declarationList.declarations.every((declaration) => (ts.getCombinedModifierFlags(declaration) &
-                ts.ModifierFlags.Export) ===
-                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))
@@ -214,6 +258,6 @@ function passiveStatement(node) {
         ts.isFunctionDeclaration(node) ||
         ts.isEmptyStatement(node));
 }
-export function passiveCandidateModule(source) {
-    return source.statements.every(passiveStatement);
+export function passiveCandidateModule(source, kind = "workflow") {
+    return source.statements.every((node) => passiveStatement(node, kind));
 }

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,143 @@
+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) => workflow.scope !== "bundled" &&
+        (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;

package/dist/tools/workflow-folder-capture.js

@@ -1,6 +1,8 @@
 import { constants } from "node:fs";
 import { lstat, open, readdir, realpath, } from "node:fs/promises";
 import { isAbsolute, join, relative, sep } from "node:path";
+import ts from "typescript";
+import { workflowHelperPath } from "../src/workflow-candidate.js";
 function contained(root, path) {
     const suffix = relative(root, path);
     return (!isAbsolute(suffix) && suffix !== ".." && !suffix.startsWith(`..${sep}`));
@@ -92,6 +94,19 @@ async function openSource(folder, name) {
     }
 }
 async function inspectFile(folder, name) {
+    const parts = name.split("/");
+    const fileName = parts.pop();
+    if (!fileName || parts.some((part) => !safeComponent(part)))
+        throw new Error("unsafe-workflow-path");
+    let parent = folder;
+    for (const part of parts) {
+        const path = join(parent.path, part);
+        const stats = await lstat(path, { bigint: true });
+        if (!stats.isDirectory())
+            throw new Error("unsafe-workflow-path");
+        parent = { path, components: [...parent.components, { path, stats }] };
+    }
+    await verifyFolder(parent);
     const path = join(folder.path, name);
     const stats = await lstat(path, { bigint: true });
     if (!stats.isFile())
@@ -101,11 +116,12 @@ async function inspectFile(folder, name) {
         throw new Error("workflow-source-changed");
     if (!contained(folder.path, resolved))
         throw new Error("unsafe-workflow-path");
-    return { path, name, stats };
+    return { path, name, stats, folder: parent, fileName };
 }
 async function captureFile(folder, file) {
     const { stats } = file;
-    const handle = await openSource(folder, file.name).catch(changedPathError);
+    await verifyFolder(folder);
+    const handle = await openSource(file.folder, file.fileName).catch(changedPathError);
     try {
         if (!sameSnapshot(stats, await handle.stat({ bigint: true })))
             throw new Error("workflow-source-changed");
@@ -140,11 +156,38 @@ async function captureFiles(folder, names) {
         }
     }
     for (const file of captured) {
+        await verifyFolder(file.folder);
         if (!sameSnapshot(file.stats, await capturedStats(file.path)))
             throw new Error("workflow-source-changed");
     }
     return { captured, codes };
 }
+async function captureImports(folder, snapshot) {
+    const { captured, codes } = snapshot;
+    const helpers = {};
+    for (const source of captured) {
+        if (!source.name.endsWith(".ts"))
+            continue;
+        for (const imported of ts.preProcessFile(source.bytes.toString("utf8"))
+            .importedFiles) {
+            const name = workflowHelperPath(source.name, imported.fileName);
+            if (!name || captured.some((file) => file.name === name))
+                continue;
+            const result = await captureFiles(folder, [name]);
+            codes.push(...result.codes);
+            captured.push(...result.captured);
+            const text = decodedFile({ bytes: result.captured[0]?.bytes, code: "unsupported-source" }, codes);
+            if (text !== undefined)
+                helpers[name] = text;
+        }
+    }
+    for (const file of captured) {
+        await verifyFolder(file.folder);
+        if (!sameSnapshot(file.stats, await capturedStats(file.path)))
+            throw new Error("workflow-source-changed");
+    }
+    return helpers;
+}
 function decodedFile(input, codes) {
     if (input.bytes === undefined)
         return undefined;
@@ -163,6 +206,7 @@ export async function captureWorkflowCandidate(folder, name) {
         name,
         declarationName,
     ]);
+    const helpers = await captureImports(folder, { captured, codes });
     await verifyFolder(folder);
     const source = decodedFile({
         bytes: captured.find((file) => file.name === name)?.bytes,
@@ -175,6 +219,7 @@ export async function captureWorkflowCandidate(folder, name) {
     return {
         source,
         declaration,
+        helpers,
         codes: [
             ...new Set(codes.includes("unsafe-workflow-path")
                 ? codes.filter((code) => code !== "workflow-read-failed")

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

@@ -1,4 +1,5 @@
-import type { WorkflowCandidateCode } from "../src/workflow-candidate.ts";
+import type { WorkflowDeclaration } from "../src/workflow-declaration.ts";
+import { type CandidateDeclaration, type WorkflowCandidateCode } from "../src/workflow-candidate.ts";
 import { type WorkflowConflictCode, type WorkflowReservation } from "../src/workflow-discovery.ts";
 import type { CandidatePackageOptions } from "./workflow-candidate-program.ts";
 import { type WorkflowCaptureCode } from "./workflow-folder-capture.ts";
@@ -6,6 +7,7 @@ export interface WorkflowFolderInput {
     readonly repository: string;
     readonly home: string;
     readonly xdgConfigHome?: string | undefined;
+    readonly userFolder?: string | undefined;
     readonly bundled: readonly WorkflowReservation[];
 }
 interface WorkflowLabel {
@@ -16,6 +18,7 @@ interface WorkflowSnapshot extends WorkflowLabel {
     readonly baseName: string;
     readonly source: string;
     readonly declaration: string;
+    readonly helpers: Readonly<Record<string, string>>;
 }
 export interface WorkflowFolderCandidate extends WorkflowSnapshot {
     readonly repository: string;
@@ -24,10 +27,23 @@ export interface WorkflowFolderCandidate extends WorkflowSnapshot {
 export interface WorkflowFolderRefusal extends WorkflowLabel {
     readonly codes: readonly (WorkflowCandidateCode | WorkflowCaptureCode | WorkflowConflictCode | "compile-failed")[];
 }
+export interface WorkflowListing {
+    readonly scope: "bundled" | "project" | "user";
+    readonly workflowId: string | null;
+    readonly file: string;
+    readonly admitted: boolean;
+    readonly codes: readonly string[];
+    readonly declaration?: CandidateDeclaration | WorkflowDeclaration;
+}
 export interface WorkflowFolderResult {
+    readonly workflows: readonly WorkflowListing[];
     readonly repository: string;
     readonly candidates: readonly WorkflowFolderCandidate[];
     readonly refusals: readonly WorkflowFolderRefusal[];
 }
+export declare function userLocation(input: Pick<WorkflowFolderInput, "home" | "xdgConfigHome" | "userFolder">): {
+    readonly root: string;
+    readonly parts: readonly string[];
+};
 export declare function loadWorkflowFolders(input: WorkflowFolderInput, installed?: CandidatePackageOptions): Promise<WorkflowFolderResult>;
 export {};