akm-cli 0.8.7 → 0.8.14

package/dist/commands/wiki-cli.js

@@ -0,0 +1,307 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * `akm wiki` command family. Extracted verbatim from src/cli.ts (WS6) so the
+ * God Module shrinks; the `main.subCommands.wiki` key and every subcommand's
+ * args/output shape are byte-identical. Handlers whose body is a plain
+ * `runWithJsonErrors(...) + output(...)` are migrated to `defineJsonCommand`,
+ * which emits the same JSON envelope (stdout/stderr/exit-code) as the inline
+ * form. `wiki lint` keeps an explicit `runWithJsonErrors` because it calls
+ * `process.exit(1)` after the wrapper when findings exist.
+ */
+import { defineCommand } from "citty";
+import { getStringArg, hasSubcommand, parsePositiveIntFlag } from "../cli/parse-args.js";
+import { defineJsonCommand, output, runWithJsonErrors } from "../cli/shared.js";
+import { isHttpUrl, resolveStashDir } from "../core/common.js";
+import { loadConfig, resolveConfiguredSources } from "../core/config/config.js";
+import { ConfigError, UsageError } from "../core/errors.js";
+import { getHyphenatedArg, getHyphenatedBoolean } from "../output/context.js";
+import { akmAgentDispatch } from "./agent/agent-dispatch.js";
+import { readKnowledgeInput } from "./read/knowledge.js";
+import { buildWebsiteOptions } from "./sources/add-cli.js";
+const wikiCreateCommand = defineJsonCommand({
+    meta: { name: "create", description: "Scaffold a new wiki under <stashDir>/wikis/<name>/" },
+    args: {
+        name: { type: "positional", description: "Wiki name (lowercase, digits, hyphens)", required: true },
+    },
+    async run({ args }) {
+        const { createWiki } = await import("../wiki/wiki.js");
+        const stashDir = resolveStashDir();
+        const result = createWiki(stashDir, args.name);
+        output("wiki-create", result);
+    },
+});
+const wikiRegisterCommand = defineJsonCommand({
+    meta: {
+        name: "register",
+        description: "Register an existing directory or repo as a first-class wiki without copying or mutating it; refreshes source and wiki search state immediately",
+    },
+    args: {
+        name: { type: "positional", description: "Wiki name (lowercase, digits, hyphens)", required: true },
+        ref: { type: "positional", description: "Path or repo ref for the external wiki source", required: true },
+        writable: {
+            type: "boolean",
+            description: "Mark a git-backed source as writable so changes can be pushed back",
+            default: false,
+        },
+        "max-pages": { type: "string", description: "Maximum pages to crawl for website sources (default: 50)" },
+        "max-depth": { type: "string", description: "Maximum crawl depth for website sources (default: 3)" },
+    },
+    async run({ args }) {
+        const { registerWikiSource } = await import("./sources/source-add.js");
+        const result = await registerWikiSource({
+            ref: args.ref.trim(),
+            name: args.name,
+            options: Object.keys(buildWebsiteOptions(args)).length > 0 ? buildWebsiteOptions(args) : undefined,
+            writable: args.writable,
+        });
+        output("wiki-register", result);
+    },
+});
+const wikiListCommand = defineJsonCommand({
+    meta: { name: "list", description: "List wikis with page/raw counts and last-modified timestamps" },
+    async run() {
+        const { listWikis } = await import("../wiki/wiki.js");
+        const stashDir = resolveStashDir();
+        const wikis = listWikis(stashDir);
+        output("wiki-list", { wikis });
+    },
+});
+const wikiShowCommand = defineJsonCommand({
+    meta: { name: "show", description: "Show a wiki's path, description, counts, and last 3 log entries" },
+    args: {
+        name: { type: "positional", description: "Wiki name", required: true },
+    },
+    async run({ args }) {
+        const { showWiki } = await import("../wiki/wiki.js");
+        const stashDir = resolveStashDir();
+        const result = showWiki(stashDir, args.name);
+        output("wiki-show", result);
+    },
+});
+const wikiRemoveCommand = defineJsonCommand({
+    meta: {
+        name: "remove",
+        description: "Remove a wiki and refresh the index. Preserves raw/ by default; pass --with-sources to also delete raw/",
+    },
+    args: {
+        name: { type: "positional", description: "Wiki name", required: true },
+        yes: {
+            type: "boolean",
+            alias: "y",
+            description: "Skip confirmation prompt (required in non-interactive shells)",
+            default: false,
+        },
+        "with-sources": {
+            type: "boolean",
+            description: "Also delete the raw/ directory (immutable ingested sources)",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const { confirmDestructive } = await import("../cli/confirm.js");
+        const confirmed = await confirmDestructive(`Remove wiki "${args.name}"? This cannot be undone.`, {
+            yes: args.yes === true,
+        });
+        if (!confirmed) {
+            process.stderr.write("Aborted.\n");
+            return;
+        }
+        const withSources = getHyphenatedBoolean(args, "with-sources");
+        const { removeWiki } = await import("../wiki/wiki.js");
+        const { akmIndex } = await import("../indexer/indexer.js");
+        const stashDir = resolveStashDir();
+        const result = removeWiki(stashDir, args.name, { withSources });
+        await akmIndex({ stashDir });
+        output("wiki-remove", result);
+    },
+});
+const wikiPagesCommand = defineJsonCommand({
+    meta: {
+        name: "pages",
+        description: "List wiki pages (ref + frontmatter description), excluding schema/index/log/raw",
+    },
+    args: {
+        name: { type: "positional", description: "Wiki name", required: true },
+    },
+    async run({ args }) {
+        const { listPages } = await import("../wiki/wiki.js");
+        const stashDir = resolveStashDir();
+        const pages = listPages(stashDir, args.name);
+        output("wiki-pages", { wiki: args.name, pages });
+    },
+});
+const wikiSearchCommand = defineJsonCommand({
+    meta: {
+        name: "search",
+        description: "Search wiki pages within a single wiki (scoped wrapper over `akm search --type wiki`; excludes raw/schema/index/log and returns canonical wiki refs)",
+    },
+    args: {
+        name: { type: "positional", description: "Wiki name", required: true },
+        query: { type: "positional", description: "Search query", required: true },
+        limit: { type: "string", description: "Max hits (default 20)", required: false },
+    },
+    async run({ args }) {
+        const { resolveWikiSource, searchInWiki } = await import("../wiki/wiki.js");
+        const stashDir = resolveStashDir();
+        resolveWikiSource(stashDir, args.name);
+        const parsedLimit = args.limit ? Number(args.limit) : undefined;
+        const limit = typeof parsedLimit === "number" && Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : undefined;
+        const response = await searchInWiki({ stashDir, wikiName: args.name, query: args.query, limit });
+        output("search", response);
+    },
+});
+const wikiStashCommand = defineJsonCommand({
+    meta: {
+        name: "stash",
+        description: "Copy a source into wikis/<name>/raw/<slug>.md with frontmatter. Source may be a file path, URL, or '-' for stdin.",
+    },
+    args: {
+        name: { type: "positional", description: "Wiki name", required: true },
+        source: { type: "positional", description: "Source file path, URL, or '-' to read from stdin", required: true },
+        as: { type: "string", description: "Preferred slug base (defaults to source filename or first-line slug)" },
+        target: {
+            type: "string",
+            description: "Name of a writable stash source to write into instead of the default stash. Must match a configured source name (run `akm list` to see sources).",
+        },
+    },
+    async run({ args }) {
+        const { stashRaw } = await import("../wiki/wiki.js");
+        const { content, preferredName } = await (async () => {
+            if (!isHttpUrl(args.source))
+                return readKnowledgeInput(args.source);
+            const { fetchWebsiteMarkdownSnapshot } = await import("../sources/website-ingest.js");
+            const snapshot = await fetchWebsiteMarkdownSnapshot(args.source);
+            return { content: snapshot.content, preferredName: args.as ?? snapshot.preferredName };
+        })();
+        let stashDir;
+        if (args.target) {
+            // Resolve the named source to its filesystem path.
+            const cfg = loadConfig();
+            const sources = resolveConfiguredSources(cfg);
+            const match = sources.find((s) => s.name === args.target);
+            if (!match) {
+                throw new UsageError(`--target must reference a configured source name. No source named "${args.target}" found. Run \`akm list\` to see available sources.`, "INVALID_FLAG_VALUE");
+            }
+            const spec = match.source;
+            if (spec.type !== "filesystem" && spec.type !== "local") {
+                throw new ConfigError(`Source "${args.target}" is not a filesystem source and cannot be used as a wiki stash target.`, "INVALID_CONFIG_FILE", `Use a source with type "filesystem" or "local", or omit --target to use the default stash.`);
+            }
+            stashDir = spec.path;
+        }
+        else {
+            stashDir = resolveStashDir();
+        }
+        const result = stashRaw({
+            stashDir,
+            wikiName: args.name,
+            content,
+            preferredName: args.as ?? preferredName,
+            explicitSlug: args.as !== undefined,
+        });
+        output("wiki-stash", { ok: true, wiki: args.name, source: args.source, ...result });
+    },
+});
+const wikiLintCommand = defineCommand({
+    meta: {
+        name: "lint",
+        description: "Structural lint for a wiki: orphans, broken xrefs, missing descriptions, uncited raws, stale index",
+    },
+    args: {
+        name: { type: "positional", description: "Wiki name", required: true },
+    },
+    async run({ args }) {
+        let findingCount = 0;
+        await runWithJsonErrors(async () => {
+            const { lintWiki } = await import("../wiki/wiki.js");
+            const stashDir = resolveStashDir();
+            const report = lintWiki(stashDir, args.name);
+            output("wiki-lint", report);
+            findingCount = report.findings.length;
+        });
+        if (findingCount > 0)
+            process.exit(1); // EXIT_GENERAL
+    },
+});
+const wikiIngestCommand = defineJsonCommand({
+    meta: {
+        name: "ingest",
+        description: "Dispatch an agent to execute the ingest workflow for this wiki. Uses --profile or config.defaults.agent.",
+    },
+    args: {
+        name: { type: "positional", description: "Wiki name", required: true },
+        profile: {
+            type: "string",
+            description: "Agent profile to use (default: config.defaults.agent).",
+        },
+        model: {
+            type: "string",
+            description: "Model override — accepts aliases (opus, sonnet, haiku) or exact platform model IDs.",
+        },
+        "timeout-ms": { type: "string", description: "Override the agent CLI timeout in milliseconds." },
+    },
+    async run({ args }) {
+        const { buildIngestWorkflow } = await import("../wiki/wiki.js");
+        const stashDir = resolveStashDir();
+        const built = buildIngestWorkflow(stashDir, args.name);
+        const config = loadConfig();
+        const profileName = getStringArg(args, "profile") ?? config.defaults?.agent;
+        if (!profileName) {
+            throw new UsageError("akm wiki ingest requires an agent profile. Pass --profile <name> or set defaults.agent in config.", "MISSING_REQUIRED_ARGUMENT", "Available profiles are listed under profiles.agent in your config. Run `akm config get profiles.agent` to inspect.");
+        }
+        const timeoutMs = parsePositiveIntFlag(getHyphenatedArg(args, "timeout-ms"), "--timeout-ms");
+        const model = getStringArg(args, "model");
+        const { getDefaultLlmConfig } = await import("../core/config/config.js");
+        const dispatchResult = await akmAgentDispatch({
+            profileName,
+            agentConfig: config,
+            llmConfig: getDefaultLlmConfig(config),
+            prompt: built.workflow,
+            dispatch: {
+                prompt: built.workflow,
+                ...(model !== undefined ? { model } : {}),
+            },
+            ...(timeoutMs !== undefined && Number.isFinite(timeoutMs) ? { timeoutMs } : {}),
+        });
+        output("wiki-ingest", {
+            wiki: built.wiki,
+            path: built.path,
+            schemaPath: built.schemaPath,
+            dispatched: true,
+            profile: profileName,
+            agentResult: dispatchResult,
+        });
+    },
+});
+// Single source of truth: the routing set is derived from the subCommands keys
+// (M10) so adding a subcommand can never silently desync from `hasSubcommand`.
+const wikiSubCommands = {
+    create: wikiCreateCommand,
+    register: wikiRegisterCommand,
+    list: wikiListCommand,
+    show: wikiShowCommand,
+    remove: wikiRemoveCommand,
+    pages: wikiPagesCommand,
+    search: wikiSearchCommand,
+    stash: wikiStashCommand,
+    lint: wikiLintCommand,
+    ingest: wikiIngestCommand,
+};
+const WIKI_SUBCOMMAND_SET = new Set(Object.keys(wikiSubCommands));
+export const wikiCommand = defineCommand({
+    meta: {
+        name: "wiki",
+        description: "Manage multiple markdown wikis (Karpathy-style). akm surfaces (lifecycle, raw/, lint, index); the agent writes pages.",
+    },
+    subCommands: wikiSubCommands,
+    run({ args }) {
+        return runWithJsonErrors(async () => {
+            if (hasSubcommand(args, WIKI_SUBCOMMAND_SET))
+                return;
+            // Default action: list wikis
+            const { listWikis } = await import("../wiki/wiki.js");
+            output("wiki-list", { wikis: listWikis(resolveStashDir()) });
+        });
+    },
+});

package/dist/commands/workflow-cli.js

@@ -0,0 +1,329 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * `akm workflow` command family. Extracted verbatim from src/cli.ts (WS6) so the
+ * God Module shrinks; the `main.subCommands.workflow` key and every subcommand's
+ * args/output shape are byte-identical. Handlers whose body is a plain
+ * `runWithJsonErrors(...) + output(...)` are migrated to `defineJsonCommand`,
+ * which emits the same JSON envelope (stdout/stderr/exit-code) as the inline
+ * form. `workflow template` keeps a plain `defineCommand` because it writes the
+ * template straight to stdout with no JSON envelope. The private helpers
+ * `looksLikeWorkflowRunId` and `resolveWorkflowFilePath` move with the family.
+ */
+import { defineCommand } from "citty";
+import { defineJsonCommand, output, runWithJsonErrors } from "../cli/shared.js";
+import { assertFlatAssetName, combineCreatePath, normalizeCreateSubPath } from "../core/asset/asset-create.js";
+import { parseAssetRef } from "../core/asset/asset-ref.js";
+import { loadConfig } from "../core/config/config.js";
+import { NotFoundError, UsageError } from "../core/errors.js";
+import { akmIndex } from "../indexer/indexer.js";
+import { resolveSourceEntries } from "../indexer/search/search-source.js";
+import { hasBooleanFlag } from "../output/context.js";
+import { resolveSourcesForOrigin } from "../registry/origin-resolve.js";
+import { resolveAssetPath } from "../sources/resolve.js";
+import { createWorkflowAsset, formatWorkflowErrors, getWorkflowTemplate, validateWorkflowSource, } from "../workflows/authoring/authoring.js";
+import { hasWorkflowSubcommand, parseWorkflowJsonObject, parseWorkflowStepState, WORKFLOW_STEP_STATES, } from "../workflows/cli.js";
+import { completeWorkflowStep, getNextWorkflowStep, getWorkflowStatus, listWorkflowRuns, resumeWorkflowRun, startWorkflowRun, } from "../workflows/runtime/runs.js";
+const workflowStartCommand = defineJsonCommand({
+    meta: {
+        name: "start",
+        description: "Start a new workflow run in the current working scope",
+    },
+    args: {
+        ref: { type: "positional", description: "Workflow ref (workflow:<name>)", required: true },
+        params: { type: "string", description: "Workflow parameters as a JSON object" },
+        force: {
+            type: "boolean",
+            description: "Allow a parallel run when an active run already exists in this scope (#485)",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const result = await startWorkflowRun(args.ref, parseWorkflowJsonObject(args.params, "--params"), {
+            force: args.force === true,
+        });
+        output("workflow-start", result);
+    },
+});
+const workflowNextCommand = defineJsonCommand({
+    meta: {
+        name: "next",
+        description: "Show the next actionable workflow step in the current scope, auto-starting a run when passed a workflow ref",
+    },
+    args: {
+        target: { type: "positional", description: "Workflow run id or workflow ref", required: true },
+        params: { type: "string", description: "Workflow parameters as a JSON object (only for auto-started runs)" },
+    },
+    async run({ args }) {
+        // `--dry-run` is intentionally NOT a declared arg (so it stays out of
+        // --help). The guard reads it straight from process.argv so existing
+        // callers still get a clear, actionable error instead of a generic
+        // "unknown flag" from citty.
+        if (hasBooleanFlag(process.argv, "--dry-run")) {
+            throw new UsageError("`akm workflow next` does not support --dry-run. Remove the flag to start or resume a run.", "INVALID_FLAG_VALUE");
+        }
+        const parsedParams = args.params ? parseWorkflowJsonObject(args.params, "--params") : undefined;
+        // If the target looks like a UUID-style run id (no `:` and matches the
+        // run-id shape), short-circuit with a structured WORKFLOW_NOT_FOUND
+        // error before parseAssetRef gets to throw an unhelpful ref-parse error.
+        if (looksLikeWorkflowRunId(args.target)) {
+            const { hasWorkflowRun } = await import("../workflows/runtime/runs.js");
+            if (!(await hasWorkflowRun(args.target))) {
+                throw new NotFoundError(`Workflow run "${args.target}" not found.`, "WORKFLOW_NOT_FOUND", "Run `akm workflow list --active` to see runs.");
+            }
+        }
+        const result = await getNextWorkflowStep(args.target, parsedParams);
+        output("workflow-next", result);
+    },
+});
+/**
+ * Heuristic: a workflow run id is a UUID-shaped or hex-id-shaped string with
+ * no `:` separator (refs always contain a colon: `workflow:<name>` or
+ * `<origin>//workflow:<name>`). When this matches we can give a much better
+ * error than parseAssetRef's "Invalid asset type" failure.
+ */
+function looksLikeWorkflowRunId(target) {
+    if (target.includes(":"))
+        return false;
+    if (target.includes("/"))
+        return false;
+    // UUID v4-ish: 8-4-4-4-12 hex digits separated by dashes.
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(target))
+        return true;
+    // Bare hex/alphanumeric run ids of >=8 chars (covers shortened ids).
+    if (/^[0-9a-z][0-9a-z_-]{7,}$/i.test(target) && /[0-9]/.test(target))
+        return true;
+    return false;
+}
+const workflowCompleteCommand = defineJsonCommand({
+    meta: {
+        name: "complete",
+        description: "Update a workflow step state and persist notes/evidence",
+    },
+    args: {
+        runId: { type: "positional", description: "Workflow run id", required: true },
+        step: { type: "string", description: "Workflow step id", required: true },
+        state: {
+            type: "string",
+            description: `Step state (default: completed). One of: ${WORKFLOW_STEP_STATES.join(", ")}.`,
+        },
+        notes: { type: "string", description: "Notes for the completed step" },
+        summary: {
+            type: "string",
+            description: "Summary of work done (required when completing a step); validated against completion criteria",
+        },
+        evidence: { type: "string", description: "Evidence JSON object for the step" },
+    },
+    async run({ args }) {
+        const result = await completeWorkflowStep({
+            runId: args.runId,
+            stepId: args.step,
+            status: parseWorkflowStepState(args.state),
+            notes: args.notes,
+            summary: args.summary,
+            evidence: args.evidence ? parseWorkflowJsonObject(args.evidence, "--evidence") : undefined,
+        });
+        if ("ok" in result && result.ok === false) {
+            // Summary failed the completion-criteria validation gate (#506): the
+            // step stays pending and the agent receives corrective feedback.
+            output("workflow-complete-rejected", result);
+            return;
+        }
+        output("workflow-complete", result);
+    },
+});
+const workflowStatusCommand = defineJsonCommand({
+    meta: {
+        name: "status",
+        description: "Show full workflow run state for review or resume; workflow refs resolve within the current scope",
+    },
+    args: {
+        target: { type: "positional", description: "Workflow run id or workflow ref (workflow:<name>)", required: true },
+    },
+    async run({ args }) {
+        const target = args.target;
+        // Check if target looks like a workflow ref
+        const parsed = (() => {
+            try {
+                return parseAssetRef(target);
+            }
+            catch {
+                return null;
+            }
+        })();
+        if (parsed?.type === "workflow") {
+            const ref = `${parsed.origin ? `${parsed.origin}//` : ""}workflow:${parsed.name}`;
+            const { runs } = await listWorkflowRuns({ workflowRef: ref });
+            if (runs.length === 0) {
+                throw new NotFoundError(`No workflow runs found for ${ref}`, "WORKFLOW_NOT_FOUND");
+            }
+            const mostRecent = runs[0];
+            if (!mostRecent)
+                throw new NotFoundError(`No workflow runs found for ${ref}`, "WORKFLOW_NOT_FOUND");
+            const result = await getWorkflowStatus(mostRecent.id);
+            output("workflow-status", result);
+        }
+        else {
+            const result = await getWorkflowStatus(target);
+            output("workflow-status", result);
+        }
+    },
+});
+const workflowListCommand = defineJsonCommand({
+    meta: {
+        name: "list",
+        description: "List workflow runs in the current working scope",
+    },
+    args: {
+        ref: { type: "string", description: "Filter to one workflow ref" },
+        active: { type: "boolean", description: "Only show active runs", default: false },
+    },
+    async run({ args }) {
+        const result = await listWorkflowRuns({ workflowRef: args.ref, activeOnly: args.active });
+        output("workflow-list", result);
+    },
+});
+const workflowCreateCommand = defineJsonCommand({
+    meta: {
+        name: "create",
+        description: "Create a workflow markdown document in the working stash",
+    },
+    args: {
+        name: {
+            type: "positional",
+            description: "Workflow name (flat, no '/'; use --path for a subdirectory)",
+            required: true,
+        },
+        path: {
+            type: "string",
+            description: "Relative subdirectory under workflows/ to place the workflow in (e.g. 'release'). The filename comes from the name.",
+        },
+        from: { type: "string", description: "Import and validate markdown from an existing file" },
+        force: {
+            type: "boolean",
+            description: "Overwrite an existing workflow (requires --from or --reset)",
+            default: false,
+        },
+        reset: {
+            type: "boolean",
+            description: "Explicitly replace an existing workflow with a fresh template (use with --force)",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        // `name` is flat; subdirectory placement is `--path`'s job.
+        assertFlatAssetName(args.name);
+        const effectiveName = combineCreatePath(normalizeCreateSubPath(args.path), args.name);
+        const namePattern = /^[a-z0-9][a-z0-9._/-]*$/;
+        if (!namePattern.test(effectiveName)) {
+            throw new UsageError("Workflow name must start with a lowercase letter or digit and contain only lowercase letters, digits, hyphens, dots, underscores, and slashes.");
+        }
+        if (args.force && !args.from && !args.reset) {
+            throw new UsageError("Refusing to overwrite with template: pass --from <file> to replace content, or --reset to explicitly replace with a fresh template.");
+        }
+        const result = createWorkflowAsset({
+            name: effectiveName,
+            from: args.from,
+            force: args.force,
+        });
+        // Index the newly-written workflow so `akm workflow start` can resolve
+        // a workflowEntryId without requiring an explicit `akm index` call
+        // first. Uses the same incremental index path that `akm add` uses.
+        await akmIndex({ stashDir: result.stashDir });
+        output("workflow-create", { ok: true, ...result });
+    },
+});
+const workflowTemplateCommand = defineCommand({
+    meta: {
+        name: "template",
+        description: "Print a valid workflow markdown template",
+    },
+    run() {
+        process.stdout.write(getWorkflowTemplate());
+    },
+});
+const workflowValidateCommand = defineJsonCommand({
+    meta: {
+        name: "validate",
+        description: "Validate a workflow markdown file or ref and print any errors",
+    },
+    args: {
+        target: {
+            type: "positional",
+            description: "Workflow ref (workflow:<name>) or filesystem path to a workflow .md",
+            required: true,
+        },
+    },
+    async run({ args }) {
+        const filePath = await resolveWorkflowFilePath(args.target);
+        const { parse } = validateWorkflowSource(filePath);
+        if (parse.ok) {
+            output("workflow-validate", {
+                ok: true,
+                path: filePath,
+                title: parse.document.title,
+                stepCount: parse.document.steps.length,
+            });
+            return;
+        }
+        throw new UsageError(formatWorkflowErrors(filePath, parse.errors));
+    },
+});
+async function resolveWorkflowFilePath(target) {
+    if (!target.startsWith("workflow:"))
+        return target;
+    const parsed = parseAssetRef(target);
+    if (parsed.type !== "workflow") {
+        throw new UsageError(`Expected a workflow ref (workflow:<name>), got "${target}".`);
+    }
+    const config = loadConfig();
+    const allSources = resolveSourceEntries(undefined, config);
+    const searchSources = resolveSourcesForOrigin(parsed.origin, allSources);
+    for (const source of searchSources) {
+        try {
+            return await resolveAssetPath(source.path, "workflow", parsed.name);
+        }
+        catch {
+            /* try next source */
+        }
+    }
+    throw new UsageError(`Workflow not found for ref: workflow:${parsed.name}`);
+}
+const workflowResumeCommand = defineJsonCommand({
+    meta: {
+        name: "resume",
+        description: "Resume a blocked or failed workflow run, flipping it back to active",
+    },
+    args: {
+        runId: { type: "positional", description: "Workflow run id", required: true },
+    },
+    async run({ args }) {
+        const result = await resumeWorkflowRun(args.runId);
+        output("workflow-resume", result);
+    },
+});
+export const workflowCommand = defineCommand({
+    meta: {
+        name: "workflow",
+        description: "Author, inspect, and execute step-by-step workflow assets",
+    },
+    subCommands: {
+        start: workflowStartCommand,
+        next: workflowNextCommand,
+        complete: workflowCompleteCommand,
+        status: workflowStatusCommand,
+        list: workflowListCommand,
+        create: workflowCreateCommand,
+        template: workflowTemplateCommand,
+        resume: workflowResumeCommand,
+        validate: workflowValidateCommand,
+    },
+    run({ args }) {
+        return runWithJsonErrors(async () => {
+            if (hasWorkflowSubcommand(args))
+                return;
+            output("workflow-list", await listWorkflowRuns({ activeOnly: true }));
+        });
+    },
+});

package/dist/core/action-contributors.js

@@ -1,7 +1,7 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { defaultRendererRegistry } from "./asset-registry";
+import { defaultRendererRegistry } from "./asset/asset-registry.js";
 function registryActionContributor(registry) {
     return {
         name: "registry-action-contributor",