chainlesschain 0.37.12 → 0.38.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.37.12",
+  "version": "0.38.1",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/commands/agent.js

@@ -19,12 +19,14 @@ export function registerAgentCommand(program) {
     .option("--provider <provider>", "LLM provider (ollama, openai)", "ollama")
     .option("--base-url <url>", "API base URL")
     .option("--api-key <key>", "API key")
+    .option("--session <id>", "Resume a previous agent session")
     .action(async (options) => {
       await startAgentRepl({
         model: options.model,
         provider: options.provider,
         baseUrl: options.baseUrl,
         apiKey: options.apiKey,
+        sessionId: options.session,
       });
     });
 }

package/src/commands/chat.js

@@ -18,12 +18,14 @@ export function registerChatCommand(program) {
       "--agent",
       "Agentic mode - AI can read/write files and run commands (like Claude Code)",
     )
+    .option("--session <id>", "Resume a previous session (agent mode)")
     .action(async (options) => {
       const replOptions = {
         model: options.model,
         provider: options.provider,
         baseUrl: options.baseUrl,
         apiKey: options.apiKey,
+        sessionId: options.session,
       };
 
       if (options.agent) {

package/src/commands/compliance.js

@@ -0,0 +1,216 @@
+/**
+ * Compliance commands
+ * chainlesschain compliance evidence|report|classify|scan|policies|check-access
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureComplianceTables,
+  collectEvidence,
+  generateReport,
+  classifyData,
+  scanCompliance,
+  listPolicies,
+  addPolicy,
+  checkAccess,
+} from "../lib/compliance-manager.js";
+
+export function registerComplianceCommand(program) {
+  const compliance = program
+    .command("compliance")
+    .description(
+      "Compliance management — evidence, reports, scanning, policies",
+    );
+
+  // compliance evidence
+  compliance
+    .command("evidence <framework>")
+    .description("Collect compliance evidence (gdpr, soc2, hipaa, iso27001)")
+    .option("-t, --type <type>", "Evidence type", "general")
+    .option("-d, --description <text>", "Evidence description")
+    .option("-s, --source <source>", "Evidence source", "cli")
+    .action(async (framework, 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();
+        ensureComplianceTables(db);
+
+        const result = collectEvidence(
+          db,
+          framework,
+          options.type,
+          options.description,
+          options.source,
+        );
+        logger.success("Evidence collected");
+        logger.log(`  ${chalk.bold("ID:")}        ${chalk.cyan(result.id)}`);
+        logger.log(`  ${chalk.bold("Framework:")} ${result.framework}`);
+        logger.log(`  ${chalk.bold("Type:")}      ${result.type}`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // compliance report
+  compliance
+    .command("report <framework>")
+    .description("Generate compliance report")
+    .option("-t, --title <title>", "Report title")
+    .option("--json", "Output as JSON")
+    .action(async (framework, 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();
+        ensureComplianceTables(db);
+
+        const result = generateReport(db, framework, options.title);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success("Report generated");
+          logger.log(`  ${chalk.bold("ID:")}        ${chalk.cyan(result.id)}`);
+          logger.log(`  ${chalk.bold("Title:")}     ${result.title}`);
+          logger.log(`  ${chalk.bold("Score:")}     ${result.score}`);
+          logger.log(`  ${chalk.bold("Summary:")}   ${result.summary}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // compliance classify
+  compliance
+    .command("classify <content>")
+    .description("Classify data sensitivity")
+    .option("--json", "Output as JSON")
+    .action(async (content, options) => {
+      try {
+        const result = classifyData(content);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(
+            `  ${chalk.bold("Sensitive:")}       ${result.hasClassifiedData ? "Yes" : "No"}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Classifications:")} ${result.classifications.join(", ") || "none"}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Sensitivity:")}     ${result.sensitivity}`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // compliance scan
+  compliance
+    .command("scan <framework>")
+    .description("Scan compliance posture against policies")
+    .option("--json", "Output as JSON")
+    .action(async (framework, 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();
+        ensureComplianceTables(db);
+
+        const result = scanCompliance(db, framework);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Framework:")} ${result.framework}`);
+          logger.log(`  ${chalk.bold("Score:")}     ${result.score}%`);
+          logger.log(
+            `  ${chalk.bold("Passed:")}    ${result.passed}/${result.total}`,
+          );
+          logger.log(
+            `  ${chalk.bold("Failed:")}    ${result.failed}/${result.total}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // compliance policies
+  compliance
+    .command("policies")
+    .description("List compliance policies")
+    .option("--framework <fw>", "Filter by framework")
+    .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();
+        ensureComplianceTables(db);
+
+        const policies = listPolicies(db, { framework: options.framework });
+        if (options.json) {
+          console.log(JSON.stringify(policies, null, 2));
+        } else if (policies.length === 0) {
+          logger.info("No policies configured.");
+        } else {
+          for (const p of policies) {
+            logger.log(
+              `  ${chalk.cyan(p.id.slice(0, 8))} ${p.name} [${p.type}] ${p.framework} severity=${p.severity}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // compliance check-access
+  compliance
+    .command("check-access <resource> <action> <role>")
+    .description("Check RBAC access permission")
+    .option("--json", "Output as JSON")
+    .action(async (resource, action, role, options) => {
+      try {
+        const result = checkAccess(resource, action, role);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(
+            `  ${chalk.bold("Access:")} ${result.granted ? chalk.green("GRANTED") : chalk.red("DENIED")} (${role} → ${action} on ${resource})`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/dao.js

@@ -0,0 +1,312 @@
+/**
+ * DAO Governance v2 commands
+ * chainlesschain dao propose|vote|delegate|execute|treasury|allocate|stats|configure
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureDAOv2Tables,
+  propose,
+  vote,
+  delegate,
+  execute,
+  getTreasury,
+  allocate,
+  depositToTreasury,
+  getStats,
+  configure,
+} from "../lib/dao-governance.js";
+
+export function registerDaoCommand(program) {
+  const dao = program
+    .command("dao")
+    .description("DAO Governance v2 — proposals, voting, delegation, treasury");
+
+  // dao propose
+  dao
+    .command("propose <title>")
+    .description("Create a governance proposal")
+    .option("-d, --description <text>", "Proposal description")
+    .option("-p, --proposer <id>", "Proposer identity", "cli-user")
+    .option(
+      "--voting-type <type>",
+      "Voting type: simple or quadratic",
+      "simple",
+    )
+    .action(async (title, 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();
+        ensureDAOv2Tables(db);
+
+        const result = propose(
+          db,
+          title,
+          options.description,
+          options.proposer,
+          {
+            votingType: options.votingType,
+          },
+        );
+        logger.success("Proposal created");
+        logger.log(`  ${chalk.bold("ID:")}      ${chalk.cyan(result.id)}`);
+        logger.log(`  ${chalk.bold("Title:")}   ${result.title}`);
+        logger.log(`  ${chalk.bold("Status:")}  ${result.status}`);
+        logger.log(`  ${chalk.bold("Type:")}    ${result.votingType}`);
+        logger.log(`  ${chalk.bold("Ends:")}    ${result.endsAt}`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // dao vote
+  dao
+    .command("vote <proposal-id> <direction>")
+    .description('Vote on a proposal (direction: "for" or "against")')
+    .option("-v, --voter <id>", "Voter identity", "cli-user")
+    .option("-w, --weight <n>", "Vote weight", "1")
+    .action(async (proposalId, direction, 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();
+        ensureDAOv2Tables(db);
+
+        const result = vote(
+          db,
+          proposalId,
+          options.voter,
+          direction,
+          parseFloat(options.weight),
+        );
+        logger.success("Vote recorded");
+        logger.log(
+          `  ${chalk.bold("Vote ID:")}   ${chalk.cyan(result.voteId)}`,
+        );
+        logger.log(`  ${chalk.bold("Direction:")} ${result.direction}`);
+        logger.log(`  ${chalk.bold("Weight:")}    ${result.weight}`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // dao delegate
+  dao
+    .command("delegate <delegator> <delegate-to>")
+    .description("Delegate voting power")
+    .option("-w, --weight <n>", "Delegation weight", "1")
+    .action(async (delegator, delegateTo, 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();
+        ensureDAOv2Tables(db);
+
+        const result = delegate(
+          db,
+          delegator,
+          delegateTo,
+          parseFloat(options.weight),
+        );
+        logger.success("Delegation set");
+        logger.log(`  ${chalk.bold("From:")}   ${result.delegator}`);
+        logger.log(`  ${chalk.bold("To:")}     ${result.delegate}`);
+        logger.log(`  ${chalk.bold("Weight:")} ${result.weight}`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // dao execute
+  dao
+    .command("execute <proposal-id>")
+    .description("Execute a passed proposal")
+    .action(async (proposalId) => {
+      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();
+        ensureDAOv2Tables(db);
+
+        const result = execute(db, proposalId);
+        logger.success(`Proposal ${chalk.cyan(result.proposalId)} executed`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // dao treasury
+  dao
+    .command("treasury")
+    .description("Show treasury balance and allocations")
+    .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();
+        ensureDAOv2Tables(db);
+
+        const result = getTreasury();
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Balance:")}     ${result.balance}`);
+          logger.log(
+            `  ${chalk.bold("Allocations:")} ${result.allocations.length}`,
+          );
+          for (const a of result.allocations) {
+            logger.log(
+              `    ${chalk.cyan(a.id.slice(0, 12))} ${a.amount} — ${a.description || "N/A"}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // dao allocate
+  dao
+    .command("allocate <proposal-id> <amount>")
+    .description("Allocate treasury funds to a proposal")
+    .option("-d, --description <text>", "Allocation description")
+    .action(async (proposalId, amount, 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();
+        ensureDAOv2Tables(db);
+
+        const result = allocate(
+          db,
+          proposalId,
+          parseFloat(amount),
+          options.description,
+        );
+        logger.success("Funds allocated");
+        logger.log(`  ${chalk.bold("ID:")}       ${chalk.cyan(result.id)}`);
+        logger.log(`  ${chalk.bold("Amount:")}   ${result.amount}`);
+        logger.log(`  ${chalk.bold("Proposal:")} ${result.proposalId}`);
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // dao stats
+  dao
+    .command("stats")
+    .description("Show governance statistics")
+    .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();
+        ensureDAOv2Tables(db);
+
+        const result = getStats();
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(
+            `  ${chalk.bold("Total Proposals:")} ${result.totalProposals}`,
+          );
+          logger.log(`  ${chalk.bold("Active:")}          ${result.active}`);
+          logger.log(`  ${chalk.bold("Executed:")}        ${result.executed}`);
+          logger.log(
+            `  ${chalk.bold("Delegations:")}     ${result.delegations}`,
+          );
+          logger.log(`  ${chalk.bold("Treasury:")}        ${result.treasury}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // dao configure
+  dao
+    .command("configure")
+    .description("Update governance configuration")
+    .option("--voting-period <ms>", "Voting period in milliseconds")
+    .option("--quorum <ratio>", "Quorum ratio (0-1)")
+    .option("--execution-delay <ms>", "Execution delay in milliseconds")
+    .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();
+        ensureDAOv2Tables(db);
+
+        const cfg = {};
+        if (options.votingPeriod)
+          cfg.votingPeriod = parseInt(options.votingPeriod);
+        if (options.quorum) cfg.quorum = parseFloat(options.quorum);
+        if (options.executionDelay)
+          cfg.executionDelay = parseInt(options.executionDelay);
+
+        const result = configure(cfg);
+        logger.success("Configuration updated");
+        logger.log(
+          `  ${chalk.bold("Voting Period:")}    ${result.votingPeriod}ms`,
+        );
+        logger.log(`  ${chalk.bold("Quorum:")}           ${result.quorum}`);
+        logger.log(
+          `  ${chalk.bold("Execution Delay:")}  ${result.executionDelay}ms`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}