chainlesschain 0.37.12 → 0.40.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.37.12",
+  "version": "0.40.1",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {
@@ -50,7 +50,8 @@
     "@chainlesschain/shared-logger": "0.1.0",
     "@chainlesschain/core-db": "0.1.0",
     "@chainlesschain/core-config": "0.1.0",
-    "@chainlesschain/core-infra": "0.1.0"
+    "@chainlesschain/core-infra": "0.1.0",
+    "ws": "^8.14.2"
   },
   "devDependencies": {
     "vitest": "^3.1.1"

package/src/commands/agent.js

@@ -16,15 +16,21 @@ export function registerAgentCommand(program) {
       "Start an agentic AI session (reads/writes files, runs commands)",
     )
     .option("--model <model>", "Model name", "qwen2:7b")
-    .option("--provider <provider>", "LLM provider (ollama, openai)", "ollama")
+    .option(
+      "--provider <provider>",
+      "LLM provider (ollama, openai, volcengine, deepseek, ...)",
+      "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/ask.js

@@ -6,6 +6,7 @@
 import ora from "ora";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
+import { BUILT_IN_PROVIDERS } from "../lib/llm-providers.js";
 
 /**
  * Send a single question to an LLM provider
@@ -37,12 +38,24 @@ async function queryLLM(question, options = {}) {
 
     const data = await response.json();
     return data.response;
-  } else if (provider === "openai") {
-    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+  } else {
+    // OpenAI-compatible providers (openai, volcengine, deepseek, dashscope, mistral, gemini)
+    const providerDef = BUILT_IN_PROVIDERS[provider];
+    if (!providerDef) {
+      throw new Error(
+        `Unsupported provider: ${provider}. Supported: ollama, openai, volcengine, deepseek, dashscope, gemini, mistral, anthropic`,
+      );
+    }
+
+    const apiKey =
+      options.apiKey ||
+      (providerDef.apiKeyEnv ? process.env[providerDef.apiKeyEnv] : null);
     if (!apiKey)
-      throw new Error("OpenAI API key required (--api-key or OPENAI_API_KEY)");
+      throw new Error(
+        `API key required for ${provider} (--api-key or ${providerDef.apiKeyEnv})`,
+      );
 
-    const apiBase = options.baseUrl || "https://api.openai.com/v1";
+    const apiBase = options.baseUrl || providerDef.baseUrl;
     const response = await fetch(`${apiBase}/chat/completions`, {
       method: "POST",
       headers: {
@@ -50,22 +63,20 @@ async function queryLLM(question, options = {}) {
         Authorization: `Bearer ${apiKey}`,
       },
       body: JSON.stringify({
-        model: model || "gpt-4o-mini",
+        model: model || providerDef.models[0],
         messages: [{ role: "user", content: question }],
       }),
     });
 
     if (!response.ok) {
       throw new Error(
-        `OpenAI error: ${response.status} ${response.statusText}`,
+        `${provider} error: ${response.status} ${response.statusText}`,
       );
     }
 
     const data = await response.json();
     return data.choices[0].message.content;
   }
-
-  throw new Error(`Unsupported provider: ${provider}`);
 }
 
 export function registerAskCommand(program) {
@@ -74,7 +85,11 @@ export function registerAskCommand(program) {
     .description("Ask a question to the AI (single-shot)")
     .argument("<question>", "The question to ask")
     .option("--model <model>", "Model name", "qwen2:7b")
-    .option("--provider <provider>", "LLM provider (ollama, openai)", "ollama")
+    .option(
+      "--provider <provider>",
+      "LLM provider (ollama, openai, volcengine, deepseek, ...)",
+      "ollama",
+    )
     .option("--base-url <url>", "API base URL")
     .option("--api-key <key>", "API key")
     .option("--json", "Output as JSON")

package/src/commands/chat.js

@@ -11,19 +11,25 @@ export function registerChatCommand(program) {
     .command("chat")
     .description("Start an interactive AI chat session")
     .option("--model <model>", "Model name", "qwen2:7b")
-    .option("--provider <provider>", "LLM provider (ollama, openai)", "ollama")
+    .option(
+      "--provider <provider>",
+      "LLM provider (ollama, openai, volcengine, deepseek, ...)",
+      "ollama",
+    )
     .option("--base-url <url>", "API base URL")
     .option("--api-key <key>", "API key")
     .option(
       "--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/cli-anything.js

@@ -0,0 +1,266 @@
+/**
+ * CLI-Anything commands — discover & register CLI-Anything generated tools
+ * chainlesschain cli-anything doctor|scan|register|list|remove
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureCliAnythingTables,
+  detectPython,
+  detectCliAnything,
+  scanPathForTools,
+  parseToolHelp,
+  registerTool,
+  removeTool,
+  listTools,
+} from "../lib/cli-anything-bridge.js";
+
+export function registerCliAnythingCommand(program) {
+  const cliAny = program
+    .command("cli-anything")
+    .description(
+      "CLI-Anything — discover and register Agent-native CLI tools as skills",
+    );
+
+  /* ---- doctor ---- */
+  cliAny
+    .command("doctor")
+    .description("Check Python & CLI-Anything environment")
+    .option("--json", "Output as JSON")
+    .action(async (opts) => {
+      const py = detectPython();
+      const clia = py.found ? detectCliAnything() : { installed: false };
+      const tools = scanPathForTools();
+
+      const report = {
+        python: py,
+        cliAnything: clia,
+        toolsOnPath: tools.length,
+      };
+
+      if (opts.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+      }
+
+      logger.log("");
+      logger.log(chalk.bold("  CLI-Anything Environment"));
+      logger.log("");
+
+      // Python
+      if (py.found) {
+        logger.log(
+          `  ${chalk.green("✓")} Python ${chalk.cyan(py.version)} (${py.command})`,
+        );
+      } else {
+        logger.log(`  ${chalk.red("✗")} Python not found`);
+      }
+
+      // CLI-Anything
+      if (clia.installed) {
+        logger.log(
+          `  ${chalk.green("✓")} CLI-Anything ${chalk.cyan(clia.version)}`,
+        );
+      } else {
+        logger.log(`  ${chalk.red("✗")} CLI-Anything not installed`);
+        if (py.found) {
+          logger.log(
+            `    ${chalk.gray(`Install: ${py.command} -m pip install cli-anything`)}`,
+          );
+        }
+      }
+
+      // Tools
+      logger.log(
+        `  ${tools.length > 0 ? chalk.green("✓") : chalk.yellow("○")} ${tools.length} tool(s) on PATH`,
+      );
+      for (const t of tools) {
+        logger.log(
+          `    ${chalk.gray(`cli-anything-${t.name}`)} → ${chalk.gray(t.path)}`,
+        );
+      }
+      logger.log("");
+    });
+
+  /* ---- scan ---- */
+  cliAny
+    .command("scan")
+    .description("Scan PATH for cli-anything-* tools")
+    .option("--json", "Output as JSON")
+    .action(async (opts) => {
+      const tools = scanPathForTools();
+
+      if (opts.json) {
+        console.log(JSON.stringify(tools, null, 2));
+        return;
+      }
+
+      if (tools.length === 0) {
+        logger.info("No cli-anything-* tools found on PATH.");
+        logger.log(
+          chalk.gray(
+            "  Use CLI-Anything to generate tools first: /cli-anything <software>",
+          ),
+        );
+        return;
+      }
+
+      logger.log("");
+      logger.log(chalk.bold(`  Found ${tools.length} tool(s):`));
+      logger.log("");
+      for (const t of tools) {
+        const help = parseToolHelp(t.command);
+        logger.log(`  ${chalk.cyan(t.name)}`);
+        logger.log(`    Command: ${chalk.gray(t.command)}`);
+        logger.log(`    Path:    ${chalk.gray(t.path)}`);
+        if (help.description) {
+          logger.log(`    Desc:    ${chalk.gray(help.description)}`);
+        }
+        if (help.subcommands.length > 0) {
+          logger.log(
+            `    Subs:    ${chalk.gray(help.subcommands.map((s) => s.name).join(", "))}`,
+          );
+        }
+      }
+      logger.log("");
+    });
+
+  /* ---- register ---- */
+  cliAny
+    .command("register <name>")
+    .description("Register a cli-anything-* tool as a ChainlessChain skill")
+    .option("--force", "Overwrite existing registration")
+    .option("--json", "Output as JSON")
+    .action(async (name, opts) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error(
+            "Database not available. Run `chainlesschain setup` first.",
+          );
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureCliAnythingTables(db);
+
+        const command = `cli-anything-${name}`;
+        const helpData = parseToolHelp(command);
+
+        const result = registerTool(db, name, {
+          command,
+          helpData,
+          force: opts.force,
+        });
+
+        await shutdown();
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        logger.success(
+          `Registered ${chalk.cyan(name)} as skill ${chalk.bold(result.skillName)}`,
+        );
+        logger.log(`  Skill dir: ${chalk.gray(result.dir)}`);
+        if (result.subcommands.length > 0) {
+          logger.log(
+            `  Subcommands: ${chalk.gray(result.subcommands.map((s) => s.name).join(", "))}`,
+          );
+        }
+        logger.log(
+          chalk.gray(
+            `  Use in Agent: /skill ${result.skillName} <subcommand> [args]`,
+          ),
+        );
+      } catch (err) {
+        logger.error(`Register failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  /* ---- list (default) ---- */
+  cliAny
+    .command("list", { isDefault: true })
+    .description("List registered CLI-Anything tools")
+    .option("--json", "Output as JSON")
+    .action(async (opts) => {
+      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();
+        ensureCliAnythingTables(db);
+
+        const tools = listTools(db);
+        await shutdown();
+
+        if (opts.json) {
+          console.log(JSON.stringify(tools, null, 2));
+          return;
+        }
+
+        if (tools.length === 0) {
+          logger.info("No CLI-Anything tools registered.");
+          logger.log(
+            chalk.gray(
+              "  Run `chainlesschain cli-anything scan` to discover tools.",
+            ),
+          );
+          return;
+        }
+
+        logger.log("");
+        logger.log(chalk.bold(`  ${tools.length} registered tool(s):`));
+        logger.log("");
+        for (const t of tools) {
+          const statusColor =
+            t.status === "registered" ? chalk.green : chalk.yellow;
+          logger.log(
+            `  ${chalk.cyan(t.name)} ${statusColor(`[${t.status}]`)} → ${chalk.gray(t.skill_name)}`,
+          );
+          if (t.description) {
+            logger.log(`    ${chalk.gray(t.description)}`);
+          }
+        }
+        logger.log("");
+      } catch (err) {
+        logger.error(`List failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  /* ---- remove ---- */
+  cliAny
+    .command("remove <name>")
+    .description("Remove a registered CLI-Anything tool")
+    .option("--json", "Output as JSON")
+    .action(async (name, opts) => {
+      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();
+        ensureCliAnythingTables(db);
+
+        const result = removeTool(db, name);
+        await shutdown();
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        logger.success(`Removed tool ${chalk.cyan(name)}`);
+      } catch (err) {
+        logger.error(`Remove failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

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);
+      }
+    });
+}