@mindrian_os/cli 1.13.0-beta.10 → 1.13.0-beta.43

package/lib/mcp/resources.cjs

@@ -1,227 +0,0 @@
-/**
- * MindrianOS MCP Resources — Read-only room browsing via room:// and reasoning:// URI schemes
- *
- * Resources let Desktop users browse room state without tool calls
- * (application-controlled, zero token cost).
- *
- * Registered resources:
- *   1. room-state        — room://state              (room STATE.md)
- *   2. room-sections     — room://sections            (section listing with metadata)
- *   3. room-section      — room://section/{name}      (template: section contents)
- *   4. room-meetings     — room://meetings            (meeting folder listing)
- *   5. room-intelligence — room://intelligence         (MEETINGS-INTELLIGENCE.md)
- *   6. reasoning-state   — reasoning://state           (reasoning status across all sections)
- *   7. reasoning-section — reasoning://section/{name}  (reasoning analysis for a section)
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { ResourceTemplate } = require('@modelcontextprotocol/sdk/server/mcp.js');
-const { getState } = require('../core/state-ops.cjs');
-const { discoverSections } = require('../core/section-registry.cjs');
-const { safeReadFile } = require('../core/index.cjs');
-const reasoningOps = require('../core/reasoning-ops.cjs');
-
-/**
- * Register all MCP Resources on the server.
- *
- * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
- * @param {string} roomDir - Absolute path to the Data Room directory
- */
-function registerResources(server, roomDir) {
-  // -------------------------------------------------------------------------
-  // 1. room-state (static) — room://state
-  // -------------------------------------------------------------------------
-  server.resource(
-    'room-state',
-    'room://state',
-    { description: 'Current Data Room state (STATE.md)', mimeType: 'text/markdown' },
-    async (uri) => {
-      const state = getState(roomDir);
-      const text = state || 'No room initialized. Run /mos:new-project to create one.';
-      return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text }] };
-    }
-  );
-
-  // -------------------------------------------------------------------------
-  // 2. room-sections (static) — room://sections
-  // -------------------------------------------------------------------------
-  server.resource(
-    'room-sections',
-    'room://sections',
-    { description: 'All discovered sections with metadata (name, type, label, color)', mimeType: 'application/json' },
-    async (uri) => {
-      const sections = discoverSections(roomDir);
-      const listing = sections.all.map((name) => {
-        const meta = sections.getMeta(name);
-        return { name, type: meta.type, label: meta.label, color: meta.color };
-      });
-      const text = JSON.stringify(listing, null, 2);
-      return { contents: [{ uri: uri.href, mimeType: 'application/json', text }] };
-    }
-  );
-
-  // -------------------------------------------------------------------------
-  // 3. room-section (template) — room://section/{sectionName}
-  // -------------------------------------------------------------------------
-  const sectionTemplate = new ResourceTemplate('room://section/{sectionName}', {
-    list: async () => {
-      const sections = discoverSections(roomDir);
-      return {
-        resources: sections.all.map((name) => ({
-          name: `room-section-${name}`,
-          uri: `room://section/${name}`,
-          description: `Contents of the ${name} section`,
-          mimeType: 'text/markdown',
-        })),
-      };
-    },
-  });
-
-  server.resource(
-    'room-section',
-    sectionTemplate,
-    { description: 'Contents of a specific Data Room section (all .md files)', mimeType: 'text/markdown' },
-    async (uri, params) => {
-      const sectionName = params.sectionName;
-      const sectionDir = path.join(roomDir, sectionName);
-
-      if (!fs.existsSync(sectionDir) || !fs.statSync(sectionDir).isDirectory()) {
-        return {
-          contents: [{
-            uri: uri.href,
-            mimeType: 'text/markdown',
-            text: `Section "${sectionName}" not found in this Data Room.`,
-          }],
-        };
-      }
-
-      // Read all .md files in the section directory
-      let files;
-      try {
-        files = fs.readdirSync(sectionDir).filter((f) => f.endsWith('.md')).sort();
-      } catch (e) {
-        files = [];
-      }
-
-      if (files.length === 0) {
-        return {
-          contents: [{
-            uri: uri.href,
-            mimeType: 'text/markdown',
-            text: `Section "${sectionName}" exists but contains no markdown files yet.`,
-          }],
-        };
-      }
-
-      const combined = files.map((f) => {
-        const content = safeReadFile(path.join(sectionDir, f)) || '';
-        return `# ${f}\n\n${content}`;
-      }).join('\n\n---\n\n');
-
-      return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text: combined }] };
-    }
-  );
-
-  // -------------------------------------------------------------------------
-  // 4. room-meetings (static) — room://meetings
-  // -------------------------------------------------------------------------
-  server.resource(
-    'room-meetings',
-    'room://meetings',
-    { description: 'List of filed meeting folders', mimeType: 'application/json' },
-    async (uri) => {
-      const meetingsDir = path.join(roomDir, 'meetings');
-
-      if (!fs.existsSync(meetingsDir) || !fs.statSync(meetingsDir).isDirectory()) {
-        return {
-          contents: [{
-            uri: uri.href,
-            mimeType: 'application/json',
-            text: 'No meetings filed yet.',
-          }],
-        };
-      }
-
-      let folders;
-      try {
-        folders = fs.readdirSync(meetingsDir, { withFileTypes: true })
-          .filter((d) => d.isDirectory())
-          .map((d) => d.name)
-          .sort();
-      } catch (e) {
-        folders = [];
-      }
-
-      if (folders.length === 0) {
-        return {
-          contents: [{
-            uri: uri.href,
-            mimeType: 'application/json',
-            text: 'No meetings filed yet.',
-          }],
-        };
-      }
-
-      const text = JSON.stringify(folders, null, 2);
-      return { contents: [{ uri: uri.href, mimeType: 'application/json', text }] };
-    }
-  );
-
-  // -------------------------------------------------------------------------
-  // 5. room-intelligence (static) — room://intelligence
-  // -------------------------------------------------------------------------
-  server.resource(
-    'room-intelligence',
-    'room://intelligence',
-    { description: 'Cross-meeting intelligence analysis', mimeType: 'text/markdown' },
-    async (uri) => {
-      const intel = safeReadFile(path.join(roomDir, 'MEETINGS-INTELLIGENCE.md'));
-      const text = intel || 'No meeting intelligence generated yet. File meetings first.';
-      return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text }] };
-    }
-  );
-
-  // -------------------------------------------------------------------------
-  // 6. reasoning-state (static) — reasoning://state
-  // -------------------------------------------------------------------------
-  server.resource(
-    'reasoning-state',
-    'reasoning://state',
-    { description: 'Reasoning status across all room sections', mimeType: 'application/json' },
-    async (uri) => {
-      const listing = reasoningOps.listReasoning(roomDir);
-      const text = (listing && listing.length > 0)
-        ? JSON.stringify(listing, null, 2)
-        : 'No reasoning generated yet. Run /mos:reason generate to create reasoning for room sections.';
-      return { contents: [{ uri: uri.href, mimeType: 'application/json', text }] };
-    }
-  );
-
-  // -------------------------------------------------------------------------
-  // 7. reasoning-section (template) — reasoning://section/{name}
-  // -------------------------------------------------------------------------
-  const reasoningTemplate = new ResourceTemplate('reasoning://section/{name}', {
-    list: undefined,
-  });
-
-  server.resource(
-    'reasoning-section',
-    reasoningTemplate,
-    { description: 'Reasoning analysis for a specific room section', mimeType: 'text/markdown' },
-    async (uri, params) => {
-      const name = params.name;
-      const result = reasoningOps.getReasoning(roomDir, name);
-
-      const text = result.error
-        ? `No reasoning generated for ${name}. Run /mos:reason generate ${name} to create.`
-        : result.content;
-
-      return { contents: [{ uri: uri.href, mimeType: 'text/markdown', text }] };
-    }
-  );
-}
-
-module.exports = { registerResources };

