chainlesschain 0.66.0 → 0.132.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

@@ -23,6 +23,35 @@ import {
   getChatMessages,
   getChatThreads,
   getSocialStats,
+  RELATIONSHIP_MATURITY_V2,
+  THREAD_LIFECYCLE_V2,
+  getMaxConnectedPerUserV2,
+  setMaxConnectedPerUserV2,
+  getMaxOpenThreadsPerUserV2,
+  setMaxOpenThreadsPerUserV2,
+  getRelationshipIdleMsV2,
+  setRelationshipIdleMsV2,
+  getThreadStuckMsV2,
+  setThreadStuckMsV2,
+  getConnectedCountV2,
+  getOpenThreadCountV2,
+  registerRelationshipV2,
+  getRelationshipV2,
+  listRelationshipsV2,
+  connectRelationshipV2,
+  muteRelationshipV2,
+  blockRelationshipV2,
+  touchRelationshipV2,
+  createThreadV2,
+  getThreadV2,
+  listThreadsV2,
+  engageThreadV2,
+  resolveThreadV2,
+  abandonThreadV2,
+  reportThreadV2,
+  autoMuteIdleRelationshipsV2,
+  autoAbandonStuckThreadsV2,
+  getSocialManagerStatsV2,
 } from "../lib/social-manager.js";
 import { classifyTopic, detectLanguage } from "../lib/topic-classifier.js";
 import {
@@ -1053,4 +1082,231 @@ export function registerSocialCommand(program) {
         process.exit(1);
       }
     });
