chainlesschain 0.38.1 → 0.40.2

package/README.md

@@ -169,7 +169,7 @@ chainlesschain llm models               # List installed Ollama models
 chainlesschain llm models --json        # JSON output
 chainlesschain llm test                 # Test Ollama connectivity
 chainlesschain llm test --provider openai --api-key sk-...
-chainlesschain llm providers            # List 7 built-in LLM providers
+chainlesschain llm providers            # List 8 built-in LLM providers
 chainlesschain llm add-provider <name>  # Add custom provider
 chainlesschain llm switch <name>        # Switch active provider
 ```
@@ -638,6 +638,198 @@ chainlesschain lowcode publish <id>                    # Publish app
 
 ---
 
+## EvoMap Gene Exchange Protocol
+
+### `chainlesschain evomap <action>`
+
+Gene exchange protocol for sharing AI capabilities across instances.
+
+```bash
+chainlesschain evomap search "tool name"               # Search genes on hub
+chainlesschain evomap download <gene-id>                # Download gene
+chainlesschain evomap publish --name "my-gene"          # Publish gene to hub
+chainlesschain evomap list                              # List local genes
+chainlesschain evomap hubs                              # List available hubs
+chainlesschain evomap federation list-hubs              # List federated hubs
+chainlesschain evomap federation sync <hub>             # Sync genes with hub
+chainlesschain evomap federation pressure               # Pressure analytics report
+chainlesschain evomap gov propose "title"               # Governance proposal
+chainlesschain evomap gov vote <id> for                 # Vote on proposal
+chainlesschain evomap gov dashboard                     # Governance dashboard
+```
+
+---
+
+## DAO Governance
+
+### `chainlesschain dao <action>`
+
+Decentralized governance with quadratic voting.
+
+```bash
+chainlesschain dao propose "title"                      # Create DAO proposal
+chainlesschain dao vote <id> for                        # Vote (quadratic voting)
+chainlesschain dao delegate <from> <to>                 # Delegate voting power
+chainlesschain dao execute <id>                         # Execute passed proposal
+chainlesschain dao treasury                             # Show treasury balance
+chainlesschain dao stats                                # Governance statistics
+```
+
+---
+
+## Phase 8: Security & Compliance
+
+### `chainlesschain compliance <action>`
+
+Compliance evidence collection and reporting (GDPR, SOC2, HIPAA).
+
+```bash
+chainlesschain compliance evidence gdpr                 # Collect compliance evidence
+chainlesschain compliance report soc2                   # Generate compliance report
+chainlesschain compliance classify "text"               # Classify data sensitivity
+chainlesschain compliance scan hipaa                    # Scan compliance posture
+```
+
+### `chainlesschain dlp <action>`
+
+Data Loss Prevention (DLP) content scanning and policy management.
+
+```bash
+chainlesschain dlp scan "content"                       # DLP content scanning
+chainlesschain dlp incidents                            # List DLP incidents
+chainlesschain dlp policy create --name "rule"          # Create DLP policy
+```
+
+### `chainlesschain siem <action>`
+
+Security Information and Event Management (SIEM) integration.
+
+```bash
+chainlesschain siem targets                             # List SIEM targets
+chainlesschain siem add-target splunk_hec <url>         # Add SIEM export target
+chainlesschain siem export <target-id>                  # Export logs to SIEM
+```
+
+### `chainlesschain pqc <action>`
+
+Post-Quantum Cryptography key management and migration.
+
+```bash
+chainlesschain pqc keys                                 # List PQC keys
+chainlesschain pqc generate ML-KEM-768                  # Generate PQC key pair
+chainlesschain pqc migration-status                     # PQC migration status
+chainlesschain pqc migrate "plan" ML-KEM-768            # Execute PQC migration
+```
+
+---
+
+## Phase 8: Communication Bridges
+
+### `chainlesschain nostr <action>`
+
+Nostr protocol bridge for decentralized social messaging.
+
+```bash
+chainlesschain nostr relays                             # List Nostr relays
+chainlesschain nostr publish "Hello"                    # Publish Nostr event
+chainlesschain nostr keygen                             # Generate Nostr keypair
+chainlesschain nostr map-did <did> <pubkey>             # Map DID to Nostr
+```
+
+### `chainlesschain matrix <action>`
+
+Matrix protocol bridge for federated messaging.
+
+```bash
+chainlesschain matrix login                             # Login to Matrix
+chainlesschain matrix rooms                             # List Matrix rooms
+chainlesschain matrix send <room> "message"             # Send Matrix message
+```
+
+### `chainlesschain scim <action>`
+
+SCIM protocol for enterprise user provisioning.
+
+```bash
+chainlesschain scim users list                          # List SCIM users
+chainlesschain scim users create --name "user"          # Create SCIM user
+chainlesschain scim sync <connector-id>                 # Trigger SCIM sync
+```
+
+---
+
+## Phase 8: Infrastructure & Hardening
+
+### `chainlesschain terraform <action>`
+
+Infrastructure-as-Code workspace management.
+
+```bash
+chainlesschain terraform workspaces                     # List Terraform workspaces
+chainlesschain terraform create "prod"                  # Create workspace
+chainlesschain terraform plan <workspace-id>            # Run Terraform plan
+```
+
+### `chainlesschain hardening <action>`
+
+Security hardening and performance baseline management.
+
+```bash
+chainlesschain hardening baseline collect "v1"          # Collect performance baseline
+chainlesschain hardening baseline compare <id>          # Compare baseline (regression)
+chainlesschain hardening audit run "quarterly"          # Run security audit
+```
+
+---
+
+## Phase 8: Social Platform
+
+### `chainlesschain social <action>`
+
+Decentralized social networking features.
+
+```bash
+chainlesschain social contact add "Alice"               # Add a contact
+chainlesschain social contact list                      # List contacts
+chainlesschain social friend add <contact-id>           # Send friend request
+chainlesschain social post publish "Hello"              # Publish a post
+chainlesschain social chat send <user> "msg"            # Send chat message
+chainlesschain social stats                             # Social statistics
+```
+
+---
+
+## CLI-Anything: Agent-Native Software Integration
+
+### `chainlesschain cli-anything <action>`
+
+Discover and register external CLI tools as ChainlessChain skills.
+
+```bash
+chainlesschain cli-anything doctor                      # Check Python + CLI-Anything environment
+chainlesschain cli-anything scan                        # Scan PATH for cli-anything-* tools
+chainlesschain cli-anything register <name>             # Register tool as ChainlessChain skill
+chainlesschain cli-anything list                        # List registered tools
+chainlesschain cli-anything remove <name>               # Remove registered tool
+```
+
+---
+
+## WebSocket Server Interface
+
+### `chainlesschain serve`
+
+Start a WebSocket server for external tool integration, enabling real-time bidirectional communication with the CLI engine.
+
+```bash
+chainlesschain serve                                    # Start WebSocket server (port 18800)
+chainlesschain serve --port 9000                        # Custom port
+chainlesschain serve --token <secret>                   # Enable token auth
+chainlesschain serve --allow-remote --token <secret>    # Allow remote + auth
+```
+
+---
+
 ## Global Options
 
 ```bash
