@mc1global/opencode-jarvis 0.13.0 → 0.14.0

package/dist/tools/pipeline-tools.js

@@ -1,411 +1,394 @@
 /**
- * Pipeline Tools — OpenCode tool definitions for pipeline lifecycle and gate operations.
+ * Pipeline Tools
  *
- * 9 tools: pipeline-init, pipeline-activate, pipeline-cancel, pipeline-retry,
- * pipeline-run, pipeline-gate, pipeline-status, pipeline-list, pipeline-template.
+ * OpenCode tool definitions for managing CI/CD pipelines with quality gates.
+ * Provides agent-accessible tools for pipeline lifecycle, gate operations,
+ * and template management.
  *
- * SOLID: SRP - pipeline tools only
- * SOLID: DIP - depends on use case abstractions
+ * Tools defined (7):
+ *   pipeline-init        — Create a new pipeline from a stack template
+ *   pipeline-activate    — Activate a draft pipeline
+ *   pipeline-cancel      — Cancel a draft or active pipeline
+ *   pipeline-retry       — Retry a failed pipeline
+ *   gate-run             — Execute a gate via Dagger
+ *   gate-pass            — Manually pass a gate
+ *   gate-fail            — Manually fail a gate
+ *   gate-skip            — Skip a gate with reason
+ *   pipeline-query       — Query pipelines and templates
+ *
+ * SOLID: SRP — pipeline tool exposure only
+ * SOLID: DIP — depends on use case abstractions
  */
+import { PIPELINE_STATUS_VALUES, PIPELINE_SCOPE_VALUES, PIPELINE_QUERY_VALUES, } from "../domain/pipeline/enum-values.js";
 import { tool } from "@opencode-ai/plugin";
 const z = tool.schema;
