chainlesschain 0.37.10 → 0.37.12

package/src/commands/workflow.js

@@ -0,0 +1,359 @@
+/**
+ * Workflow engine commands
+ * chainlesschain workflow create|list|run|status|pause|resume|rollback|templates|delete
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  createWorkflow,
+  listWorkflows,
+  executeWorkflow,
+  getExecutionLog,
+  pauseExecution,
+  resumeExecution,
+  rollbackExecution,
+  getTemplates,
+  deleteWorkflow,
+} from "../lib/workflow-engine.js";
+
+export function registerWorkflowCommand(program) {
+  const workflow = program
+    .command("workflow")
+    .description(
+      "Workflow engine — create, run, and manage DAG-based workflows",
+    );
+
+  // workflow create <name>
+  workflow
+    .command("create <name>")
+    .description("Create a new workflow")
+    .option("-d, --description <desc>", "Workflow description")
+    .option("-t, --template <id>", "Use a built-in template")
+    .option("-s, --stages <json>", "Stages as JSON array")
+    .option("--json", "Output as JSON")
+    .action(async (name, 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();
+
+        let stages;
+        if (options.template) {
+          const templates = getTemplates();
+          const tpl = templates.find((t) => t.id === options.template);
+          if (!tpl) {
+            logger.error(
+              `Template not found: ${options.template}. Use "workflow templates" to list.`,
+            );
+            await shutdown();
+            process.exit(1);
+          }
+          stages = tpl.stages;
+        } else if (options.stages) {
+          try {
+            stages = JSON.parse(options.stages);
+          } catch (_err) {
+            logger.error("Invalid JSON for --stages");
+            await shutdown();
+            process.exit(1);
+          }
+        } else {
+          logger.error("Provide --template <id> or --stages <json>");
+          await shutdown();
+          process.exit(1);
+        }
+
+        const result = createWorkflow(db, {
+          name,
+          description: options.description,
+          stages,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(chalk.green(`Workflow created: ${result.id}`));
+          logger.log(`  Name: ${chalk.cyan(name)}`);
+          logger.log(`  Stages: ${result.stages.length}`);
+          logger.log(`  Status: ${result.status}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow list
+  workflow
+    .command("list")
+    .description("List all workflows")
+    .option("--json", "Output as JSON")
+    .action(async (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 workflows = listWorkflows(db);
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              workflows.map((w) => ({
+                id: w.id,
+                name: w.name,
+                description: w.description,
+                status: w.status,
+                stages: w.dag.length,
+                created_at: w.created_at,
+              })),
+              null,
+              2,
+            ),
+          );
+        } else if (workflows.length === 0) {
+          logger.info(
+            'No workflows found. Create one with "chainlesschain workflow create"',
+          );
+        } else {
+          logger.log(chalk.bold(`Workflows (${workflows.length}):\n`));
+          for (const w of workflows) {
+            logger.log(
+              `  ${chalk.cyan(w.id)} — ${w.name} [${chalk.green(w.status)}]`,
+            );
+            if (w.description) logger.log(`    ${chalk.gray(w.description)}`);
+            logger.log(`    Stages: ${w.dag.length}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow run <id>
+  workflow
+    .command("run <id>")
+    .description("Execute a workflow")
+    .option("-i, --input <json>", "Input data as JSON")
+    .option("--json", "Output as JSON")
+    .action(async (id, 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();
+
+        let input = {};
+        if (options.input) {
+          try {
+            input = JSON.parse(options.input);
+          } catch (_err) {
+            logger.error("Invalid JSON for --input");
+            await shutdown();
+            process.exit(1);
+          }
+        }
+
+        const result = executeWorkflow(db, id, input);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(chalk.green(`Workflow executed: ${result.id}`));
+          logger.log(`  Status: ${result.status}`);
+          logger.log(`  Steps completed: ${result.log.length}`);
+          for (const entry of result.log) {
+            logger.log(
+              `    ${chalk.gray("•")} ${entry.stageName} [${entry.type}] — ${chalk.green(entry.status)}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow status <exec-id>
+  workflow
+    .command("status <exec-id>")
+    .description("Show execution status and log")
+    .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 result = getExecutionLog(db, execId);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(chalk.bold(`Execution: ${result.id}`));
+          logger.log(`  Workflow: ${result.workflowId}`);
+          logger.log(`  Status: ${chalk.cyan(result.status)}`);
+          logger.log(`  Started: ${result.startedAt || "N/A"}`);
+          logger.log(`  Completed: ${result.completedAt || "N/A"}`);
+          if (result.log.length > 0) {
+            logger.log(`  Log:`);
+            for (const entry of result.log) {
+              if (entry.stageName) {
+                logger.log(
+                  `    ${chalk.gray("•")} ${entry.stageName} — ${entry.status}`,
+                );
+              } else if (entry.action) {
+                logger.log(
+                  `    ${chalk.gray("•")} ${entry.action} at ${entry.timestamp}`,
+                );
+              }
+            }
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow pause <exec-id>
+  workflow
+    .command("pause <exec-id>")
+    .description("Pause a running execution")
+    .action(async (execId) => {
+      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 = pauseExecution(db, execId);
+        logger.log(chalk.yellow(`Execution paused: ${result.id}`));
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow resume <exec-id>
+  workflow
+    .command("resume <exec-id>")
+    .description("Resume a paused execution")
+    .action(async (execId) => {
+      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 = resumeExecution(db, execId);
+        logger.log(chalk.green(`Execution resumed: ${result.id}`));
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow rollback <exec-id>
+  workflow
+    .command("rollback <exec-id>")
+    .description("Rollback an execution")
+    .action(async (execId) => {
+      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 = rollbackExecution(db, execId);
+        logger.log(chalk.red(`Execution rolled back: ${result.id}`));
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // workflow templates
+  workflow
+    .command("templates")
+    .description("List built-in workflow templates")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const templates = getTemplates();
+
+        if (options.json) {
+          console.log(JSON.stringify(templates, null, 2));
+        } else {
+          logger.log(chalk.bold(`Workflow 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 delete <id>
+  workflow
+    .command("delete <id>")
+    .description("Delete a workflow")
+    .action(async (id) => {
+      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 = deleteWorkflow(db, id);
+
+        if (result.deleted) {
+          logger.log(chalk.green(`Workflow deleted: ${id}`));
+        } else {
+          logger.warn(`Workflow not found: ${id}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/zkp.js

@@ -0,0 +1,277 @@
+/**
+ * ZKP commands
+ * chainlesschain zkp compile|prove|verify|identity|stats|circuits|proofs
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureZKPTables,
+  compileCircuit,
+  generateProof,
+  verifyProof,
+  createIdentityProof,
+  getZKPStats,
+  listCircuits,
+  listProofs,
+} from "../lib/zkp-engine.js";
+
+export function registerZkpCommand(program) {
+  const zkp = program
+    .command("zkp")
+    .description("Zero-knowledge proof engine — circuits, proofs, identity");
+
+  // zkp compile
+  zkp
+    .command("compile <name>")
+    .description("Compile a ZKP circuit")
+    .option("--definition <json>", "Circuit definition as JSON")
+    .action(async (name, 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();
+        ensureZKPTables(db);
+
+        const def = options.definition || "{}";
+        const circuit = compileCircuit(db, name, def);
+        logger.success(`Circuit compiled: ${chalk.cyan(name)}`);
+        logger.log(
+          `  ${chalk.bold("ID:")}           ${chalk.cyan(circuit.id)}`,
+        );
+        logger.log(`  ${chalk.bold("Constraints:")}  ${circuit.constraints}`);
+        logger.log(
+          `  ${chalk.bold("VK:")}           ${circuit.verificationKey.slice(0, 16)}...`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp prove
+  zkp
+    .command("prove <circuit-id>")
+    .description("Generate a zero-knowledge proof")
+    .option("--private <json>", "Private inputs as JSON")
+    .option("--public <json>", "Public inputs as JSON")
+    .option("--json", "Output as JSON")
+    .action(async (circuitId, 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();
+        ensureZKPTables(db);
+
+        const privateInputs = options.private
+          ? JSON.parse(options.private)
+          : {};
+        const publicInputs = options.public ? JSON.parse(options.public) : [];
+        const proof = generateProof(db, circuitId, privateInputs, publicInputs);
+
+        if (options.json) {
+          console.log(JSON.stringify(proof, null, 2));
+        } else {
+          logger.success("Proof generated");
+          logger.log(`  ${chalk.bold("ID:")}      ${chalk.cyan(proof.id)}`);
+          logger.log(`  ${chalk.bold("Scheme:")}  ${proof.scheme}`);
+          logger.log(`  ${chalk.bold("Circuit:")} ${proof.circuitId}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp verify
+  zkp
+    .command("verify <proof-id>")
+    .description("Verify a zero-knowledge proof")
+    .option("--json", "Output as JSON")
+    .action(async (proofId, 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();
+        ensureZKPTables(db);
+
+        const result = verifyProof(db, proofId);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          const status = result.valid
+            ? chalk.green("VALID")
+            : chalk.red("INVALID");
+          logger.log(
+            `  ${chalk.bold("Proof:")}   ${chalk.cyan(result.proofId)}`,
+          );
+          logger.log(`  ${chalk.bold("Result:")}  ${status}`);
+          logger.log(`  ${chalk.bold("Scheme:")}  ${result.scheme}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp identity
+  zkp
+    .command("identity")
+    .description("Create a selective-disclosure identity proof")
+    .option("--claims <json>", "Identity claims as JSON")
+    .option("--disclose <fields>", "Comma-separated fields to disclose")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const claims = options.claims ? JSON.parse(options.claims) : {};
+        const disclose = options.disclose
+          ? options.disclose.split(",").map((s) => s.trim())
+          : [];
+        const result = createIdentityProof(claims, disclose);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success("Identity proof created");
+          logger.log(`  ${chalk.bold("ID:")}      ${chalk.cyan(result.id)}`);
+          logger.log(`  ${chalk.bold("Type:")}    ${result.type}`);
+          logger.log(
+            `  ${chalk.bold("Disclosed:")} ${JSON.stringify(result.disclosed)}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Hidden:")}  ${result.hiddenCount} field(s)`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp stats
+  zkp
+    .command("stats")
+    .description("Show ZKP engine statistics")
+    .option("--json", "Output as JSON")
+    .action(async (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();
+        ensureZKPTables(db);
+
+        const stats = getZKPStats();
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Circuits:")}       ${stats.circuits}`);
+          logger.log(`  ${chalk.bold("Proofs:")}         ${stats.proofs}`);
+          logger.log(
+            `  ${chalk.bold("Verified:")}       ${stats.verifiedProofs}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp circuits
+  zkp
+    .command("circuits")
+    .description("List all compiled circuits")
+    .option("--json", "Output as JSON")
+    .action(async (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();
+        ensureZKPTables(db);
+
+        const circuits = listCircuits(db);
+        if (options.json) {
+          console.log(JSON.stringify(circuits, null, 2));
+        } else {
+          if (circuits.length === 0) {
+            logger.log("No circuits compiled");
+          } else {
+            for (const c of circuits) {
+              logger.log(
+                `  ${chalk.cyan(c.id.slice(0, 8))} ${chalk.bold(c.name)} — ${c.constraints} constraint(s)`,
+              );
+            }
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // zkp proofs
+  zkp
+    .command("proofs")
+    .description("List proofs")
+    .option("--circuit <id>", "Filter by circuit ID")
+    .option("--json", "Output as JSON")
+    .action(async (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();
+        ensureZKPTables(db);
+
+        const proofs = listProofs(db, { circuitId: options.circuit });
+        if (options.json) {
+          console.log(JSON.stringify(proofs, null, 2));
+        } else {
+          if (proofs.length === 0) {
+            logger.log("No proofs generated");
+          } else {
+            for (const p of proofs) {
+              const status = p.verified
+                ? chalk.green("verified")
+                : chalk.yellow("unverified");
+              logger.log(
+                `  ${chalk.cyan(p.id.slice(0, 8))} ${p.scheme} [${status}]`,
+              );
+            }
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/index.js

@@ -34,6 +34,26 @@ import { registerSyncCommand } from "./commands/sync.js";
 import { registerWalletCommand } from "./commands/wallet.js";
 import { registerOrgCommand } from "./commands/org.js";
 import { registerPluginCommand } from "./commands/plugin.js";
+import { registerInitCommand } from "./commands/init.js";
+import { registerCoworkCommand } from "./commands/cowork.js";
+
+// Phase 6: Advanced AI & Hooks
+import { registerHookCommand } from "./commands/hook.js";
+import { registerWorkflowCommand } from "./commands/workflow.js";
+import { registerHmemoryCommand } from "./commands/hmemory.js";
+import { registerA2aCommand } from "./commands/a2a.js";
+
+// Phase 7: Security & Evolution
+import { registerSandboxCommand } from "./commands/sandbox.js";
+import { registerEvolutionCommand } from "./commands/evolution.js";
+
+// Phase 8: Blockchain & Enterprise
+import { registerEconomyCommand } from "./commands/economy.js";
+import { registerZkpCommand } from "./commands/zkp.js";
+import { registerBiCommand } from "./commands/bi.js";
+
+// Phase 9: Low-Code & Multi-Agent
+import { registerLowcodeCommand } from "./commands/lowcode.js";
 
 export function createProgram() {
   const program = new Command();
@@ -47,6 +67,9 @@ export function createProgram() {
     .option("--verbose", "Enable verbose output")
     .option("--quiet", "Suppress non-essential output");
 
+  // Project initialization
+  registerInitCommand(program);
+
   // Existing commands
   registerSetupCommand(program);
   registerStartCommand(program);
@@ -95,5 +118,26 @@ export function createProgram() {
   registerOrgCommand(program);
   registerPluginCommand(program);
 
+  // Multi-agent collaboration
+  registerCoworkCommand(program);
+
+  // Phase 6: Advanced AI & Hooks
+  registerHookCommand(program);
+  registerWorkflowCommand(program);
+  registerHmemoryCommand(program);
+  registerA2aCommand(program);
+
+  // Phase 7: Security & Evolution
+  registerSandboxCommand(program);
+  registerEvolutionCommand(program);
+
+  // Phase 8: Blockchain & Enterprise
+  registerEconomyCommand(program);
+  registerZkpCommand(program);
+  registerBiCommand(program);
+
+  // Phase 9: Low-Code & Multi-Agent
+  registerLowcodeCommand(program);
+
   return program;
 }