@smartmemory/compose 0.2.39-beta → 0.2.40-beta

package/lib/get-roadmap.js

@@ -0,0 +1,121 @@
+/**
+ * get-roadmap.js — COMP-MCP-ROADMAP-READ.
+ *
+ * Read-only roadmap reader for the compose MCP `get_roadmap` tool. Renders the
+ * roadmap from canon (feature.json) WITHOUT writing any file, parses rows via the
+ * shared parseRoadmap, and reports a staleness flag vs the on-disk ROADMAP.md.
+ *
+ * Invariants:
+ *   - Never mutates the filesystem (no writeRoadmap / renderRoadmap).
+ *   - Narrative-owned workspaces read ROADMAP.md verbatim (no console.warn path),
+ *     and are never reported stale (the file IS the canon).
+ *   - Row parsing reuses parseRoadmap — no second hand-rolled regex.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { generateRoadmap } from './roadmap-gen.js';
+import { isNarrativeOwned } from './roadmap-config.js';
+import { parseRoadmap, parseStatusToken } from './roadmap-parser.js';
+
+// Whole `**Last updated:** <date>` line — date-only and per-day, so it is
+// stripped (not literal-matched) before drift comparison.
+const LAST_UPDATED_RE = /^\*\*Last updated:\*\*.*$/m;
+
+const ACTIVE_STATUSES = new Set(['IN_PROGRESS', 'PARTIAL']);
+
+// Normalized status token -> summary bucket.
+const BUCKET = {
+  COMPLETE: 'complete',
+  IN_PROGRESS: 'active',
+  PARTIAL: 'active',
+  PLANNED: 'planned',
+  BLOCKED: 'blocked',
+  PARKED: 'parked',
+  SUPERSEDED: 'superseded',
+};
+
+function emptySummary() {
+  return { complete: 0, active: 0, planned: 0, blocked: 0, parked: 0, superseded: 0 };
+}
+
+function stripVolatile(text) {
+  return text.replace(LAST_UPDATED_RE, '').trimEnd();
+}
+
+/**
+ * @param {string} root - Project root.
+ * @param {object} [opts]
+ * @param {string} [opts.status] - Comma-list status filter applied to active/blocked rows.
+ * @param {string} [opts.phase] - Exact phaseId filter applied to active/blocked rows.
+ * @param {'summary'|'markdown'} [opts.format='summary'] - Omit or include raw markdown.
+ * @param {boolean} [opts.check_drift=true] - Compare render vs on-disk ROADMAP.md.
+ */
+export function getRoadmap(root, opts = {}) {
+  const { status, phase, format = 'summary', check_drift = true } = opts ?? {};
+
+  const roadmapPath = join(root, 'ROADMAP.md');
+  const onDisk = existsSync(roadmapPath) ? readFileSync(roadmapPath, 'utf-8') : '';
+
+  // Branch on narrative ownership ourselves: read the file directly for narrative
+  // workspaces (avoids generateRoadmap's console.warn and is a true no-op read).
+  const narrative = isNarrativeOwned(root);
+  const markdown = narrative ? onDisk : generateRoadmap(root, {});
+  const source = narrative ? 'narrative' : 'rendered';
+
+  const rows = parseRoadmap(markdown);
+
+  // Summary counts over ALL rows (anonymous included).
+  const summary = emptySummary();
+  for (const r of rows) {
+    const bucket = BUCKET[parseStatusToken(r.status)];
+    if (bucket) summary[bucket]++;
+  }
+
+  // active/blocked lists exclude anonymous rows. parseRoadmap rewrites
+  // codeless rows to `_anon_${position}` (roadmap-parser.js), so filter on that
+  // prefix — not the raw '—' glyph, which never reaches us.
+  const named = rows.filter((r) => r.code && !r.code.startsWith('_anon_'));
+
+  const matchFilter = (r) => {
+    if (status) {
+      const wanted = status.split(',').map((s) => s.trim().toUpperCase());
+      if (!wanted.includes(parseStatusToken(r.status))) return false;
+    }
+    if (phase && r.phaseId !== phase) return false;
+    return true;
+  };
+  const pick = (r) => ({
+    code: r.code,
+    description: r.description,
+    status: parseStatusToken(r.status),
+    phaseId: r.phaseId,
+  });
+
+  const active = named
+    .filter((r) => ACTIVE_STATUSES.has(parseStatusToken(r.status)))
+    .filter(matchFilter)
+    .map(pick);
+  const blocked = named
+    .filter((r) => parseStatusToken(r.status) === 'BLOCKED')
+    .filter(matchFilter)
+    .map(pick);
+
+  const out = { source, path: roadmapPath, summary, active, blocked };
+
+  if (check_drift) {
+    if (narrative) {
+      out.stale = false; // the content IS the file
+    } else {
+      const drifted = stripVolatile(markdown) !== stripVolatile(onDisk);
+      out.stale = drifted;
+      if (drifted) {
+        out.drift = 'ROADMAP.md differs from the feature.json render (run validate_project --fix to reconcile)';
+      }
+    }
+  }
+
+  if (format === 'markdown') out.markdown = markdown;
+
+  return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartmemory/compose",
-  "version": "0.2.39-beta",
+  "version": "0.2.40-beta",
   "description": "Structured AI dev pipeline — goal-to-product orchestration with gates, iteration loops, and feature lifecycle management.",
   "author": "SmartMemory",
   "license": "MIT",

package/server/compose-mcp-tools.js

@@ -11,6 +11,7 @@ import path from 'node:path';
 import { ArtifactManager, ARTIFACT_SCHEMAS } from './artifact-manager.js';
 import { getTargetRoot, getDataDir, resolveProjectPath, switchProject, setCurrentWorkspaceId, loadProjectConfig } from './project-root.js';
 import { resolveProfile, isToolAllowed } from './mcp-tool-policy.js';
+import { getRoadmap } from '../lib/get-roadmap.js';
 
 /**
  * COMP-MCP-ENFORCE Slice 3 — kill the `force` escape hatch at the MCP tool
@@ -152,6 +153,12 @@ export function loadSessions() {
 // Tool implementations
 // ---------------------------------------------------------------------------
 
+// COMP-MCP-ROADMAP-READ — read-only roadmap reader. Thin wrapper over
+// lib/get-roadmap.js; never mutates the filesystem.
+export function toolGetRoadmap(args = {}) {
+  return getRoadmap(getTargetRoot(), args ?? {});
+}
+
 export function toolGetVisionItems({ phase, status, type, keyword, limit = 30 }) {
   const { items } = loadVisionState();
 

package/server/compose-mcp.js

@@ -28,6 +28,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import {
   toolGetVisionItems,
+  toolGetRoadmap,
   toolGetItemDetail,
   toolGetPhasesSummary,
   toolGetBlockedItems,
@@ -358,6 +359,19 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'get_roadmap',
+    description: 'Read the current roadmap rendered from canon (feature.json) WITHOUT writing. Returns a status summary plus active/blocked rows, and a staleness flag comparing the render against on-disk ROADMAP.md. Narrative-owned workspaces return the hand-authored file verbatim. Read-only — prefer this over reading ROADMAP.md directly.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', description: 'Filter active/blocked rows by status (comma-separated): PLANNED, IN_PROGRESS, PARTIAL, BLOCKED, COMPLETE, …' },
+        phase: { type: 'string', description: 'Filter active/blocked rows to a single phase (matched against phaseId)' },
+        format: { type: 'string', description: '"summary" (default — counts + lists, token-safe) or "markdown" (full rendered text)' },
+        check_drift: { type: 'boolean', description: 'Compare the render against on-disk ROADMAP.md and set stale/drift (default true)' },
+      },
+    },
+  },
   {
     name: 'validate_feature',
     description: 'Cross-check a single feature against ROADMAP, vision-state, feature.json, folder contents, linked artifacts, and cross-references. Returns structured findings with severity (error/warning/info). FEATURE_NOT_FOUND emitted as a finding (not thrown) when the code matches strict regex but exists in no source.',
@@ -733,6 +747,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'add_roadmap_entry':        result = await toolAddRoadmapEntry(args); break;
       case 'set_feature_status':       result = await toolSetFeatureStatus(args); break;
       case 'roadmap_diff':             result = await toolRoadmapDiff(args); break;
+      case 'get_roadmap':              result = toolGetRoadmap(args); break;
       case 'link_artifact':            result = await toolLinkArtifact(args); break;
       case 'link_features':            result = await toolLinkFeatures(args); break;
       case 'get_feature_artifacts':    result = await toolGetFeatureArtifacts(args); break;

package/server/mcp-tool-policy.js

@@ -34,7 +34,7 @@ const REVIEWER_ALLOW = [
   'get_vision_items', 'get_item_detail', 'get_phase_summary', 'get_blocked_items',
   'get_current_session', 'get_feature_lifecycle', 'get_feature_artifacts', 'get_feature_links',
   'get_pending_gates', 'get_changelog_entries', 'get_journal_entries', 'get_completions',
-  'validate_feature', 'validate_project', 'roadmap_diff', 'roadmap_graph_check', 'assess_feature_artifacts',
+  'validate_feature', 'validate_project', 'roadmap_diff', 'get_roadmap', 'roadmap_graph_check', 'assess_feature_artifacts',
   'set_workspace', 'get_workspace', 'bind_session',
 ];