package/lib/mcp/session-catchup.cjs

@@ -1,327 +0,0 @@
-'use strict';
-
-/**
- * MindrianOS Plugin -- Session Catch-Up (SCHED-01)
- *
- * On MCP server init (Cowork), reads room/.mindrian/last-session.json,
- * computes what changed since the last session:
- *   - Hours since last scout run
- *   - Predictions approaching deadline
- *   - New files added since last session
- *   - Stale sections (no updates in 7+ days)
- *
- * Returns a structured catch-up summary for the first resource notification.
- * Writes last-session.json on SIGTERM / graceful shutdown.
- *
- * @module session-catchup
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const STALE_THRESHOLD_DAYS = 7;
-const MS_PER_HOUR = 3600000;
-const MS_PER_DAY = 86400000;
-
-/**
- * Path to last-session.json inside a room.
- * @param {string} roomDir
- * @returns {string}
- */
-function lastSessionPath(roomDir) {
-  return path.join(roomDir, '.mindrian', 'last-session.json');
-}
-
-/**
- * Read the last session record.
- * @param {string} roomDir
- * @returns {{ timestamp: string, scoutTimestamp: string|null, fileSnapshot: string[], activeMethodology: string|null } | null}
- */
-function readLastSession(roomDir) {
-  const p = lastSessionPath(roomDir);
-  try {
-    const raw = fs.readFileSync(p, 'utf8');
-    return JSON.parse(raw);
-  } catch (_e) {
-    return null;
-  }
-}
-
-/**
- * Write the last session record.
- * @param {string} roomDir
- * @param {object} data
- */
-function writeLastSession(roomDir, data) {
-  const p = lastSessionPath(roomDir);
-  const dir = path.dirname(p);
-  try {
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(p, JSON.stringify(data, null, 2));
-  } catch (e) {
-    process.stderr.write(`[session-catchup] Failed to write last-session.json: ${e.message}\n`);
-  }
-}
-
-/**
- * Recursively collect all .md files in a directory with their mtimes.
- * @param {string} dir
- * @param {string} baseDir - root for relative paths
- * @returns {Array<{relPath: string, mtime: number}>}
- */
-function collectFiles(dir, baseDir) {
-  const results = [];
-  if (!fs.existsSync(dir)) return results;
-
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith('.')) continue;
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...collectFiles(fullPath, baseDir));
-      } else if (entry.name.endsWith('.md') && entry.name !== 'STATE.md' && entry.name !== 'ROOM.md') {
-        try {
-          const stat = fs.statSync(fullPath);
-          results.push({
-            relPath: path.relative(baseDir, fullPath),
-            mtime: stat.mtimeMs,
-          });
-        } catch (_e) { /* skip */ }
-      }
-    }
-  } catch (_e) { /* skip */ }
-
-  return results;
-}
-
-/**
- * Read prediction registry and find approaching deadlines.
- * @param {string} roomDir
- * @returns {Array<{title: string, deadline: string, daysRemaining: number}>}
- */
-function getApproachingPredictions(roomDir) {
-  const registryPath = path.join(roomDir, '.predictions', 'REGISTRY.json');
-  if (!fs.existsSync(registryPath)) return [];
-
-  try {
-    const raw = fs.readFileSync(registryPath, 'utf8');
-    const registry = JSON.parse(raw);
-    const predictions = registry.predictions || registry.entries || [];
-    const now = Date.now();
-    const approaching = [];
-
-    for (const pred of predictions) {
-      if (!pred.deadline && !pred.due_date) continue;
-      const deadline = pred.deadline || pred.due_date;
-      const deadlineMs = new Date(deadline).getTime();
-      if (isNaN(deadlineMs)) continue;
-
-      const daysRemaining = Math.floor((deadlineMs - now) / MS_PER_DAY);
-      // Show predictions due within 14 days (including overdue)
-      if (daysRemaining <= 14) {
-        approaching.push({
-          title: pred.title || pred.description || pred.id || 'Untitled prediction',
-          deadline,
-          daysRemaining,
-        });
-      }
-    }
-
-    // Sort: overdue first, then by soonest
-    approaching.sort((a, b) => a.daysRemaining - b.daysRemaining);
-    return approaching;
-  } catch (_e) {
-    return [];
-  }
-}
-
-/**
- * Detect stale sections (no file updates in 7+ days).
- * @param {string} roomDir
- * @returns {Array<{section: string, daysSinceUpdate: number}>}
- */
-function getStaleSections(roomDir) {
-  const stale = [];
-  const now = Date.now();
-
-  try {
-    const entries = fs.readdirSync(roomDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name.startsWith('.') || entry.name === 'exports' || entry.name === 'intelligence') continue;
-
-      const sectionDir = path.join(roomDir, entry.name);
-      const files = collectFiles(sectionDir, sectionDir);
-      if (files.length === 0) continue;
-
-      const latestMtime = Math.max(...files.map(f => f.mtime));
-      const daysSince = Math.floor((now - latestMtime) / MS_PER_DAY);
-
-      if (daysSince >= STALE_THRESHOLD_DAYS) {
-        stale.push({
-          section: entry.name,
-          daysSinceUpdate: daysSince,
-        });
-      }
-    }
-  } catch (_e) { /* skip */ }
-
-  // Sort by stalest first
-  stale.sort((a, b) => b.daysSinceUpdate - a.daysSinceUpdate);
-  return stale;
-}
-
-/**
- * Compute the full catch-up summary for this session.
- *
- * @param {string} roomDir - Absolute path to room directory
- * @returns {{ hasCatchUp: boolean, hoursSinceLastSession: number|null, hoursSinceScout: number|null, newFiles: string[], predictionsApproaching: Array, staleSections: Array, summary: string }}
- */
-function computeCatchUp(roomDir) {
-  const result = {
-    hasCatchUp: false,
-    hoursSinceLastSession: null,
-    hoursSinceScout: null,
-    newFiles: [],
-    predictionsApproaching: [],
-    staleSections: [],
-    summary: '',
-  };
-
-  if (!fs.existsSync(roomDir)) {
-    result.summary = 'No room directory found.';
-    return result;
-  }
-
-  const lastSession = readLastSession(roomDir);
-  const now = Date.now();
-
-  // Hours since last session
-  if (lastSession && lastSession.timestamp) {
-    const lastMs = new Date(lastSession.timestamp).getTime();
-    if (!isNaN(lastMs)) {
-      result.hoursSinceLastSession = Math.round((now - lastMs) / MS_PER_HOUR * 10) / 10;
-      result.hasCatchUp = true;
-    }
-  }
-
-  // Hours since last scout
-  if (lastSession && lastSession.scoutTimestamp) {
-    const scoutMs = new Date(lastSession.scoutTimestamp).getTime();
-    if (!isNaN(scoutMs)) {
-      result.hoursSinceScout = Math.round((now - scoutMs) / MS_PER_HOUR * 10) / 10;
-    }
-  }
-
-  // New files since last session
-  if (lastSession && lastSession.fileSnapshot) {
-    const previousFiles = new Set(lastSession.fileSnapshot);
-    const currentFiles = collectFiles(roomDir, roomDir);
-    result.newFiles = currentFiles
-      .filter(f => !previousFiles.has(f.relPath))
-      .map(f => f.relPath);
-  }
-
-  // Approaching predictions
-  result.predictionsApproaching = getApproachingPredictions(roomDir);
-
-  // Stale sections
-  result.staleSections = getStaleSections(roomDir);
-
-  // Build human-readable summary
-  const parts = [];
-
-  if (result.hoursSinceLastSession !== null) {
-    parts.push(`Last session was ${result.hoursSinceLastSession} hours ago.`);
-  } else {
-    parts.push('This is the first session (no previous session data).');
-  }
-
-  if (result.hoursSinceScout !== null && result.hoursSinceScout > 24) {
-    parts.push(`Scout hasn't run in ${Math.round(result.hoursSinceScout)} hours - consider running /mos:scout.`);
-  }
-
-  if (result.newFiles.length > 0) {
-    parts.push(`${result.newFiles.length} new file(s) since last session: ${result.newFiles.slice(0, 5).join(', ')}${result.newFiles.length > 5 ? '...' : ''}`);
-  }
-
-  const overdue = result.predictionsApproaching.filter(p => p.daysRemaining < 0);
-  const urgent = result.predictionsApproaching.filter(p => p.daysRemaining >= 0 && p.daysRemaining <= 3);
-  if (overdue.length > 0) {
-    parts.push(`${overdue.length} OVERDUE prediction(s): ${overdue.map(p => p.title).join(', ')}`);
-  }
-  if (urgent.length > 0) {
-    parts.push(`${urgent.length} prediction(s) due within 3 days: ${urgent.map(p => p.title).join(', ')}`);
-  }
-
-  if (result.staleSections.length > 0) {
-    parts.push(`${result.staleSections.length} stale section(s) (7+ days): ${result.staleSections.map(s => `${s.section} (${s.daysSinceUpdate}d)`).join(', ')}`);
-  }
-
-  result.summary = parts.join(' ');
-  if (result.predictionsApproaching.length > 0 || result.staleSections.length > 0 || result.newFiles.length > 0) {
-    result.hasCatchUp = true;
-  }
-
-  return result;
-}
-
-/**
- * Create a snapshot of the current session state for later comparison.
- * Call this on SIGTERM or session end.
- *
- * @param {string} roomDir
- * @param {object} [extra] - Additional fields to persist (scoutTimestamp, activeMethodology)
- */
-function snapshotSession(roomDir, extra = {}) {
-  const currentFiles = collectFiles(roomDir, roomDir);
-  const data = {
-    timestamp: new Date().toISOString(),
-    scoutTimestamp: extra.scoutTimestamp || null,
-    activeMethodology: extra.activeMethodology || null,
-    fileSnapshot: currentFiles.map(f => f.relPath),
-    fileCount: currentFiles.length,
-  };
-  writeLastSession(roomDir, data);
-}
-
-/**
- * Register SIGTERM handler to snapshot session on server shutdown.
- * Safe to call multiple times (idempotent).
- *
- * @param {string} roomDir
- */
-let _shutdownRegistered = false;
-function registerShutdownHandler(roomDir) {
-  if (_shutdownRegistered) return;
-  _shutdownRegistered = true;
-
-  // I-4 fix: guard against double-fire when SIGINT triggers followed by beforeExit
-  let _shutdownDone = false;
-  const handler = () => {
-    if (_shutdownDone) return;
-    _shutdownDone = true;
-    try {
-      snapshotSession(roomDir);
-      process.stderr.write('[session-catchup] Session state saved on shutdown.\n');
-    } catch (e) {
-      process.stderr.write(`[session-catchup] Failed to save on shutdown: ${e.message}\n`);
-    }
-  };
-
-  process.on('SIGTERM', handler);
-  process.on('SIGINT', handler);
-  // Also handle graceful exit
-  process.on('beforeExit', handler);
-}
-
-module.exports = {
-  computeCatchUp,
-  snapshotSession,
-  readLastSession,
-  writeLastSession,
-  registerShutdownHandler,
-  getApproachingPredictions,
-  getStaleSections,
-};

