chainlesschain 0.38.1 → 0.40.1

package/src/lib/cli-anything-bridge.js

@@ -0,0 +1,379 @@
+/**
+ * CLI-Anything Bridge — discovers and registers CLI-Anything generated tools
+ * as ChainlessChain managed-layer skills.
+ *
+ * CLI-Anything (https://github.com/HKUDS/CLI-Anything) generates Agent-native
+ * CLI wrappers for arbitrary software.  This bridge scans for those wrappers
+ * on the user's PATH and turns each one into a SKILL.md + handler.js pair
+ * that the existing 4-layer skill-loader picks up automatically.
+ */
+
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { getElectronUserDataDir } from "./paths.js";
+
+/* ---------- _deps injection (Vitest CJS mock pattern) ---------- */
+export const _deps = { execSync, fs, path };
+
+/* ----------------------------------------------------------------
+ * Database helpers
+ * ---------------------------------------------------------------- */
+
+const CREATE_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS cli_anything_tools (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL UNIQUE,
+  software_path TEXT,
+  cli_command TEXT NOT NULL,
+  version TEXT DEFAULT '1.0.0',
+  description TEXT,
+  subcommands TEXT,
+  skill_name TEXT,
+  status TEXT DEFAULT 'discovered',
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+)`;
+
+export function ensureCliAnythingTables(db) {
+  db.exec(CREATE_TABLE_SQL);
+}
+
+/* ----------------------------------------------------------------
+ * Python / CLI-Anything detection
+ * ---------------------------------------------------------------- */
+
+/**
+ * Detect a usable Python interpreter.
+ * Returns { found: boolean, command?: string, version?: string }.
+ */
+export function detectPython() {
+  const candidates =
+    process.platform === "win32"
+      ? ["python", "python3", "py"]
+      : ["python3", "python"];
+
+  for (const cmd of candidates) {
+    try {
+      const ver = _deps
+        .execSync(`${cmd} --version`, {
+          encoding: "utf-8",
+          timeout: 10000,
+          stdio: ["pipe", "pipe", "pipe"],
+        })
+        .trim();
+      const match = ver.match(/Python\s+([\d.]+)/i);
+      if (match) {
+        return { found: true, command: cmd, version: match[1] };
+      }
+    } catch (_err) {
+      // This candidate not available — try next
+    }
+  }
+  return { found: false };
+}
+
+/**
+ * Check whether the `cli-anything` Python package is installed.
+ * Returns { installed: boolean, version?: string }.
+ */
+export function detectCliAnything() {
+  const py = detectPython();
+  if (!py.found) return { installed: false };
+
+  try {
+    const out = _deps.execSync(`${py.command} -m pip show cli-anything`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    const verMatch = out.match(/Version:\s*([\d.]+)/i);
+    return {
+      installed: true,
+      version: verMatch ? verMatch[1] : "unknown",
+      pythonCommand: py.command,
+    };
+  } catch (_err) {
+    return { installed: false, pythonCommand: py.command };
+  }
+}
+
+/**
+ * Install CLI-Anything via pip.
+ */
+export function installCliAnything(pythonCmd) {
+  _deps.execSync(`${pythonCmd} -m pip install cli-anything`, {
+    encoding: "utf-8",
+    timeout: 120000,
+    stdio: "inherit",
+  });
+}
+
+/* ----------------------------------------------------------------
+ * Tool scanning
+ * ---------------------------------------------------------------- */
+
+/**
+ * Scan PATH for executables matching `cli-anything-*`.
+ * Returns an array of { name, command, path }.
+ */
+export function scanPathForTools() {
+  const results = [];
+  const seen = new Set();
+  const dirs = (process.env.PATH || "").split(_deps.path.delimiter);
+
+  for (const dir of dirs) {
+    try {
+      const entries = _deps.fs.readdirSync(dir);
+      for (const entry of entries) {
+        const baseName = entry.replace(/\.exe$/i, "");
+        if (!baseName.startsWith("cli-anything-")) continue;
+        if (seen.has(baseName)) continue;
+        seen.add(baseName);
+
+        const toolName = baseName.replace(/^cli-anything-/, "");
+        results.push({
+          name: toolName,
+          command: baseName,
+          path: _deps.path.join(dir, entry),
+        });
+      }
+    } catch (_err) {
+      // Directory not readable — skip
+    }
+  }
+  return results;
+}
+
+/**
+ * Parse `--help` output of a cli-anything generated tool.
+ * Returns { description, subcommands: [{ name, description }] }.
+ */
+export function parseToolHelp(command) {
+  let helpText;
+  try {
+    helpText = _deps.execSync(`${command} --help`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+  } catch (err) {
+    const raw = err.stdout || err.stderr || "";
+    helpText = typeof raw === "string" ? raw : raw.toString("utf-8");
+  }
+
+  const lines = helpText.split("\n").map((l) => l.trimEnd());
+
+  // First non-empty, non-"usage:" line is typically the description
+  let description = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^usage:/i.test(trimmed)) continue;
+    if (/^options?:/i.test(trimmed)) break;
+    if (/^commands?:/i.test(trimmed)) break;
+    description = trimmed;
+    break;
+  }
+
+  // Parse subcommands section
+  const subcommands = [];
+  let inCommands = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^commands?:/i.test(trimmed) || /^subcommands?:/i.test(trimmed)) {
+      inCommands = true;
+      continue;
+    }
+    if (inCommands) {
+      if (!trimmed || /^options?:/i.test(trimmed)) break;
+      const match = trimmed.match(/^(\S+)\s+(.*)/);
+      if (match) {
+        subcommands.push({ name: match[1], description: match[2].trim() });
+      }
+    }
+  }
+
+  return {
+    description: description || `CLI-Anything tool: ${command}`,
+    subcommands,
+  };
+}
+
+/* ----------------------------------------------------------------
+ * Skill registration / removal
+ * ---------------------------------------------------------------- */
+
+function _skillDir(toolName) {
+  const userData = getElectronUserDataDir();
+  return _deps.path.join(userData, "skills", `cli-anything-${toolName}`);
+}
+
+/**
+ * Generate SKILL.md content for a CLI-Anything tool.
+ */
+export function _generateSkillMd(name, helpData) {
+  const subs = (helpData.subcommands || [])
+    .map((s) => `- **${s.name}**: ${s.description}`)
+    .join("\n");
+
+  return `---
+name: cli-anything-${name}
+display-name: CLI-Anything ${name}
+description: ${helpData.description || `Agent-native CLI for ${name}`}
+version: 1.0.0
+category: integration
+tags: [cli-anything, ${name}, external-tool]
+user-invocable: true
+handler: handler.js
+capabilities: [shell-exec]
+os: [linux, darwin, win32]
+---
+
+# cli-anything-${name}
+
+Auto-registered by \`chainlesschain cli-anything register ${name}\`.
+
+${helpData.description || ""}
+
+${subs ? `## Subcommands\n\n${subs}\n` : ""}
+## Usage
+
+Pass the subcommand and arguments as plain text input:
+
+\`\`\`
+/skill cli-anything-${name} <subcommand> [args...]
+\`\`\`
+`;
+}
+
+/**
+ * Generate handler.js content for a CLI-Anything tool.
+ */
+export function _generateHandlerJs(name, command) {
+  return `"use strict";
+const { execSync } = require("child_process");
+
+module.exports = {
+  async execute(task, context) {
+    const input = (task?.params?.input || task?.action || "").trim();
+    if (!input) return { success: false, error: "No input provided" };
+    try {
+      const output = execSync(\`${command} \${input}\`, {
+        encoding: "utf-8",
+        timeout: 60000,
+        cwd: context?.projectRoot || process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      let result;
+      try { result = JSON.parse(output); } catch (_e) { result = { output: output.trim() }; }
+      return { success: true, result, message: "Completed" };
+    } catch (err) {
+      const errMsg = typeof err.stderr === "string" ? err.stderr : (err.stderr?.toString("utf-8") || "");
+      return { success: false, error: errMsg || err.message };
+    }
+  },
+};
+`;
+}
+
+/**
+ * Register a CLI-Anything tool as a managed-layer skill.
+ */
+export function registerTool(db, toolName, opts = {}) {
+  const command = opts.command || `cli-anything-${toolName}`;
+  const helpData = opts.helpData || parseToolHelp(command);
+  const force = opts.force || false;
+
+  const dir = _skillDir(toolName);
+
+  // Check existing
+  const existing = db
+    .prepare("SELECT id FROM cli_anything_tools WHERE name = ?")
+    .get(toolName);
+  if (existing && !force) {
+    throw new Error(
+      `Tool "${toolName}" already registered. Use --force to overwrite.`,
+    );
+  }
+
+  // Write skill files
+  _deps.fs.mkdirSync(dir, { recursive: true });
+  _deps.fs.writeFileSync(
+    _deps.path.join(dir, "SKILL.md"),
+    _generateSkillMd(toolName, helpData),
+    "utf-8",
+  );
+  _deps.fs.writeFileSync(
+    _deps.path.join(dir, "handler.js"),
+    _generateHandlerJs(toolName, command),
+    "utf-8",
+  );
+
+  // Upsert DB record
+  const id = existing ? existing.id : `clia-${toolName}-${Date.now()}`;
+  const skillName = `cli-anything-${toolName}`;
+  const subcommandsJson = JSON.stringify(helpData.subcommands || []);
+
+  if (existing) {
+    db.prepare(
+      `
+      UPDATE cli_anything_tools
+      SET cli_command = ?, description = ?, subcommands = ?,
+          skill_name = ?, status = 'registered', updated_at = datetime('now')
+      WHERE name = ?
+    `,
+    ).run(command, helpData.description, subcommandsJson, skillName, toolName);
+  } else {
+    db.prepare(
+      `
+      INSERT INTO cli_anything_tools (id, name, software_path, cli_command, description, subcommands, skill_name, status)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 'registered')
+    `,
+    ).run(
+      id,
+      toolName,
+      opts.softwarePath || null,
+      command,
+      helpData.description,
+      subcommandsJson,
+      skillName,
+    );
+  }
+
+  return { id, skillName, dir, subcommands: helpData.subcommands || [] };
+}
+
+/**
+ * Remove a registered CLI-Anything tool.
+ */
+export function removeTool(db, toolName) {
+  const row = db
+    .prepare("SELECT id FROM cli_anything_tools WHERE name = ?")
+    .get(toolName);
+  if (!row) {
+    throw new Error(`Tool "${toolName}" is not registered.`);
+  }
+
+  // Remove skill directory
+  const dir = _skillDir(toolName);
+  try {
+    _deps.fs.rmSync(dir, { recursive: true, force: true });
+  } catch (_err) {
+    // Directory may already be gone
+  }
+
+  db.prepare("DELETE FROM cli_anything_tools WHERE name = ?").run(toolName);
+  return { removed: true, toolName };
+}
+
+/**
+ * List all registered CLI-Anything tools.
+ */
+export function listTools(db) {
+  return db
+    .prepare(
+      "SELECT id, name, cli_command, description, skill_name, status, created_at, updated_at FROM cli_anything_tools ORDER BY name",
+    )
+    .all();
+}