+
+  // ─────────────────────────────────────────────────────────────
+  // V2 Surface — relationship + thread lifecycle (in-memory, throwing)
+  // ─────────────────────────────────────────────────────────────
+
+  social
+    .command("relationship-maturities-v2")
+    .description("List V2 relationship maturity states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const v = Object.values(RELATIONSHIP_MATURITY_V2);
+      if (options.json) console.log(JSON.stringify(v));
+      else logger.log(v.join(", "));
+    });
+
+  social
+    .command("thread-lifecycles-v2")
+    .description("List V2 thread lifecycle states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const v = Object.values(THREAD_LIFECYCLE_V2);
+      if (options.json) console.log(JSON.stringify(v));
+      else logger.log(v.join(", "));
+    });
+
+  social
+    .command("stats-v2")
+    .description("Show V2 social stats")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const stats = getSocialManagerStatsV2();
+      if (options.json) console.log(JSON.stringify(stats, null, 2));
+      else logger.log(JSON.stringify(stats, null, 2));
+    });
+
+  social
+    .command("get-max-connected-v2")
+    .description("Get max connected per user")
+    .action(() => logger.log(String(getMaxConnectedPerUserV2())));
+  social
+    .command("set-max-connected-v2 <n>")
+    .description("Set max connected per user")
+    .action((n) => {
+      setMaxConnectedPerUserV2(Number(n));
+      logger.log(String(getMaxConnectedPerUserV2()));
+    });
+  social
+    .command("get-max-open-threads-v2")
+    .description("Get max open threads per user")
+    .action(() => logger.log(String(getMaxOpenThreadsPerUserV2())));
+  social
+    .command("set-max-open-threads-v2 <n>")
+    .description("Set max open threads per user")
+    .action((n) => {
+      setMaxOpenThreadsPerUserV2(Number(n));
+      logger.log(String(getMaxOpenThreadsPerUserV2()));
+    });
+  social
+    .command("get-relationship-idle-ms-v2")
+    .description("Get relationship idle ms")
+    .action(() => logger.log(String(getRelationshipIdleMsV2())));
+  social
+    .command("set-relationship-idle-ms-v2 <ms>")
+    .description("Set relationship idle ms")
+    .action((ms) => {
+      setRelationshipIdleMsV2(Number(ms));
+      logger.log(String(getRelationshipIdleMsV2()));
+    });
+  social
+    .command("get-thread-stuck-ms-v2")
+    .description("Get thread stuck ms")
+    .action(() => logger.log(String(getThreadStuckMsV2())));
+  social
+    .command("set-thread-stuck-ms-v2 <ms>")
+    .description("Set thread stuck ms")
+    .action((ms) => {
+      setThreadStuckMsV2(Number(ms));
+      logger.log(String(getThreadStuckMsV2()));
+    });
+
+  social
+    .command("connected-count-v2 <userId>")
+    .description("Count connected relationships for user")
+    .action((userId) => logger.log(String(getConnectedCountV2(userId))));
+  social
+    .command("open-thread-count-v2 <userId>")
+    .description("Count open+engaged threads for user")
+    .action((userId) => logger.log(String(getOpenThreadCountV2(userId))));
+
+  social
+    .command("register-relationship-v2 <id>")
+    .description("Register V2 relationship (initial=pending)")
+    .requiredOption("-u, --user <userId>", "user id")
+    .requiredOption("-p, --peer <peerId>", "peer id")
+    .option("-m, --metadata <json>", "metadata JSON", "{}")
+    .action((id, opts) => {
+      const meta = JSON.parse(opts.metadata);
+      const r = registerRelationshipV2(id, {
+        userId: opts.user,
+        peerId: opts.peer,
+        metadata: meta,
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  social
+    .command("get-relationship-v2 <id>")
+    .description("Get V2 relationship by id")
+    .action((id) => {
+      const r = getRelationshipV2(id);
+      if (!r) {
+        logger.error(`relationship ${id} not found`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  social
+    .command("list-relationships-v2")
+    .description("List V2 relationships")
+    .option("-u, --user <userId>", "filter by user")
+    .option("-s, --status <state>", "filter by status")
+    .action((opts) => {
+      const out = listRelationshipsV2({
+        userId: opts.user,
+        status: opts.status,
+      });
+      console.log(JSON.stringify(out, null, 2));
+    });
+
+  social
+    .command("connect-relationship-v2 <id>")
+    .description("Transition relationship → connected")
+    .action((id) =>
+      console.log(JSON.stringify(connectRelationshipV2(id), null, 2)),
+    );
+  social
+    .command("mute-relationship-v2 <id>")
+    .description("Transition relationship → muted")
+    .action((id) =>
+      console.log(JSON.stringify(muteRelationshipV2(id), null, 2)),
+    );
+  social
+    .command("block-relationship-v2 <id>")
+    .description("Transition relationship → blocked (terminal)")
+    .action((id) =>
+      console.log(JSON.stringify(blockRelationshipV2(id), null, 2)),
+    );
+  social
+    .command("touch-relationship-v2 <id>")
+    .description("Update relationship lastSeenAt")
+    .action((id) =>
+      console.log(JSON.stringify(touchRelationshipV2(id), null, 2)),
+    );
+
+  social
+    .command("create-thread-v2 <id>")
+    .description("Create V2 thread (initial=open)")
+    .requiredOption("-u, --user <userId>", "user id")
+    .requiredOption("-t, --topic <topic>", "topic")
+    .option("-m, --metadata <json>", "metadata JSON", "{}")
+    .action((id, opts) => {
+      const meta = JSON.parse(opts.metadata);
+      const t = createThreadV2(id, {
+        userId: opts.user,
+        topic: opts.topic,
+        metadata: meta,
+      });
+      console.log(JSON.stringify(t, null, 2));
+    });
+
+  social
+    .command("get-thread-v2 <id>")
+    .description("Get V2 thread by id")
+    .action((id) => {
+      const t = getThreadV2(id);
+      if (!t) {
+        logger.error(`thread ${id} not found`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(t, null, 2));
+    });
+
+  social
+    .command("list-threads-v2")
+    .description("List V2 threads")
+    .option("-u, --user <userId>", "filter by user")
+    .option("-s, --status <state>", "filter by status")
+    .action((opts) => {
+      const out = listThreadsV2({
+        userId: opts.user,
+        status: opts.status,
+      });
+      console.log(JSON.stringify(out, null, 2));
+    });
+
+  social
+    .command("engage-thread-v2 <id>")
+    .description("Transition thread → engaged")
+    .action((id) => console.log(JSON.stringify(engageThreadV2(id), null, 2)));
+  social
+    .command("resolve-thread-v2 <id>")
+    .description("Transition thread → resolved (terminal)")
+    .action((id) => console.log(JSON.stringify(resolveThreadV2(id), null, 2)));
+  social
+    .command("abandon-thread-v2 <id>")
+    .description("Transition thread → abandoned (terminal)")
+    .action((id) => console.log(JSON.stringify(abandonThreadV2(id), null, 2)));
+  social
+    .command("report-thread-v2 <id>")
+    .description("Transition thread → reported (terminal)")
+    .action((id) => console.log(JSON.stringify(reportThreadV2(id), null, 2)));
+
+  social
+    .command("auto-mute-idle-rel-v2")
+    .description("Auto-mute idle connected relationships; output flipped")
+    .action(() => {
+      const flipped = autoMuteIdleRelationshipsV2();
+      console.log(JSON.stringify(flipped, null, 2));
+    });
+  social
+    .command("auto-abandon-stuck-threads-v2")
+    .description("Auto-abandon stuck threads; output flipped")
+    .action(() => {
+      const flipped = autoAbandonStuckThreadsV2();
+      console.log(JSON.stringify(flipped, null, 2));
+    });
 }