chainlesschain 0.51.0 → 0.81.0

package/src/commands/sla.js

@@ -21,6 +21,25 @@ import {
   generateReport,
   SLA_TERMS,
   VIOLATION_SEVERITY,
+  // V2
+  SLA_STATUS_V2,
+  SLA_TIER_V2,
+  SLA_TERM_V2,
+  VIOLATION_SEVERITY_V2,
+  VIOLATION_STATUS_V2,
+  SLA_DEFAULT_MAX_ACTIVE_PER_ORG,
+  setMaxActiveSlasPerOrg,
+  getMaxActiveSlasPerOrg,
+  getActiveSlaCountForOrg,
+  createSLAV2,
+  setSLAStatus,
+  expireSLA,
+  autoExpireSLAs,
+  setViolationStatus,
+  acknowledgeViolation,
+  resolveViolation,
+  waiveViolation,
+  getSLAStatsV2,
 } from "../lib/sla-manager.js";
 
 function _dbFromCtx(ctx) {
@@ -349,4 +368,244 @@ export function registerSlaCommand(program) {
         process.exit(1);
       }
     });
+
+  // ---------- V2 (Phase 61) ----------
+  const withDb = async (fn) => {
+    const ctx = await bootstrap({ verbose: program.opts().verbose });
+    if (!ctx.db) {
+      logger.error("Database not available");
+      process.exit(1);
+    }
+    try {
+      const db = ctx.db.getDatabase();
+      ensureSlaTables(db);
+      return await fn(db);
+    } finally {
+      await shutdown();
+    }
+  };
+
+  sla
+    .command("statuses")
+    .description("List SLA_STATUS_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SLA_STATUS_V2), null, 2));
+    });
+
+  sla
+    .command("tier-names")
+    .description("List SLA_TIER_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SLA_TIER_V2), null, 2));
+    });
+
+  sla
+    .command("term-names")
+    .description("List SLA_TERM_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(SLA_TERM_V2), null, 2));
+    });
+
+  sla
+    .command("severities")
+    .description("List VIOLATION_SEVERITY_V2 values")
+    .action(() => {
+      console.log(
+        JSON.stringify(Object.values(VIOLATION_SEVERITY_V2), null, 2),
+      );
+    });
+
+  sla
+    .command("violation-statuses")
+    .description("List VIOLATION_STATUS_V2 values")
+    .action(() => {
+      console.log(JSON.stringify(Object.values(VIOLATION_STATUS_V2), null, 2));
+    });
+
+  sla
+    .command("default-max-active")
+    .description("Show SLA_DEFAULT_MAX_ACTIVE_PER_ORG")
+    .action(() => {
+      console.log(SLA_DEFAULT_MAX_ACTIVE_PER_ORG);
+    });
+
+  sla
+    .command("max-active")
+    .description("Show current max active SLAs per org")
+    .action(() => {
+      console.log(getMaxActiveSlasPerOrg());
+    });
+
+  sla
+    .command("set-max-active <n>")
+    .description("Set per-org active-contract admission cap")
+    .action((n) => {
+      try {
+        const v = setMaxActiveSlasPerOrg(Number(n));
+        logger.success(`maxActiveSlasPerOrg=${v}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("active-count <org-id>")
+    .description("Show active SLA count for an org")
+    .action((orgId) => {
+      console.log(getActiveSlaCountForOrg(orgId));
+    });
+
+  sla
+    .command("create-v2 <org-id>")
+    .description("Create a V2 SLA contract (enforces per-org active cap)")
+    .option("-t, --tier <tier>", "gold|silver|bronze", "silver")
+    .option("-d, --duration <ms>", "Contract duration in ms", parseInt)
+    .option("-f, --fee <amount>", "Monthly fee", parseFloat)
+    .option("--json", "Output as JSON")
+    .action(async (orgId, options) => {
+      try {
+        await withDb((db) => {
+          const c = createSLAV2(db, {
+            orgId,
+            tier: options.tier,
+            duration: options.duration,
+            monthlyFee: options.fee,
+          });
+          if (options.json) {
+            console.log(JSON.stringify(c, null, 2));
+          } else {
+            logger.success(
+              `Created ${c.slaId.slice(0, 8)} [${c.tier}] → ${c.status}`,
+            );
+          }
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("set-status <sla-id> <status>")
+    .description("Transition SLA to a given status (state-machine guarded)")
+    .action(async (slaId, status) => {
+      try {
+        await withDb((db) => {
+          const c = setSLAStatus(db, slaId, status);
+          logger.success(`${c.slaId.slice(0, 8)} → ${c.status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("expire <sla-id>")
+    .description("Expire an SLA (shortcut for set-status ... expired)")
+    .action(async (slaId) => {
+      try {
+        await withDb((db) => {
+          const c = expireSLA(db, slaId);
+          logger.success(`${c.slaId.slice(0, 8)} → ${c.status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("auto-expire")
+    .description("Bulk-flip ACTIVE contracts past endDate to EXPIRED")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        await withDb((db) => {
+          const flipped = autoExpireSLAs(db);
+          if (options.json) {
+            console.log(JSON.stringify(flipped, null, 2));
+          } else {
+            logger.success(`Auto-expired ${flipped.length} contract(s)`);
+          }
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("set-violation-status <violation-id> <status>")
+    .description("Transition a violation (open→{acknowledged,resolved,waived})")
+    .option("--note <note>", "Attach a note")
+    .action(async (violationId, status, options) => {
+      try {
+        await withDb((db) => {
+          const v = setViolationStatus(db, violationId, status, {
+            note: options.note,
+          });
+          logger.success(`${v.violationId.slice(0, 8)} → ${v.v2Status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("acknowledge-violation <violation-id>")
+    .description("Acknowledge a violation")
+    .option("--note <note>", "Attach a note")
+    .action(async (violationId, options) => {
+      try {
+        await withDb((db) => {
+          const v = acknowledgeViolation(db, violationId, options.note);
+          logger.success(`${v.violationId.slice(0, 8)} → ${v.v2Status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("resolve-violation <violation-id>")
+    .description("Resolve a violation")
+    .option("--note <note>", "Attach a note")
+    .action(async (violationId, options) => {
+      try {
+        await withDb((db) => {
+          const v = resolveViolation(db, violationId, options.note);
+          logger.success(`${v.violationId.slice(0, 8)} → ${v.v2Status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("waive-violation <violation-id>")
+    .description("Waive a violation")
+    .option("--note <note>", "Attach a note")
+    .action(async (violationId, options) => {
+      try {
+        await withDb((db) => {
+          const v = waiveViolation(db, violationId, options.note);
+          logger.success(`${v.violationId.slice(0, 8)} → ${v.v2Status}`);
+        });
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  sla
+    .command("stats-v2")
+    .description("Show aggregate V2 SLA stats (byStatus/byTier/violations)")
+    .action(() => {
+      console.log(JSON.stringify(getSLAStatsV2(), null, 2));
+    });
 }

package/src/commands/social.js

@@ -35,6 +35,18 @@ import {
   subscribe as graphSubscribe,
   EDGE_TYPES,
 } from "../lib/social-graph.js";
+import {
+  METRICS as ANALYTICS_METRICS,
+  degreeCentrality,
+  closenessCentrality,
+  betweennessCentrality,
+  eigenvectorCentrality,
+  influenceScore,
+  detectCommunities,
+  shortestPath,
+  topByMetric,
+  analyticsStats,
+} from "../lib/social-graph-analytics.js";
 
 export function registerSocialCommand(program) {
   const social = program
@@ -742,4 +754,303 @@ export function registerSocialCommand(program) {
         process.exit(1);
       }
     });
+
+  // ── Graph analytics (Phase 42) ──────────────────────────────
+
+  async function _loadSnapshot(options) {
+    const ctx = await bootstrap({ verbose: program.opts().verbose });
+    if (!ctx.db) {
+      logger.error("Database not available");
+      process.exit(1);
+    }
+    const db = ctx.db.getDatabase();
+    ensureGraphTables(db);
+    graphLoadFromDb(db);
+    return getGraphSnapshot({ edgeType: options.type });
+  }
+
+  function _splitEdgeTypes(list) {
+    if (!list) return undefined;
+    return list
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+  }
+
+  function _printScoreMap(scores, limit) {
+    const entries = Object.entries(scores).sort((a, b) => {
+      if (b[1] !== a[1]) return b[1] - a[1];
+      return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+    });
+    const slice = limit > 0 ? entries.slice(0, limit) : entries;
+    for (const [did, score] of slice) {
+      console.log(`${chalk.cyan(did.padEnd(28))} ${score.toFixed(6)}`);
+    }
+  }
+
+  graph
+    .command("degree")
+    .description("Degree centrality per DID")
+    .option("-d, --direction <in|out|both>", "Edge direction", "both")
+    .option("--no-normalize", "Disable normalization by (n-1)")
+    .option("-e, --edge-types <list>", "Comma-separated edge types to include")
+    .option("-l, --limit <n>", "Show top N", "10")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const snap = await _loadSnapshot(options);
+        const scores = degreeCentrality(snap, {
+          direction: options.direction,
+          normalize: options.normalize !== false,
+          edgeTypes: _splitEdgeTypes(options.edgeTypes),
+        });
+        if (options.json) console.log(JSON.stringify(scores, null, 2));
+        else _printScoreMap(scores, parseInt(options.limit, 10) || 10);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("closeness")
+    .description("Harmonic closeness centrality per DID")
+    .option("--directed", "Treat graph as directed")
+    .option("--no-normalize", "Disable normalization by (n-1)")
+    .option("-e, --edge-types <list>", "Comma-separated edge types")
+    .option("-l, --limit <n>", "Show top N", "10")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const snap = await _loadSnapshot(options);
+        const scores = closenessCentrality(snap, {
+          directed: !!options.directed,
+          normalize: options.normalize !== false,
+          edgeTypes: _splitEdgeTypes(options.edgeTypes),
+        });
+        if (options.json) console.log(JSON.stringify(scores, null, 2));
+        else _printScoreMap(scores, parseInt(options.limit, 10) || 10);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("betweenness")
+    .description("Betweenness centrality (Brandes' algorithm)")
+    .option("--directed", "Treat graph as directed")
+    .option("--no-normalize", "Disable normalization")
+    .option("-e, --edge-types <list>", "Comma-separated edge types")
+    .option("-l, --limit <n>", "Show top N", "10")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const snap = await _loadSnapshot(options);
+        const scores = betweennessCentrality(snap, {
+          directed: !!options.directed,
+          normalize: options.normalize !== false,
+          edgeTypes: _splitEdgeTypes(options.edgeTypes),
+        });
+        if (options.json) console.log(JSON.stringify(scores, null, 2));
+        else _printScoreMap(scores, parseInt(options.limit, 10) || 10);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("eigenvector")
+    .description("Eigenvector centrality via power iteration")
+    .option("--directed", "Treat graph as directed")
+    .option("-e, --edge-types <list>", "Comma-separated edge types")
+    .option("--iterations <n>", "Max iterations", "100")
+    .option("--tolerance <f>", "Convergence tolerance", "1e-6")
+    .option("-l, --limit <n>", "Show top N", "10")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const snap = await _loadSnapshot(options);
+        const scores = eigenvectorCentrality(snap, {
+          directed: !!options.directed,
+          edgeTypes: _splitEdgeTypes(options.edgeTypes),
+          iterations: parseInt(options.iterations, 10) || 100,
+          tolerance: parseFloat(options.tolerance) || 1e-6,
+        });
+        if (options.json) console.log(JSON.stringify(scores, null, 2));
+        else _printScoreMap(scores, parseInt(options.limit, 10) || 10);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("influence")
+    .description("Composite influence score (weighted sum of 4 centralities)")
+    .option("--directed", "Treat graph as directed")
+    .option("-e, --edge-types <list>", "Comma-separated edge types")
+    .option("--w-degree <f>", "Weight for degree", "0.25")
+    .option("--w-closeness <f>", "Weight for closeness", "0.25")
+    .option("--w-betweenness <f>", "Weight for betweenness", "0.25")
+    .option("--w-eigenvector <f>", "Weight for eigenvector", "0.25")
+    .option("-l, --limit <n>", "Show top N", "10")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const snap = await _loadSnapshot(options);
+        const scores = influenceScore(snap, {
+          directed: !!options.directed,
+          edgeTypes: _splitEdgeTypes(options.edgeTypes),
+          weights: {
+            degree: parseFloat(options.wDegree),
+            closeness: parseFloat(options.wCloseness),
+            betweenness: parseFloat(options.wBetweenness),
+            eigenvector: parseFloat(options.wEigenvector),
+          },
+        });
+        if (options.json) console.log(JSON.stringify(scores, null, 2));
+        else _printScoreMap(scores, parseInt(options.limit, 10) || 10);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("communities")
+    .description("Label-propagation community detection")
+    .option("-e, --edge-types <list>", "Comma-separated edge types")
+    .option("--max-iterations <n>", "Max propagation rounds", "20")
+    .option("--min-size <n>", "Drop communities smaller than this", "1")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const snap = await _loadSnapshot(options);
+        const result = detectCommunities(snap, {
+          edgeTypes: _splitEdgeTypes(options.edgeTypes),
+          maxIterations: parseInt(options.maxIterations, 10) || 20,
+          minSize: parseInt(options.minSize, 10) || 1,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(
+            chalk.bold(
+              `Communities: ${result.communities.length}    modularity: ${result.modularity.toFixed(4)}`,
+            ),
+          );
+          for (const c of result.communities) {
+            console.log(
+              `  ${chalk.cyan(c.id)} (size ${c.size}) ${c.members.join(", ")}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("path <source> <target>")
+    .description("Shortest path between two DIDs (unweighted BFS)")
+    .option("--undirected", "Treat graph as undirected (default: directed)")
+    .option("-e, --edge-types <list>", "Comma-separated edge types")
+    .option("--json", "Output as JSON")
+    .action(async (source, target, options) => {
+      try {
+        const snap = await _loadSnapshot(options);
+        const result = shortestPath(snap, source, target, {
+          directed: !options.undirected,
+          edgeTypes: _splitEdgeTypes(options.edgeTypes),
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else if (!result.found) {
+          console.log(chalk.yellow("No path found"));
+        } else {
+          console.log(
+            `${chalk.bold("distance")}: ${result.distance}    ${result.path.join(" → ")}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("top <metric>")
+    .description(`Top-N DIDs by metric (${ANALYTICS_METRICS.join("|")})`)
+    .option("--directed", "Treat graph as directed (where applicable)")
+    .option("-e, --edge-types <list>", "Comma-separated edge types")
+    .option("-l, --limit <n>", "Limit", "10")
+    .option("--json", "Output as JSON")
+    .action(async (metric, options) => {
+      try {
+        const snap = await _loadSnapshot(options);
+        const rows = topByMetric(snap, metric, {
+          directed: !!options.directed,
+          edgeTypes: _splitEdgeTypes(options.edgeTypes),
+          limit: parseInt(options.limit, 10) || 10,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else {
+          for (const r of rows) {
+            console.log(
+              `${chalk.cyan(r.did.padEnd(28))} ${r.score.toFixed(6)}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("analytics-stats")
+    .description("Graph-wide analytics rollup (counts, density, top influence)")
+    .option("-e, --edge-types <list>", "Comma-separated edge types")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const snap = await _loadSnapshot(options);
+        const stats = analyticsStats(snap, {
+          edgeTypes: _splitEdgeTypes(options.edgeTypes),
+        });
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else {
+          console.log(chalk.bold("Social Graph Analytics"));
+          console.log(`  Nodes:    ${stats.nodeCount}`);
+          console.log(`  Edges:    ${stats.edgeCount}`);
+          console.log(`  Density:  ${stats.density.toFixed(4)}`);
+          console.log(`  Generated: ${stats.generatedAt}`);
+          if (stats.topInfluence.length > 0) {
+            console.log(chalk.bold("\nTop influence:"));
+            for (const r of stats.topInfluence) {
+              console.log(
+                `  ${chalk.cyan(r.did.padEnd(28))} ${r.score.toFixed(6)}`,
+              );
+            }
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }