chainlesschain 0.66.0 → 0.132.0

package/src/commands/lowcode.js

@@ -20,7 +20,22 @@ import {
   exportApp,
   listApps,
   deployApp,
+  // Phase 93 V2 surface
+  COMPONENT_CATEGORY,
+  DATASOURCE_TYPE,
+  APP_STATUS,
+  listComponentsV2,
+  registerDataSourceV2,
+  testDataSourceConnection,
+  updateAppStatus,
+  archiveApp,
+  getStatusHistory,
+  cloneApp,
+  exportAppJSON,
+  importAppJSON,
+  getLowcodeStatsV2,
 } from "../lib/app-builder.js";
+import fs from "fs";
 
 export function registerLowcodeCommand(program) {
   const lowcode = program
@@ -305,6 +320,347 @@ export function registerLowcodeCommand(program) {
       }
     });
 
+  // ─── Phase 93 V2 subcommands ────────────────────────────────
+
+  // lowcode categories
+  lowcode
+    .command("categories")
+    .description("List component categories (V2)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const categories = Object.values(COMPONENT_CATEGORY);
+      if (options.json) {
+        console.log(JSON.stringify(categories, null, 2));
+      } else {
+        logger.log(chalk.bold("Component Categories:"));
+        for (const c of categories) logger.log(`  ${chalk.cyan(c)}`);
+      }
+    });
+
+  // lowcode datasource-types
+  lowcode
+    .command("datasource-types")
+    .description("List supported data source types (V2)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const types = Object.values(DATASOURCE_TYPE);
+      if (options.json) {
+        console.log(JSON.stringify(types, null, 2));
+      } else {
+        logger.log(chalk.bold("Data Source Types:"));
+        for (const t of types) logger.log(`  ${chalk.cyan(t)}`);
+      }
+    });
+
+  // lowcode statuses
+  lowcode
+    .command("statuses")
+    .description("List canonical app statuses (V2)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const statuses = Object.values(APP_STATUS);
+      if (options.json) {
+        console.log(JSON.stringify(statuses, null, 2));
+      } else {
+        logger.log(chalk.bold("App Statuses:"));
+        for (const s of statuses) logger.log(`  ${chalk.cyan(s)}`);
+      }
+    });
+
+  // lowcode components-v2
+  lowcode
+    .command("components-v2")
+    .description("List built-in components with category filter (V2)")
+    .option("-c, --category <cat>", "Filter by category")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      try {
+        const list = listComponentsV2(
+          options.category ? { category: options.category } : {},
+        );
+        if (options.json) {
+          console.log(JSON.stringify(list, null, 2));
+        } else {
+          logger.log(chalk.bold(`Components (${list.length}):`));
+          for (const c of list) {
+            logger.log(
+              `  ${chalk.cyan(c.name)} [${c.category}] props: ${c.props.join(", ")}`,
+            );
+          }
+        }
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode datasource-v2 <app-id> <name> <type>
+  lowcode
+    .command("datasource-v2")
+    .description("Register a validated data source (V2)")
+    .argument("<app-id>", "Application ID")
+    .argument("<name>", "Data source name")
+    .argument("<type>", "Type: rest|graphql|database|csv")
+    .option("--config <json>", "Config as JSON string", "{}")
+    .action(async (appId, name, type, options) => {
+      const spinner = ora("Registering data source...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        let config;
+        try {
+          config = JSON.parse(options.config);
+        } catch (_err) {
+          config = {};
+        }
+
+        const result = registerDataSourceV2(db, {
+          appId,
+          name,
+          type,
+          config,
+        });
+        spinner.succeed(
+          `Data source "${chalk.cyan(name)}" registered (${type})`,
+        );
+        logger.log(`  ID: ${chalk.gray(result.id)}`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode test-connection <datasource-id>
+  lowcode
+    .command("test-connection")
+    .description("Heuristic connection check for a data source (V2)")
+    .argument("<datasource-id>", "Data source ID")
+    .option("--json", "Output as JSON")
+    .action((dsId, options) => {
+      const result = testDataSourceConnection(dsId);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        const icon = result.ok ? chalk.green("✓") : chalk.red("✗");
+        logger.log(
+          `${icon} ${chalk.cyan(dsId)} (${result.type || "?"}): ${result.reason}`,
+        );
+      }
+    });
+
+  // lowcode set-status <app-id> <status>
+  lowcode
+    .command("set-status")
+    .description("Update app status with validated transition (V2)")
+    .argument("<app-id>", "Application ID")
+    .argument("<status>", "New status: draft|published|archived")
+    .action(async (appId, status) => {
+      const spinner = ora(`Transitioning to ${status}...`).start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const result = updateAppStatus(db, { appId, status });
+        spinner.succeed(
+          `${chalk.cyan(appId)}: ${result.previous} → ${chalk.bold(result.status)}`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode archive <app-id>
+  lowcode
+    .command("archive")
+    .description("Archive an application (V2)")
+    .argument("<app-id>", "Application ID")
+    .action(async (appId) => {
+      const spinner = ora("Archiving...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        archiveApp(db, appId);
+        spinner.succeed(`${chalk.cyan(appId)} archived`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode status-history <app-id>
+  lowcode
+    .command("status-history")
+    .description("Show status transition history for an app (V2)")
+    .argument("<app-id>", "Application ID")
+    .option("--json", "Output as JSON")
+    .action((appId, options) => {
+      const hist = getStatusHistory(appId);
+      if (options.json) {
+        console.log(JSON.stringify(hist, null, 2));
+      } else if (hist.length === 0) {
+        logger.info("No status transitions recorded");
+      } else {
+        logger.log(chalk.bold(`Status History (${hist.length}):`));
+        for (const h of hist) {
+          logger.log(`  ${chalk.gray(h.at)}  ${h.from} → ${chalk.cyan(h.to)}`);
+        }
+      }
+    });
+
+  // lowcode clone <source-id>
+  lowcode
+    .command("clone")
+    .description("Clone an application (V2)")
+    .argument("<source-id>", "Source app ID")
+    .option("--name <name>", "New name for the clone")
+    .action(async (sourceId, options) => {
+      const spinner = ora("Cloning...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const result = cloneApp(db, {
+          sourceId,
+          newName: options.name,
+        });
+        spinner.succeed(`Cloned ${chalk.cyan(sourceId)} → ${result.clonedId}`);
+        logger.log(`  Name: ${result.name}`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode export-json <app-id>
+  lowcode
+    .command("export-json")
+    .description("Export an app as canonical JSON (V2)")
+    .argument("<app-id>", "Application ID")
+    .option("-o, --output <file>", "Write to file instead of stdout")
+    .action(async (appId, 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();
+        ensureLowcodeTables(db);
+
+        const result = exportAppJSON(db, appId);
+        const json = JSON.stringify(result, null, 2);
+        if (options.output) {
+          fs.writeFileSync(options.output, json, "utf-8");
+          logger.log(chalk.green(`Wrote ${options.output}`));
+        } else {
+          console.log(json);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode import-json <file>
+  lowcode
+    .command("import-json")
+    .description("Import an app from a canonical JSON file (V2)")
+    .argument("<file>", "Path to JSON export")
+    .action(async (file) => {
+      const spinner = ora("Importing...").start();
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          spinner.fail("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureLowcodeTables(db);
+
+        const raw = fs.readFileSync(file, "utf-8");
+        const json = JSON.parse(raw);
+        const result = importAppJSON(db, json);
+        spinner.succeed(
+          `Imported "${chalk.cyan(result.name)}" → ${result.importedId}`,
+        );
+        logger.log(`  Data sources: ${result.dataSources}`);
+
+        await shutdown();
+      } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+      }
+    });
+
+  // lowcode stats-v2
+  lowcode
+    .command("stats-v2")
+    .description("Low-code platform statistics (V2)")
+    .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();
+        ensureLowcodeTables(db);
+
+        const stats = getLowcodeStatsV2(db);
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          logger.log(chalk.bold("Low-Code Stats (V2):"));
+          logger.log(`  Total apps:    ${chalk.cyan(stats.totalApps)}`);
+          logger.log(`  By status:     ${JSON.stringify(stats.byStatus)}`);
+          logger.log(`  By platform:   ${JSON.stringify(stats.byPlatform)}`);
+          logger.log(
+            `  Data sources:  ${stats.dataSources.total} (${JSON.stringify(stats.dataSources.byType)})`,
+          );
+          logger.log(`  Components:    ${stats.componentsAvailable}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
   // lowcode deploy <app-id>
   lowcode
     .command("deploy")

package/src/commands/marketplace.js

@@ -18,6 +18,21 @@ import {
   recordInvocation,
   listInvocations,
   getInvocationStats,
+  // V2 (Phase 65)
+  SERVICE_STATUS_V2,
+  INVOCATION_STATUS_V2,
+  PRICING_MODEL_V2,
+  MARKETPLACE_DEFAULT_MAX_CONCURRENT_INVOCATIONS,
+  setMaxConcurrentInvocations,
+  getMaxConcurrentInvocations,
+  getActiveInvocationCount,
+  beginInvocationV2,
+  startInvocation,
+  completeInvocationV2,
+  failInvocationV2,
+  timeoutInvocationV2,
+  setInvocationStatus,
+  getMarketplaceStatsV2,
 } from "../lib/skill-marketplace.js";
 
 function _dbFromCtx(ctx) {
@@ -323,4 +338,245 @@ export function registerMarketplaceCommand(program) {
         process.exit(1);
       }
     });
+
+  /* ── V2 (Phase 65) ───────────────────────────────────────── */
+
+  mp.command("service-statuses-v2")
+    .description("List V2 service statuses (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(SERVICE_STATUS_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  mp.command("invocation-statuses-v2")
+    .description("List V2 invocation statuses (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(INVOCATION_STATUS_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  mp.command("pricing-models")
+    .description("List V2 pricing models (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(PRICING_MODEL_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  mp.command("default-max-concurrent")
+    .description("Show default per-service concurrency cap")
+    .action(() => {
+      logger.log(`  ${MARKETPLACE_DEFAULT_MAX_CONCURRENT_INVOCATIONS}`);
+    });
+
+  mp.command("max-concurrent")
+    .description("Show current per-service concurrency cap")
+    .action(() => {
+      logger.log(`  ${getMaxConcurrentInvocations()}`);
+    });
+
+  mp.command("active-invocation-count [service-id]")
+    .description(
+      "Show count of PENDING + RUNNING invocations (all services by default)",
+    )
+    .action((serviceId) => {
+      logger.log(`  ${getActiveInvocationCount(serviceId)}`);
+    });
+
+  mp.command("set-max-concurrent <n>")
+    .description("Set the per-service concurrency cap")
+    .action((n) => {
+      try {
+        const v = setMaxConcurrentInvocations(Number(n));
+        logger.success(`Max concurrent invocations = ${v}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("begin-v2 <service-id>")
+    .description("Begin a V2 invocation (creates PENDING, enforces cap)")
+    .option("-c, --caller <id>", "Caller ID")
+    .option("-i, --input <json>", "JSON-encoded input")
+    .option("--json", "Output as JSON")
+    .action(async (serviceId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        let input = null;
+        if (options.input) {
+          try {
+            input = JSON.parse(options.input);
+          } catch {
+            input = options.input;
+          }
+        }
+        const inv = beginInvocationV2(db, {
+          serviceId,
+          callerId: options.caller,
+          input,
+        });
+        if (options.json) console.log(JSON.stringify(inv, null, 2));
+        else {
+          logger.success(`Invocation queued [${inv.status}]`);
+          logger.log(`  ${chalk.bold("ID:")} ${chalk.cyan(inv.id)}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("start-invocation <invocation-id>")
+    .description("Start a V2 invocation (PENDING → RUNNING)")
+    .option("--json", "Output as JSON")
+    .action(async (invocationId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = startInvocation(db, invocationId);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`Status = ${result.status}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("complete-invocation <invocation-id>")
+    .description("Complete a V2 invocation (RUNNING → SUCCESS)")
+    .option("-o, --output <json>", "JSON-encoded output")
+    .option("-d, --duration-ms <n>", "Duration in milliseconds", parseInt)
+    .option("--json", "Output as JSON")
+    .action(async (invocationId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        let output = null;
+        if (options.output) {
+          try {
+            output = JSON.parse(options.output);
+          } catch {
+            output = options.output;
+          }
+        }
+        const result = completeInvocationV2(db, invocationId, {
+          output,
+          durationMs: options.durationMs,
+        });
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`Status = ${result.status}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("fail-invocation <invocation-id>")
+    .description("Fail a V2 invocation")
+    .option("-m, --message <msg>", "Error message")
+    .option("-d, --duration-ms <n>", "Duration in milliseconds", parseInt)
+    .action(async (invocationId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = failInvocationV2(db, invocationId, options.message, {
+          durationMs: options.durationMs,
+        });
+        logger.success(`Status = ${result.status}`);
+        if (result.error) logger.log(`  Error: ${result.error}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("timeout-invocation <invocation-id>")
+    .description("Timeout a V2 invocation")
+    .option("-d, --duration-ms <n>", "Duration in milliseconds", parseInt)
+    .action(async (invocationId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = timeoutInvocationV2(db, invocationId, {
+          durationMs: options.durationMs,
+        });
+        logger.success(`Status = ${result.status}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("set-invocation-status <invocation-id> <status>")
+    .description("Set V2 invocation status via the state machine")
+    .option("-m, --message <msg>", "Error message (FAILED/TIMEOUT)")
+    .option("--json", "Output as JSON")
+    .action(async (invocationId, status, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const patch = options.message ? { error: options.message } : {};
+        const result = setInvocationStatus(db, invocationId, status, patch);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`Status = ${result.status}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("stats-v2")
+    .description("V2 aggregated stats")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const stats = getMarketplaceStatsV2();
+        if (options.json) console.log(JSON.stringify(stats, null, 2));
+        else {
+          logger.log(
+            `  ${chalk.bold("Services:")}       ${stats.totalServices}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Invocations:")}    ${stats.totalInvocations} (active: ${stats.activeInvocations})`,
+          );
+          logger.log(
+            `  ${chalk.bold("Max concurrent:")} ${stats.maxConcurrentInvocations}`,
+          );
+          logger.log(`  ${chalk.bold("Services by status:")}`);
+          for (const [k, v] of Object.entries(stats.servicesByStatus))
+            logger.log(`    ${k.padEnd(12)} ${v}`);
+          logger.log(`  ${chalk.bold("Services by pricing:")}`);
+          for (const [k, v] of Object.entries(stats.servicesByPricing))
+            logger.log(`    ${k.padEnd(14)} ${v}`);
+          logger.log(`  ${chalk.bold("Invocations by status:")}`);
+          for (const [k, v] of Object.entries(stats.invocationsByStatus))
+            logger.log(`    ${k.padEnd(10)} ${v}`);
+          logger.log(
+            `  ${chalk.bold("Success rate:")}   ${(stats.successRate * 100).toFixed(1)}%`,
+          );
+          logger.log(
+            `  ${chalk.bold("Avg duration:")}   ${stats.avgDurationMs}ms`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }