chainlesschain 0.47.9 → 0.49.0

package/src/commands/kg.js

@@ -0,0 +1,371 @@
+/**
+ * Knowledge Graph commands (Phase 94)
+ * chainlesschain kg entity-types|add|list|show|remove|add-relation|relations|
+ *                    query|reason|stats|export|import
+ */
+
+import fs from "fs";
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureKnowledgeGraphTables,
+  listEntityTypes,
+  addEntity,
+  getEntity,
+  listEntities,
+  removeEntity,
+  addRelation,
+  listRelations,
+  reason,
+  getStats,
+  exportGraph,
+  importGraph,
+} from "../lib/knowledge-graph.js";
+
+function _dbFromCtx(ctx) {
+  if (!ctx.db) {
+    logger.error("Database not available");
+    process.exit(1);
+  }
+  const db = ctx.db.getDatabase();
+  ensureKnowledgeGraphTables(db);
+  return db;
+}
+
+function _printEntity(e) {
+  logger.log(`  ${chalk.bold("ID:")}         ${chalk.cyan(e.id)}`);
+  logger.log(`  ${chalk.bold("Name:")}       ${e.name}`);
+  logger.log(`  ${chalk.bold("Type:")}       ${chalk.yellow(e.type)}`);
+  if (e.tags && e.tags.length > 0) {
+    logger.log(`  ${chalk.bold("Tags:")}       ${e.tags.join(", ")}`);
+  }
+  if (e.properties) {
+    logger.log(
+      `  ${chalk.bold("Properties:")} ${JSON.stringify(e.properties)}`,
+    );
+  }
+}
+
+export function registerKgCommand(program) {
+  const kg = program
+    .command("kg")
+    .description(
+      "Knowledge graph — entities, relations, multi-hop reasoning, stats",
+    );
+
+  kg.command("entity-types")
+    .description("List recommended entity types")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const types = listEntityTypes();
+      if (options.json) {
+        console.log(JSON.stringify(types, null, 2));
+      } else {
+        for (const t of types) {
+          logger.log(`  ${chalk.cyan(t.name.padEnd(14))} ${t.description}`);
+        }
+      }
+    });
+
+  kg.command("add <name> <type>")
+    .description("Add an entity")
+    .option("-p, --properties <json>", "Properties JSON")
+    .option("-g, --tags <csv>", "Comma-separated tags")
+    .option("--json", "Output as JSON")
+    .action(async (name, type, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const properties = options.properties
+          ? JSON.parse(options.properties)
+          : null;
+        const tags = options.tags
+          ? options.tags
+              .split(",")
+              .map((s) => s.trim())
+              .filter(Boolean)
+          : null;
+        const entity = addEntity(db, { name, type, properties, tags });
+        if (options.json) {
+          console.log(JSON.stringify(entity, null, 2));
+        } else {
+          logger.success(`Entity added: ${name} [${type}]`);
+          _printEntity(entity);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("list")
+    .description("List entities")
+    .option("-t, --type <t>", "Filter by type")
+    .option("-n, --name <substr>", "Filter by name substring")
+    .option("-g, --tag <tag>", "Filter by tag")
+    .option("--limit <n>", "Maximum entries", parseInt, 50)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const rows = listEntities({
+          type: options.type,
+          name: options.name,
+          tag: options.tag,
+          limit: options.limit,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No entities.");
+        } else {
+          for (const e of rows) {
+            logger.log(
+              `  ${chalk.cyan(e.id.slice(0, 8))} ${chalk.yellow(e.type.padEnd(14))} ${e.name}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("show <entity-id>")
+    .description("Show entity details")
+    .option("--json", "Output as JSON")
+    .action(async (entityId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const entity = getEntity(entityId);
+        if (!entity) {
+          logger.error(`Entity not found: ${entityId}`);
+          process.exit(1);
+        }
+        if (options.json) {
+          console.log(JSON.stringify(entity, null, 2));
+        } else {
+          _printEntity(entity);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("remove <entity-id>")
+    .description("Remove entity (cascades to relations)")
+    .action(async (entityId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const ok = removeEntity(db, entityId);
+        if (ok) {
+          logger.success(`Entity removed: ${entityId}`);
+        } else {
+          logger.info(`No such entity: ${entityId}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("add-relation <source-id> <target-id> <relation-type>")
+    .description("Add a directed relation between two entities")
+    .option("-w, --weight <n>", "Relation weight", parseFloat, 1.0)
+    .option("-p, --properties <json>", "Properties JSON")
+    .option("--json", "Output as JSON")
+    .action(async (sourceId, targetId, relationType, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const properties = options.properties
+          ? JSON.parse(options.properties)
+          : null;
+        const relation = addRelation(db, {
+          sourceId,
+          targetId,
+          relationType,
+          weight: options.weight,
+          properties,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(relation, null, 2));
+        } else {
+          logger.success(
+            `Relation added: ${sourceId.slice(0, 8)} ─[${relationType}]─> ${targetId.slice(0, 8)}`,
+          );
+          logger.log(
+            `  ${chalk.bold("ID:")}     ${chalk.cyan(relation.id.slice(0, 8))}`,
+          );
+          logger.log(`  ${chalk.bold("Weight:")} ${relation.weight}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("relations")
+    .description("List relations")
+    .option("-s, --source <id>", "Filter by source entity")
+    .option("-t, --target <id>", "Filter by target entity")
+    .option("-r, --type <type>", "Filter by relation type")
+    .option("--limit <n>", "Maximum entries", parseInt, 50)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const rows = listRelations({
+          sourceId: options.source,
+          targetId: options.target,
+          relationType: options.type,
+          limit: options.limit,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No relations.");
+        } else {
+          for (const r of rows) {
+            logger.log(
+              `  ${chalk.cyan(r.id.slice(0, 8))} ${r.sourceId.slice(0, 8)} ─[${chalk.yellow(r.relationType)}:${r.weight}]─> ${r.targetId.slice(0, 8)}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("reason <start-id>")
+    .description("BFS multi-hop reasoning from a start entity")
+    .option("-d, --max-depth <n>", "Maximum hops", parseInt, 3)
+    .option("--direction <d>", "out | in | both", "out")
+    .option("-r, --relation-type <t>", "Filter edges by relation type")
+    .option("--include-start", "Include the start entity in result")
+    .option("--json", "Output as JSON")
+    .action(async (startId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const results = reason(startId, {
+          maxDepth: options.maxDepth,
+          direction: options.direction,
+          relationType: options.relationType,
+          includeStart: options.includeStart,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else if (results.length === 0) {
+          logger.info("No reachable entities.");
+        } else {
+          for (const r of results) {
+            logger.log(
+              `  [depth=${r.depth}] ${chalk.cyan(r.entity.id.slice(0, 8))} ${chalk.yellow(r.entity.type.padEnd(14))} ${r.entity.name}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("stats")
+    .description("Graph statistics — counts, type distribution, density")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const stats = getStats();
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Entities:")}    ${stats.entityCount}`);
+          logger.log(`  ${chalk.bold("Relations:")}   ${stats.relationCount}`);
+          logger.log(`  ${chalk.bold("Avg Degree:")}  ${stats.avgDegree}`);
+          logger.log(`  ${chalk.bold("Density:")}     ${stats.density}`);
+          if (Object.keys(stats.typeDistribution).length > 0) {
+            logger.log(chalk.bold("  Entity types:"));
+            for (const [t, n] of Object.entries(stats.typeDistribution)) {
+              logger.log(`    ${chalk.yellow(t.padEnd(14))} ${n}`);
+            }
+          }
+          if (Object.keys(stats.relationTypeDistribution).length > 0) {
+            logger.log(chalk.bold("  Relation types:"));
+            for (const [t, n] of Object.entries(
+              stats.relationTypeDistribution,
+            )) {
+              logger.log(`    ${chalk.yellow(t.padEnd(14))} ${n}`);
+            }
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("export [output-file]")
+    .description("Export entire graph as JSON (stdout if no file)")
+    .action(async (outputFile) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const data = exportGraph();
+        const json = JSON.stringify(data, null, 2);
+        if (outputFile) {
+          fs.writeFileSync(outputFile, json, "utf-8");
+          logger.success(
+            `Exported ${data.entities.length} entities + ${data.relations.length} relations → ${outputFile}`,
+          );
+        } else {
+          console.log(json);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("import <input-file>")
+    .description("Import graph from JSON file ({entities[], relations[]})")
+    .option("--json", "Output result as JSON")
+    .action(async (inputFile, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const raw = fs.readFileSync(inputFile, "utf-8");
+        const data = JSON.parse(raw);
+        const result = importGraph(db, data);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success(
+            `Imported ${result.importedEntities} entities + ${result.importedRelations} relations (skipped ${result.skippedRelations})`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/marketplace.js

@@ -0,0 +1,326 @@
+/**
+ * Skill Marketplace commands (Phase 65)
+ * chainlesschain marketplace status-types|invocation-statuses|publish|list|
+ *                             show|status|record|invocations|stats
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureMarketplaceTables,
+  listServiceStatus,
+  listInvocationStatus,
+  publishService,
+  getService,
+  listServices,
+  updateServiceStatus,
+  recordInvocation,
+  listInvocations,
+  getInvocationStats,
+} from "../lib/skill-marketplace.js";
+
+function _dbFromCtx(ctx) {
+  if (!ctx.db) {
+    logger.error("Database not available");
+    process.exit(1);
+  }
+  const db = ctx.db.getDatabase();
+  ensureMarketplaceTables(db);
+  return db;
+}
+
+function _printService(s) {
+  logger.log(
+    `  ${chalk.bold("ID:")}           ${chalk.cyan(s.id.slice(0, 8))}`,
+  );
+  logger.log(`  ${chalk.bold("Name:")}         ${s.name} @ ${s.version}`);
+  logger.log(`  ${chalk.bold("Status:")}       ${s.status}`);
+  if (s.description) {
+    logger.log(`  ${chalk.bold("Description:")}  ${s.description}`);
+  }
+  if (s.endpoint) {
+    logger.log(`  ${chalk.bold("Endpoint:")}     ${s.endpoint}`);
+  }
+  if (s.owner) {
+    logger.log(`  ${chalk.bold("Owner:")}        ${s.owner}`);
+  }
+  logger.log(`  ${chalk.bold("Invocations:")}  ${s.invocationCount}`);
+}
+
+export function registerMarketplaceCommand(program) {
+  const mp = program
+    .command("marketplace")
+    .description(
+      "Skill marketplace — publish skill services, record invocations, view stats",
+    );
+
+  mp.command("status-types")
+    .description("List known service statuses")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const statuses = listServiceStatus();
+      if (options.json) {
+        console.log(JSON.stringify(statuses, null, 2));
+      } else {
+        for (const s of statuses) logger.log(`  ${chalk.cyan(s)}`);
+      }
+    });
+
+  mp.command("invocation-statuses")
+    .description("List known invocation statuses")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const statuses = listInvocationStatus();
+      if (options.json) {
+        console.log(JSON.stringify(statuses, null, 2));
+      } else {
+        for (const s of statuses) logger.log(`  ${chalk.cyan(s)}`);
+      }
+    });
+
+  mp.command("publish <name>")
+    .description("Publish a skill service")
+    .option("-v, --version <v>", "Version", "1.0.0")
+    .option("-d, --description <text>", "Description", "")
+    .option("-e, --endpoint <url>", "Invocation endpoint")
+    .option("-o, --owner <did>", "Service owner (DID)")
+    .option("-p, --pricing <json>", "Pricing info (JSON)")
+    .option(
+      "-s, --status <s>",
+      "Initial status (draft|published|deprecated|suspended)",
+      "published",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const pricing = options.pricing ? JSON.parse(options.pricing) : null;
+        const service = publishService(db, {
+          name,
+          version: options.version,
+          description: options.description,
+          endpoint: options.endpoint,
+          owner: options.owner,
+          pricing,
+          status: options.status,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(service, null, 2));
+        } else {
+          logger.success("Service published");
+          _printService(service);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("list")
+    .description("List skill services")
+    .option(
+      "-s, --status <s>",
+      "Filter by status (draft|published|deprecated|suspended)",
+    )
+    .option("-o, --owner <did>", "Filter by owner DID")
+    .option("-n, --name <substring>", "Name substring filter")
+    .option("--limit <n>", "Maximum entries", parseInt, 50)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const rows = listServices({
+          status: options.status,
+          owner: options.owner,
+          name: options.name,
+          limit: options.limit,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No services.");
+        } else {
+          for (const s of rows) {
+            logger.log(
+              `  ${chalk.cyan(s.id.slice(0, 8))} [${s.status.padEnd(10)}] ${chalk.bold(s.name.padEnd(22))} v${s.version.padEnd(8)} invocations=${s.invocationCount}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("show <service-id>")
+    .description("Show full details of a skill service")
+    .option("--json", "Output as JSON")
+    .action(async (serviceId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const service = getService(serviceId);
+        if (!service) {
+          logger.error(`Service not found: ${serviceId}`);
+          process.exit(1);
+        }
+        if (options.json) {
+          console.log(JSON.stringify(service, null, 2));
+        } else {
+          _printService(service);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("status <service-id> <new-status>")
+    .description(
+      "Transition service status (draft|published|deprecated|suspended)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (serviceId, newStatus, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const service = updateServiceStatus(db, serviceId, newStatus);
+        if (options.json) {
+          console.log(JSON.stringify(service, null, 2));
+        } else {
+          logger.success(`Status updated → ${service.status}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("record <service-id>")
+    .description("Record a skill invocation against a published service")
+    .option("-c, --caller <did>", "Caller DID")
+    .option("-i, --input <json>", "Invocation input (JSON)")
+    .option("-o, --output <json>", "Invocation output (JSON)")
+    .option(
+      "-s, --status <s>",
+      "Status (pending|running|success|failed|timeout)",
+      "success",
+    )
+    .option("-d, --duration-ms <n>", "Duration in ms", parseInt)
+    .option("-e, --error <text>", "Error message when failed")
+    .option("--json", "Output as JSON")
+    .action(async (serviceId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const input = options.input ? JSON.parse(options.input) : null;
+        const output = options.output ? JSON.parse(options.output) : null;
+        const inv = recordInvocation(db, {
+          serviceId,
+          callerId: options.caller,
+          input,
+          output,
+          status: options.status,
+          durationMs: options.durationMs,
+          error: options.error,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(inv, null, 2));
+        } else {
+          logger.success("Invocation recorded");
+          logger.log(
+            `  ${chalk.bold("ID:")}        ${chalk.cyan(inv.id.slice(0, 8))}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Service:")}   ${inv.serviceId.slice(0, 8)}`,
+          );
+          logger.log(`  ${chalk.bold("Status:")}    ${inv.status}`);
+          if (inv.durationMs != null) {
+            logger.log(`  ${chalk.bold("Duration:")}  ${inv.durationMs}ms`);
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("invocations")
+    .description("List skill invocations")
+    .option("-s, --service <id>", "Filter by service")
+    .option("-c, --caller <did>", "Filter by caller")
+    .option("-S, --status <s>", "Filter by status")
+    .option("--limit <n>", "Maximum entries", parseInt, 50)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const rows = listInvocations({
+          serviceId: options.service,
+          callerId: options.caller,
+          status: options.status,
+          limit: options.limit,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No invocations.");
+        } else {
+          for (const i of rows) {
+            const duration = i.durationMs != null ? `${i.durationMs}ms` : "-";
+            logger.log(
+              `  ${chalk.cyan(i.id.slice(0, 8))} svc=${i.serviceId.slice(0, 8)} [${i.status.padEnd(8)}] ${duration.padStart(7)} caller=${i.callerId || "anon"}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  mp.command("stats")
+    .description("Aggregate invocation stats (optionally scoped to a service)")
+    .option("-s, --service <id>", "Scope to a single service")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const stats = getInvocationStats({ serviceId: options.service });
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Total:")}         ${stats.total}`);
+          logger.log(
+            `  ${chalk.bold("Success rate:")}  ${(stats.successRate * 100).toFixed(1)}%`,
+          );
+          logger.log(
+            `  ${chalk.bold("Avg duration:")}  ${stats.avgDurationMs}ms (success-only)`,
+          );
+          logger.log(
+            `  ${chalk.bold("Counts:")}        success=${stats.counts.success} failed=${stats.counts.failed} timeout=${stats.counts.timeout} pending=${stats.counts.pending} running=${stats.counts.running}`,
+          );
+          if (stats.scopedToService) {
+            logger.log(
+              `  ${chalk.bold("Scope:")}         service ${stats.scopedToService.slice(0, 8)}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}