mantisai-cli 2.0.0

package/lib/claude-plugin.js

@@ -0,0 +1,150 @@
+import { execSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { loadConfig } from './config.js';
+import { syncMcpConfigs } from './mcp-config.js';
+
+const MARKETPLACE = 'mantis-plugins';
+const PLUGIN_ID = `mantis@${MARKETPLACE}`;
+const MARKETPLACE_REPO = 'KellisLab/mantis-cli';
+const NPM_PACKAGE = 'mantisai-cli';
+const LEGACY_NPM_PACKAGES = ['mantis-cli', 'mantis-claude-code'];
+
+export function resolvePluginRoot() {
+  try {
+    const root = execSync('npm root -g', { encoding: 'utf8', windowsHide: true }).trim();
+    for (const candidate of [NPM_PACKAGE, ...LEGACY_NPM_PACKAGES]) {
+      const globalPkg = path.join(root, candidate);
+      if (fs.existsSync(path.join(globalPkg, '.claude-plugin', 'plugin.json'))) {
+        return path.normalize(globalPkg);
+      }
+    }
+  } catch {
+    /* not installed globally */
+  }
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.normalize(path.resolve(here, '..'));
+}
+
+function settingsPath() {
+  return path.join(os.homedir(), '.claude', 'settings.json');
+}
+
+function installedPluginsPath() {
+  return path.join(os.homedir(), '.claude', 'plugins', 'installed_plugins.json');
+}
+
+function readSettings() {
+  const file = settingsPath();
+  if (!fs.existsSync(file)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeSettings(settings) {
+  const file = settingsPath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(settings, null, 2)}\n`);
+}
+
+function stripBrokenInlinePlugins(settings) {
+  const bad = (v) =>
+    typeof v === 'string' &&
+    (v.includes('$(npm') || v.includes('mantis-claude-code-plugin') || v.includes('mantis-cli-plugin'));
+  if (Array.isArray(settings.plugins)) {
+    settings.plugins = settings.plugins.filter((p) => {
+      const paths = [p?.path, p?.commands, p?.source?.path].filter(Boolean);
+      return !paths.some(bad);
+    });
+    if (!settings.plugins.length) delete settings.plugins;
+  }
+}
+
+export function isPluginInstalled() {
+  try {
+    const data = JSON.parse(fs.readFileSync(installedPluginsPath(), 'utf8'));
+    const entries = data.plugins?.[PLUGIN_ID];
+    if (!Array.isArray(entries) || !entries.length) return false;
+    const installPath = entries[0]?.installPath;
+    if (!installPath || !fs.existsSync(installPath)) return false;
+    return !fs.existsSync(path.join(installPath, '.orphaned_at'));
+  } catch {
+    return false;
+  }
+}
+
+function mergeMarketplaceIntoSettings() {
+  const settings = readSettings();
+  stripBrokenInlinePlugins(settings);
+  settings.extraKnownMarketplaces = settings.extraKnownMarketplaces || {};
+  settings.extraKnownMarketplaces[MARKETPLACE] = {
+    source: { source: 'github', repo: MARKETPLACE_REPO },
+  };
+  writeSettings(settings);
+}
+
+const BENIGN = [
+  /already enabled/i,
+  /already installed/i,
+  /already on disk/i,
+  /no updates/i,
+  /is already enabled/i,
+];
+
+function quoteCmdArg(arg) {
+  return `"${String(arg).replace(/"/g, '\\"')}"`;
+}
+
+function runClaude(argv, { optional = false } = {}) {
+  const opts = { encoding: 'utf8', windowsHide: true };
+  const r = process.platform === 'win32'
+    ? spawnSync(['claude', ...argv.map(quoteCmdArg)].join(' '), { ...opts, shell: true })
+    : spawnSync('claude', argv, opts);
+  if (r.error) {
+    const msg =
+      r.error.code === 'ENOENT'
+        ? 'claude not found on PATH — install Claude Code CLI first'
+        : r.error.message;
+    if (optional) return null;
+    throw new Error(msg);
+  }
+  const out = `${r.stdout || ''}${r.stderr || ''}`.trim();
+  if (r.status === 0 || BENIGN.some((re) => re.test(out))) return out;
+  if (optional) return null;
+  throw new Error(out || `claude ${argv.join(' ')} failed (exit ${r.status})`);
+}
+
+function installPluginScopes() {
+  for (const scope of ['user', 'local']) {
+    if (isPluginInstalled()) return scope;
+    runClaude(['plugin', 'install', PLUGIN_ID, '--scope', scope], { optional: true });
+  }
+  return isPluginInstalled() ? 'user' : null;
+}
+
+export function installClaudePlugin() {
+  const pluginRoot = resolvePluginRoot();
+  mergeMarketplaceIntoSettings();
+
+  runClaude(['plugin', 'marketplace', 'add', MARKETPLACE_REPO, '--scope', 'user'], { optional: true });
+  const scope = installPluginScopes();
+  if (!scope) {
+    throw new Error(
+      'Plugin not registered after install. Run: claude plugin install mantis@mantis-plugins',
+    );
+  }
+  runClaude(['plugin', 'update', PLUGIN_ID, '--scope', scope], { optional: true });
+  runClaude(['plugin', 'enable', PLUGIN_ID, '--scope', scope], { optional: true });
+  const settings = readSettings();
+  settings.enabledPlugins = settings.enabledPlugins || {};
+  settings.enabledPlugins[PLUGIN_ID] = true;
+  writeSettings(settings);
+  syncMcpConfigs(loadConfig());
+  return { ok: true, method: 'cli', pluginRoot, scope };
+}

