@smartmemory/compose 0.1.7-beta → 0.1.9-beta

package/lib/discover-workspaces.js

@@ -0,0 +1,109 @@
+/**
+ * discover-workspaces.js — bounded bidirectional discovery of compose workspaces.
+ *
+ * Walks upward to find an "anchor" (any of ANCHOR_MARKERS), then scans the anchor
+ * subtree to MAX_DEPTH for `.compose/` markers. Hard-capped at MAX_VISITED dirs;
+ * over-cap throws an Error with code='WorkspaceDiscoveryTooBroad'. Permission
+ * errors during readdir are skipped silently — discovery is best-effort, not
+ * authoritative for individual subtrees.
+ *
+ * Exports:
+ *   - findAnchor(startDir) → string|null
+ *   - discoverWorkspaces(startDir) → { anchor, candidates: [{id, root, configPath}] }
+ *   - deriveId({root}) → {id, root, configPath}
+ */
+import path from 'node:path';
+import fs from 'node:fs';
+
+export const ANCHOR_MARKERS = ['.compose', '.stratum.yaml', '.git'];
+export const WORKSPACE_MARKER = '.compose';
+export const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo']);
+export const MAX_DEPTH = 3;
+export const MAX_VISITED = 500;
+
+/**
+ * Walk upward from startDir; return the first directory containing any
+ * ANCHOR_MARKER, or null if none found before filesystem root.
+ */
+export function findAnchor(startDir) {
+  let dir = path.resolve(startDir);
+  const { root } = path.parse(dir);
+  while (true) {
+    for (const marker of ANCHOR_MARKERS) {
+      if (fs.existsSync(path.join(dir, marker))) return dir;
+    }
+    if (dir === root) return null;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * Discover candidate workspaces under the anchor for startDir.
+ * If no anchor exists upward, anchors at startDir itself.
+ */
+export function discoverWorkspaces(startDir) {
+  const anchor = findAnchor(startDir) ?? path.resolve(startDir);
+  const visited = { count: 0 };
+  const candidates = [];
+  walkDescendants(anchor, 0, candidates, visited);
+  if (fs.existsSync(path.join(anchor, WORKSPACE_MARKER))) {
+    if (!candidates.find((c) => c.root === anchor)) {
+      candidates.unshift({ root: anchor });
+    }
+  }
+  return { anchor, candidates: candidates.map(deriveId) };
+}
+
+function walkDescendants(dir, depth, out, visited) {
+  if (depth > MAX_DEPTH) return;
+  if (++visited.count > MAX_VISITED) {
+    const e = new Error(
+      `Workspace discovery exceeded ${MAX_VISITED} directories from anchor. ` +
+      'Set COMPOSE_TARGET=/absolute/path to bypass discovery.',
+    );
+    e.code = 'WorkspaceDiscoveryTooBroad';
+    throw e;
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    // EACCES, EPERM, ENOENT (race with rm), ENOTDIR (symlink target gone) —
+    // skip silently. Discovery is best-effort; missing perms aren't fatal.
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
+    const child = path.join(dir, entry.name);
+    if (fs.existsSync(path.join(child, WORKSPACE_MARKER))) {
+      out.push({ root: child });
+    }
+    walkDescendants(child, depth + 1, out, visited);
+  }
+}
+
+/**
+ * Resolve {id, root, configPath} for a candidate workspace root.
+ * Honors `.compose/compose.json#workspaceId` if it matches the canonical regex;
+ * otherwise falls back to path.basename(root).
+ *
+ * Exported so resolve-workspace.js can derive ids without re-running discovery.
+ */
+export function deriveId({ root }) {
+  const configPath = path.join(root, '.compose', 'compose.json');
+  let id = path.basename(root);
+  try {
+    const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    if (
+      typeof cfg.workspaceId === 'string' &&
+      /^[a-z][a-z0-9-]{1,63}$/.test(cfg.workspaceId)
+    ) {
+      id = cfg.workspaceId;
+    }
+  } catch {
+    // missing/unreadable/malformed → basename is fine
+  }
+  return { id, root, configPath };
+}

package/lib/feature-events.js

@@ -52,6 +52,9 @@ export function appendEvent(cwd, event) {
   const row = {
     ts: new Date().toISOString(),
     actor: actor(),
+    // COMP-MCP-MIGRATION-1: stamp build correlation ID when running inside a
+    // build runner. Null outside of a build (manual CLI/MCP invocations).
+    build_id: process.env.COMPOSE_BUILD_ID || null,
     ...event,
   };
   appendFileSync(path, JSON.stringify(row) + '\n');

package/lib/feature-writer.js

@@ -24,6 +24,7 @@ const _listFeatures = listFeatures;
 import { writeRoadmap } from './roadmap-gen.js';
 import { appendEvent, readEvents } from './feature-events.js';
 import { checkOrInsert } from './idempotency.js';
+import { loadFeaturesDir } from './project-paths.js';
 
 // ---------------------------------------------------------------------------
 // Status / transition policy
@@ -98,8 +99,9 @@ export async function addRoadmapEntry(cwd, args) {
     throw new Error(`feature-writer: invalid status "${status}"`);
   }
 
+  const featuresDir = loadFeaturesDir(cwd);
   return maybeIdempotent({ ...args, cwd }, () => {
-    const existing = readFeature(cwd, args.code);
+    const existing = readFeature(cwd, args.code, featuresDir);
     if (existing) {
       throw new Error(`feature-writer: feature "${args.code}" already exists`);
     }
@@ -116,14 +118,14 @@ export async function addRoadmapEntry(cwd, args) {
     if (args.complexity) feature.complexity = args.complexity;
     feature.position = args.position !== undefined
       ? args.position
-      : nextPositionInPhase(cwd, args.phase);
+      : nextPositionInPhase(cwd, args.phase, featuresDir);
     if (args.parent) feature.parent = args.parent;
     if (args.tags && args.tags.length) feature.tags = args.tags;
 
-    writeFeature(cwd, feature);
+    writeFeature(cwd, feature, featuresDir);
     let roadmapPath;
     try {
-      roadmapPath = writeRoadmap(cwd);
+      roadmapPath = writeRoadmap(cwd, { featuresDir });
     } catch (err) {
       throw partialWriteError(
         `add_roadmap_entry: feature.json for "${args.code}" was written but ROADMAP.md regeneration failed. ` +
@@ -151,8 +153,8 @@ export async function addRoadmapEntry(cwd, args) {
 
 // Default position for a new feature: max existing position in the same
 // phase, plus 1. Falls back to 1 when the phase is empty.
-function nextPositionInPhase(cwd, phase) {
-  const peers = _listFeatures(cwd).filter(f => f.phase === phase);
+function nextPositionInPhase(cwd, phase, featuresDir) {
+  const peers = _listFeatures(cwd, featuresDir).filter(f => f.phase === phase);
   if (peers.length === 0) return 1;
   const maxPos = peers.reduce((m, f) => {
     const p = typeof f.position === 'number' ? f.position : 0;
@@ -205,8 +207,9 @@ export async function setFeatureStatus(cwd, args) {
     throw new Error(`feature-writer: invalid status "${args.status}" — must be one of ${[...STATUSES].join(', ')}`);
   }
 
+  const featuresDir = loadFeaturesDir(cwd);
   return maybeIdempotent({ ...args, cwd }, () => {
-    const feature = readFeature(cwd, args.code);
+    const feature = readFeature(cwd, args.code, featuresDir);
     if (!feature) {
       throw new Error(`feature-writer: feature "${args.code}" not found`);
     }
@@ -229,9 +232,9 @@ export async function setFeatureStatus(cwd, args) {
 
     const updates = { status: to };
     if (args.commit_sha) updates.commit_sha = args.commit_sha;
-    updateFeature(cwd, args.code, updates);
+    updateFeature(cwd, args.code, updates, featuresDir);
     try {
-      writeRoadmap(cwd);
+      writeRoadmap(cwd, { featuresDir });
     } catch (err) {
       throw partialWriteError(
         `set_feature_status: feature.json for "${args.code}" was updated (${from} → ${to}) but ROADMAP.md regeneration failed. ` +
@@ -269,12 +272,17 @@ export async function setFeatureStatus(cwd, args) {
  */
 export function roadmapDiff(cwd, args = {}) {
   const since = args.since ?? '24h';
-  const events = readEvents(cwd, {
+  const rawEvents = readEvents(cwd, {
     since,
     code: args.feature_code,
     tool: args.tool,
   });
 
+  // Filter out internal reconciliation events that aren't user-driven mutations.
+  // `roadmap_drift` events fire when a curated phase override diverges from
+  // the auto-rollup; they're observability output, not roadmap changes.
+  const events = rawEvents.filter(e => e.tool !== 'roadmap_drift');
+
   const added = [];
   const status_changed = [];
   for (const e of events) {
@@ -336,14 +344,14 @@ function validateRepoPath(cwd, path) {
   return normalized;
 }
 
-function rejectCanonicalArtifact(featureCode, normalizedPath) {
-  // Reject paths like docs/features/<CODE>/design.md, prd.md, etc.
+function rejectCanonicalArtifact(featuresDir, featureCode, normalizedPath) {
+  // Reject paths like <featuresDir>/<CODE>/design.md, prd.md, etc.
   const file = basename(normalizedPath);
   if (!CANONICAL_ARTIFACT_NAMES.has(file)) return;
   // The canonical files live under the feature folder. If this path points
   // inside the feature's own folder, refuse — those are auto-discovered.
   const parent = dirname(normalizedPath);
-  if (parent.endsWith(`docs/features/${featureCode}`)) {
+  if (parent.endsWith(`${featuresDir}/${featureCode}`)) {
     throw new Error(
       `feature-writer: "${file}" inside the feature folder is a canonical artifact; ` +
       `it is auto-discovered by assess_feature_artifacts and should not be linked explicitly.`
@@ -371,10 +379,11 @@ export async function linkArtifact(cwd, args) {
     throw new Error('feature-writer: artifact_type is required (non-empty string)');
   }
   const normalizedPath = validateRepoPath(cwd, args.path);
-  rejectCanonicalArtifact(args.feature_code, normalizedPath);
+  const featuresDir = loadFeaturesDir(cwd);
+  rejectCanonicalArtifact(featuresDir, args.feature_code, normalizedPath);
 
   return maybeIdempotent({ ...args, cwd }, () => {
-    const feature = readFeature(cwd, args.feature_code);
+    const feature = readFeature(cwd, args.feature_code, featuresDir);
     if (!feature) {
       throw new Error(`feature-writer: feature "${args.feature_code}" not found`);
     }
@@ -399,7 +408,7 @@ export async function linkArtifact(cwd, args) {
     if (matchIdx !== -1) artifacts[matchIdx] = entry;
     else artifacts.push(entry);
 
-    updateFeature(cwd, args.feature_code, { artifacts });
+    updateFeature(cwd, args.feature_code, { artifacts }, featuresDir);
 
     safeAppendEvent(cwd, {
       tool: 'link_artifact',
@@ -443,8 +452,9 @@ export async function linkFeatures(cwd, args) {
     );
   }
 
+  const featuresDir = loadFeaturesDir(cwd);
   return maybeIdempotent({ ...args, cwd }, () => {
-    const feature = readFeature(cwd, args.from_code);
+    const feature = readFeature(cwd, args.from_code, featuresDir);
     if (!feature) {
       throw new Error(`feature-writer: feature "${args.from_code}" not found`);
     }
@@ -464,7 +474,7 @@ export async function linkFeatures(cwd, args) {
     if (matchIdx !== -1) links[matchIdx] = entry;
     else links.push(entry);
 
-    updateFeature(cwd, args.from_code, { links });
+    updateFeature(cwd, args.from_code, { links }, featuresDir);
 
     safeAppendEvent(cwd, {
       tool: 'link_features',
@@ -498,7 +508,8 @@ export async function linkFeatures(cwd, args) {
  */
 export async function getFeatureArtifacts(cwd, args) {
   validateCode(args.feature_code);
-  const feature = readFeature(cwd, args.feature_code);
+  const featuresDir = loadFeaturesDir(cwd);
+  const feature = readFeature(cwd, args.feature_code, featuresDir);
   if (!feature) {
     throw new Error(`feature-writer: feature "${args.feature_code}" not found`);
   }
@@ -514,7 +525,7 @@ export async function getFeatureArtifacts(cwd, args) {
   let canonical = null;
   try {
     const { ArtifactManager } = await import('../server/artifact-manager.js');
-    const featureRoot = resolve(realCwd, 'docs', 'features');
+    const featureRoot = resolve(realCwd, featuresDir);
     if (existsSync(featureRoot)) {
       const manager = new ArtifactManager(featureRoot);
       canonical = manager.assess(args.feature_code);
@@ -549,10 +560,11 @@ export function getFeatureLinks(cwd, args) {
   }
   const kind = args.kind;
 
+  const featuresDir = loadFeaturesDir(cwd);
   const out = { feature_code: args.feature_code };
 
   if (direction === 'outgoing' || direction === 'both') {
-    const feature = readFeature(cwd, args.feature_code);
+    const feature = readFeature(cwd, args.feature_code, featuresDir);
     if (!feature) {
       throw new Error(`feature-writer: feature "${args.feature_code}" not found`);
     }
@@ -562,7 +574,7 @@ export function getFeatureLinks(cwd, args) {
   }
 
   if (direction === 'incoming' || direction === 'both') {
-    const all = _listFeatures(cwd);
+    const all = _listFeatures(cwd, featuresDir);
     const incoming = [];
     for (const f of all) {
       if (f.code === args.feature_code) continue;