chainlesschain 0.38.1 → 0.40.1

package/package.json

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

package/src/commands/serve.js

@@ -0,0 +1,109 @@
+/**
+ * serve command — start a WebSocket server for remote CLI access
+ * chainlesschain serve [--port] [--host] [--token] [--max-connections] [--timeout] [--allow-remote]
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { ChainlessChainWSServer } from "../lib/ws-server.js";
+
+export function registerServeCommand(program) {
+  program
+    .command("serve")
+    .description("Start WebSocket server for remote CLI access")
+    .option("-p, --port <port>", "Port number", "18800")
+    .option("-H, --host <host>", "Bind host", "127.0.0.1")
+    .option(
+      "--token <token>",
+      "Authentication token (required for remote access)",
+    )
+    .option("--max-connections <n>", "Maximum concurrent connections", "10")
+    .option(
+      "--timeout <ms>",
+      "Command execution timeout in milliseconds",
+      "30000",
+    )
+    .option(
+      "--allow-remote",
+      "Allow non-localhost connections (requires --token)",
+    )
+    .action(async (opts) => {
+      const port = parseInt(opts.port, 10);
+      const maxConnections = parseInt(opts.maxConnections, 10);
+      const timeout = parseInt(opts.timeout, 10);
+      let host = opts.host;
+
+      // Validation
+      if (isNaN(port) || port < 1 || port > 65535) {
+        logger.error("Invalid port number. Must be between 1 and 65535.");
+        process.exit(1);
+      }
+
+      if (opts.allowRemote) {
+        if (!opts.token) {
+          logger.error("--allow-remote requires --token for security.");
+          process.exit(1);
+        }
+        host = "0.0.0.0";
+      }
+
+      const server = new ChainlessChainWSServer({
+        port,
+        host,
+        token: opts.token || null,
+        maxConnections,
+        timeout,
+      });
+
+      // Event logging
+      server.on("connection", ({ clientId, ip }) => {
+        logger.log(chalk.green(`  + Client connected: ${clientId} (${ip})`));
+      });
+
+      server.on("disconnection", ({ clientId, reason }) => {
+        const extra = reason ? ` (${reason})` : "";
+        logger.log(
+          chalk.yellow(`  - Client disconnected: ${clientId}${extra}`),
+        );
+      });
+
+      server.on("command:start", ({ id, command }) => {
+        logger.log(chalk.cyan(`  > [${id}] ${command}`));
+      });
+
+      server.on("command:end", ({ id, exitCode }) => {
+        const color = exitCode === 0 ? chalk.green : chalk.red;
+        logger.log(color(`  < [${id}] exit ${exitCode}`));
+      });
+
+      // Graceful shutdown
+      const shutdown = async () => {
+        logger.log("\n" + chalk.yellow("Shutting down WebSocket server..."));
+        await server.stop();
+        process.exit(0);
+      };
+
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+
+      try {
+        await server.start();
+
+        logger.log("");
+        logger.log(chalk.bold("  ChainlessChain WebSocket Server"));
+        logger.log("");
+        logger.log(`  Address:  ${chalk.cyan(`ws://${host}:${port}`)}`);
+        logger.log(
+          `  Auth:     ${opts.token ? chalk.green("enabled") : chalk.yellow("disabled")}`,
+        );
+        logger.log(`  Max conn: ${maxConnections}`);
+        logger.log(`  Timeout:  ${timeout}ms`);
+        logger.log("");
+        logger.log(chalk.dim("  Press Ctrl+C to stop"));
+        logger.log("");
+      } catch (err) {
+        logger.error(`Failed to start server: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/constants.js

@@ -23,6 +23,7 @@ export const DEFAULT_PORTS = {
   redis: 6379,
   projectService: 9090,
   aiService: 8001,
+  wsServer: 18800,
 };
 
 export const LLM_PROVIDERS = {

package/src/index.js

@@ -79,6 +79,12 @@ import { registerLowcodeCommand } from "./commands/lowcode.js";
 // EvoMap: Gene Exchange Protocol
 import { registerEvoMapCommand } from "./commands/evomap.js";
 
+// CLI-Anything: Agent-Native Software Integration
+import { registerCliAnythingCommand } from "./commands/cli-anything.js";
+
+// WebSocket Server Interface
+import { registerServeCommand } from "./commands/serve.js";
+
 export function createProgram() {
   const program = new Command();
 
@@ -187,5 +193,11 @@ export function createProgram() {
   // EvoMap: Gene Exchange Protocol
   registerEvoMapCommand(program);
 
+  // CLI-Anything: Agent-Native Software Integration
+  registerCliAnythingCommand(program);
+
+  // WebSocket Server Interface
+  registerServeCommand(program);
+
   return program;
 }