reasonix 0.43.0 → 0.44.0

package/dist/cli/{chunk-XPDVG52A.js → chunk-AVFXO2EZ.js}

@@ -1755,15 +1755,126 @@ var require_picomatch2 = __commonJS({
   }
 });
 
+// src/mcp/shell-split.ts
+function shellSplit(input) {
+  const tokens = [];
+  let cur = "";
+  let quote = null;
+  let i = 0;
+  const s = input;
+  while (i < s.length) {
+    const ch = s[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+        i++;
+        continue;
+      }
+      if (ch === "\\" && quote === '"' && i + 1 < s.length) {
+        cur += s[i + 1];
+        i += 2;
+        continue;
+      }
+      cur += ch;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      i++;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      if (cur.length > 0) {
+        tokens.push(cur);
+        cur = "";
+      }
+      i++;
+      continue;
+    }
+    cur += ch;
+    i++;
+  }
+  if (quote) {
+    throw new Error(
+      `shellSplit: unterminated ${quote === '"' ? "double" : "single"} quote in input`
+    );
+  }
+  if (cur.length > 0) tokens.push(cur);
+  return tokens;
+}
+
+// src/mcp/spec.ts
+function getMcpServerEnv(spec) {
+  return spec.transport === "stdio" ? spec.env : void 0;
+}
+function getMcpServerHeaders(spec) {
+  return spec.transport !== "stdio" ? spec.headers : void 0;
+}
+function overlayMatchedSpec(parsed, matched) {
+  switch (parsed.transport) {
+    case "stdio":
+      return matched ? { ...parsed, disabled: matched.disabled, env: getMcpServerEnv(matched) } : { ...parsed };
+    case "sse":
+      return matched ? { ...parsed, disabled: matched.disabled, headers: getMcpServerHeaders(matched) } : { ...parsed };
+    case "streamable-http":
+      return matched ? { ...parsed, disabled: matched.disabled, headers: getMcpServerHeaders(matched) } : { ...parsed };
+  }
+}
+function specToRaw(spec) {
+  if (spec.transport === "stdio") {
+    const args = spec.args.map((a) => {
+      if (a.includes(" ") || a.includes('"') || a.includes("	")) {
+        return `"${a.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+      }
+      return a;
+    }).join(" ");
+    const body = args ? `${spec.command} ${args}` : spec.command;
+    return spec.name ? `${spec.name}=${body}` : body;
+  }
+  if (spec.transport === "sse") {
+    return spec.name ? `${spec.name}=${spec.url}` : spec.url;
+  }
+  return spec.name ? `${spec.name}=streamable+${spec.url}` : `streamable+${spec.url}`;
+}
+var NAME_PREFIX = /^([a-zA-Z_][a-zA-Z0-9_-]*)=(.*)$/;
+var HTTP_URL = /^https?:\/\//i;
+var STREAMABLE_PREFIX = /^streamable\+(https?:\/\/.+)$/i;
+function parseMcpSpec(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("empty MCP spec");
+  }
+  const nameMatch = NAME_PREFIX.exec(trimmed);
+  const name = nameMatch ? nameMatch[1] : null;
+  const body = (nameMatch ? nameMatch[2] : trimmed).trim();
+  if (!body) {
+    throw new Error(`MCP spec has name but no command: ${input}`);
+  }
+  const streamMatch = STREAMABLE_PREFIX.exec(body);
+  if (streamMatch) {
+    return { transport: "streamable-http", name, url: streamMatch[1] };
+  }
+  if (HTTP_URL.test(body)) {
+    return { transport: "sse", name, url: body };
+  }
+  const argv = shellSplit(body);
+  if (argv.length === 0) {
+    throw new Error(`MCP spec has name but no command: ${input}`);
+  }
+  const [command, ...args] = argv;
+  return { transport: "stdio", name, command, args };
+}
+
 // src/config.ts
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { dirname, join } from "path";
+import { dirname, isAbsolute, join, resolve } from "path";
 
 // src/cli/ui/theme/tokens.ts
 function card(fg, tone) {
   return {
-    user: { color: fg.meta, glyph: "\u25C7" },
+    user: { color: tone.brand, glyph: "\u25C7" },
     reasoning: { color: tone.accent, glyph: "\u25C6" },
     streaming: { color: tone.brand, glyph: "\u25C8" },
     task: { color: tone.warn, glyph: "\u25B6" },
@@ -2216,6 +2327,13 @@ function memoryTypeDefaults(typeName, cfg = readConfig()) {
   if (found.expires) out.expires = found.expires;
   return out;
 }
+var DEFAULT_METASO_API_KEY = "mk-E384C1DD5E8501BB7EFE27C949AFDE5B";
+function loadMetasoApiKey(path = defaultConfigPath()) {
+  if (process.env.METASO_API_KEY) return process.env.METASO_API_KEY;
+  const cfg = readConfig(path).metasoApiKey;
+  if (cfg && typeof cfg === "string" && cfg.trim()) return cfg.trim();
+  return DEFAULT_METASO_API_KEY;
+}
 var DEFAULT_OLLAMA_URL = "http://localhost:11434";
 var DEFAULT_EMBED_MODEL = "nomic-embed-text";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -2242,15 +2360,103 @@ function writeConfig(cfg, path = defaultConfigPath()) {
 function loadLanguage(path = defaultConfigPath()) {
   return readConfig(path).lang;
 }
-function mcpEnvFor(serverName, cfg) {
-  if (!serverName) return void 0;
-  const entry = cfg.mcpEnv?.[serverName];
-  if (!entry) return void 0;
-  const filtered = {};
-  for (const [k, v] of Object.entries(entry)) {
-    if (typeof v === "string" && v.length > 0) filtered[k] = v;
+function inferMcpTransport(cfg) {
+  if (cfg.transport) return cfg.transport;
+  const url = cfg.url?.trim() ?? "";
+  if (/^streamable\+https?:\/\//i.test(url)) return "streamable-http";
+  if (/^https?:\/\//i.test(url)) return "sse";
+  return "stdio";
+}
+function normalizeStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof v === "string" && v.length > 0) out[k] = v;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normalizeMcpConfig(cfg, extraLegacy) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const disabledFromLegacy = new Set(cfg.mcpDisabled ?? []);
+  const legacySpecs = extraLegacy && extraLegacy.length > 0 ? extraLegacy : cfg.mcp ?? [];
+  for (const raw of legacySpecs) {
+    if (typeof raw !== "string") continue;
+    try {
+      const spec = parseMcpSpec(raw);
+      const env = spec.name ? normalizeStringRecord(cfg.mcpEnv?.[spec.name]) : void 0;
+      const disabled = spec.name ? disabledFromLegacy.has(spec.name) : false;
+      if (spec.transport === "stdio") {
+        result.push({ ...spec, env, disabled });
+      } else if (spec.transport === "sse") {
+        result.push({ ...spec, disabled });
+      } else {
+        result.push({ ...spec, disabled });
+      }
+      if (spec.name) seen.add(spec.name);
+    } catch {
+    }
   }
-  return Object.keys(filtered).length > 0 ? filtered : void 0;
+  for (const [name, serverCfg] of Object.entries(cfg.mcpServers ?? {})) {
+    if (!serverCfg || typeof serverCfg !== "object") continue;
+    const transport = inferMcpTransport(serverCfg);
+    const disabled = serverCfg.disabled === true;
+    if (transport === "stdio") {
+      const env = normalizeStringRecord(serverCfg.env);
+      const spec = {
+        transport: "stdio",
+        name,
+        command: serverCfg.command ?? "",
+        args: serverCfg.args ?? [],
+        env,
+        disabled
+      };
+      if (seen.has(name)) {
+        const idx = result.findIndex((s) => s.name === name);
+        if (idx >= 0) result[idx] = spec;
+      } else {
+        seen.add(name);
+        result.push(spec);
+      }
+    } else {
+      let url = serverCfg.url ?? "";
+      const streamMatch = /^streamable\+(https?:\/\/.+)$/i.exec(url);
+      if (streamMatch) url = streamMatch[1];
+      const headers = normalizeStringRecord(serverCfg.headers);
+      if (transport === "sse") {
+        const spec = {
+          transport: "sse",
+          name,
+          url,
+          headers,
+          disabled
+        };
+        if (seen.has(name)) {
+          const idx = result.findIndex((s) => s.name === name);
+          if (idx >= 0) result[idx] = spec;
+        } else {
+          seen.add(name);
+          result.push(spec);
+        }
+      } else {
+        const spec = {
+          transport: "streamable-http",
+          name,
+          url,
+          headers,
+          disabled
+        };
+        if (seen.has(name)) {
+          const idx = result.findIndex((s) => s.name === name);
+          if (idx >= 0) result[idx] = spec;
+        } else {
+          seen.add(name);
+          result.push(spec);
+        }
+      }
+    }
+  }
+  return result;
 }
 function saveLanguage(lang, path = defaultConfigPath()) {
   const cfg = readConfig(path);
@@ -2275,6 +2481,93 @@ function saveBaseUrl(url, path = defaultConfigPath()) {
   }
   writeConfig(cfg, path);
 }
+function resolveSkillPath(raw, baseDir) {
+  const homeExpanded = expandCurrentUserHome(raw.trim());
+  return resolve(isAbsolute(homeExpanded) ? homeExpanded : join(baseDir, homeExpanded));
+}
+function normalizeSkillPathEntries(paths, baseDir) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of paths) {
+    if (typeof value !== "string") continue;
+    const raw = value.trim();
+    if (!raw) continue;
+    const resolved = resolveSkillPath(raw, baseDir);
+    const key = skillPathKey(resolved);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ raw, resolved });
+  }
+  return out;
+}
+function normalizeSkillPaths(paths, baseDir) {
+  return normalizeSkillPathEntries(paths, baseDir).map((entry) => entry.raw);
+}
+function resolveSkillPaths(paths, baseDir) {
+  return normalizeSkillPathEntries(paths, baseDir).map((entry) => entry.resolved);
+}
+function skillPathKey(path) {
+  return process.platform === "win32" ? path.toLowerCase() : path;
+}
+function expandCurrentUserHome(path) {
+  if (path === "~") return homedir();
+  if (path.startsWith("~/") || path.startsWith("~\\")) return join(homedir(), path.slice(2));
+  return path;
+}
+function loadSkillPaths(baseDir = process.cwd(), path = defaultConfigPath()) {
+  const raw = readConfig(path).skills?.paths;
+  return Array.isArray(raw) ? normalizeSkillPaths(raw, baseDir) : [];
+}
+function loadResolvedSkillPaths(baseDir = process.cwd(), path = defaultConfigPath()) {
+  const raw = readConfig(path).skills?.paths;
+  return Array.isArray(raw) ? resolveSkillPaths(raw, baseDir) : [];
+}
+function saveSkillPaths(paths, baseDir = process.cwd(), path = defaultConfigPath()) {
+  const cfg = readConfig(path);
+  const normalized = normalizeSkillPaths(paths, baseDir);
+  cfg.skills = { ...cfg.skills ?? {}, paths: normalized };
+  writeConfig(cfg, path);
+  return normalized;
+}
+function addSkillPath(skillPath, baseDir = process.cwd(), path = defaultConfigPath()) {
+  const entry = normalizeSkillPathEntries([skillPath], baseDir)[0];
+  if (!entry) return { error: "skill path is empty" };
+  const existing = loadSkillPaths(baseDir, path);
+  const seen = new Set(resolveSkillPaths(existing, baseDir).map(skillPathKey));
+  const key = skillPathKey(entry.resolved);
+  if (seen.has(key))
+    return { added: false, path: entry.raw, resolved: entry.resolved, paths: existing };
+  const paths = saveSkillPaths([...existing, entry.raw], baseDir, path);
+  return { added: true, path: entry.raw, resolved: entry.resolved, paths };
+}
+function removeSkillPath(target, baseDir = process.cwd(), path = defaultConfigPath()) {
+  const existing = loadSkillPaths(baseDir, path);
+  const trimmed = target.trim();
+  if (!trimmed) return { removed: false, paths: existing };
+  const existingEntries = normalizeSkillPathEntries(existing, baseDir);
+  const idx = /^\d+$/.test(trimmed) ? Number.parseInt(trimmed, 10) - 1 : -1;
+  let removeAt = idx >= 0 && idx < existing.length ? idx : -1;
+  if (removeAt < 0) {
+    const targetEntry = normalizeSkillPathEntries([trimmed], baseDir)[0];
+    const targetKey = targetEntry ? skillPathKey(targetEntry.resolved) : void 0;
+    removeAt = existingEntries.findIndex(
+      (entry) => entry.raw === trimmed || targetKey !== void 0 && skillPathKey(entry.resolved) === targetKey
+    );
+  }
+  if (removeAt < 0) return { removed: false, paths: existing };
+  const removed = existingEntries[removeAt];
+  const paths = saveSkillPaths(
+    existing.filter((_, i) => i !== removeAt),
+    baseDir,
+    path
+  );
+  return {
+    removed: true,
+    path: removed?.raw ?? existing[removeAt],
+    resolved: removed?.resolved,
+    paths
+  };
+}
 function searchEnabled(path = defaultConfigPath()) {
   const env = process.env.REASONIX_SEARCH;
   if (env === "off" || env === "false" || env === "0") return false;
@@ -2285,6 +2578,7 @@ function searchEnabled(path = defaultConfigPath()) {
 function webSearchEngine(path = defaultConfigPath()) {
   const cfg = readConfig(path).webSearchEngine;
   if (cfg === "searxng") return "searxng";
+  if (cfg === "metaso") return "metaso";
   return "mojeek";
 }
 function webSearchEndpoint(path = defaultConfigPath()) {
@@ -2447,6 +2741,20 @@ function pushRecentWorkspace(dir, path = defaultConfigPath()) {
   cfg.recentWorkspaces = list.slice(0, MAX_RECENT_WORKSPACES);
   writeConfig(cfg, path);
 }
+function loadDesktopOpenTabs(path = defaultConfigPath()) {
+  const v = readConfig(path).desktopOpenTabs;
+  return Array.isArray(v) ? v.filter((s) => typeof s === "string" && s.length > 0) : [];
+}
+function saveDesktopOpenTabs(dirs, path = defaultConfigPath()) {
+  const cfg = readConfig(path);
+  const cleaned = dirs.filter((s) => typeof s === "string" && s.length > 0);
+  if (cleaned.length === 0) {
+    cfg.desktopOpenTabs = void 0;
+  } else {
+    cfg.desktopOpenTabs = cleaned;
+  }
+  writeConfig(cfg, path);
+}
 function loadPreset(path = defaultConfigPath()) {
   return readConfig(path).preset;
 }
@@ -2573,6 +2881,31 @@ function isPlainObject(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
+function loadQQConfig(path = defaultConfigPath()) {
+  const envSandbox = process.env.QQ_SANDBOX;
+  const fromEnv = {
+    appId: process.env.QQ_APPID,
+    appSecret: process.env.QQ_SECRET,
+    sandbox: envSandbox === "1" ? true : envSandbox === "0" ? false : void 0
+  };
+  const fromCfg = readConfig(path).qq ?? {};
+  return {
+    appId: fromEnv.appId ?? fromCfg.appId,
+    appSecret: fromEnv.appSecret ?? fromCfg.appSecret,
+    sandbox: fromEnv.sandbox ?? fromCfg.sandbox ?? false,
+    enabled: fromCfg.enabled === true
+  };
+}
+function saveQQConfig(cfg, path = defaultConfigPath()) {
+  const rootCfg = readConfig(path);
+  rootCfg.qq = {
+    appId: cfg.appId,
+    appSecret: cfg.appSecret,
+    sandbox: cfg.sandbox,
+    enabled: cfg.enabled
+  };
+  writeConfig(rootCfg, path);
+}
 
 export {
   THEMES,
@@ -2596,17 +2929,28 @@ export {
   defaultIndexConfig,
   resolveIndexConfig,
   compileFilters,
+  overlayMatchedSpec,
+  specToRaw,
+  parseMcpSpec,
   loadMemoryTypeRegistry,
   memoryTypeDefaults,
+  loadMetasoApiKey,
   defaultConfigPath,
   readConfig,
   writeConfig,
   loadLanguage,
-  mcpEnvFor,
+  normalizeMcpConfig,
   saveLanguage,
   loadApiKey,
   loadBaseUrl,
   saveBaseUrl,
+  normalizeSkillPathEntries,
+  normalizeSkillPaths,
+  resolveSkillPaths,
+  loadSkillPaths,
+  loadResolvedSkillPaths,
+  addSkillPath,
+  removeSkillPath,
   searchEnabled,
   webSearchEngine,
   webSearchEndpoint,
@@ -2632,6 +2976,8 @@ export {
   saveEditor,
   loadRecentWorkspaces,
   pushRecentWorkspace,
+  loadDesktopOpenTabs,
+  saveDesktopOpenTabs,
   loadPreset,
   savePreset,
   loadIndexUserConfig,
@@ -2643,6 +2989,8 @@ export {
   markEditModeHintShown,
   markMouseClipboardHintShown,
   isPlausibleKey,
-  redactKey
+  redactKey,
+  loadQQConfig,
+  saveQQConfig
 };
-//# sourceMappingURL=chunk-XPDVG52A.js.map
+//# sourceMappingURL=chunk-AVFXO2EZ.js.map