package/src/lib/git-integration.js

@@ -24,7 +24,7 @@ export function gitExec(args, cwd) {
       stdio: ["pipe", "pipe", "pipe"],
     }).trim();
   } catch (err) {
-    const stderr = err.stderr ? err.stderr.toString().trim() : "";
+    const stderr = err.stderr ? err.stderr.toString("utf-8").trim() : "";
     throw new Error(stderr || err.message);
   }
 }

package/src/lib/llm-providers.js

@@ -70,6 +70,19 @@ export const BUILT_IN_PROVIDERS = {
     ],
     free: false,
   },
+  volcengine: {
+    name: "volcengine",
+    displayName: "Volcengine (豆包)",
+    baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
+    apiKeyEnv: "VOLCENGINE_API_KEY",
+    models: [
+      "doubao-seed-1-6-251015",
+      "doubao-seed-1-6-flash-250828",
+      "doubao-seed-1-6-lite-251015",
+      "doubao-seed-code",
+    ],
+    free: false,
+  },
 };
 
 /**
@@ -302,7 +315,7 @@ export class LLMProviderRegistry {
       return { ok: true, elapsed: Date.now() - start, response: text.trim() };
     }
 
-    // OpenAI-compatible (openai, deepseek, dashscope, mistral)
+    // OpenAI-compatible (openai, deepseek, dashscope, mistral, volcengine)
     const key = this.getApiKey(name);
     if (!key) throw new Error(`${provider.apiKeyEnv} not set`);
     const res = await fetch(`${provider.baseUrl}/chat/completions`, {

package/src/lib/task-model-selector.js

@@ -0,0 +1,232 @@
+/**
+ * Task-based intelligent model selector for CLI
+ *
+ * Detects task type from user messages and recommends the best model
+ * for each LLM provider. Enables automatic model switching based on
+ * what the user is trying to accomplish.
+ */
+
+/**
+ * Task types supported by the selector
+ */
+export const TaskType = {
+  CHAT: "chat",
+  CODE: "code",
+  REASONING: "reasoning",
+  FAST: "fast",
+  TRANSLATE: "translate",
+  CREATIVE: "creative",
+};
+
+/**
+ * Task type → recommended model per provider
+ * Each provider maps to the best model for that task type.
+ */
+const TASK_MODEL_MAP = {
+  [TaskType.CHAT]: {
+    volcengine: "doubao-seed-1-6-flash-250828",
+    openai: "gpt-4o-mini",
+    anthropic: "claude-sonnet-4-6",
+    deepseek: "deepseek-chat",
+    dashscope: "qwen-plus",
+    gemini: "gemini-2.0-flash",
+    mistral: "mistral-medium-latest",
+    ollama: "qwen2:7b",
+  },
+  [TaskType.CODE]: {
+    volcengine: "doubao-seed-code",
+    openai: "gpt-4o",
+    anthropic: "claude-sonnet-4-6",
+    deepseek: "deepseek-coder",
+    dashscope: "qwen-max",
+    gemini: "gemini-2.0-pro",
+    mistral: "mistral-large-latest",
+    ollama: "codellama:7b",
+  },
+  [TaskType.REASONING]: {
+    volcengine: "doubao-seed-1-6-251015",
+    openai: "o1",
+    anthropic: "claude-opus-4-6",
+    deepseek: "deepseek-reasoner",
+    dashscope: "qwen-max",
+    gemini: "gemini-2.0-pro",
+    mistral: "mistral-large-latest",
+    ollama: "qwen2:7b",
+  },
+  [TaskType.FAST]: {
+    volcengine: "doubao-seed-1-6-lite-251015",
+    openai: "gpt-4o-mini",
+    anthropic: "claude-haiku-4-5-20251001",
+    deepseek: "deepseek-chat",
+    dashscope: "qwen-turbo",
+    gemini: "gemini-2.0-flash",
+    mistral: "mistral-small-latest",
+    ollama: "qwen2:7b",
+  },
+  [TaskType.TRANSLATE]: {
+    volcengine: "doubao-seed-1-6-251015",
+    openai: "gpt-4o",
+    anthropic: "claude-sonnet-4-6",
+    deepseek: "deepseek-chat",
+    dashscope: "qwen-plus",
+    gemini: "gemini-2.0-flash",
+    mistral: "mistral-large-latest",
+    ollama: "qwen2:7b",
+  },
+  [TaskType.CREATIVE]: {
+    volcengine: "doubao-seed-1-6-251015",
+    openai: "gpt-4o",
+    anthropic: "claude-opus-4-6",
+    deepseek: "deepseek-chat",
+    dashscope: "qwen-max",
+    gemini: "gemini-2.0-pro",
+    mistral: "mistral-large-latest",
+    ollama: "qwen2:7b",
+  },
+};
+
+/**
+ * Task type display names (Chinese + English)
+ */
+const TASK_NAMES = {
+  [TaskType.CHAT]: "日常对话",
+  [TaskType.CODE]: "代码任务",
+  [TaskType.REASONING]: "复杂推理",
+  [TaskType.FAST]: "快速响应",
+  [TaskType.TRANSLATE]: "翻译任务",
+  [TaskType.CREATIVE]: "创意写作",
+};
+
+/**
+ * Keyword patterns for detecting task type from user message.
+ * Each pattern is [regex, taskType, priority].
+ * Higher priority wins when multiple patterns match.
+ */
+const TASK_PATTERNS = [
+  // Code patterns (priority 10) — English with word boundaries
+  [
+    /\b(code|coding|program|function|class|bug|debug|refactor|implement)\b/i,
+    TaskType.CODE,
+    10,
+  ],
+  [
+    /\b(javascript|typescript|python|java|rust|go|c\+\+|sql|html|css|react|vue|node|npm|git|api|endpoint|database)\b/i,
+    TaskType.CODE,
+    10,
+  ],
+  [/```[\s\S]*```/, TaskType.CODE, 10],
+  // Code patterns — Chinese (no \b, Chinese chars are not word-boundary compatible)
+  [
+    /(代码|编程|函数|调试|重构|实现|写[一个]*[代码函数方法])/,
+    TaskType.CODE,
+    10,
+  ],
+
+  // Reasoning patterns (priority 8)
+  [
+    /\b(analyze|reason|explain why|prove|compare|evaluate)\b/i,
+    TaskType.REASONING,
+    8,
+  ],
+  [/\b(step.by.step|think.*through)\b/i, TaskType.REASONING, 8],
+  [
+    /(分析|推理|解释为什么|证明|比较|评估|深度思考|逻辑|逐步|一步一步)/,
+    TaskType.REASONING,
+    8,
+  ],
+
+  // Translation patterns (priority 9)
+  [/\b(translate|translation|translate.*to)\b/i, TaskType.TRANSLATE, 9],
+  [/(翻译|转换.*语言|英译中|中译英)/, TaskType.TRANSLATE, 9],
+
+  // Creative patterns (priority 7)
+  [
+    /\b(write|create|compose|story|poem|essay|blog|article)\b/i,
+    TaskType.CREATIVE,
+    7,
+  ],
+  [/(写[一篇]*.*[故事诗歌文章博客]|创作|小说|剧本)/, TaskType.CREATIVE, 7],
+
+  // Fast patterns (priority 5)
+  [/\b(quick|brief|short)\b/i, TaskType.FAST, 5],
+  [/(简短|快速|简单回答|一句话)/, TaskType.FAST, 5],
+];
+
+/**
+ * Detect the task type from a user message using keyword matching.
+ *
+ * @param {string} message - User's input message
+ * @returns {{ taskType: string, confidence: number, name: string }}
+ */
+export function detectTaskType(message) {
+  if (!message || typeof message !== "string") {
+    return {
+      taskType: TaskType.CHAT,
+      confidence: 0,
+      name: TASK_NAMES[TaskType.CHAT],
+    };
+  }
+
+  let bestMatch = null;
+  let bestPriority = -1;
+  let matchCount = 0;
+
+  for (const [pattern, taskType, priority] of TASK_PATTERNS) {
+    if (pattern.test(message)) {
+      matchCount++;
+      if (priority > bestPriority) {
+        bestPriority = priority;
+        bestMatch = taskType;
+      }
+    }
+  }
+
+  if (!bestMatch) {
+    return {
+      taskType: TaskType.CHAT,
+      confidence: 0,
+      name: TASK_NAMES[TaskType.CHAT],
+    };
+  }
+
+  // Confidence based on match count and priority
+  const confidence = Math.min(1, matchCount * 0.3 + bestPriority * 0.07);
+
+  return {
+    taskType: bestMatch,
+    confidence,
+    name: TASK_NAMES[bestMatch],
+  };
+}
+
+/**
+ * Select the best model for a given provider and task type.
+ *
+ * @param {string} provider - LLM provider name
+ * @param {string} taskType - Task type from TaskType enum
+ * @returns {string|null} Model ID, or null if no recommendation
+ */
+export function selectModelForTask(provider, taskType) {
+  const taskMap = TASK_MODEL_MAP[taskType];
+  if (!taskMap) return null;
+  return taskMap[provider] || null;
+}
+
+/**
+ * Get a human-readable task name.
+ *
+ * @param {string} taskType - Task type
+ * @returns {string}
+ */
+export function getTaskName(taskType) {
+  return TASK_NAMES[taskType] || taskType;
+}
+
+/**
+ * Get all supported task types.
+ *
+ * @returns {Object} TaskType enum
+ */
+export function getTaskTypes() {
+  return { ...TaskType };
+}