mdboard 1.1.0 → 1.3.0

package/src/core/agent-scanner.js

@@ -0,0 +1,260 @@
+/**
+ * mdboard — Agent configuration scanner
+ *
+ * Scans projectDir for agent/AI configuration files and returns
+ * suggestions for autocomplete in the AI properties UI.
+ *
+ * Supported agents:
+ *   Claude Code, Codex CLI, Gemini CLI, Cursor, VS Code Copilot,
+ *   Windsurf, Cline, KiloCode, OpenClaw
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function safeReadFile(filePath) {
+  try { return fs.readFileSync(filePath, 'utf-8'); } catch { return null; }
+}
+
+function safeDirEntries(dir) {
+  try { return fs.readdirSync(dir).filter(e => !e.startsWith('.')); } catch { return []; }
+}
+
+function safeDirEntriesRecursive(dir, prefix) {
+  const results = [];
+  for (const entry of safeDirEntries(dir)) {
+    const full = path.join(dir, entry);
+    const rel = prefix ? prefix + '/' + entry : entry;
+    try {
+      if (fs.statSync(full).isDirectory()) {
+        if (fs.existsSync(path.join(full, 'SKILL.md'))) {
+          results.push(rel);
+        }
+        results.push(...safeDirEntriesRecursive(full, rel));
+      } else if (entry.endsWith('.md')) {
+        results.push(rel);
+      }
+    } catch { /* skip */ }
+  }
+  return results;
+}
+
+/** Push value to array if not already present */
+function pushUnique(arr, value) {
+  if (arr.indexOf(value) === -1) arr.push(value);
+}
+
+/** Collect .md files from a directory into an array (non-recursive) */
+function collectMdFiles(dir, arr, prefix) {
+  for (const entry of safeDirEntries(dir)) {
+    if (entry.endsWith('.md') || entry.endsWith('.mdc') || entry.endsWith('.agent.md')) {
+      pushUnique(arr, prefix ? prefix + '/' + entry : entry);
+    }
+  }
+}
+
+/** Collect all files from a directory into an array (non-recursive) */
+function collectAllFiles(dir, arr, prefix) {
+  for (const entry of safeDirEntries(dir)) {
+    const full = path.join(dir, entry);
+    try {
+      if (!fs.statSync(full).isDirectory()) {
+        pushUnique(arr, prefix ? prefix + '/' + entry : entry);
+      }
+    } catch { /* skip */ }
+  }
+}
+
+/** Extract mcpServers keys from a JSON file */
+function extractMcpServersFromJson(filePath, arr) {
+  const content = safeReadFile(filePath);
+  if (!content) return;
+  try {
+    const parsed = JSON.parse(content);
+    const servers = parsed.mcpServers || parsed;
+    if (servers && typeof servers === 'object' && !Array.isArray(servers)) {
+      for (const key of Object.keys(servers)) {
+        if (key !== '$schema' && key !== 'mcpServers') pushUnique(arr, key);
+      }
+    }
+  } catch { /* invalid JSON */ }
+}
+
+/** Check if a file exists and push to context */
+function checkContextFile(projectDir, relativePath, arr) {
+  if (fs.existsSync(path.join(projectDir, relativePath))) {
+    pushUnique(arr, relativePath);
+  }
+}
+
+/**
+ * Scan projectDir for agent configuration files across all supported agents.
+ *
+ * @param {string} projectDir - Root of the repo
+ * @returns {{ skills: string[], agents: string[], mcps: string[], commands: string[], context: string[] }}
+ */
+function scanAgentConfigs(projectDir) {
+  const result = { skills: [], agents: [], mcps: [], commands: [], context: [] };
+
+  // ─── SKILLS ───────────────────────────────────────────────
+
+  // Claude Code: .claude/skills/ — .md files and subdirs with SKILL.md
+  result.skills = safeDirEntriesRecursive(path.join(projectDir, '.claude', 'skills'), '');
+
+  // Codex CLI: .codex/skills/, .agents/skills/
+  for (const dir of ['.codex/skills', '.agents/skills']) {
+    const entries = safeDirEntriesRecursive(path.join(projectDir, ...dir.split('/')), '');
+    for (const e of entries) pushUnique(result.skills, e);
+  }
+
+  // ─── AGENTS ───────────────────────────────────────────────
+
+  // Claude Code: .claude/agents/*.md
+  collectMdFiles(path.join(projectDir, '.claude', 'agents'), result.agents, '');
+
+  // Cursor: .cursor/agents/*.md
+  collectMdFiles(path.join(projectDir, '.cursor', 'agents'), result.agents, '');
+
+  // VS Code Copilot: .github/agents/*.md
+  collectMdFiles(path.join(projectDir, '.github', 'agents'), result.agents, '');
+
+  // ─── MCP SERVERS ──────────────────────────────────────────
+
+  // Claude Code: .mcp.json (project-level)
+  extractMcpServersFromJson(path.join(projectDir, '.mcp.json'), result.mcps);
+
+  // Claude Code: .claude/settings.local.json — enabledMcpjsonServers
+  const settingsJson = safeReadFile(path.join(projectDir, '.claude', 'settings.local.json'));
+  if (settingsJson) {
+    try {
+      const parsed = JSON.parse(settingsJson);
+      if (Array.isArray(parsed.enabledMcpjsonServers)) {
+        for (const srv of parsed.enabledMcpjsonServers) {
+          if (typeof srv === 'string') pushUnique(result.mcps, srv);
+        }
+      }
+    } catch { /* invalid JSON */ }
+  }
+
+  // Cursor: .cursor/mcp.json
+  extractMcpServersFromJson(path.join(projectDir, '.cursor', 'mcp.json'), result.mcps);
+
+  // VS Code Copilot: .vscode/mcp.json
+  extractMcpServersFromJson(path.join(projectDir, '.vscode', 'mcp.json'), result.mcps);
+
+  // KiloCode: .kilocode/mcp.json
+  extractMcpServersFromJson(path.join(projectDir, '.kilocode', 'mcp.json'), result.mcps);
+
+  // Gemini CLI: .gemini/settings.json — mcpServers
+  const geminiSettings = safeReadFile(path.join(projectDir, '.gemini', 'settings.json'));
+  if (geminiSettings) {
+    try {
+      const parsed = JSON.parse(geminiSettings);
+      if (parsed.mcpServers && typeof parsed.mcpServers === 'object') {
+        for (const key of Object.keys(parsed.mcpServers)) {
+          pushUnique(result.mcps, key);
+        }
+      }
+    } catch { /* invalid JSON */ }
+  }
+
+  // Codex CLI: .codex/config.toml — [mcp_servers.<name>]
+  const codexConfig = safeReadFile(path.join(projectDir, '.codex', 'config.toml'));
+  if (codexConfig) {
+    const mcpMatches = codexConfig.matchAll(/\[mcp_servers\.(\w[\w-]*)\]/g);
+    for (const m of mcpMatches) pushUnique(result.mcps, m[1]);
+  }
+
+  // ─── COMMANDS ─────────────────────────────────────────────
+
+  // Claude Code: .claude/commands/
+  collectAllFiles(path.join(projectDir, '.claude', 'commands'), result.commands, '');
+
+  // Gemini CLI: .gemini/commands/ (.toml files)
+  collectAllFiles(path.join(projectDir, '.gemini', 'commands'), result.commands, '');
+
+  // VS Code Copilot: .github/prompts/ (.prompt.md files)
+  collectAllFiles(path.join(projectDir, '.github', 'prompts'), result.commands, '');
+
+  // Windsurf: .windsurf/workflows/
+  collectAllFiles(path.join(projectDir, '.windsurf', 'workflows'), result.commands, '');
+
+  // CLAUDE.md — parse dev commands section
+  const claudeMd = safeReadFile(path.join(projectDir, 'CLAUDE.md'))
+    || safeReadFile(path.join(projectDir, '.claude', 'CLAUDE.md'));
+  if (claudeMd) {
+    const lines = claudeMd.split('\n');
+    let inCommands = false;
+    for (const line of lines) {
+      if (/^#+\s*.*(command|script|dev)/i.test(line)) {
+        inCommands = true;
+        continue;
+      }
+      if (inCommands && /^#+\s/.test(line)) {
+        inCommands = false;
+        continue;
+      }
+      if (inCommands) {
+        const match = line.match(/^[-*]\s*`([^`]+)`/);
+        if (match) pushUnique(result.commands, match[1]);
+      }
+    }
+  }
+
+  // ─── CONTEXT / RULES ─────────────────────────────────────
+
+  // Claude Code
+  checkContextFile(projectDir, 'CLAUDE.md', result.context);
+  checkContextFile(projectDir, '.claude/CLAUDE.md', result.context);
+  checkContextFile(projectDir, 'CLAUDE.local.md', result.context);
+  collectMdFiles(path.join(projectDir, '.claude', 'rules'), result.context, '.claude/rules');
+
+  // Cursor
+  checkContextFile(projectDir, '.cursorrules', result.context);
+  for (const entry of safeDirEntries(path.join(projectDir, '.cursor', 'rules'))) {
+    pushUnique(result.context, '.cursor/rules/' + entry);
+  }
+
+  // Codex CLI
+  checkContextFile(projectDir, 'AGENTS.md', result.context);
+  checkContextFile(projectDir, 'AGENTS.override.md', result.context);
+
+  // Gemini CLI
+  checkContextFile(projectDir, 'GEMINI.md', result.context);
+
+  // Windsurf
+  checkContextFile(projectDir, '.windsurfrules', result.context);
+  for (const entry of safeDirEntries(path.join(projectDir, '.windsurf', 'rules'))) {
+    pushUnique(result.context, '.windsurf/rules/' + entry);
+  }
+
+  // Cline
+  checkContextFile(projectDir, '.clinerules', result.context);
+  // .clinerules/ as directory
+  for (const entry of safeDirEntries(path.join(projectDir, '.clinerules'))) {
+    pushUnique(result.context, '.clinerules/' + entry);
+  }
+
+  // KiloCode
+  checkContextFile(projectDir, '.kilocoderules', result.context);
+  for (const entry of safeDirEntries(path.join(projectDir, '.kilocode', 'rules'))) {
+    pushUnique(result.context, '.kilocode/rules/' + entry);
+  }
+
+  // VS Code Copilot
+  checkContextFile(projectDir, '.github/copilot-instructions.md', result.context);
+  for (const entry of safeDirEntries(path.join(projectDir, '.github', 'instructions'))) {
+    pushUnique(result.context, '.github/instructions/' + entry);
+  }
+
+  // OpenClaw
+  checkContextFile(projectDir, 'SOUL.md', result.context);
+  checkContextFile(projectDir, 'IDENTITY.md', result.context);
+  checkContextFile(projectDir, 'USER.md', result.context);
+  checkContextFile(projectDir, 'TOOLS.md', result.context);
+  checkContextFile(projectDir, 'MEMORY.md', result.context);
+
+  return result;
+}
+
+module.exports = { scanAgentConfigs };

package/{config.js → src/core/config.js}

@@ -13,7 +13,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const defaults = require('./defaults.json');
+const defaults = require('../../defaults.json');
 
 function deepMerge(target, source) {
   const result = { ...target };
@@ -70,4 +70,29 @@ function loadConfig(projectDir, explicitPath) {
   return config;
 }
 
-module.exports = { loadConfig };
+function resolveTheme(projectDir, explicitPath) {
+  const candidates = [];
+
+  if (explicitPath) {
+    candidates.push(path.resolve(explicitPath));
+  }
+
+  if (projectDir) {
+    candidates.push(path.join(projectDir, 'project', 'mdboard.json'));
+    candidates.push(path.join(projectDir, 'mdboard.json'));
+  }
+
+  const globalPath = path.join(os.homedir(), '.config', 'mdboard', 'mdboard.json');
+  candidates.push(globalPath);
+
+  for (const p of candidates) {
+    const data = tryReadJson(p);
+    if (data && data.theme) {
+      return data.theme;
+    }
+  }
+
+  return null;
+}
+
+module.exports = { loadConfig, deepMerge, resolveTheme };

package/src/core/history.js

@@ -0,0 +1,130 @@
+/**
+ * mdboard — Project History
+ *
+ * Persistent history of visited projects stored in
+ * ~/.config/mdboard/history.json.  Allows switching between
+ * projects without restarting the server.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'mdboard');
+const HISTORY_FILE = path.join(CONFIG_DIR, 'history.json');
+const MAX_ENTRIES = 50;
+
+/**
+ * Read the history file.
+ * @returns {Array<{path:string, name:string, lastOpened:string}>}
+ */
+function readHistory() {
+  try {
+    const raw = fs.readFileSync(HISTORY_FILE, 'utf-8');
+    const data = JSON.parse(raw);
+    return Array.isArray(data) ? data : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Write history to disk.
+ * @param {Array} entries
+ */
+function writeHistory(entries) {
+  try {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(entries, null, 2), 'utf-8');
+  } catch {
+    // Non-critical — silently ignore write failures
+  }
+}
+
+/**
+ * Register (or update) a project in the history.
+ * Moves the entry to the front of the list.
+ *
+ * @param {string} projectDir - Absolute path to the project directory
+ * @param {string} name - Human-friendly project name
+ */
+function registerProject(projectDir, name) {
+  const absPath = path.resolve(projectDir);
+  let entries = readHistory();
+
+  // Remove existing entry for this path
+  entries = entries.filter(e => e.path !== absPath);
+
+  // Prepend new entry
+  entries.unshift({
+    path: absPath,
+    name: name || path.basename(absPath),
+    lastOpened: new Date().toISOString(),
+  });
+
+  // Enforce limit
+  if (entries.length > MAX_ENTRIES) {
+    entries = entries.slice(0, MAX_ENTRIES);
+  }
+
+  writeHistory(entries);
+}
+
+/**
+ * Get the history list with a `isCurrent` flag.
+ *
+ * @param {string} currentProjectDir - The currently-active project dir
+ * @returns {Array<{path:string, name:string, lastOpened:string, isCurrent:boolean}>}
+ */
+function getHistory(currentProjectDir) {
+  const absCurrentDir = currentProjectDir ? path.resolve(currentProjectDir) : null;
+  const entries = readHistory();
+
+  return entries.map(e => ({
+    ...e,
+    isCurrent: e.path === absCurrentDir,
+  }));
+}
+
+/**
+ * Detect whether a directory looks like a valid mdboard project.
+ * A project has either a `project/` subdirectory or a `workspace.json`
+ * with sources.
+ *
+ * @param {string} dir - Directory to check
+ * @returns {boolean}
+ */
+function isValidProject(dir) {
+  try {
+    const absDir = path.resolve(dir);
+
+    // Check for project/ sub-directory
+    if (fs.existsSync(path.join(absDir, 'project'))) return true;
+
+    // Check for workspace.json with sources
+    const wsPath = path.join(absDir, 'workspace.json');
+    if (fs.existsSync(wsPath)) {
+      const raw = fs.readFileSync(wsPath, 'utf-8');
+      const ws = JSON.parse(raw);
+      if (ws && Array.isArray(ws.sources) && ws.sources.length > 0) return true;
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove an entry from the history.
+ *
+ * @param {string} projectPath - Absolute path to remove
+ */
+function removeFromHistory(projectPath) {
+  const absPath = path.resolve(projectPath);
+  let entries = readHistory();
+  entries = entries.filter(e => e.path !== absPath);
+  writeHistory(entries);
+}
+
+module.exports = { readHistory, registerProject, getHistory, isValidProject, removeFromHistory };