@@ -682,16 +874,17 @@ Configuration is stored at `~/.chainlesschain/config.json`. The CLI creates and
 
 ### Supported LLM Providers
 
-| Provider            | Default Model     | API Key Required |
-| ------------------- | ----------------- | ---------------- |
-| Ollama (Local)      | qwen2:7b          | No               |
-| OpenAI              | gpt-4o            | Yes              |
-| Anthropic           | claude-sonnet-4-6 | Yes              |
-| DashScope (Alibaba) | qwen-max          | Yes              |
-| DeepSeek            | deepseek-chat     | Yes              |
-| Gemini (Google)     | gemini-pro        | Yes              |
-| Mistral             | mistral-large     | Yes              |
-| Custom              | —                 | Yes              |
+| Provider               | Default Model     | API Key Required |
+| ---------------------- | ----------------- | ---------------- |
+| Ollama (Local)         | qwen2:7b          | No               |
+| OpenAI                 | gpt-4o            | Yes              |
+| Anthropic              | claude-sonnet-4-6 | Yes              |
+| DashScope (Alibaba)    | qwen-max          | Yes              |
+| DeepSeek               | deepseek-chat     | Yes              |
+| Gemini (Google)        | gemini-pro        | Yes              |
+| Mistral                | mistral-large     | Yes              |
+| Volcengine (ByteDance) | doubao-1.5-pro    | Yes              |
+| Custom                 | —                 | Yes              |
 
 ## File Structure
 
@@ -710,7 +903,7 @@ Configuration is stored at `~/.chainlesschain/config.json`. The CLI creates and
 ```bash
 cd packages/cli
 npm install
-npm test                # Run all tests (1429 tests across 67 files)
+npm test                # Run all tests (2063 tests across 99 files)
 npm run test:unit       # Unit tests only
 npm run test:integration # Integration tests
 npm run test:e2e        # End-to-end tests
@@ -720,13 +913,13 @@ npm run test:e2e        # End-to-end tests
 
 | Category                 | Files  | Tests    | Status          |
 | ------------------------ | ------ | -------- | --------------- |
-| Unit — lib modules       | 44     | 892      | All passing     |
-| Unit — commands          | 10     | 213      | All passing     |
+| Unit — lib modules       | 56     | 1200+    | All passing     |
+| Unit — commands          | 15     | 350+     | All passing     |
 | Unit — runtime           | 1      | 6        | All passing     |
-| Integration              | 3      | 7        | All passing     |
-| E2E                      | 10     | 109      | All passing     |
+| Integration              | 5      | 30+      | All passing     |
+| E2E                      | 14     | 150+     | All passing     |
 | Core packages (external) | —      | 118      | All passing     |
-| **CLI Total**            | **67** | **1429** | **All passing** |
+| **CLI Total**            | **99** | **2063** | **All passing** |
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.38.1",
+  "version": "0.40.2",
   "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,7 +16,11 @@ 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")

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,7 +11,11 @@ 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(

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