-// ── Result Formatting ─────────────────────────────────────────────────
-/** Generic Result-to-string formatter. */
-function formatResult(result, formatter) {
-    if (!result.success)
-        return `ERROR: ${result.error}`;
-    return formatter(result.data);
-}
-/** Format a gate response for display. */
-function formatGate(g) {
-    const lines = [`  [${g.order}] ${g.id} ${g.type} — ${g.status}`];
-    lines.push(`      Dagger: ${g.daggerFunction} | Skip: ${g.skipPolicy}`);
-    if (g.command !== undefined)
-        lines.push(`      Command: ${g.command}`);
-    if (g.output !== undefined) {
-        const truncated = g.output.length > 200 ? g.output.slice(0, 200) + "..." : g.output;
-        lines.push(`      Output: ${truncated}`);
-    }
-    if (g.skippedReason !== undefined)
-        lines.push(`      Skipped: ${g.skippedReason}`);
-    if (g.approvedBy !== undefined)
-        lines.push(`      Approved by: ${g.approvedBy}`);
-    if (g.startedAt !== undefined)
-        lines.push(`      Started: ${g.startedAt}`);
-    if (g.completedAt !== undefined)
-        lines.push(`      Completed: ${g.completedAt}`);
-    return lines.join("\n");
-}
-/** Format a pipeline response for display. */
-function formatPipeline(p) {
-    const lines = [
-        `Pipeline: ${p.id} [${p.status}]`,
-        `  Workspace: ${p.workspaceId}`,
-        `  Template: ${p.templateId} (${p.scope})`,
-        `  Version: ${p.version}`,
-        `  Gates: ${p.gateCount}`,
-    ];
-    if (p.cardId !== undefined)
-        lines.push(`  Card: ${p.cardId}`);
-    if (p.currentGate !== undefined)
-        lines.push(`  Current Gate: ${p.currentGate}`);
-    if (p.nextGate !== undefined)
-        lines.push(`  Next Gate: ${p.nextGate}`);
-    lines.push(`  Created: ${p.createdAt}`);
-    if (p.activatedAt !== undefined)
-        lines.push(`  Activated: ${p.activatedAt}`);
-    if (p.completedAt !== undefined)
-        lines.push(`  Completed: ${p.completedAt}`);
-    if (p.gates.length > 0) {
-        lines.push(`  Gate Details:`);
-        for (const gate of p.gates) {
-            lines.push(formatGate(gate));
-        }
-    }
-    return lines.join("\n");
-}
-/** Format a template response for display. */
-function formatTemplate(t) {
-    const lines = [
-        `Template: ${t.stack} (${t.scope})`,
-        `  Gates: ${t.gates.length}`,
-    ];
-    for (const g of t.gates) {
-        const parts = [`    - ${g.type}: dagger=${g.daggerFunction}, skip=${g.skipPolicy}`];
-        if (g.command !== undefined)
-            parts.push(`, cmd=${g.command}`);
-        lines.push(parts.join(""));
-    }
-    return lines.join("\n");
-}
-/** Format a run-gate result for display. */
-function formatRunGateResult(r) {
-    const dagger = r.daggerResult;
-    const status = dagger.success ? "PASSED" : "FAILED";
-    const lines = [
-        `Gate Run: ${r.gateId} — ${status}`,
-        `  Exit Code: ${dagger.exitCode}`,
-        `  Duration: ${dagger.durationMs}ms`,
-    ];
-    if (dagger.output.length > 0) {
-        const truncated = dagger.output.length > 500
-            ? dagger.output.slice(0, 500) + "..."
-            : dagger.output;
-        lines.push(`  Output: ${truncated}`);
-    }
-    lines.push("");
-    lines.push(formatPipeline(r.pipeline));
-    return lines.join("\n");
-}
-// ── Schema Constants ──────────────────────────────────────────────────
-const STACK_ENUM = z.enum([
-    "typescript-lib",
-    "typescript-app",
-    "python-lib",
-    "python-app",
-    "swift-ios",
-    "csharp-app",
-    "kotlin-android",
-    "generic",
-]);
-const SCOPE_ENUM = z.enum(["branch", "release"]);
-const GATE_ACTION_ENUM = z.enum(["pass", "fail", "skip", "retry"]);
 // ── Tool Factory ──────────────────────────────────────────────────────
 /**
- * Creates all pipeline OpenCode tools.
- * @param deps - Use cases and workspace resolver
- * @returns Record of 9 tool definitions
+ * Creates pipeline management tools for agent-guided CI/CD workflows.
  */
 export function createPipelineTools(deps) {
-    const { pipelineUseCases, cardUseCases, getWorkspace } = deps;
-    // ── pipeline-init ─────────────────────────────────────────────────
+    const { pipelineUseCases } = deps;
+    // ── pipeline-init ────────────────────────────────────────────────
     const pipelineInit = tool({
-        description: "Create a new CI/CD pipeline from a stack template. " +
-            "Optionally link to a kanban card for traceability. " +
-            "Returns the pipeline in draft status. Activate it to start running gates.",
+        description: "Create a new pipeline from a stack template. The pipeline starts in 'draft' status " +
+            "and must be activated before gates can run. Valid stacks: typescript-lib, typescript-app, " +
+            "python-lib, python-app, swift-ios, csharp-app, kotlin-android, generic. " +
+            "Valid scopes: branch (CI — analyze/lint/test/build), release (CD — full pipeline including tag/publish/deploy).",
         args: {
-            stack: STACK_ENUM.describe("Technology stack template"),
-            scope: SCOPE_ENUM.describe("Pipeline scope: branch (CI) or release (CD)"),
-            version: z.string().describe("Semantic version (e.g., 1.0.0)"),
-            card_id: z
+            workspace: z
+                .string()
+                .describe("Workspace identifier (e.g., 'jarvis-opencode')"),
+            stack: z
+                .string()
+                .describe("Stack template name (typescript-lib, typescript-app, python-lib, python-app, swift-ios, csharp-app, kotlin-android, generic)"),
+            scope: z
+                .enum(PIPELINE_SCOPE_VALUES)
+                .describe("Pipeline scope: 'branch' for CI (analyze/lint/test/build) or 'release' for full CD (all gates including tag/publish/deploy)"),
+            version: z.string().describe("Version string for the pipeline (e.g., 'v1.0.0')"),
+            cardId: z
                 .string()
                 .optional()
-                .describe("Kanban card ID to link (e.g., CD-001)"),
+                .describe("Optional kanban card ID to link this pipeline to"),
         },
-        async execute(args, ctx) {
-            const workspace = getWorkspace(ctx.directory);
+        async execute(args) {
             const result = await pipelineUseCases.initPipeline({
-                workspace,
+                workspace: args.workspace,
                 stack: args.stack,
                 scope: args.scope,
                 version: args.version,
-                ...(args.card_id !== undefined ? { cardId: args.card_id } : {}),
+                ...(args.cardId !== undefined ? { cardId: args.cardId } : {}),
             });
-            // Link card to pipeline (bidirectional)
-            if (result.success && args.card_id !== undefined && cardUseCases !== undefined) {
-                await cardUseCases.linkPipeline({
-                    cardId: args.card_id,
-                    pipelineId: result.data.id,
-                });
+            if (!result.success) {
+                return `Error: ${result.error}`;
             }
-            return formatResult(result, formatPipeline);
+            const p = result.data;
+            return [
+                `Pipeline ${p.id} created successfully`,
+                `Status: ${p.status}`,
+                `Template: ${p.templateId}`,
+                `Scope: ${p.scope}`,
+                `Gates: ${p.gateCount}`,
+                "",
+                "Next: Use pipeline-activate to make this pipeline runnable",
+            ].join("\n");
         },
     });
-    // ── pipeline-activate ─────────────────────────────────────────────
+    // ── pipeline-activate ────────────────────────────────────────────
     const pipelineActivate = tool({
-        description: "Activate a draft pipeline, making it runnable. " +
-            "Gates can only be executed on active pipelines.",
+        description: "Activate a draft pipeline, making it runnable. Validates that all gates " +
+            "are properly configured before activation.",
         args: {
-            pipeline_id: z.string().describe("Pipeline ID (e.g., PL-001)"),
+            pipelineId: z.string().describe("Pipeline ID to activate"),
         },
         async execute(args) {
             const result = await pipelineUseCases.activatePipeline({
-                pipelineId: args.pipeline_id,
+                pipelineId: args.pipelineId,
             });
-            return formatResult(result, formatPipeline);
+            if (!result.success) {
+                return `Error: ${result.error}`;
+            }
+            const p = result.data;
+            return [
+                `Pipeline ${p.id} activated successfully`,
+                `Status: ${p.status}`,
+                `Current gate: ${p.currentGate ?? "none"}`,
+                `Next gate: ${p.nextGate ?? "none"}`,
+                "",
+                "Pipeline is now ready for gate execution.",
+            ].join("\n");
         },
     });
-    // ── pipeline-cancel ───────────────────────────────────────────────
+    // ── pipeline-cancel ──────────────────────────────────────────────
     const pipelineCancel = tool({
-        description: "Cancel a draft or active pipeline. " +
-            "Terminal action — cancelled pipelines cannot be restarted.",
+        description: "Cancel a draft or active pipeline. This permanently stops the pipeline " +
+            "and cannot be undone. Use pipeline-retry for temporary failures.",
         args: {
-            pipeline_id: z.string().describe("Pipeline ID (e.g., PL-001)"),
+            pipelineId: z.string().describe("Pipeline ID to cancel"),
         },
         async execute(args) {
             const result = await pipelineUseCases.cancelPipeline({
-                pipelineId: args.pipeline_id,
+                pipelineId: args.pipelineId,
             });
-            return formatResult(result, formatPipeline);
+            if (!result.success) {
+                return `Error: ${result.error}`;
+            }
+            const p = result.data;
+            return [
+                `Pipeline ${p.id} cancelled successfully`,
+                `Status: ${p.status}`,
+                "",
+                "Pipeline has been permanently cancelled.",
+            ].join("\n");
         },
     });
-    // ── pipeline-retry ────────────────────────────────────────────────
+    // ── pipeline-retry ───────────────────────────────────────────────
     const pipelineRetry = tool({
-        description: "Retry a failed pipeline. Reactivates the pipeline and resets " +
-            "the failed gate to pending for re-execution.",
+        description: "Retry a failed pipeline. Resets the pipeline to active status and " +
+            "retries the gate that caused the failure.",
         args: {
-            pipeline_id: z.string().describe("Pipeline ID (e.g., PL-001)"),
+            pipelineId: z.string().describe("Pipeline ID to retry"),
         },
         async execute(args) {
             const result = await pipelineUseCases.retryPipeline({
-                pipelineId: args.pipeline_id,
+                pipelineId: args.pipelineId,
             });
-            return formatResult(result, formatPipeline);
+            if (!result.success) {
+                return `Error: ${result.error}`;
+            }
+            const p = result.data;
+            return [
+                `Pipeline ${p.id} retry initiated`,
+                `Status: ${p.status}`,
+                `Current gate: ${p.currentGate ?? "none"}`,
+                "",
+                "Pipeline is retrying the failed gate.",
+            ].join("\n");
         },
     });
-    // ── pipeline-run ──────────────────────────────────────────────────
-    const pipelineRun = tool({
-        description: "Execute a gate via Dagger. Starts the gate, invokes the Dagger " +
-            "function, and passes or fails based on the result. " +
-            "Requires Dagger CLI + container runtime.",
+    // ── gate-run ─────────────────────────────────────────────────────
+    const gateRun = tool({
+        description: "Execute a gate via Dagger. Starts the gate, runs the Dagger function, " +
+            "and automatically passes or fails the gate based on the result.",
         args: {
-            pipeline_id: z.string().describe("Pipeline ID (e.g., PL-001)"),
-            gate_id: z.string().describe("Gate ID (e.g., GT-001)"),
-            module_dir: z
+            pipelineId: z.string().describe("Pipeline ID containing the gate"),
+            gateId: z.string().describe("Gate ID to execute"),
+            moduleDir: z
                 .string()
-                .describe("Path to directory containing dagger.json module"),
+                .describe("Directory containing the Dagger module"),
             args: z
                 .array(z.string())
                 .optional()
-                .describe("Additional Dagger function arguments"),
-            timeout_ms: z
+                .describe("Optional arguments to pass to the Dagger function"),
+            timeoutMs: z
                 .number()
                 .optional()
-                .describe("Execution timeout in milliseconds (default: 300000)"),
+                .describe("Optional timeout in milliseconds (default: 300000)"),
         },
         async execute(args) {
             const result = await pipelineUseCases.runGate({
-                pipelineId: args.pipeline_id,
-                gateId: args.gate_id,
-                moduleDir: args.module_dir,
+                pipelineId: args.pipelineId,
+                gateId: args.gateId,
+                moduleDir: args.moduleDir,
                 ...(args.args !== undefined ? { args: args.args } : {}),
-                ...(args.timeout_ms !== undefined ? { timeoutMs: args.timeout_ms } : {}),
+                ...(args.timeoutMs !== undefined ? { timeoutMs: args.timeoutMs } : {}),
             });
-            return formatResult(result, formatRunGateResult);
+            if (!result.success) {
+                return `Error: ${result.error}`;
+            }
+            const { pipeline: p, gateId, daggerResult } = result.data;
+            const lines = [
+                `Gate ${gateId} execution completed`,
+                `Pipeline: ${p.id}`,
+                `Status: ${p.status}`,
+                `Result: ${daggerResult.success ? "PASSED" : "FAILED"}`,
+            ];
+            if (daggerResult.exitCode !== undefined) {
+                lines.push(`Exit code: ${daggerResult.exitCode}`);
+            }
+            if (daggerResult.durationMs !== undefined) {
+                lines.push(`Duration: ${daggerResult.durationMs}ms`);
+            }
+            if (daggerResult.output) {
+                lines.push("", "Output:", daggerResult.output);
+            }
+            return lines.join("\n");
         },
     });
-    // ── pipeline-gate ─────────────────────────────────────────────────
-    const pipelineGate = tool({
-        description: "Manual gate operations: pass, fail, skip, or retry a gate. " +
-            "Use 'pass' or 'fail' to manually set gate outcome. " +
-            "Use 'skip' with a reason (enforces skip policy). " +
-            "Use 'retry' to reset a failed gate to pending.",
+    // ── gate-pass ────────────────────────────────────────────────────
+    const gatePass = tool({
+        description: "Manually pass a gate. Use this for gates that require manual approval " +
+            "or when a gate was incorrectly failed.",
         args: {
-            pipeline_id: z.string().describe("Pipeline ID (e.g., PL-001)"),
-            gate_id: z.string().describe("Gate ID (e.g., GT-001)"),
-            action: GATE_ACTION_ENUM.describe("Gate action to perform"),
+            pipelineId: z.string().describe("Pipeline ID containing the gate"),
+            gateId: z.string().describe("Gate ID to pass"),
             output: z
                 .string()
                 .optional()
-                .describe("Output text for pass/fail actions"),
-            reason: z
-                .string()
-                .optional()
-                .describe("Justification for skip action (required for skip)"),
-            approved_by: z
-                .string()
-                .optional()
-                .describe("Approver name for skip on approval_required gates"),
+                .describe("Optional output/notes for passing the gate"),
         },
         async execute(args) {
-            switch (args.action) {
-                case "pass": {
-                    const result = await pipelineUseCases.passGate({
-                        pipelineId: args.pipeline_id,
-                        gateId: args.gate_id,
-                        ...(args.output !== undefined ? { output: args.output } : {}),
-                    });
-                    return formatResult(result, formatPipeline);
-                }
-                case "fail": {
-                    const result = await pipelineUseCases.failGate({
-                        pipelineId: args.pipeline_id,
-                        gateId: args.gate_id,
-                        ...(args.output !== undefined ? { output: args.output } : {}),
-                    });
-                    return formatResult(result, formatPipeline);
-                }
-                case "skip": {
-                    if (args.reason === undefined) {
-                        return "ERROR: reason is required for skip action";
-                    }
-                    const result = await pipelineUseCases.skipGate({
-                        pipelineId: args.pipeline_id,
-                        gateId: args.gate_id,
-                        reason: args.reason,
-                        ...(args.approved_by !== undefined
-                            ? { approvedBy: args.approved_by }
-                            : {}),
-                    });
-                    return formatResult(result, formatPipeline);
-                }
-                case "retry": {
-                    const result = await pipelineUseCases.retryGate({
-                        pipelineId: args.pipeline_id,
-                        gateId: args.gate_id,
-                    });
-                    return formatResult(result, formatPipeline);
-                }
+            const result = await pipelineUseCases.passGate({
+                pipelineId: args.pipelineId,
+                gateId: args.gateId,
+                ...(args.output !== undefined ? { output: args.output } : {}),
+            });
+            if (!result.success) {
+                return `Error: ${result.error}`;
             }
+            const p = result.data;
+            return [
+                `Gate ${args.gateId} passed successfully`,
+                `Pipeline: ${p.id}`,
+                `Status: ${p.status}`,
+                `Next gate: ${p.nextGate ?? "pipeline complete"}`,
+            ].join("\n");
         },
     });
-    // ── pipeline-status ───────────────────────────────────────────────
-    const pipelineStatus = tool({
-        description: "Get detailed information about a specific pipeline. " +
-            "Shows status, version, all gates with their statuses, and timing.",
+    // ── gate-fail ────────────────────────────────────────────────────
+    const gateFail = tool({
+        description: "Manually fail a gate. Use this when a gate needs to fail for reasons " +
+            "outside of automated checks.",
         args: {
-            pipeline_id: z.string().describe("Pipeline ID (e.g., PL-001)"),
+            pipelineId: z.string().describe("Pipeline ID containing the gate"),
+            gateId: z.string().describe("Gate ID to fail"),
+            reason: z.string().describe("Reason for failing the gate"),
         },
         async execute(args) {
-            const result = await pipelineUseCases.getPipeline({
-                pipelineId: args.pipeline_id,
-            });
-            return formatResult(result, (data) => {
-                if (data === null)
-                    return `Pipeline ${args.pipeline_id} not found`;
-                return formatPipeline(data);
-            });
-        },
-    });
-    // ── pipeline-list ─────────────────────────────────────────────────
-    const pipelineList = tool({
-        description: "List pipelines for the current workspace. " +
-            "Optionally filter by status or scope.",
-        args: {
-            status: z
-                .enum(["draft", "active", "completed", "failed", "cancelled"])
-                .optional()
-                .describe("Filter by pipeline status"),
-            scope: SCOPE_ENUM.optional().describe("Filter by pipeline scope"),
-        },
-        async execute(args, ctx) {
-            const workspace = getWorkspace(ctx.directory);
-            const result = await pipelineUseCases.listPipelines({
-                workspace,
-                ...(args.status !== undefined ? { status: args.status } : {}),
-                ...(args.scope !== undefined ? { scope: args.scope } : {}),
-            });
-            return formatResult(result, (pipelines) => {
-                if (pipelines.length === 0)
-                    return "No pipelines found";
-                return pipelines.map(formatPipeline).join("\n\n");
+            const result = await pipelineUseCases.failGate({
+                pipelineId: args.pipelineId,
+                gateId: args.gateId,
+                reason: args.reason,
             });
+            if (!result.success) {
+                return `Error: ${result.error}`;
+            }
+            const p = result.data;
+            return [
+                `Gate ${args.gateId} failed`,
+                `Pipeline: ${p.id}`,
+                `Status: ${p.status}`,
+                `Reason: ${args.reason}`,
+                "",
+                "Use pipeline-retry to retry this pipeline.",
+            ].join("\n");
         },
     });
-    // ── pipeline-template ─────────────────────────────────────────────
-    const pipelineTemplate = tool({
-        description: "Browse available pipeline templates. " +
-            "Without arguments, lists all available stack templates. " +
-            "With stack + scope, shows template details including gate definitions.",
+    // ── gate-skip ────────────────────────────────────────────────────
+    const gateSkip = tool({
+        description: "Skip a gate with a reason. Use this for gates that are not applicable " +
+            "in the current context (e.g., skipping integration tests for a docs change).",
         args: {
-            stack: STACK_ENUM.optional().describe("Stack template to inspect"),
-            scope: SCOPE_ENUM.optional().describe("Pipeline scope for template details"),
+            pipelineId: z.string().describe("Pipeline ID containing the gate"),
+            gateId: z.string().describe("Gate ID to skip"),
+            reason: z.string().describe("Reason for skipping the gate"),
         },
         async execute(args) {
-            if (args.stack !== undefined && args.scope !== undefined) {
-                const result = await pipelineUseCases.getTemplate({
-                    stack: args.stack,
-                    scope: args.scope,
-                });
-                return formatResult(result, (data) => {
-                    if (data === null)
-                        return `Template not found: ${args.stack} (${args.scope})`;
-                    return formatTemplate(data);
-                });
-            }
-            const result = await pipelineUseCases.getTemplates();
-            return formatResult(result, (data) => {
-                const lines = [
-                    `Available Pipeline Templates (${data.templates.length}):`,
-                    ...data.templates.map((t) => `  - ${t}`),
-                    "",
-                    "Use with stack + scope args to see gate details.",
-                ];
-                return lines.join("\n");
+            const result = await pipelineUseCases.skipGate({
+                pipelineId: args.pipelineId,
+                gateId: args.gateId,
+                reason: args.reason,
             });
+            if (!result.success) {
+                return `Error: ${result.error}`;
+            }
+            const p = result.data;
+            return [
+                `Gate ${args.gateId} skipped`,
+                `Pipeline: ${p.id}`,
+                `Status: ${p.status}`,
+                `Reason: ${args.reason}`,
+                `Next gate: ${p.nextGate ?? "pipeline complete"}`,
+            ].join("\n");
         },
     });
-    // ── Scaffold Tool ────────────────────────────────────────────────────
-    const pipelineScaffold = tool({
-        description: "Generate Dagger module scaffold files for a stack template. " +
-            "Outputs file paths and content for a complete Dagger module " +
-            "(.dagger/dagger.json + source files). Pass stack to generate, " +
-            "or omit to list supported stacks.",
+    // ── pipeline-query ───────────────────────────────────────────────
+    const pipelineQuery = tool({
+        description: "Query pipelines and templates. Supports various query types: get pipeline by ID, " +
+            "list pipelines by workspace (with optional status/scope filter), list templates.",
         args: {
-            stack: z
+            query: z
+                .enum(PIPELINE_QUERY_VALUES)
+                .describe("Query type to execute"),
+            pipelineId: z
                 .string()
                 .optional()
-                .describe("Stack template (e.g., typescript-lib, python-app). Omit to list supported."),
+                .describe("Pipeline ID (required for get-pipeline)"),
+            workspace: z
+                .string()
+                .optional()
+                .describe("Workspace ID (required for list-pipelines)"),
+            status: z
+                .enum(PIPELINE_STATUS_VALUES)
+                .optional()
+                .describe("Optional status filter for list-pipelines"),
+            scope: z
+                .enum(PIPELINE_SCOPE_VALUES)
+                .optional()
+                .describe("Optional scope filter for list-pipelines"),
         },
-        async execute({ stack }) {
-            if (stack === undefined) {
-                const result = await pipelineUseCases.getSupportedStacks();
-                return formatResult(result, (data) => {
-                    if (data.stacks.length === 0)
-                        return "No scaffold generators configured.";
+        async execute(args) {
+            switch (args.query) {
+                case "get-pipeline": {
+                    if (args.pipelineId === undefined) {
+                        return "Error: pipelineId is required for get-pipeline query";
+                    }
+                    const result = await pipelineUseCases.getPipeline({
+                        pipelineId: args.pipelineId,
+                    });
+                    if (!result.success) {
+                        return `Error: ${result.error}`;
+                    }
+                    const p = result.data;
                     const lines = [
-                        `Supported Scaffold Stacks (${data.stacks.length}):`,
-                        ...data.stacks.map((s) => `  - ${s}`),
+                        `Pipeline ${p.id}`,
+                        `Status: ${p.status}`,
+                        `Template: ${p.templateId}`,
+                        `Scope: ${p.scope}`,
+                        `Version: ${p.version}`,
+                        `Gates: ${p.gateCount}`,
+                        `Current gate: ${p.currentGate ?? "none"}`,
+                        `Next gate: ${p.nextGate ?? "none"}`,
+                        `Created: ${p.createdAt}`,
                     ];
+                    if (p.activatedAt !== undefined) {
+                        lines.push(`Activated: ${p.activatedAt}`);
+                    }
+                    if (p.completedAt !== undefined) {
+                        lines.push(`Completed: ${p.completedAt}`);
+                    }
+                    if (p.cardId !== undefined) {
+                        lines.push(`Card: ${p.cardId}`);
+                    }
+                    // Add gates detail
+                    if (p.gates && p.gates.length > 0) {
+                        lines.push("", "Gates:");
+                        for (const g of p.gates) {
+                            lines.push(`  ${g.order}. ${g.id} | ${g.type} | ${g.status} | ${g.daggerFunction}`);
+                        }
+                    }
                     return lines.join("\n");
-                });
-            }
-            const result = await pipelineUseCases.generateScaffold({ stack });
-            return formatResult(result, (data) => {
-                const lines = [
-                    `Dagger Module Scaffold: ${data.stack}`,
-                    `  SDK: ${data.sdk}`,
-                    `  Module: ${data.moduleName}`,
-                    `  Files (${data.files.length}):`,
-                    "",
-                ];
-                for (const file of data.files) {
-                    lines.push(`--- ${file.path} ---`);
-                    lines.push(file.content);
-                    lines.push("");
                 }
-                return lines.join("\n");
-            });
+                case "list-pipelines": {
+                    if (args.workspace === undefined) {
+                        return "Error: workspace is required for list-pipelines query";
+                    }
+                    const result = await pipelineUseCases.listPipelines({
+                        workspace: args.workspace,
+                        ...(args.status !== undefined ? { status: args.status } : {}),
+                        ...(args.scope !== undefined ? { scope: args.scope } : {}),
+                    });
+                    if (!result.success) {
+                        return `Error: ${result.error}`;
+                    }
+                    if (result.data.length === 0) {
+                        return "No pipelines found";
+                    }
+                    const lines = [
+                        `Pipelines for workspace ${args.workspace}${args.status ? ` (status=${args.status})` : ""}${args.scope ? ` (scope=${args.scope})` : ""}:`,
+                        "",
+                    ];
+                    for (const p of result.data) {
+                        lines.push(`- ${p.id} | ${p.status} | ${p.templateId} | ${p.scope} | ${p.gateCount} gates`);
+                    }
+                    return lines.join("\n");
+                }
+                case "list-templates": {
+                    const result = await pipelineUseCases.getTemplates();
+                    if (!result.success) {
+                        return `Error: ${result.error}`;
+                    }
+                    if (result.data.templates.length === 0) {
+                        return "No templates found";
+                    }
+                    const lines = ["Available pipeline templates:", ""];
+                    for (const t of result.data.templates) {
+                        lines.push(`- ${t}`);
+                    }
+                    return lines.join("\n");
+                }
+                default:
+                    return `Error: Unknown query type "${args.query}"`;
+            }
         },
     });
     return {
@@ -413,12 +396,11 @@ export function createPipelineTools(deps) {
         "pipeline-activate": pipelineActivate,
         "pipeline-cancel": pipelineCancel,
         "pipeline-retry": pipelineRetry,
-        "pipeline-run": pipelineRun,
-        "pipeline-gate": pipelineGate,
-        "pipeline-status": pipelineStatus,
-        "pipeline-list": pipelineList,
-        "pipeline-template": pipelineTemplate,
-        "pipeline-scaffold": pipelineScaffold,
+        "gate-run": gateRun,
+        "gate-pass": gatePass,
+        "gate-fail": gateFail,
+        "gate-skip": gateSkip,
+        "pipeline-query": pipelineQuery,
     };
 }
 //# sourceMappingURL=pipeline-tools.js.map