chainlesschain 0.51.0 → 0.81.0

package/src/commands/workflow.js

@@ -16,7 +16,20 @@ import {
   rollbackExecution,
   getTemplates,
   deleteWorkflow,
+  TEMPLATE_TYPE,
+  WORKFLOW_STATUS,
+  NODE_STATUS,
+  listTemplates,
+  createCheckpoint,
+  listCheckpoints,
+  rollbackToCheckpoint,
+  setBreakpoint,
+  listBreakpoints,
+  removeBreakpoint,
+  exportWorkflow,
+  importWorkflow,
 } from "../lib/workflow-engine.js";
+import fs from "fs";
 
 export function registerWorkflowCommand(program) {
   const workflow = program
@@ -356,4 +369,311 @@ export function registerWorkflowCommand(program) {
         process.exit(1);
       }
     });
+
+  // workflow canonical-templates (Phase 82)
+  workflow
+    .command("canonical-templates")
+    .description(
+      "List 5 canonical Phase 82 templates (ci_cd/data_pipeline/...)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const templates = listTemplates();
+        if (options.json) {
+          console.log(JSON.stringify(templates, null, 2));
+        } else {
+          logger.log(
+            chalk.bold(`Canonical Phase 82 Templates (${templates.length}):\n`),
+          );
+          for (const tpl of templates) {
+            logger.log(`  ${chalk.cyan(tpl.id)} — ${tpl.name}`);
+            logger.log(`    ${chalk.gray(tpl.description)}`);
+            logger.log(
+              `    Stages: ${tpl.stages.map((s) => s.name).join(" → ")}`,
+            );
+            logger.log("");
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow statuses (Phase 82) — enum reference
+  workflow
+    .command("statuses")
+    .description("Show workflow and node status enum values (Phase 82)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      const payload = {
+        workflow: WORKFLOW_STATUS,
+        node: NODE_STATUS,
+        template: TEMPLATE_TYPE,
+      };
+      if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+      } else {
+        logger.log(chalk.bold("Workflow statuses:"));
+        for (const v of Object.values(WORKFLOW_STATUS)) {
+          logger.log(`  ${chalk.cyan(v)}`);
+        }
+        logger.log(chalk.bold("\nNode statuses:"));
+        for (const v of Object.values(NODE_STATUS)) {
+          logger.log(`  ${chalk.cyan(v)}`);
+        }
+        logger.log(chalk.bold("\nTemplate types:"));
+        for (const v of Object.values(TEMPLATE_TYPE)) {
+          logger.log(`  ${chalk.cyan(v)}`);
+        }
+      }
+    });
+
+  // workflow checkpoint <exec-id>
+  workflow
+    .command("checkpoint <exec-id>")
+    .description("Create a checkpoint snapshot of an execution")
+    .option("--json", "Output as JSON")
+    .action(async (execId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const cp = createCheckpoint(db, execId);
+        if (options.json) {
+          console.log(JSON.stringify(cp, null, 2));
+        } else {
+          logger.log(chalk.green(`Checkpoint created: ${cp.id}`));
+          logger.log(`  Execution: ${cp.executionId}`);
+          logger.log(`  Workflow:  ${cp.workflowId}`);
+          logger.log(`  Captured:  ${cp.snapshot.capturedAt}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow checkpoints <exec-id>
+  workflow
+    .command("checkpoints <exec-id>")
+    .description("List checkpoints for an execution")
+    .option("--json", "Output as JSON")
+    .action(async (execId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const list = listCheckpoints(db, execId);
+        if (options.json) {
+          console.log(JSON.stringify(list, null, 2));
+        } else if (list.length === 0) {
+          logger.info("No checkpoints for this execution.");
+        } else {
+          logger.log(chalk.bold(`Checkpoints (${list.length}):\n`));
+          for (const cp of list) {
+            logger.log(
+              `  ${chalk.cyan(cp.id)} — ${cp.createdAt} (stage: ${cp.snapshot.currentStage || "?"})`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow rollback-to <exec-id> <checkpoint-id>
+  workflow
+    .command("rollback-to <exec-id> <checkpoint-id>")
+    .description("Rollback an execution to a specific checkpoint")
+    .action(async (execId, cpId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const result = rollbackToCheckpoint(db, execId, cpId);
+        logger.log(
+          chalk.yellow(
+            `Rolled back execution ${result.id} to checkpoint ${result.checkpointId}`,
+          ),
+        );
+        logger.log(`  Status: ${chalk.cyan(result.status)}`);
+        if (result.restoredStage) {
+          logger.log(`  Restored stage: ${result.restoredStage}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow breakpoint-set <wf-id> <node-id> [condition]
+  workflow
+    .command("breakpoint-set <wf-id> <node-id>")
+    .description("Set a breakpoint on a workflow node (optionally conditional)")
+    .option(
+      "-c, --condition <expr>",
+      "Conditional expression, e.g. 'input.priority > 5'",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (wfId, nodeId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const bp = setBreakpoint(db, wfId, nodeId, options.condition || null);
+        if (options.json) {
+          console.log(JSON.stringify(bp, null, 2));
+        } else {
+          logger.log(chalk.green(`Breakpoint set: ${bp.id}`));
+          logger.log(`  Node: ${chalk.cyan(bp.nodeId)}`);
+          if (bp.condition) logger.log(`  Condition: ${bp.condition}`);
+          else logger.log(`  Condition: ${chalk.gray("(unconditional)")}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow breakpoints <wf-id>
+  workflow
+    .command("breakpoints <wf-id>")
+    .description("List breakpoints on a workflow")
+    .option("--json", "Output as JSON")
+    .action(async (wfId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const list = listBreakpoints(db, wfId);
+        if (options.json) {
+          console.log(JSON.stringify(list, null, 2));
+        } else if (list.length === 0) {
+          logger.info("No breakpoints for this workflow.");
+        } else {
+          logger.log(chalk.bold(`Breakpoints (${list.length}):\n`));
+          for (const bp of list) {
+            logger.log(
+              `  ${chalk.cyan(bp.id)} @ node=${bp.nodeId} ${bp.enabled ? chalk.green("enabled") : chalk.gray("disabled")}`,
+            );
+            if (bp.condition) logger.log(`    when: ${bp.condition}`);
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow breakpoint-remove <bp-id>
+  workflow
+    .command("breakpoint-remove <bp-id>")
+    .description("Remove a breakpoint")
+    .action(async (bpId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const result = removeBreakpoint(db, bpId);
+        if (result.removed) {
+          logger.log(chalk.green(`Breakpoint removed: ${bpId}`));
+        } else {
+          logger.warn(`Breakpoint not found: ${bpId}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow export <wf-id>
+  workflow
+    .command("export <wf-id>")
+    .description("Export a workflow as a JSON definition")
+    .option("-o, --output <file>", "Write to file instead of stdout")
+    .action(async (wfId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const def = exportWorkflow(db, wfId);
+        const json = JSON.stringify(def, null, 2);
+        if (options.output) {
+          fs.writeFileSync(options.output, json, "utf-8");
+          logger.log(chalk.green(`Exported to ${options.output}`));
+        } else {
+          console.log(json);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow import <file>
+  workflow
+    .command("import <file>")
+    .description("Import a workflow from a JSON definition file")
+    .option("--json", "Output as JSON")
+    .action(async (file, options) => {
+      try {
+        const raw = fs.readFileSync(file, "utf-8");
+        let def;
+        try {
+          def = JSON.parse(raw);
+        } catch (_err) {
+          logger.error(`Invalid JSON in ${file}`);
+          process.exit(1);
+        }
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const result = importWorkflow(db, def);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(chalk.green(`Workflow imported: ${result.id}`));
+          logger.log(`  Name: ${chalk.cyan(def.name)}`);
+          logger.log(`  Stages: ${result.stages.length}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }