chainlesschain 0.47.9 → 0.51.0

package/src/commands/incentive.js

@@ -0,0 +1,373 @@
+/**
+ * Token Incentive commands (Phase 66)
+ * chainlesschain incentive contribution-types|tx-types|balance|accounts|transfer|
+ *                          mint|history|contribute|reward|contributions|leaderboard
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureTokenTables,
+  listContributionTypes,
+  listTxTypes,
+  getBalance,
+  listAccounts,
+  transfer,
+  mint,
+  getTransactionHistory,
+  recordContribution,
+  rewardContribution,
+  getContributions,
+  getLeaderboard,
+} from "../lib/token-incentive.js";
+
+function _dbFromCtx(ctx) {
+  if (!ctx.db) {
+    logger.error("Database not available");
+    process.exit(1);
+  }
+  const db = ctx.db.getDatabase();
+  ensureTokenTables(db);
+  return db;
+}
+
+function _printAccount(a) {
+  logger.log(`  ${chalk.bold("Account:")}       ${chalk.cyan(a.accountId)}`);
+  logger.log(`  ${chalk.bold("Balance:")}       ${a.balance}`);
+  logger.log(`  ${chalk.bold("Total Earned:")}  ${a.totalEarned}`);
+  logger.log(`  ${chalk.bold("Total Spent:")}   ${a.totalSpent}`);
+}
+
+export function registerIncentiveCommand(program) {
+  const inc = program
+    .command("incentive")
+    .description(
+      "Token incentive — ledger accounts, transfers, contributions, leaderboard",
+    );
+
+  inc
+    .command("contribution-types")
+    .description("List known contribution types and their base rewards")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const types = listContributionTypes();
+      if (options.json) {
+        console.log(JSON.stringify(types, null, 2));
+      } else {
+        for (const t of types) {
+          logger.log(
+            `  ${chalk.cyan(t.name.padEnd(22))} base=${String(t.baseReward).padStart(6)}  ${t.description}`,
+          );
+        }
+      }
+    });
+
+  inc
+    .command("tx-types")
+    .description("List known transaction types")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const types = listTxTypes();
+      if (options.json) {
+        console.log(JSON.stringify(types, null, 2));
+      } else {
+        for (const t of types) logger.log(`  ${chalk.cyan(t)}`);
+      }
+    });
+
+  inc
+    .command("balance <account-id>")
+    .description("Query token balance for an account")
+    .option("--json", "Output as JSON")
+    .action(async (accountId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const account = getBalance(accountId);
+        if (!account) {
+          logger.info(`No account: ${accountId} (balance 0)`);
+        } else if (options.json) {
+          console.log(JSON.stringify(account, null, 2));
+        } else {
+          _printAccount(account);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  inc
+    .command("accounts")
+    .description("List accounts (sorted by balance DESC)")
+    .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 = listAccounts({ limit: options.limit });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No accounts.");
+        } else {
+          for (const a of rows) {
+            logger.log(
+              `  ${chalk.cyan(a.accountId.padEnd(24))} balance=${String(a.balance).padStart(10)}  earned=${a.totalEarned}  spent=${a.totalSpent}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  inc
+    .command("mint <to> <amount>")
+    .description("Mint tokens into an account (admin op)")
+    .option("-r, --reason <text>", "Reason (e.g. initial grant)")
+    .option("--json", "Output as JSON")
+    .action(async (to, amountStr, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const tx = mint(db, {
+          to,
+          amount: Number(amountStr),
+          reason: options.reason,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(tx, null, 2));
+        } else {
+          logger.success(`Minted ${tx.amount} → ${tx.toAccount}`);
+          logger.log(
+            `  ${chalk.bold("Tx:")}      ${chalk.cyan(tx.id.slice(0, 8))}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  inc
+    .command("transfer <from> <to> <amount>")
+    .description("Transfer tokens between accounts")
+    .option("-r, --reason <text>", "Reason for transfer")
+    .option("--json", "Output as JSON")
+    .action(async (from, to, amountStr, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const tx = transfer(db, {
+          from,
+          to,
+          amount: Number(amountStr),
+          reason: options.reason,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(tx, null, 2));
+        } else {
+          logger.success(`Transferred ${tx.amount} from ${from} → ${to}`);
+          logger.log(
+            `  ${chalk.bold("Tx:")}      ${chalk.cyan(tx.id.slice(0, 8))}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  inc
+    .command("history")
+    .description("Show transaction history")
+    .option("-a, --account <id>", "Filter by account (from OR to)")
+    .option("-t, --type <t>", "Filter by tx type (transfer|reward|mint|burn)")
+    .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 = getTransactionHistory({
+          accountId: options.account,
+          type: options.type,
+          limit: options.limit,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No transactions.");
+        } else {
+          for (const tx of rows) {
+            const from = tx.fromAccount || "(system)";
+            const to = tx.toAccount || "(burn)";
+            logger.log(
+              `  ${chalk.cyan(tx.id.slice(0, 8))} [${tx.type.padEnd(8)}] ${String(tx.amount).padStart(10)} ${from} → ${to}${tx.reason ? `  (${tx.reason})` : ""}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  inc
+    .command("contribute <user-id> <type> [value]")
+    .description(
+      "Record a contribution (type: skill_publication|invocation_provided|skill_review|bug_report|code_contribution|documentation|community_support)",
+    )
+    .option("-m, --metadata <json>", "Metadata JSON")
+    .option("-a, --auto-reward", "Auto-reward this contribution")
+    .option(
+      "-M, --multiplier <n>",
+      "Reward multiplier (requires --auto-reward)",
+      parseFloat,
+      1.0,
+    )
+    .option("--json", "Output as JSON")
+    .action(async (userId, type, valueStr, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const metadata = options.metadata ? JSON.parse(options.metadata) : null;
+        const contribution = recordContribution(db, {
+          userId,
+          type,
+          value: valueStr != null ? Number(valueStr) : 1,
+          metadata,
+          autoReward: options.autoReward,
+          multiplier: options.multiplier,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(contribution, null, 2));
+        } else {
+          logger.success(
+            `Contribution recorded: ${userId} → ${type} (value=${contribution.value})`,
+          );
+          logger.log(
+            `  ${chalk.bold("ID:")}          ${chalk.cyan(contribution.id.slice(0, 8))}`,
+          );
+          if (contribution.rewarded) {
+            logger.log(
+              `  ${chalk.bold("Rewarded:")}    ${contribution.rewardAmount} tokens`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  inc
+    .command("reward <contribution-id>")
+    .description("Reward a previously-recorded contribution")
+    .option("-M, --multiplier <n>", "Reward multiplier", parseFloat, 1.0)
+    .option("--json", "Output as JSON")
+    .action(async (contributionId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = rewardContribution(db, contributionId, {
+          multiplier: options.multiplier,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else if (result.tx) {
+          logger.success(
+            `Rewarded ${result.tx.amount} tokens → ${result.tx.toAccount}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Tx:")}          ${chalk.cyan(result.tx.id.slice(0, 8))}`,
+          );
+        } else {
+          logger.info("No reward (amount was 0).");
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  inc
+    .command("contributions")
+    .description("List contributions")
+    .option("-u, --user <id>", "Filter by user")
+    .option("-t, --type <t>", "Filter by contribution type")
+    .option("--rewarded", "Only rewarded contributions")
+    .option("--unrewarded", "Only unrewarded contributions")
+    .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);
+        let rewardedFilter;
+        if (options.rewarded) rewardedFilter = true;
+        if (options.unrewarded) rewardedFilter = false;
+        const rows = getContributions({
+          userId: options.user,
+          type: options.type,
+          rewarded: rewardedFilter,
+          limit: options.limit,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No contributions.");
+        } else {
+          for (const c of rows) {
+            const flag = c.rewarded ? chalk.green("✓") : chalk.yellow("…");
+            logger.log(
+              `  ${flag} ${chalk.cyan(c.id.slice(0, 8))} ${c.userId.padEnd(16)} ${c.type.padEnd(22)} value=${c.value} reward=${c.rewardAmount}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  inc
+    .command("leaderboard")
+    .description("Top contributors by total reward earned")
+    .option("--limit <n>", "Maximum entries", parseInt, 10)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const rows = getLeaderboard({ limit: options.limit });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No contributions yet.");
+        } else {
+          rows.forEach((r, i) => {
+            logger.log(
+              `  ${chalk.bold(`#${i + 1}`.padStart(3))} ${chalk.cyan(r.userId.padEnd(20))} reward=${String(r.totalReward).padStart(10)}  value=${r.totalValue}  count=${r.contributions}`,
+            );
+          });
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/inference.js

@@ -0,0 +1,304 @@
+/**
+ * `cc inference` — CLI surface for Phase 67 Decentralized Inference Network.
+ */
+
+import { Command } from "commander";
+
+import {
+  NODE_STATUS,
+  TASK_STATUS,
+  PRIVACY_MODE,
+  DEFAULT_CONFIG,
+  ensureInferenceTables,
+  registerNode,
+  unregisterNode,
+  heartbeat,
+  updateNodeStatus,
+  getNode,
+  listNodes,
+  submitTask,
+  completeTask,
+  failTask,
+  getTask,
+  listTasks,
+  getSchedulerStats,
+} from "../lib/inference-network.js";
+
+function _dbFromCtx(cmd) {
+  const root = cmd?.parent?.parent ?? cmd?.parent;
+  return root?._db;
+}
+
+export function registerInferenceCommand(program) {
+  const inf = new Command("inference")
+    .description("Decentralized inference network (Phase 67)")
+    .hook("preAction", (thisCmd) => {
+      const db = _dbFromCtx(thisCmd);
+      if (db) ensureInferenceTables(db);
+    });
+
+  /* ── Catalogs ────────────────────────────────────── */
+
+  inf
+    .command("node-statuses")
+    .description("List node statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const statuses = Object.values(NODE_STATUS);
+      if (opts.json) return console.log(JSON.stringify(statuses, null, 2));
+      for (const s of statuses) console.log(`  ${s}`);
+    });
+
+  inf
+    .command("task-statuses")
+    .description("List task statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const statuses = Object.values(TASK_STATUS);
+      if (opts.json) return console.log(JSON.stringify(statuses, null, 2));
+      for (const s of statuses) console.log(`  ${s}`);
+    });
+
+  inf
+    .command("privacy-modes")
+    .description("List privacy modes")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const modes = Object.values(PRIVACY_MODE);
+      if (opts.json) return console.log(JSON.stringify(modes, null, 2));
+      for (const m of modes) console.log(`  ${m}`);
+    });
+
+  /* ── Node Registry ───────────────────────────────── */
+
+  inf
+    .command("register <node-id>")
+    .description("Register inference node")
+    .option("-e, --endpoint <url>", "Node endpoint URL")
+    .option("-c, --capabilities <list>", "Comma-separated capabilities")
+    .option("-g, --gpu <mb>", "GPU memory in MB", parseInt)
+    .option("--json", "JSON output")
+    .action((nodeId, opts) => {
+      const db = _dbFromCtx(inf);
+      const caps = opts.capabilities ? opts.capabilities.split(",") : [];
+      const result = registerNode(db, nodeId, {
+        endpoint: opts.endpoint,
+        capabilities: caps,
+        gpuMemory: opts.gpu,
+      });
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      if (result.nodeId) console.log(`Node registered: ${result.nodeId}`);
+      else console.log(`Failed: ${result.reason}`);
+    });
+
+  inf
+    .command("unregister <id>")
+    .description("Unregister inference node")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(inf);
+      const result = unregisterNode(db, id);
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(
+        result.removed ? "Node unregistered." : `Failed: ${result.reason}`,
+      );
+    });
+
+  inf
+    .command("heartbeat <id>")
+    .description("Send node heartbeat")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(inf);
+      const result = heartbeat(db, id);
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(
+        result.updated
+          ? `Heartbeat OK (status=${result.status})`
+          : `Failed: ${result.reason}`,
+      );
+    });
+
+  inf
+    .command("node-status <id> <status>")
+    .description("Update node status")
+    .option("--json", "JSON output")
+    .action((id, status, opts) => {
+      const db = _dbFromCtx(inf);
+      const result = updateNodeStatus(db, id, status);
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(
+        result.updated ? "Node status updated." : `Failed: ${result.reason}`,
+      );
+    });
+
+  inf
+    .command("show-node <id>")
+    .description("Show node details")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(inf);
+      const n = getNode(db, id);
+      if (!n) return console.log("Node not found.");
+      if (opts.json) return console.log(JSON.stringify(n, null, 2));
+      console.log(`ID:           ${n.id}`);
+      console.log(`Node ID:      ${n.node_id}`);
+      console.log(`Status:       ${n.status}`);
+      if (n.endpoint) console.log(`Endpoint:     ${n.endpoint}`);
+      console.log(`GPU:          ${n.gpu_memory_mb} MB`);
+      console.log(`Tasks:        ${n.task_count}`);
+      console.log(
+        `Capabilities: ${Array.isArray(n.capabilities) ? n.capabilities.join(", ") : "none"}`,
+      );
+    });
+
+  inf
+    .command("nodes")
+    .description("List inference nodes")
+    .option("-s, --status <status>", "Filter by status")
+    .option("-c, --capability <cap>", "Filter by capability")
+    .option("--limit <n>", "Max results", parseInt)
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(inf);
+      const nodes = listNodes(db, {
+        status: opts.status,
+        capability: opts.capability,
+        limit: opts.limit,
+      });
+      if (opts.json) return console.log(JSON.stringify(nodes, null, 2));
+      if (nodes.length === 0) return console.log("No nodes.");
+      for (const n of nodes) {
+        console.log(
+          `  ${n.status.padEnd(10)} ${n.node_id.padEnd(20)} gpu=${n.gpu_memory_mb}MB  tasks=${n.task_count}  ${n.id.slice(0, 8)}`,
+        );
+      }
+    });
+
+  /* ── Task Scheduler ──────────────────────────────── */
+
+  inf
+    .command("submit <model>")
+    .description("Submit inference task")
+    .option("-i, --input <text>", "Input data")
+    .option("-p, --priority <n>", "Priority (1-10)", parseInt)
+    .option("-m, --mode <mode>", "Privacy mode (standard/encrypted/federated)")
+    .option("--json", "JSON output")
+    .action((model, opts) => {
+      const db = _dbFromCtx(inf);
+      const result = submitTask(db, model, {
+        input: opts.input,
+        privacyMode: opts.mode,
+        priority: opts.priority,
+      });
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      if (result.taskId) {
+        console.log(`Task submitted: ${result.taskId}`);
+        console.log(`Status: ${result.status}`);
+        if (result.assignedNode)
+          console.log(`Assigned: ${result.assignedNode}`);
+      } else console.log(`Failed: ${result.reason}`);
+    });
+
+  inf
+    .command("complete <task-id>")
+    .description("Mark task as complete")
+    .option("-o, --output <text>", "Task output")
+    .option("-d, --duration <ms>", "Duration in ms", parseInt)
+    .option("--json", "JSON output")
+    .action((taskId, opts) => {
+      const db = _dbFromCtx(inf);
+      const result = completeTask(db, taskId, {
+        output: opts.output,
+        durationMs: opts.duration,
+      });
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(
+        result.completed
+          ? `Task completed (${result.durationMs}ms)`
+          : `Failed: ${result.reason}`,
+      );
+    });
+
+  inf
+    .command("fail-task <task-id>")
+    .description("Mark task as failed")
+    .option("-e, --error <text>", "Error message")
+    .option("--json", "JSON output")
+    .action((taskId, opts) => {
+      const db = _dbFromCtx(inf);
+      const result = failTask(db, taskId, { error: opts.error });
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(
+        result.failed ? "Task marked as failed." : `Failed: ${result.reason}`,
+      );
+    });
+
+  inf
+    .command("show-task <task-id>")
+    .description("Show task details")
+    .option("--json", "JSON output")
+    .action((taskId, opts) => {
+      const db = _dbFromCtx(inf);
+      const t = getTask(db, taskId);
+      if (!t) return console.log("Task not found.");
+      if (opts.json) return console.log(JSON.stringify(t, null, 2));
+      console.log(`ID:       ${t.id}`);
+      console.log(`Model:    ${t.model}`);
+      console.log(`Status:   ${t.status}`);
+      console.log(`Priority: ${t.priority}`);
+      console.log(`Privacy:  ${t.privacy_mode}`);
+      if (t.assigned_node) console.log(`Node:     ${t.assigned_node}`);
+      if (t.input) console.log(`Input:    ${t.input}`);
+      if (t.output) console.log(`Output:   ${t.output}`);
+      if (t.duration_ms) console.log(`Duration: ${t.duration_ms}ms`);
+    });
+
+  inf
+    .command("tasks")
+    .description("List inference tasks")
+    .option("-s, --status <status>", "Filter by status")
+    .option("-m, --model <model>", "Filter by model")
+    .option("-p, --privacy <mode>", "Filter by privacy mode")
+    .option("--limit <n>", "Max results", parseInt)
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(inf);
+      const tasks = listTasks(db, {
+        status: opts.status,
+        model: opts.model,
+        privacyMode: opts.privacy,
+        limit: opts.limit,
+      });
+      if (opts.json) return console.log(JSON.stringify(tasks, null, 2));
+      if (tasks.length === 0) return console.log("No tasks.");
+      for (const t of tasks) {
+        console.log(
+          `  ${t.status.padEnd(12)} ${t.model.padEnd(16)} prio=${t.priority}  ${t.privacy_mode.padEnd(10)} ${t.id.slice(0, 8)}`,
+        );
+      }
+    });
+
+  /* ── Stats ───────────────────────────────────────── */
+
+  inf
+    .command("stats")
+    .description("Inference network statistics")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(inf);
+      const stats = getSchedulerStats(db);
+      if (opts.json) return console.log(JSON.stringify(stats, null, 2));
+      const n = stats.nodes;
+      console.log(
+        `Nodes:  ${n.total} total  (${n.online} online, ${n.offline} offline, ${n.busy} busy)`,
+      );
+      const t = stats.tasks;
+      console.log(
+        `Tasks:  ${t.total} total  (${t.queued} queued, ${t.completed} completed, ${t.failed} failed)`,
+      );
+      if (t.avgDurationMs > 0) console.log(`Avg latency: ${t.avgDurationMs}ms`);
+    });
+
+  program.addCommand(inf);
+}