@otto-code/cli 0.8.18 → 0.9.0

package/dist/commands/project/rename.js

@@ -0,0 +1,50 @@
+import { buildDaemonConnectionCommandError, connectToDaemon } from "../../utils/client.js";
+const projectRenameSchema = {
+    idField: "projectId",
+    columns: [
+        { header: "PROJECT ID", field: "projectId", width: 20 },
+        { header: "NAME", field: "name", width: 30 },
+    ],
+};
+export function resolveProjectName(input) {
+    if (input.reset) {
+        if (input.name !== undefined) {
+            throw {
+                code: "INVALID_OPTIONS",
+                message: "--reset cannot be combined with a name",
+            };
+        }
+        return null;
+    }
+    const name = input.name?.trim() ?? "";
+    if (name.length === 0) {
+        throw {
+            code: "MISSING_NAME",
+            message: "Project name cannot be empty",
+            details: "Usage: otto project rename <project-id> <name> | --reset",
+        };
+    }
+    return name;
+}
+export async function runRenameCommand(projectId, nameArg, options, _command) {
+    const name = resolveProjectName({ name: nameArg, reset: options.reset });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    });
+    try {
+        const applied = await client.renameProject(projectId, name);
+        return {
+            type: "single",
+            data: { projectId, name: applied.customName },
+            schema: projectRenameSchema,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "PROJECT_RENAME_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=rename.js.map

package/dist/commands/project/shared.d.ts

@@ -0,0 +1,11 @@
+import type { WorkspaceProjectDescriptorPayload } from "@otto-code/protocol/messages";
+import type { OutputSchema } from "../../output/index.js";
+export interface ProjectRow {
+    projectId: string;
+    name: string;
+    kind: "git" | "non_git" | "directory";
+    path: string;
+}
+export declare const projectSchema: OutputSchema<ProjectRow>;
+export declare function toProjectRow(project: WorkspaceProjectDescriptorPayload): ProjectRow;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/project/shared.js

@@ -0,0 +1,18 @@
+export const projectSchema = {
+    idField: "projectId",
+    columns: [
+        { header: "PROJECT ID", field: "projectId", width: 20 },
+        { header: "NAME", field: "name", width: 24 },
+        { header: "KIND", field: "kind", width: 10 },
+        { header: "PATH", field: "path", width: 42 },
+    ],
+};
+export function toProjectRow(project) {
+    return {
+        projectId: project.projectId,
+        name: project.projectDisplayName,
+        kind: project.projectKind,
+        path: project.projectRootPath,
+    };
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/schedule/shared.js

@@ -49,6 +49,9 @@ export function formatTarget(target) {
     if (target.type === "agent") {
         return `agent:${target.agentId.slice(0, 7)}`;
     }
+    if (target.type === "workflow") {
+        return `workflow:${target.definitionId}`;
+    }
     const modelSuffix = target.config.model ? `/${target.config.model}` : "";
     return `new-agent:${target.config.provider}${modelSuffix}`;
 }

package/dist/commands/schedule/types.d.ts

@@ -24,6 +24,10 @@ export type ScheduleTarget = {
         title?: string | null;
         providerOptions?: Record<string, unknown>;
     };
+} | {
+    type: "workflow";
+    definitionId: string;
+    projectRoot: string;
 };
 export interface ScheduleRunRecord {
     id: string;

package/dist/commands/workflow/graph.d.ts

@@ -0,0 +1,85 @@
+import type { Command } from "commander";
+import { type OrchestrationGraph, type WorkflowGraphExport } from "@otto-code/protocol/workflow";
+import type { CommandDiagnostic, CommandOptions, ListResult, OutputSchema, SingleResult } from "../../output/index.js";
+export interface WorkflowGraphCommandOptions extends CommandOptions {
+}
+export interface WorkflowGraphRunOptions extends WorkflowGraphCommandOptions {
+    cwd?: string;
+    workspace?: string;
+    title?: string;
+    description?: string;
+    input?: string[];
+    orchestratorProfile?: string;
+    orchestratorProvider?: string;
+    orchestratorModel?: string;
+    orchestratorThinking?: string;
+}
+export interface WorkflowGraphRow {
+    id: string;
+    name: string;
+    description: string | null;
+    nodes: number;
+    edges: number;
+    updatedAt: string | null;
+}
+export declare const workflowGraphSchema: OutputSchema<WorkflowGraphRow>;
+export interface WorkflowGraphInspectRow {
+    key: string;
+    value: string;
+}
+export interface WorkflowGraphValidationResult {
+    file: string;
+    valid: true;
+    scope: "structural";
+    warnings: string[];
+    diagnostics: CommandDiagnostic[];
+    nodes: number;
+    edges: number;
+}
+export interface WorkflowGraphRunResult {
+    runId: string;
+    graphId: string;
+    agentId: string | null;
+    workspaceId: string | null;
+}
+export interface WorkflowGraphExportResult {
+    graphId: string;
+    output: string;
+    source: string;
+    contentHash: string;
+}
+export interface WorkflowGraphImportCommandResult {
+    status: string;
+    graphId: string | null;
+    source: string | null;
+    destination: string | null;
+    remediation: string;
+}
+export declare function runWorkflowGraphExportCommand(id: string, options: WorkflowGraphCommandOptions & {
+    output?: string;
+}, _command: Command): Promise<SingleResult<WorkflowGraphExportResult>>;
+export declare function runWorkflowGraphImportCommand(file: string, options: WorkflowGraphCommandOptions & {
+    cwd?: string;
+    confirm?: boolean;
+}, _command: Command): Promise<SingleResult<WorkflowGraphImportCommandResult>>;
+export declare function runWorkflowGraphListCommand(options: WorkflowGraphCommandOptions, _command: Command): Promise<ListResult<WorkflowGraphRow>>;
+export declare function runWorkflowGraphInspectCommand(id: string, options: WorkflowGraphCommandOptions, _command: Command): Promise<ListResult<WorkflowGraphInspectRow>>;
+export declare function runWorkflowGraphValidateCommand(file: string, _options: CommandOptions, _command: Command): Promise<SingleResult<WorkflowGraphValidationResult>>;
+export declare function runWorkflowGraphRunCommand(id: string, options: WorkflowGraphRunOptions, _command: Command): Promise<SingleResult<WorkflowGraphRunResult>>;
+export declare function loadWorkflowGraphFile(file: string): Promise<OrchestrationGraph>;
+export declare function loadWorkflowGraphExportFile(file: string): Promise<WorkflowGraphExport>;
+export declare function parseWorkflowGraphRunInput(id: string, options: WorkflowGraphRunOptions): {
+    graphId: string;
+    cwd: string;
+    workspaceId?: string;
+    title?: string;
+    description?: string;
+    graphInputs: Record<string, string>;
+    orchestratorProfile?: string;
+    orchestratorProvider?: string;
+    orchestratorModel?: string;
+    orchestratorThinking?: string;
+};
+export declare function parseGraphInputAssignments(values: readonly string[] | undefined): Record<string, string>;
+export declare function resolveWorkflowGraphInputs(graph: OrchestrationGraph, supplied: Record<string, string>): Record<string, string>;
+//# sourceMappingURL=graph.d.ts.map

package/dist/commands/workflow/graph.js

@@ -0,0 +1,462 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { OrchestrationGraphSchema, reviewOrchestrationGraph, validateGraphDocument, validateOrchestrationGraph, } from "@otto-code/protocol/workflow";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export const workflowGraphSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 24 },
+        { header: "NAME", field: "name", width: 28 },
+        { header: "NODES", field: "nodes", width: 7, align: "right" },
+        { header: "EDGES", field: "edges", width: 7, align: "right" },
+        { header: "UPDATED", field: "updatedAt", width: 24 },
+    ],
+};
+const graphValidationSchema = {
+    idField: "file",
+    columns: [
+        { header: "FILE", field: "file", width: 48 },
+        { header: "SCOPE", field: "scope", width: 12 },
+        { header: "NODES", field: "nodes", width: 7, align: "right" },
+        { header: "EDGES", field: "edges", width: 7, align: "right" },
+        { header: "WARNINGS", field: (result) => result.warnings.length, width: 9, align: "right" },
+    ],
+};
+const graphRunSchema = {
+    idField: "runId",
+    columns: [
+        { header: "RUN ID", field: "runId", width: 24 },
+        { header: "GRAPH ID", field: "graphId", width: 24 },
+        { header: "ORCHESTRATOR CHAT", field: "agentId", width: 24 },
+        { header: "WORKSPACE", field: "workspaceId", width: 24 },
+    ],
+};
+const graphExportSchema = {
+    idField: "graphId",
+    columns: [
+        { header: "GRAPH ID", field: "graphId", width: 24 },
+        { header: "OUTPUT", field: "output", width: 48 },
+        { header: "SOURCE", field: "source", width: 30 },
+    ],
+};
+const graphImportSchema = {
+    idField: "graphId",
+    columns: [
+        { header: "STATUS", field: "status", width: 18 },
+        { header: "GRAPH ID", field: "graphId", width: 24 },
+        { header: "DESTINATION", field: "destination", width: 32 },
+        { header: "REMEDIATION", field: "remediation", width: 72 },
+    ],
+};
+export async function runWorkflowGraphExportCommand(id, options, _command) {
+    const graphId = id.trim();
+    const output = options.output?.trim();
+    if (!graphId)
+        throw { code: "INVALID_GRAPH_ID", message: "Graph id cannot be empty" };
+    if (!output)
+        throw {
+            code: "MISSING_EXPORT_OUTPUT",
+            message: "--output is required for Graph export",
+        };
+    const client = await connectWorkflowGraphClient(options.host);
+    try {
+        const exported = await client.exportWorkflowGraph(graphId);
+        const file = resolve(output);
+        await writeFile(file, `${JSON.stringify(exported, null, 2)}\n`, "utf8");
+        return {
+            type: "single",
+            data: {
+                graphId,
+                output: file,
+                source: exported.source.storeKey,
+                contentHash: exported.contentHash,
+            },
+            schema: graphExportSchema,
+        };
+    }
+    catch (error) {
+        throw toWorkflowGraphCommandError("WORKFLOW_GRAPH_EXPORT_FAILED", "export Graph", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function runWorkflowGraphImportCommand(file, options, _command) {
+    const cwd = options.cwd?.trim();
+    if (!cwd)
+        throw {
+            code: "MISSING_CWD",
+            message: "--cwd is required to select the destination project store",
+        };
+    const exported = await loadWorkflowGraphExportFile(file);
+    const client = await connectWorkflowGraphClient(options.host);
+    try {
+        const result = await client.importWorkflowGraph({
+            cwd,
+            export: exported,
+            confirmed: options.confirm === true,
+        });
+        return { type: "single", data: toGraphImportCommandResult(result), schema: graphImportSchema };
+    }
+    catch (error) {
+        throw toWorkflowGraphCommandError("WORKFLOW_GRAPH_IMPORT_FAILED", "import Graph", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function runWorkflowGraphListCommand(options, _command) {
+    const client = await connectWorkflowGraphClient(options.host);
+    try {
+        const graphs = await client.listOrchestrationGraphs();
+        return { type: "list", data: graphs.map(toWorkflowGraphRow), schema: workflowGraphSchema };
+    }
+    catch (error) {
+        throw toWorkflowGraphCommandError("WORKFLOW_GRAPH_LIST_FAILED", "list Graphs", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function runWorkflowGraphInspectCommand(id, options, _command) {
+    const client = await connectWorkflowGraphClient(options.host);
+    try {
+        const graph = await findWorkflowGraph(client, id);
+        const rows = [
+            { key: "Id", value: graph.id },
+            { key: "Name", value: graph.name },
+            { key: "Description", value: graph.description ?? "" },
+            { key: "Nodes", value: String(graph.nodes.length) },
+            { key: "Edges", value: String(graph.edges?.length ?? 0) },
+            { key: "UpdatedAt", value: graph.updatedAt ?? "" },
+        ];
+        return {
+            type: "list",
+            data: rows,
+            schema: {
+                idField: "key",
+                columns: [
+                    { header: "KEY", field: "key", width: 16 },
+                    { header: "VALUE", field: "value", width: 84 },
+                ],
+                serialize: () => graph,
+            },
+        };
+    }
+    catch (error) {
+        throw toWorkflowGraphCommandError("WORKFLOW_GRAPH_INSPECT_FAILED", "inspect Graph", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function runWorkflowGraphValidateCommand(file, _options, _command) {
+    const graph = await loadWorkflowGraphFile(file);
+    const diagnostics = validateGraphDocument(graph);
+    const problems = validateOrchestrationGraph(graph);
+    if (problems.length > 0) {
+        const documentErrors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+        throw {
+            code: documentErrors.length > 0
+                ? "WORKFLOW_GRAPH_DOCUMENT_INVALID"
+                : "WORKFLOW_GRAPH_NOT_STRUCTURALLY_VALID",
+            message: documentErrors.length > 0
+                ? `Graph ${resolve(file)} has an unsupported document format`
+                : `Graph ${resolve(file)} is not structurally valid`,
+            details: problems,
+            diagnostics,
+        };
+    }
+    return {
+        type: "single",
+        data: {
+            file: resolve(file),
+            valid: true,
+            scope: "structural",
+            warnings: reviewOrchestrationGraph(graph),
+            diagnostics,
+            nodes: graph.nodes.length,
+            edges: graph.edges?.length ?? 0,
+        },
+        schema: graphValidationSchema,
+    };
+}
+export async function runWorkflowGraphRunCommand(id, options, _command) {
+    const input = parseWorkflowGraphRunInput(id, options);
+    const client = await connectWorkflowGraphClient(options.host);
+    try {
+        const graph = await findWorkflowGraph(client, input.graphId);
+        const graphInputs = resolveWorkflowGraphInputs(graph, input.graphInputs);
+        const workspaceId = await resolveWorkflowGraphWorkspaceId(client, input);
+        const started = await client.startWorkflow({
+            flavor: "graph",
+            cwd: input.cwd,
+            workspaceId,
+            ...(input.title ? { title: input.title } : {}),
+            ...(input.description ? { description: input.description } : {}),
+            ...(input.orchestratorProfile
+                ? { orchestratorPersonalityId: input.orchestratorProfile }
+                : {}),
+            ...(input.orchestratorProvider ? { orchestratorProvider: input.orchestratorProvider } : {}),
+            ...(input.orchestratorModel ? { orchestratorModel: input.orchestratorModel } : {}),
+            ...(input.orchestratorThinking
+                ? { orchestratorThinkingOptionId: input.orchestratorThinking }
+                : {}),
+            graphId: input.graphId,
+            graphInputs,
+        });
+        if (!started.runId) {
+            throw new Error("Daemon did not return a Workflow run ID.");
+        }
+        return {
+            type: "single",
+            data: {
+                runId: started.runId,
+                graphId: input.graphId,
+                agentId: started.agentId ?? null,
+                workspaceId: started.workspaceId ?? null,
+            },
+            schema: graphRunSchema,
+        };
+    }
+    catch (error) {
+        throw toWorkflowGraphCommandError("WORKFLOW_GRAPH_RUN_FAILED", "run Graph", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function loadWorkflowGraphFile(file) {
+    const resolved = resolve(file);
+    let raw;
+    try {
+        raw = await readFile(resolved, "utf-8");
+    }
+    catch (error) {
+        throw {
+            code: "WORKFLOW_GRAPH_FILE_UNREADABLE",
+            message: `Cannot read Graph file ${resolved}`,
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+    let document;
+    try {
+        document = JSON.parse(raw);
+    }
+    catch (error) {
+        throw {
+            code: "WORKFLOW_GRAPH_FILE_INVALID_JSON",
+            message: `Graph file ${resolved} is not valid JSON`,
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const parsed = OrchestrationGraphSchema.safeParse(document);
+    if (!parsed.success) {
+        throw {
+            code: "WORKFLOW_GRAPH_FILE_INVALID_SHAPE",
+            message: `Graph file ${resolved} does not match the Graph document format`,
+            details: parsed.error.issues.map((issue) => `${issue.path.join(".") || "document"}: ${issue.message}`),
+        };
+    }
+    return parsed.data;
+}
+export async function loadWorkflowGraphExportFile(file) {
+    const resolved = resolve(file);
+    let raw;
+    try {
+        raw = await readFile(resolved, "utf-8");
+    }
+    catch (error) {
+        throw {
+            code: "WORKFLOW_GRAPH_EXPORT_UNREADABLE",
+            message: `Cannot read Graph export ${resolved}`,
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+    let document;
+    try {
+        document = JSON.parse(raw);
+    }
+    catch (error) {
+        throw {
+            code: "WORKFLOW_GRAPH_EXPORT_INVALID_JSON",
+            message: `Graph export ${resolved} is not valid JSON`,
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const { WorkflowGraphExportSchema } = await import("@otto-code/protocol/workflow");
+    const parsed = WorkflowGraphExportSchema.safeParse(document);
+    if (!parsed.success)
+        throw {
+            code: "WORKFLOW_GRAPH_EXPORT_INVALID_SHAPE",
+            message: `Graph export ${resolved} does not match the sharing format`,
+            details: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`),
+        };
+    return parsed.data;
+}
+function toGraphImportCommandResult(result) {
+    return {
+        status: result.status,
+        graphId: result.graph?.id ?? null,
+        source: result.source?.storeKey ?? null,
+        destination: result.destination?.storeKey ?? null,
+        remediation: result.remediation,
+    };
+}
+export function parseWorkflowGraphRunInput(id, options) {
+    const graphId = id.trim();
+    if (!graphId) {
+        throw { code: "INVALID_GRAPH_ID", message: "Graph id cannot be empty" };
+    }
+    const cwdOption = options.cwd?.trim();
+    if (options.host !== undefined && !cwdOption) {
+        throw {
+            code: "MISSING_CWD",
+            message: "--cwd is required when --host is specified",
+            details: "The local working directory may not exist on the remote daemon.",
+        };
+    }
+    const orchestratorProfile = trimOptional(options.orchestratorProfile);
+    const orchestratorProvider = trimOptional(options.orchestratorProvider);
+    const orchestratorModel = trimOptional(options.orchestratorModel);
+    if (orchestratorProfile && (orchestratorProvider || orchestratorModel)) {
+        throw {
+            code: "CONFLICTING_ORCHESTRATOR_SEAT",
+            message: "Use either --orchestrator-profile or --orchestrator-provider/--orchestrator-model",
+        };
+    }
+    if (orchestratorModel && !orchestratorProvider) {
+        throw {
+            code: "MISSING_ORCHESTRATOR_PROVIDER",
+            message: "--orchestrator-model requires --orchestrator-provider",
+        };
+    }
+    return {
+        graphId,
+        cwd: cwdOption ?? process.cwd(),
+        ...(trimOptional(options.workspace) ? { workspaceId: trimOptional(options.workspace) } : {}),
+        ...(trimOptional(options.title) ? { title: trimOptional(options.title) } : {}),
+        ...(trimOptional(options.description)
+            ? { description: trimOptional(options.description) }
+            : {}),
+        graphInputs: parseGraphInputAssignments(options.input),
+        ...(orchestratorProfile ? { orchestratorProfile } : {}),
+        ...(orchestratorProvider ? { orchestratorProvider } : {}),
+        ...(orchestratorModel ? { orchestratorModel } : {}),
+        ...(trimOptional(options.orchestratorThinking)
+            ? { orchestratorThinking: trimOptional(options.orchestratorThinking) }
+            : {}),
+    };
+}
+export function parseGraphInputAssignments(values) {
+    const inputs = {};
+    for (const value of values ?? []) {
+        const separator = value.indexOf("=");
+        const key = separator >= 0 ? value.slice(0, separator).trim() : "";
+        if (!key) {
+            throw {
+                code: "INVALID_GRAPH_INPUT",
+                message: `Graph input "${value}" must use key=value form`,
+            };
+        }
+        if (Object.hasOwn(inputs, key)) {
+            throw {
+                code: "DUPLICATE_GRAPH_INPUT",
+                message: `Graph input "${key}" was supplied more than once`,
+            };
+        }
+        inputs[key] = value.slice(separator + 1);
+    }
+    return inputs;
+}
+export function resolveWorkflowGraphInputs(graph, supplied) {
+    const declared = new Map((graph.inputs ?? []).map((input) => [input.key, input]));
+    for (const key of Object.keys(supplied)) {
+        if (!declared.has(key)) {
+            throw {
+                code: "UNKNOWN_GRAPH_INPUT",
+                message: `Graph "${graph.name}" does not declare input "${key}"`,
+            };
+        }
+    }
+    const resolved = {};
+    for (const input of graph.inputs ?? []) {
+        const value = (supplied[input.key] ?? input.defaultValue ?? "").trim();
+        if (input.required && !value) {
+            throw {
+                code: "MISSING_GRAPH_INPUT",
+                message: `Graph "${graph.name}" requires input "${input.key}"`,
+            };
+        }
+        if (value) {
+            resolved[input.key] = value;
+        }
+    }
+    return resolved;
+}
+async function connectWorkflowGraphClient(host) {
+    const resolvedHost = getDaemonHost({ host });
+    try {
+        return (await connectToDaemon({ host }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${resolvedHost}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+}
+async function findWorkflowGraph(client, id) {
+    const graph = (await client.listOrchestrationGraphs()).find((candidate) => candidate.id === id);
+    if (!graph) {
+        throw { code: "GRAPH_NOT_FOUND", message: `Graph not found: ${id}` };
+    }
+    return graph;
+}
+async function resolveWorkflowGraphWorkspaceId(client, input) {
+    if (input.workspaceId) {
+        return input.workspaceId;
+    }
+    let cursor;
+    do {
+        const page = await client.fetchWorkspaces({
+            page: { limit: 200, ...(cursor ? { cursor } : {}) },
+        });
+        const workspace = page.entries.find((entry) => entry.workspaceDirectory === input.cwd);
+        if (workspace) {
+            return workspace.id;
+        }
+        cursor = page.pageInfo.nextCursor ?? undefined;
+    } while (cursor);
+    throw {
+        code: "WORKFLOW_GRAPH_WORKSPACE_REQUIRED",
+        message: `No workspace is registered for ${input.cwd}`,
+        details: "Create or open the workspace first, or pass its ID with --workspace.",
+    };
+}
+function toWorkflowGraphRow(graph) {
+    return {
+        id: graph.id,
+        name: graph.name,
+        description: graph.description ?? null,
+        nodes: graph.nodes.length,
+        edges: graph.edges?.length ?? 0,
+        updatedAt: graph.updatedAt ?? null,
+    };
+}
+function trimOptional(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function toWorkflowGraphCommandError(code, action, error) {
+    if (error && typeof error === "object" && "code" in error) {
+        return error;
+    }
+    return {
+        code,
+        message: `Failed to ${action}: ${error instanceof Error ? error.message : String(error)}`,
+    };
+}
+//# sourceMappingURL=graph.js.map

package/dist/commands/workflow/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createWorkflowCommand(): Command;
+//# sourceMappingURL=index.d.ts.map