package/lib/codebase-csv.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { stringify } from 'csv-stringify/sync';
+
+const DEFAULT_IGNORES = [
+  '**/.git/**',
+  '**/.next/**',
+  '**/.turbo/**',
+  '**/.venv/**',
+  '**/__pycache__/**',
+  '**/build/**',
+  '**/coverage/**',
+  '**/dist/**',
+  '**/node_modules/**',
+  '**/vendor/**',
+  '**/*.lock',
+  '**/package-lock.json',
+  '**/pnpm-lock.yaml',
+  '**/yarn.lock',
+];
+
+const EXT_LANGUAGE = {
+  '.css': 'css',
+  '.go': 'go',
+  '.html': 'html',
+  '.java': 'java',
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+  '.json': 'json',
+  '.md': 'markdown',
+  '.py': 'python',
+  '.rs': 'rust',
+  '.scss': 'scss',
+  '.sql': 'sql',
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.vue': 'vue',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+};
+
+const SOURCE_EXTENSIONS = Object.keys(EXT_LANGUAGE);
+
+function inferKind(rel) {
+  const base = path.basename(rel).toLowerCase();
+  if (base.includes('test') || base.includes('spec')) return 'test';
+  if (rel.includes('/components/') || rel.includes('\\components\\')) return 'component';
+  if (rel.includes('/pages/') || rel.includes('\\pages\\') || rel.includes('/app/')) return 'route';
+  if (rel.includes('/api/') || rel.includes('\\api\\')) return 'api';
+  if (rel.includes('/hooks/') || rel.includes('\\hooks\\')) return 'hook';
+  if (rel.includes('/utils/') || rel.includes('\\utils\\') || rel.includes('/lib/')) return 'utility';
+  return 'source';
+}
+
+function importsFrom(content) {
+  const imports = new Set();
+  const patterns = [
+    /^\s*import\s+.*?\s+from\s+['"]([^'"]+)['"]/gm,
+    /^\s*import\s+['"]([^'"]+)['"]/gm,
+    /^\s*const\s+.*?=\s+require\(['"]([^'"]+)['"]\)/gm,
+    /^\s*from\s+([\w.]+)\s+import\s+/gm,
+  ];
+  for (const re of patterns) {
+    for (const match of content.matchAll(re)) imports.add(match[1]);
+  }
+  return [...imports].slice(0, 40).join(', ');
+}
+
+function summarize(content) {
+  const lines = content.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const comment = lines.find((l) => /^\/\/|^#|^\/\*|^\*|^<!--/.test(l));
+  return (comment || lines[0] || '').replace(/^\/\/|^#|^\/\*+|^\*|<!--|-->/g, '').trim().slice(0, 240);
+}
+
+function readText(file, maxChars) {
+  const raw = fs.readFileSync(file, 'utf8');
+  return raw.length > maxChars ? `${raw.slice(0, maxChars)}\n\n[truncated]` : raw;
+}
+
+export async function createCodebaseCsv(rootDir, outFile, { maxChars = 12000, include } = {}) {
+  const root = path.resolve(rootDir || process.cwd());
+  const patterns = include?.length ? include : SOURCE_EXTENSIONS.map((ext) => `**/*${ext}`);
+  const files = await fg(patterns, {
+    cwd: root,
+    absolute: true,
+    dot: false,
+    ignore: DEFAULT_IGNORES,
+    onlyFiles: true,
+  });
+
+  const rows = files.sort().map((file) => {
+    const rel = path.relative(root, file).replace(/\\/g, '/');
+    const ext = path.extname(file).toLowerCase();
+    const content = readText(file, maxChars);
+    const stat = fs.statSync(file);
+    return {
+      path: rel,
+      file_name: path.basename(file),
+      extension: ext.replace(/^\./, ''),
+      language: EXT_LANGUAGE[ext] || ext.replace(/^\./, ''),
+      kind: inferKind(rel),
+      loc: content.split(/\r?\n/).length,
+      bytes: stat.size,
+      imports: importsFrom(content),
+      summary: summarize(content),
+      content,
+    };
+  });
+
+  if (!rows.length) throw new Error(`No source files found in ${root}`);
+  fs.mkdirSync(path.dirname(path.resolve(outFile)), { recursive: true });
+  fs.writeFileSync(outFile, stringify(rows, { header: true }));
+  return { root, outFile: path.resolve(outFile), count: rows.length };
+}

package/lib/config.js

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_NAME = 'config.json';
+export const DEFAULT_API_BASE = 'https://kellis-h200-1.csail.mit.edu';
+export const DEVELOPER_PORTAL_URL = 'https://mantis.csail.mit.edu/developer/#keys';
+
+export function canonicalConfigPath() {
+  return path.join(os.homedir(), '.mantis', 'claude-code', CONFIG_NAME);
+}
+
+function pluginDataConfigPath() {
+  if (!process.env.CLAUDE_PLUGIN_DATA) return null;
+  return path.join(process.env.CLAUDE_PLUGIN_DATA, CONFIG_NAME);
+}
+
+/** Paths that may hold config (canonical first). */
+export function allConfigPaths() {
+  const paths = [canonicalConfigPath()];
+  const plugin = pluginDataConfigPath();
+  if (plugin) paths.push(plugin);
+  return [...new Set(paths)];
+}
+
+export function configPath() {
+  return canonicalConfigPath();
+}
+
+export function loadConfig() {
+  const canonical = canonicalConfigPath();
+  if (fs.existsSync(canonical)) {
+    try {
+      return JSON.parse(fs.readFileSync(canonical, 'utf8'));
+    } catch {
+      /* fall through */
+    }
+  }
+  const plugin = pluginDataConfigPath();
+  if (plugin && fs.existsSync(plugin)) {
+    try {
+      return JSON.parse(fs.readFileSync(plugin, 'utf8'));
+    } catch {
+      /* empty */
+    }
+  }
+  return {};
+}
+
+export function saveConfig(cfg) {
+  const body = JSON.stringify(cfg, null, 2);
+  for (const file of allConfigPaths()) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, body);
+  }
+}
+
+export function normalizeBaseUrl(url) {
+  return String(url || '').trim().replace(/\/+$/, '');
+}
+
+export function mcpUrl(cfg) {
+  const base = normalizeBaseUrl(cfg.apiBaseUrl || process.env.MANTIS_API_URL || DEFAULT_API_BASE);
+  return `${base}/mcp_integrated/`;
+}

package/lib/csv.js

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+import { parse } from 'csv-parse/sync';
+
+export function readCsvHeaders(file) {
+  const input = fs.readFileSync(file, 'utf8');
+  const rows = parse(input, { to_line: 1, relax_quotes: true });
+  const headers = rows[0] || [];
+  if (!headers.length) throw new Error('CSV has no header row.');
+  return headers.map((h) => String(h).trim()).filter(Boolean);
+}

package/lib/fetch.js

@@ -0,0 +1,36 @@
+import { createSpaceState, listSpaceStates, listSpaces } from './api.js';
+
+const PAGE = 100;
+
+async function fetchPaginated(fetchPage) {
+  const all = [];
+  let offset = 0;
+  for (;;) {
+    const { items, total } = await fetchPage(PAGE, offset);
+    const batch = items || [];
+    all.push(...batch);
+    if (batch.length < PAGE) break;
+    if (Number.isFinite(total) && all.length >= total) break;
+    offset += PAGE;
+  }
+  return all;
+}
+
+export async function fetchAccessibleSpaces(baseUrl, apiKey) {
+  return fetchPaginated(async (limit, offset) => {
+    const page = await listSpaces(baseUrl, apiKey, { scope: 'accessible', limit, offset });
+    return { items: page.spaces, total: page.total };
+  });
+}
+
+/** @deprecated use fetchAccessibleSpaces */
+export const fetchOwnedSpaces = fetchAccessibleSpaces;
+
+export async function fetchThreads(baseUrl, apiKey, spaceId) {
+  return fetchPaginated(async (limit, offset) => {
+    const page = await listSpaceStates(baseUrl, apiKey, spaceId, { limit, offset });
+    return { items: page.space_states, total: page.total };
+  });
+}
+
+export { createSpaceState };

package/lib/fields.js

@@ -0,0 +1,61 @@
+export const FIELD_KEYS = [
+  'title',
+  'semantic',
+  'numeric',
+  'categoric',
+  'date',
+  'links',
+  'custom_model',
+  'connection',
+  'delete',
+];
+
+function splitColumns(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.flatMap(splitColumns);
+  return String(value).split(',').map((v) => v.trim()).filter(Boolean);
+}
+
+export function columnSet(value) {
+  return new Set(splitColumns(value));
+}
+
+export function inferFieldTypes(headers, opts = {}) {
+  const title = columnSet(opts.titleColumn || opts.titleColumns);
+  const semantic = columnSet(opts.semanticColumn || opts.semanticColumns);
+  const numeric = columnSet(opts.numericColumn || opts.numericColumns);
+  const categoric = columnSet(opts.categoricColumn || opts.categoricColumns);
+  const date = columnSet(opts.dateColumn || opts.dateColumns);
+  const links = columnSet(opts.linksColumn || opts.linksColumns);
+  const deleted = columnSet(opts.deleteColumn || opts.deleteColumns);
+
+  if (!title.size) {
+    const candidate = headers.find((h) => ['title', 'name', 'path', 'file'].includes(h.toLowerCase()));
+    if (candidate) title.add(candidate);
+  }
+  if (!semantic.size) {
+    const candidates = headers.filter((h) =>
+      ['content', 'summary', 'description', 'text', 'body'].includes(h.toLowerCase()),
+    );
+    for (const h of candidates.length ? candidates : headers.filter((h) => !title.has(h))) semantic.add(h);
+  }
+
+  return headers.map((h) => ({
+    title: title.has(h),
+    semantic: semantic.has(h),
+    numeric: numeric.has(h),
+    categoric: categoric.has(h),
+    date: date.has(h),
+    links: links.has(h),
+    custom_model: false,
+    connection: false,
+    delete: deleted.has(h),
+  }));
+}
+
+export function fieldSummary(headers, dataTypes) {
+  return headers.map((h, i) => {
+    const types = FIELD_KEYS.filter((k) => dataTypes[i]?.[k]);
+    return `${h}: ${types.length ? types.join(', ') : 'unused'}`;
+  });
+}

package/lib/list-cli.js

@@ -0,0 +1,55 @@
+import { loadConfig } from './config.js';
+import { searchSpaces } from './spaces.js';
+import { fetchThreads } from './fetch.js';
+
+export function filterItems(items, query, keys) {
+  const terms = (query || '').trim().toLowerCase().split(/\s+/).filter(Boolean);
+  if (!terms.length) return items;
+  return items.filter((item) => {
+    const hay = keys.map((k) => String(item[k] ?? '')).join(' ').toLowerCase();
+    return terms.every((t) => hay.includes(t));
+  });
+}
+
+export async function spacesForPrompt(filter = '', { limit = 4, offset = 0 } = {}) {
+  const cfg = loadConfig();
+  if (!cfg.apiKey || !cfg.apiBaseUrl) {
+    throw new Error('Run mantis setup first (API key + URL).');
+  }
+  const page = await searchSpaces(cfg.apiBaseUrl, cfg.apiKey, {
+    q: filter,
+    limit,
+    offset,
+  });
+  return {
+    spaces: page.spaces || [],
+    total: page.total,
+    offset,
+    limit,
+    hasMore: offset + limit < page.total,
+    filter,
+  };
+}
+
+export async function threadsForPrompt(filter = '', { limit = 4, offset = 0 } = {}) {
+  const cfg = loadConfig();
+  if (!cfg.apiKey || !cfg.apiBaseUrl) throw new Error('Run mantis setup first.');
+  if (!cfg.spaceId) throw new Error('Pick a space first (/mantis:space).');
+
+  const all = filterItems(
+    await fetchThreads(cfg.apiBaseUrl, cfg.apiKey, cfg.spaceId),
+    filter,
+    ['name', 'id'],
+  );
+  const page = all.slice(offset, offset + limit);
+  return {
+    threads: page,
+    total: all.length,
+    offset,
+    limit,
+    hasMore: offset + limit < all.length,
+    spaceId: cfg.spaceId,
+    spaceName: cfg.spaceName,
+    filter,
+  };
+}

package/lib/map-create.js

@@ -0,0 +1,128 @@
+import path from 'node:path';
+
+import { createMapInSpace, createSpace, createSpaceState } from './api.js';
+import { loadConfig, normalizeBaseUrl, saveConfig } from './config.js';
+import { readCsvHeaders } from './csv.js';
+import { fieldSummary, inferFieldTypes } from './fields.js';
+import { fetchSpaceById, searchSpaces } from './spaces.js';
+import { syncMcpConfigs } from './mcp-config.js';
+import { info, promptConfirm, promptInput, promptSelect, success } from './ui.js';
+
+function requireAuth() {
+  const cfg = loadConfig();
+  if (!cfg.apiKey || !cfg.apiBaseUrl) {
+    throw new Error('Run mantis setup first (API key + URL).');
+  }
+  return cfg;
+}
+
+function boolOption(value, fallback = false) {
+  if (value == null) return fallback;
+  if (typeof value === 'boolean') return value;
+  return ['1', 'true', 'yes', 'public'].includes(String(value).toLowerCase());
+}
+
+function spaceUrl(baseUrl, spaceId) {
+  const root = normalizeBaseUrl(baseUrl).replace(/\/api\/?$/, '');
+  return `${root}/space/${spaceId}`;
+}
+
+async function chooseExistingSpace(cfg, filter = '') {
+  const page = await searchSpaces(cfg.apiBaseUrl, cfg.apiKey, { q: filter, limit: 12 });
+  if (!page.spaces?.length) throw new Error('No spaces found.');
+  return promptSelect('Which space should receive this map?', page.spaces.map((s) => ({
+    name: `${s.name} · ${s.map_count ?? 0} map(s) · ${s.role || 'space'}`,
+    value: s,
+    description: s.id,
+  })));
+}
+
+async function resolveSpaceTarget(cfg, opts) {
+  let mode = opts.spaceMode;
+  if (!mode) {
+    mode = await promptSelect('Where should this map go?', [
+      { name: 'Create a new space', value: 'new' },
+      { name: 'Add to an existing space', value: 'existing' },
+    ]);
+  }
+
+  if (mode === 'existing') {
+    if (opts.spaceId) {
+      const space = opts.spaceName ? null : await fetchSpaceById(cfg.apiBaseUrl, cfg.apiKey, opts.spaceId);
+      return { spaceId: opts.spaceId, spaceName: opts.spaceName || space?.name };
+    }
+    const picked = await chooseExistingSpace(cfg, opts.spaceSearch || '');
+    return { spaceId: picked.id, spaceName: picked.name };
+  }
+
+  const spaceName = opts.spaceName || await promptInput('New space name', {
+    default: path.basename(opts.file, path.extname(opts.file)) || 'Claude Code Map',
+  });
+  const isPublic = opts.public != null ? boolOption(opts.public) : await promptConfirm('Make this space public?', { default: false });
+  return { spaceName, isPublic };
+}
+
+export async function createMapFlow(file, opts = {}) {
+  const cfg = requireAuth();
+  const mapName = opts.mapName || await promptInput('Map name', {
+    default: path.basename(file, path.extname(file)),
+  });
+  const headers = readCsvHeaders(file);
+  const dataTypes = opts.dataTypes ? JSON.parse(opts.dataTypes) : inferFieldTypes(headers, opts);
+  info(`Fields: ${fieldSummary(headers, dataTypes).join(' | ')}`);
+
+  const target = await resolveSpaceTarget(cfg, { ...opts, file });
+
+  let spaceId = target.spaceId;
+  let spaceName = target.spaceName;
+  if (!spaceId) {
+    const space = await createSpace(cfg.apiBaseUrl, cfg.apiKey, {
+      name: target.spaceName,
+      isPublic: target.isPublic,
+    });
+    spaceId = space.id;
+    spaceName = space.name;
+    info(`Created space: ${spaceName} (${spaceId})`);
+  }
+
+  const result = await createMapInSpace(cfg.apiBaseUrl, cfg.apiKey, spaceId, {
+    file,
+    mapName,
+    dataTypes,
+    selectedFields: opts.selectedFields,
+    fieldWeights: opts.fieldWeights,
+  });
+
+  const primaryMapId = result.map_id || result.base_map_id || result.map_ids?.[0];
+  target.spaceName = spaceName;
+  success('Map creation started');
+  info(`Space: ${target.spaceName || spaceId} (${spaceId})`);
+  info(`Map:   ${mapName}${primaryMapId ? ` (${primaryMapId})` : ''}`);
+  if (spaceId) info(`Link:  ${spaceUrl(cfg.apiBaseUrl, spaceId)}`);
+
+  const activate = opts.activate != null ? boolOption(opts.activate) : await promptConfirm('Set this as the active Claude Code Mantis space?', { default: true });
+  let thread = null;
+  if (activate) {
+    const threadName = opts.threadName || await promptInput('Thread name', { default: `${mapName} Exploration` });
+    thread = await createSpaceState(cfg.apiBaseUrl, cfg.apiKey, spaceId, threadName);
+    const next = {
+      ...cfg,
+      spaceId,
+      spaceName: target.spaceName || mapName,
+      spaceStateId: thread.id,
+      spaceStateName: thread.name,
+    };
+    saveConfig(next);
+    syncMcpConfigs(next);
+    success(`Active thread: ${thread.name}`);
+    info('Run /reload-plugins in Claude Code before using Mantis MCP tools.');
+  }
+
+  return {
+    ...result,
+    space_id: spaceId,
+    map_id: primaryMapId,
+    space_url: spaceId ? spaceUrl(cfg.apiBaseUrl, spaceId) : undefined,
+    thread,
+  };
+}

package/lib/mcp-config.js

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { mcpUrl } from './config.js';
+
+const MARKETPLACE = 'mantis-plugins';
+const PACKAGE = 'mantisai-cli';
+
+function existingPackageRoot(root) {
+  return root && fs.existsSync(path.join(root, 'package.json')) ? path.normalize(root) : null;
+}
+
+function isInstallRoot(root) {
+  const p = root.toLowerCase();
+  return p.includes(`${path.sep}.claude${path.sep}plugins${path.sep}`) ||
+    p.endsWith(`${path.sep}node_modules${path.sep}${PACKAGE}`);
+}
+
+function cacheRoots() {
+  const base = path.join(os.homedir(), '.claude', 'plugins', 'cache', MARKETPLACE, 'mantis');
+  if (!fs.existsSync(base)) return [];
+  return fs.readdirSync(base).map((v) => path.join(base, v));
+}
+
+export function pluginRoots() {
+  const here = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+  const home = os.homedir();
+  return [
+    here,
+    path.join(home, '.claude', 'plugins', 'marketplaces', MARKETPLACE),
+    path.join(home, '.claude', 'plugins', 'npm-cache', 'node_modules', PACKAGE),
+    path.join(home, 'AppData', 'Roaming', 'npm', 'node_modules', PACKAGE),
+    ...cacheRoots(),
+  ].map(existingPackageRoot).filter(Boolean).filter(isInstallRoot).filter((v, i, a) => a.indexOf(v) === i);
+}
+
+export function mcpConfig(cfg) {
+  const server = { type: 'http', url: mcpUrl(cfg) };
+  if (cfg.spaceStateId) server.headers = { 'X-Space-State-ID': String(cfg.spaceStateId) };
+  return { mcpServers: { mantis: server } };
+}
+
+export function syncMcpConfigs(cfg) {
+  const body = `${JSON.stringify(mcpConfig(cfg), null, 2)}\n`;
+  for (const root of pluginRoots()) {
+    fs.writeFileSync(path.join(root, '.mcp.json'), body);
+  }
+}