package/lib/mcp/surface-detect.cjs

@@ -1,75 +0,0 @@
-'use strict';
-
-/**
- * Surface Detection for MindrianOS MCP Server
- *
- * Auto-detects CLI/Desktop/Cowork at server startup.
- * Called once before McpServer creation to determine transport
- * and capability set.
- *
- * Detection order (highest priority first):
- *   1. MINDRIAN_TRANSPORT env (explicit override)
- *   2. CLAUDE_SURFACE env (Anthropic-set)
- *   3. COWORK_SESSION_ID env or /sessions dir (Cowork VM)
- *   4. Non-TTY stdin with minimal argv (Desktop child process)
- *   5. TTY stdin (interactive CLI)
- *   6. Default: stdio (Desktop safe default)
- */
-
-const fs = require('fs');
-
-/** @type {Record<string, { hooks: boolean, apps: boolean, tasks: boolean, scripts: boolean }>} */
-const CAPABILITY_MAP = {
-  cli:     { hooks: true,  apps: false, tasks: false, scripts: true  },
-  desktop: { hooks: false, apps: true,  tasks: false, scripts: false },
-  cowork:  { hooks: false, apps: true,  tasks: true,  scripts: false },
-};
-
-/**
- * Detect the current surface (CLI, Desktop, Cowork) and return
- * transport type plus capability flags.
- *
- * @returns {{ surface: 'cli'|'desktop'|'cowork', transport: 'stdio'|'http', capabilities: { hooks: boolean, apps: boolean, tasks: boolean, scripts: boolean } }}
- */
-function detectSurface() {
-  // 1. Explicit override via env
-  const explicitTransport = process.env.MINDRIAN_TRANSPORT;
-  if (explicitTransport === 'http') {
-    return { surface: 'cowork', transport: 'http', capabilities: CAPABILITY_MAP.cowork };
-  }
-  if (explicitTransport === 'stdio') {
-    return { surface: 'desktop', transport: 'stdio', capabilities: CAPABILITY_MAP.desktop };
-  }
-
-  // 2. Anthropic-set surface env
-  const claudeSurface = process.env.CLAUDE_SURFACE;
-  if (claudeSurface === 'cowork') {
-    return { surface: 'cowork', transport: 'http', capabilities: CAPABILITY_MAP.cowork };
-  }
-  if (claudeSurface === 'desktop') {
-    return { surface: 'desktop', transport: 'stdio', capabilities: CAPABILITY_MAP.desktop };
-  }
-  if (claudeSurface === 'cli') {
-    return { surface: 'cli', transport: 'stdio', capabilities: CAPABILITY_MAP.cli };
-  }
-
-  // 3. Cowork VM indicators
-  if (process.env.COWORK_SESSION_ID || (fs.existsSync('/sessions'))) {
-    return { surface: 'cowork', transport: 'http', capabilities: CAPABILITY_MAP.cowork };
-  }
-
-  // 4. Non-TTY stdin with minimal argv = Desktop spawned child process
-  if (!process.stdin.isTTY && process.argv.length <= 2) {
-    return { surface: 'desktop', transport: 'stdio', capabilities: CAPABILITY_MAP.desktop };
-  }
-
-  // 5. Interactive TTY = CLI
-  if (process.stdin.isTTY) {
-    return { surface: 'cli', transport: 'stdio', capabilities: CAPABILITY_MAP.cli };
-  }
-
-  // 6. Default: Desktop (stdio is the safe default)
-  return { surface: 'desktop', transport: 'stdio', capabilities: CAPABILITY_MAP.desktop };
-}
-
-module.exports = { detectSurface, CAPABILITY_MAP };