mixdog 0.9.2 → 0.9.3

package/src/session-runtime/plugin-mcp.mjs

@@ -0,0 +1,114 @@
+// Plugin/project MCP server discovery + normalization, and skill-file counting.
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { clean } from './session-text.mjs';
+import { readJsonSafe } from './fs-utils.mjs';
+
+// Project-local MCP ingress: read `.mcp.json` from the project root and return
+// a cleaned { name: cfg } map. Best-effort — never throws. Accepts either the
+// standard `{ mcpServers: {...} }` shape or a bare name->cfg map. Self-ref
+// servers (`mixdog` / `trib-plugin`) are stripped for parity with loadConfig.
+// Inputs are not mutated.
+export function readProjectMcpServers(cwd) {
+  const path = join(cwd || '.', '.mcp.json');
+  if (!existsSync(path)) return {};
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, 'utf8'));
+  } catch (error) {
+    process.stderr.write(`[mcp-client] Ignoring unparseable .mcp.json at ${path}: ${error?.message || String(error)}\n`);
+    return {};
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const map = raw.mcpServers && typeof raw.mcpServers === 'object' && !Array.isArray(raw.mcpServers)
+    ? raw.mcpServers
+    : raw;
+  if (!map || typeof map !== 'object' || Array.isArray(map)) return {};
+  const out = {};
+  for (const [name, cfg] of Object.entries(map)) {
+    const key = clean(name);
+    if (!key) continue;
+    const lower = key.toLowerCase();
+    if (lower === 'mixdog' || lower === 'trib-plugin') continue;
+    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) continue;
+    // stdio entries (command + no url) spawn relative to the process launch
+    // dir, but mixdog tracks the project dir in memory (no process.chdir).
+    // Anchor their cwd to the .mcp.json directory: default when absent, resolve
+    // relative values against it, keep absolute values as-is.
+    const isStdio = typeof cfg.command === 'string' && cfg.command !== '' && !cfg.url;
+    if (isStdio) {
+      out[key] = { ...cfg, cwd: typeof cfg.cwd === 'string' && cfg.cwd ? resolve(cwd, cfg.cwd) : resolve(cwd) };
+    } else {
+      out[key] = cfg;
+    }
+  }
+  return out;
+}
+
+export function countSkillFiles(root) {
+  const skillsDir = join(root, 'skills');
+  if (!existsSync(skillsDir)) return 0;
+  let count = 0;
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (/^(SKILL|skill)\.md$/i.test(entry.name) || entry.name.toLowerCase().endsWith('.md')) count += 1;
+    }
+  };
+  try { walk(skillsDir); } catch { return count; }
+  return count;
+}
+
+export function mcpScriptForPlugin(root) {
+  const candidates = [
+    '.mcp.json',
+    'scripts/run-mcp.mjs',
+    'mcp/server.mjs',
+    'server.mjs',
+  ];
+  return candidates.find((rel) => existsSync(join(root, rel))) || null;
+}
+
+function substitutePluginRootTokens(value, root) {
+  if (typeof value !== 'string') return value;
+  return value
+    .replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, root)
+    .replace(/\$\{CODEX_PLUGIN_ROOT\}/g, root);
+}
+
+function substitutePluginRootTokensDeep(value, root) {
+  if (typeof value === 'string') return substitutePluginRootTokens(value, root);
+  if (Array.isArray(value)) return value.map((v) => substitutePluginRootTokensDeep(v, root));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = substitutePluginRootTokensDeep(v, root);
+    return out;
+  }
+  return value;
+}
+
+export function normalizePluginMcpServerConfig(cfg, root) {
+  const substituted = substitutePluginRootTokensDeep(cfg, root) || {};
+  const out = { ...substituted };
+  if (typeof out.cwd === 'string' && out.cwd) {
+    out.cwd = isAbsolute(out.cwd) ? out.cwd : join(root, out.cwd);
+  } else {
+    out.cwd = root;
+  }
+  return out;
+}
+
+export function pluginManifest(root) {
+  return readJsonSafe(join(root, '.codex-plugin', 'plugin.json'))
+    || readJsonSafe(join(root, 'plugin.json'))
+    || {};
+}
+
+export function pluginMcpServerName(plugin = {}) {
+  const base = clean(plugin.name || plugin.title || 'plugin')
+    .toLowerCase()
+    .replace(/[^a-z0-9_.-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return base ? `plugin-${base}` : 'plugin-mcp';
+}

package/src/session-runtime/session-text.mjs

@@ -0,0 +1,100 @@
+// Session message/preview text helpers. Pure, no runtime-closure deps.
+
+export function sessionMessageText(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  const parts = Array.isArray(content)
+    ? content
+    : (content && typeof content === 'object' && Array.isArray(content.content) ? content.content : null);
+  if (parts) {
+    return parts.map((part) => {
+      if (typeof part === 'string') return part;
+      return part?.text ?? '';
+    }).filter(Boolean).join('\n');
+  }
+  if (typeof content === 'object' && typeof content.text === 'string') return content.text;
+  try { return JSON.stringify(content); } catch { return String(content); }
+}
+
+export function messageContextText(message) {
+  if (!message || typeof message !== 'object') return '';
+  let text = sessionMessageText(message.content);
+  if (message.role === 'assistant' && Array.isArray(message.toolCalls) && message.toolCalls.length) {
+    try { text += `\n${JSON.stringify(message.toolCalls)}`; }
+    catch { text += `\n[${message.toolCalls.length} tool calls]`; }
+  }
+  if (message.role === 'tool' && message.toolCallId) text += `\n${message.toolCallId}`;
+  return text;
+}
+
+export function isSessionPreviewNoise(text) {
+  const value = String(text || '').trim();
+  return !value
+    || value.startsWith('<system-reminder>')
+    || value.startsWith('</system-reminder>')
+    || /^#\s*permission\b/i.test(value)
+    || /^permission:\s*/i.test(value)
+    || /^cwd:\s*/i.test(value);
+}
+
+export function cleanSessionPreview(text) {
+  return String(text || '')
+    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 160);
+}
+
+export function clean(value) {
+  return String(value ?? '').trim();
+}
+
+export function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj || {}, key);
+}
+
+export function toolResponseText(result) {
+  if (result && typeof result === 'object' && Array.isArray(result.content)) {
+    return result.content
+      .map((part) => (part?.type === 'text' ? part.text || '' : JSON.stringify(part)))
+      .join('\n');
+  }
+  if (typeof result === 'string') return result;
+  return JSON.stringify(result, null, 2);
+}
+
+export function isEmptyRecallText(value) {
+  const text = String(value || '').trim();
+  return !text || /^\(?no results\)?$/i.test(text) || /^\(?empty memory result\)?$/i.test(text);
+}
+
+export function currentSessionRecallRows(session, query, { limit = 10 } = {}) {
+  const messages = Array.isArray(session?.messages) ? session.messages : [];
+  if (!messages.length) return '(no results)';
+  const terms = [...new Set(String(query || '').toLowerCase().match(/[\p{L}\p{N}_./:-]{2,}/gu) || [])]
+    .filter(Boolean)
+    .slice(0, 16);
+  const max = Math.max(1, Math.min(100, Number(limit) || 10));
+  const rows = [];
+  for (let i = messages.length - 1; i >= 0 && rows.length < max; i -= 1) {
+    const m = messages[i];
+    if (!m || (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool')) continue;
+    const text = messageContextText(m).replace(/\s+/g, ' ').trim();
+    if (!text) continue;
+    if (terms.length && !terms.some((term) => text.toLowerCase().includes(term))) continue;
+    rows.push(`[session:${i + 1}] ${m.role}: ${text.slice(0, 1000)}`);
+  }
+  return rows.length ? rows.join('\n') : '(no results)';
+}
+
+export function sessionHasConversationMessages(activeSession) {
+  const messages = Array.isArray(activeSession?.messages) ? activeSession.messages : [];
+  return messages.some((message) => {
+    const role = message?.role;
+    if (role !== 'user' && role !== 'assistant' && role !== 'tool') return false;
+    const text = sessionMessageText(message.content).trim();
+    if (!text && role !== 'assistant') return false;
+    if (role === 'user' && isSessionPreviewNoise(text)) return false;
+    return true;
+  });
+}

package/src/session-runtime/statusline-route.mjs

@@ -0,0 +1,35 @@
+// Statusline route serialization. Pure helpers.
+import { clean, hasOwn } from './session-text.mjs';
+
+export function routeForStatusline(route) {
+  const out = {
+    mode: 'fixed',
+    defaultProvider: route.provider,
+    defaultModel: route.model,
+  };
+  const preset = route.preset || {};
+  if (preset.id) out.presetId = preset.id;
+  if (preset.name) out.presetName = preset.name;
+  // Prefer the preset's curated label, then the route's resolved model display
+  // (set by refreshRouteEffort from the live/offline catalog). Without the
+  // route fallback, a preset-less direct model (e.g. claude-fable-5) reaches
+  // the statusline with no display and renders as the raw id.
+  const modelDisplay = clean(preset.modelDisplay) || clean(route.modelDisplay);
+  if (modelDisplay) out.modelDisplay = modelDisplay;
+  if (route.fast === true || route.fast === false) out.fast = route.fast;
+  else if (preset.fast === true || preset.fast === false) out.fast = preset.fast;
+  if (route.effectiveEffort) {
+    out.effort = route.effectiveEffort;
+    out.displayEffort = route.effectiveEffort;
+  } else if (hasOwn(route, 'effort')) {
+    delete out.effort;
+    delete out.displayEffort;
+  }
+  return out;
+}
+
+export function writeStatuslineRoute(statusRoutes, session, route) {
+  if (!session?.id || !route) return;
+  const clientHostPid = session?.clientHostPid || process.pid;
+  statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route), { clientHostPid });
+}