@mindrian_os/install 1.13.0-beta.11

package/lib/mcp/pipeline-state.cjs

@@ -0,0 +1,275 @@
+'use strict';
+
+/**
+ * MindrianOS Pipeline State Manager
+ *
+ * Manages pipeline state via room artifacts. When a methodology tool writes
+ * output, metadata is stored in room/.mindrian/pipeline-state.json so the
+ * next tool in the chain knows what came before.
+ *
+ * State file: room/.mindrian/pipeline-state.json
+ * Schema:
+ *   {
+ *     last_tool: string,        // e.g. "scenario-plan"
+ *     output_path: string,      // relative path to filed artifact
+ *     chain_position: number,   // 0-based index in current chain
+ *     suggested_next: string,   // next tool name
+ *     chain: string[],          // full ordered chain (from Brain or heuristic)
+ *     chain_source: string,     // "brain" | "local" | "manual"
+ *     started_at: string,       // ISO timestamp of chain start
+ *     updated_at: string,       // ISO timestamp of last update
+ *     history: Array<{tool: string, output_path: string, completed_at: string}>
+ *   }
+ *
+ * Follows ICM principle: state lives inside room/ (folder IS orchestration).
+ * Pipeline state is a room artifact, not external infrastructure.
+ *
+ * @module pipeline-state
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PIPELINE_DIR = '.mindrian';
+const PIPELINE_FILE = 'pipeline-state.json';
+
+/**
+ * Resolve the pipeline state file path for a room.
+ * @param {string} roomDir - Absolute path to the room directory
+ * @returns {string} Absolute path to pipeline-state.json
+ */
+function statePath(roomDir) {
+  return path.join(roomDir, PIPELINE_DIR, PIPELINE_FILE);
+}
+
+/**
+ * Ensure the .mindrian directory exists in the room.
+ * @param {string} roomDir
+ */
+function ensureDir(roomDir) {
+  const dir = path.join(roomDir, PIPELINE_DIR);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * Read the current pipeline state from a room.
+ * Returns null if no pipeline is active (no state file or empty).
+ *
+ * @param {string} roomDir - Absolute path to the room directory
+ * @returns {object|null} Pipeline state or null
+ */
+function read(roomDir) {
+  const fp = statePath(roomDir);
+  try {
+    const raw = fs.readFileSync(fp, 'utf8');
+    return JSON.parse(raw);
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * Write pipeline state to a room.
+ *
+ * @param {string} roomDir - Absolute path to the room directory
+ * @param {object} state - Pipeline state object
+ */
+function write(roomDir, state) {
+  ensureDir(roomDir);
+  const fp = statePath(roomDir);
+  fs.writeFileSync(fp, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Initialize a new pipeline chain in a room.
+ * Called when Brain or local heuristic provides a chain recommendation.
+ *
+ * @param {string} roomDir - Absolute path to the room directory
+ * @param {string[]} chain - Ordered array of methodology/analysis tool names
+ * @param {string} source - Where the chain came from: "brain" | "local" | "manual"
+ * @returns {object} The initialized pipeline state
+ */
+function initChain(roomDir, chain, source) {
+  const state = {
+    last_tool: null,
+    output_path: null,
+    chain_position: -1,
+    suggested_next: chain.length > 0 ? chain[0] : null,
+    chain,
+    chain_source: source,
+    started_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    history: []
+  };
+  write(roomDir, state);
+  return state;
+}
+
+/**
+ * Record that a tool completed and advance the pipeline position.
+ *
+ * If the tool matches the next expected tool in the chain, advance
+ * chain_position. If it doesn't match (user ran a different tool),
+ * still record it but don't advance -- the chain ordering is advisory.
+ *
+ * @param {string} roomDir - Absolute path to the room directory
+ * @param {string} toolName - The methodology/analysis tool that just completed
+ * @param {string} outputPath - Relative path (from room root) to the filed artifact
+ * @returns {object} Updated pipeline state
+ */
+function recordStep(roomDir, toolName, outputPath) {
+  let state = read(roomDir);
+
+  if (!state) {
+    // No active pipeline -- create a minimal one
+    state = {
+      last_tool: null,
+      output_path: null,
+      chain_position: -1,
+      suggested_next: null,
+      chain: [],
+      chain_source: 'manual',
+      started_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      history: []
+    };
+  }
+
+  // Record the step in history
+  state.history.push({
+    tool: toolName,
+    output_path: outputPath,
+    completed_at: new Date().toISOString()
+  });
+
+  state.last_tool = toolName;
+  state.output_path = outputPath;
+  state.updated_at = new Date().toISOString();
+
+  // Check if this tool matches the next expected in the chain
+  const nextExpected = state.chain[state.chain_position + 1];
+  if (nextExpected && nextExpected === toolName) {
+    // Advance position in the chain
+    state.chain_position += 1;
+  }
+
+  // Set suggested_next to the next tool in the chain (if any remain)
+  const nextInChain = state.chain[state.chain_position + 1];
+  state.suggested_next = nextInChain || null;
+
+  write(roomDir, state);
+  return state;
+}
+
+/**
+ * Check if a given tool is the next expected step in the active pipeline.
+ *
+ * @param {string} roomDir - Absolute path to the room directory
+ * @param {string} toolName - Tool about to be executed
+ * @returns {{ inPipeline: boolean, isNext: boolean, position: number, chain: string[], previousOutput: string|null }}
+ */
+function checkPosition(roomDir, toolName) {
+  const state = read(roomDir);
+
+  if (!state || !state.chain || state.chain.length === 0) {
+    return {
+      inPipeline: false,
+      isNext: false,
+      position: -1,
+      chain: [],
+      previousOutput: null
+    };
+  }
+
+  const nextExpected = state.chain[state.chain_position + 1];
+  const isInChain = state.chain.includes(toolName);
+
+  return {
+    inPipeline: true,
+    isNext: nextExpected === toolName,
+    position: state.chain.indexOf(toolName),
+    chain: state.chain,
+    previousOutput: state.output_path
+  };
+}
+
+/**
+ * Get the output path from the previous step in the pipeline.
+ * Returns null if no previous step or no active pipeline.
+ *
+ * @param {string} roomDir - Absolute path to the room directory
+ * @returns {string|null} Relative path to previous step's artifact, or null
+ */
+function getPreviousOutput(roomDir) {
+  const state = read(roomDir);
+  if (!state || !state.output_path) return null;
+  return state.output_path;
+}
+
+/**
+ * Clear the pipeline state (pipeline completed or abandoned).
+ *
+ * @param {string} roomDir - Absolute path to the room directory
+ */
+function clear(roomDir) {
+  const fp = statePath(roomDir);
+  try {
+    fs.unlinkSync(fp);
+  } catch (_e) {
+    // Already gone
+  }
+}
+
+/**
+ * Format a Pipeline Context section for tool output.
+ * Included in every methodology/analysis tool response so the LLM
+ * knows where the output was filed and what comes next.
+ *
+ * @param {string} roomDir - Absolute path to the room directory
+ * @param {string} toolName - Current tool name
+ * @param {string} outputPath - Relative path to filed artifact
+ * @returns {string} Formatted markdown section
+ */
+function formatPipelineContext(roomDir, toolName, outputPath) {
+  const state = read(roomDir);
+  const lines = [
+    '\n\n## Pipeline Context',
+    '',
+    `**Tool:** \`${toolName}\``,
+    `**Output filed:** \`${outputPath}\``
+  ];
+
+  if (state && state.chain && state.chain.length > 0) {
+    const pos = state.chain_position >= 0 ? state.chain_position + 1 : 0;
+    lines.push(`**Chain:** ${state.chain.map((t, i) => i === pos ? `**${t}**` : t).join(' -> ')}`);
+    lines.push(`**Position:** ${pos + 1} of ${state.chain.length}`);
+
+    if (state.suggested_next) {
+      lines.push(`**Next:** \`${state.suggested_next}\``);
+    } else {
+      lines.push('**Status:** Pipeline complete');
+    }
+  }
+
+  if (state && state.history && state.history.length > 0) {
+    lines.push('', '**Previous steps:**');
+    for (const step of state.history.slice(-3)) {
+      lines.push(`- \`${step.tool}\` -> \`${step.output_path}\``);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  read,
+  write,
+  initChain,
+  recordStep,
+  checkPosition,
+  getPreviousOutput,
+  clear,
+  formatPipelineContext
+};

package/lib/mcp/prompts.cjs

@@ -0,0 +1,302 @@
+/**
+ * MindrianOS MCP Prompts — Methodology workflows with Larry personality injection
+ *
+ * Prompts deliver methodology workflows pre-loaded with room context
+ * so Desktop Larry matches CLI Larry.
+ *
+ * Registered prompts:
+ *   1. file-meeting    — File a meeting transcript to Data Room
+ *   2. analyze-room    — Analyze current Data Room state
+ *   3. grade-venture   — Grade the venture using PWS rubrics
+ *   4. run-methodology — Run any of the 25 methodology frameworks
+ *   5. suggest-next    — What should I work on next?
+ *   6. reason-section  — Analyze a room section using Minto/MECE structured reasoning
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { loadLarryContext } = require('./larry-context.cjs');
+const { getState, computeState } = require('../core/state-ops.cjs');
+const { safeReadFile } = require('../core/index.cjs');
+const reasoningOps = require('../core/reasoning-ops.cjs');
+
+// All 25 methodology framework names (matching CLI commands)
+const METHODOLOGY_NAMES = [
+  // methodology group (13)
+  'lean-canvas', 'think-hats', 'structure-argument', 'beautiful-question',
+  'build-knowledge', 'challenge-assumptions', 'validate', 'map-unknowns',
+  'diagnose', 'score-innovation', 'explore-domains', 'analyze-needs',
+  'user-needs',
+  // analysis group (10)
+  'analyze-systems', 'analyze-timing', 'find-bottlenecks', 'root-cause',
+  'systems-thinking', 'macro-trends', 'explore-trends', 'explore-futures',
+  'dominant-designs', 'scenario-plan',
+  // intelligence/strategy (2 from intelligence group that are methodology-like)
+  'find-connections', 'build-thesis',
+];
+
+/**
+ * Safely load a reference file from the plugin references directory.
+ * Returns the file content or an empty string if not found.
+ *
+ * @param {string} pluginRoot
+ * @param {...string} segments - Path segments relative to references/
+ * @returns {string}
+ */
+function loadReference(pluginRoot, ...segments) {
+  const refPath = path.join(pluginRoot, 'references', ...segments);
+  return safeReadFile(refPath) || '';
+}
+
+/**
+ * Build a prompt message with Larry personality, room state, and optional reference.
+ *
+ * @param {string} larryFull - Full Larry personality text
+ * @param {string} roomState - Current room state text
+ * @param {string} reference - Reference material (may be empty)
+ * @param {string} userContent - User-specific content or instructions
+ * @returns {{ messages: Array<{role: string, content: {type: string, text: string}}> }}
+ */
+function buildPromptResponse(larryFull, roomState, reference, userContent) {
+  const parts = [
+    '# Larry Personality Context\n\n' + larryFull,
+    '\n\n---\n\n# Current Data Room State\n\n' + (roomState || 'No room initialized yet.'),
+  ];
+
+  if (reference) {
+    parts.push('\n\n---\n\n# Reference Material\n\n' + reference);
+  }
+
+  parts.push('\n\n---\n\n# User Request\n\n' + userContent);
+
+  return {
+    messages: [{
+      role: 'user',
+      content: { type: 'text', text: parts.join('') },
+    }],
+  };
+}
+
+/**
+ * Register all MCP Prompts on the server.
+ *
+ * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
+ * @param {string} roomDir - Absolute path to the Data Room directory
+ * @param {string} pluginRoot - Root of the plugin repository
+ */
+function registerPrompts(server, roomDir, pluginRoot) {
+  const larryFull = loadLarryContext(pluginRoot).full;
+
+  // -------------------------------------------------------------------------
+  // 1. file-meeting — File a meeting transcript to Data Room
+  // -------------------------------------------------------------------------
+  server.prompt(
+    'file-meeting',
+    {
+      description: 'File a meeting transcript into the Data Room. Larry extracts insights, maps to sections, and files artifacts.',
+      arguments: [
+        { name: 'transcript', description: 'The full meeting transcript text', required: true },
+        { name: 'meetingDate', description: 'Meeting date (YYYY-MM-DD format)', required: false },
+      ],
+    },
+    async (args) => {
+      const roomState = getState(roomDir) || '';
+      const filingRef = loadReference(pluginRoot, 'meeting', 'section-mapping.md');
+      const segmentRef = loadReference(pluginRoot, 'meeting', 'segment-classification.md');
+      const reference = [filingRef, segmentRef].filter(Boolean).join('\n\n---\n\n');
+
+      const dateNote = args.meetingDate ? `Meeting date: ${args.meetingDate}\n\n` : '';
+      const userContent = `${dateNote}Please file this meeting transcript into the Data Room. Extract key insights, classify segments, map findings to the appropriate sections, and identify cross-section relationships.\n\n## Transcript\n\n${args.transcript}`;
+
+      return buildPromptResponse(larryFull, roomState, reference, userContent);
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 2. analyze-room — Analyze current Data Room state
+  // -------------------------------------------------------------------------
+  server.prompt(
+    'analyze-room',
+    {
+      description: 'Analyze the current Data Room state. Larry identifies gaps, strengths, and what needs attention.',
+      arguments: [
+        { name: 'focus', description: 'Specific section or concern to focus on', required: false },
+      ],
+    },
+    async (args) => {
+      // Use computeState for richer analysis (runs the full state computation)
+      let roomState;
+      try {
+        roomState = computeState(roomDir);
+      } catch (e) {
+        roomState = getState(roomDir) || '';
+      }
+
+      const focusNote = args.focus ? `Focus area: ${args.focus}\n\n` : '';
+      const userContent = `${focusNote}Analyze the current state of my Data Room. Identify gaps, strengths, cross-section relationships, and what I should work on. Be specific about which sections need attention and why.`;
+
+      return buildPromptResponse(larryFull, roomState, '', userContent);
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 3. grade-venture — Grade the venture using PWS rubrics
+  // -------------------------------------------------------------------------
+  server.prompt(
+    'grade-venture',
+    {
+      description: 'Grade the venture using PWS assessment rubrics. Quick mode gives overview, deep mode provides detailed component analysis.',
+      arguments: [
+        { name: 'depth', description: 'Assessment depth: "quick" (overview) or "deep" (detailed component analysis)', required: false },
+      ],
+    },
+    async (args) => {
+      const depth = args.depth || 'quick';
+      const roomState = getState(roomDir) || '';
+
+      const assessmentPhilosophy = loadReference(pluginRoot, 'personality', 'assessment-philosophy.md');
+
+      let gradingRef;
+      if (depth === 'deep') {
+        gradingRef = loadReference(pluginRoot, 'methodology', 'deep-grade.md')
+          || loadReference(pluginRoot, 'methodology', 'grade.md');
+      } else {
+        gradingRef = loadReference(pluginRoot, 'methodology', 'grade.md');
+      }
+
+      const reference = [assessmentPhilosophy, gradingRef].filter(Boolean).join('\n\n---\n\n');
+
+      const userContent = `Grade my venture using a ${depth} assessment. Evaluate each Data Room section against PWS rubrics, identify the strongest and weakest areas, and provide an overall grade with specific improvement recommendations.`;
+
+      return buildPromptResponse(larryFull, roomState, reference, userContent);
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 4. run-methodology — Run any of the 25 methodology frameworks
+  // -------------------------------------------------------------------------
+  server.prompt(
+    'run-methodology',
+    {
+      description: 'Run a PWS innovation methodology framework. Larry guides you through the chosen framework applied to your venture.',
+      arguments: [
+        {
+          name: 'methodology',
+          description: `Methodology to run. One of: ${METHODOLOGY_NAMES.join(', ')}`,
+          required: true,
+        },
+        { name: 'focus', description: 'Specific venture aspect or question to focus the methodology on', required: false },
+      ],
+    },
+    async (args) => {
+      const methodology = args.methodology;
+      const roomState = getState(roomDir) || '';
+
+      // Try methodology-specific reference file
+      const methodRef = loadReference(pluginRoot, 'methodology', `${methodology}.md`);
+
+      const focusNote = args.focus ? `Focus: ${args.focus}\n\n` : '';
+      const userContent = `${focusNote}Run the "${methodology}" methodology framework on my venture. Guide me through the framework step by step, applying it specifically to what you see in my Data Room.`;
+
+      return buildPromptResponse(larryFull, roomState, methodRef, userContent);
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 5. suggest-next — What should I work on next?
+  // -------------------------------------------------------------------------
+  server.prompt(
+    'suggest-next',
+    {
+      description: 'Larry analyzes room gaps and suggests what to work on next.',
+      arguments: [],
+    },
+    async () => {
+      let roomState;
+      try {
+        roomState = computeState(roomDir);
+      } catch (e) {
+        roomState = getState(roomDir) || '';
+      }
+
+      const suggestRef = loadReference(pluginRoot, 'methodology', 'index.md');
+
+      const userContent = 'Based on the current state of my Data Room, what should I work on next? Consider which sections are weakest, what methodologies would help most, and what the highest-impact next step would be.';
+
+      return buildPromptResponse(larryFull, roomState, suggestRef, userContent);
+    }
+  );
+
+  // -------------------------------------------------------------------------
+  // 6. reason-section — Analyze a room section using Minto/MECE structured reasoning
+  // -------------------------------------------------------------------------
+  server.prompt(
+    'reason-section',
+    {
+      description: 'Analyze a room section using Minto/MECE structured reasoning. Larry captures WHY a section matters, rates confidence, and identifies cross-section dependencies.',
+      arguments: [
+        { name: 'section', description: 'Room section to reason about', required: true },
+      ],
+    },
+    async (args) => {
+      const section = args.section;
+
+      // a. Read room STATE.md for venture context
+      const roomState = getState(roomDir) || 'No room initialized yet.';
+
+      // b. Read section artifacts (list .md files in room/{section}/)
+      const sectionDir = path.join(roomDir, section);
+      let artifactSummary = '';
+      try {
+        const files = fs.readdirSync(sectionDir).filter(f => f.endsWith('.md')).sort();
+        if (files.length > 0) {
+          const artifacts = files.map(f => {
+            const content = safeReadFile(path.join(sectionDir, f)) || '';
+            // Truncate long artifacts to keep prompt manageable
+            const truncated = content.length > 2000
+              ? content.slice(0, 2000) + '\n\n[... truncated, ' + content.length + ' chars total]'
+              : content;
+            return `### ${f}\n\n${truncated}`;
+          });
+          artifactSummary = artifacts.join('\n\n---\n\n');
+        } else {
+          artifactSummary = 'No artifacts in this section yet.';
+        }
+      } catch (e) {
+        artifactSummary = `Section "${section}" directory not found or empty.`;
+      }
+
+      // c. Read existing reasoning if any
+      const existingReasoning = reasoningOps.getReasoning(roomDir, section);
+      const existingContent = existingReasoning.error
+        ? 'No existing reasoning for this section.'
+        : existingReasoning.content;
+
+      // d. Read the reasoning template
+      const reasoningTemplate = loadReference(pluginRoot, 'reasoning', 'reasoning-template.md');
+
+      // e. Compose prompt message array
+      const systemMessage = 'You are Larry, MindrianOS reasoning engine. Analyze this section using Minto Pyramid (Situation-Complication-Question-Answer) and MECE structure. Fill in the REASONING.md template below with specific claims from the section artifacts. Rate confidence levels. Identify cross-section dependencies. Be specific about what must be TRUE for this section to be complete.';
+
+      const userMessage = [
+        '# Venture Context\n\n' + roomState,
+        '\n\n---\n\n# Section Artifacts: ' + section + '\n\n' + artifactSummary,
+        '\n\n---\n\n# Existing Reasoning\n\n' + existingContent,
+        '\n\n---\n\n# REASONING.md Template (fill this in)\n\n' + (reasoningTemplate || 'Template not found — generate Minto/MECE structured reasoning.'),
+      ].join('');
+
+      return {
+        messages: [
+          {
+            role: 'user',
+            content: { type: 'text', text: systemMessage + '\n\n---\n\n' + userMessage },
+          },
+        ],
+      };
+    }
+  );
+}
+
+module.exports = { registerPrompts, METHODOLOGY_NAMES };