@smartmemory/compose 0.1.8-beta → 0.1.10-beta

package/server/compose-mcp.js

@@ -59,7 +59,12 @@ import {
   toolGetCompletions,
   toolValidateFeature,
   toolValidateProject,
+  toolSetWorkspace,
+  toolGetWorkspace,
+  _getBinding,
 } from './compose-mcp-tools.js';
+import { switchProject, getTargetRoot } from './project-root.js';
+import { resolveWorkspace } from '../lib/resolve-workspace.js';
 
 // ---------------------------------------------------------------------------
 // Tool definitions
@@ -151,6 +156,20 @@ const TOOLS = [
       required: ['featureCode'],
     },
   },
+  {
+    name: 'set_workspace',
+    description: 'Bind this MCP session to a workspace. Required when cwd contains multiple workspaces. Lives in process memory; lost on MCP restart.',
+    inputSchema: {
+      type: 'object',
+      required: ['workspaceId'],
+      properties: { workspaceId: { type: 'string', description: 'Workspace ID (kebab-case)' } },
+    },
+  },
+  {
+    name: 'get_workspace',
+    description: 'Get the current MCP workspace binding plus all candidates discovered from cwd.',
+    inputSchema: { type: 'object', properties: {} },
+  },
   {
     name: 'get_feature_lifecycle',
     description: 'Get the lifecycle state of a feature: current phase, phase history, artifacts, warnings.',
@@ -570,7 +589,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args = {} } = request.params;
 
+  const WORKSPACE_EXEMPT = new Set(['set_workspace', 'get_workspace']);
+
   try {
+    if (!WORKSPACE_EXEMPT.has(name)) {
+      const ws = resolveWorkspace({ getBinding: _getBinding });
+      if (ws.root !== getTargetRoot()) switchProject(ws.root);
+    }
     let result;
     switch (name) {
       case 'get_vision_items':    result = toolGetVisionItems(args); break;
@@ -579,6 +604,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'get_blocked_items':   result = toolGetBlockedItems(); break;
       case 'get_current_session': result = await toolGetCurrentSession(args); break;
       case 'bind_session':             result = await toolBindSession(args); break;
+      case 'set_workspace':            result = toolSetWorkspace(args); break;
+      case 'get_workspace':            result = toolGetWorkspace(); break;
       case 'get_feature_lifecycle':    result = toolGetFeatureLifecycle(args); break;
       case 'kill_feature':             result = await toolKillFeature(args); break;
       case 'complete_feature':         result = await toolCompleteFeature(args); break;
@@ -624,6 +651,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     let text = err && err.code
       ? `Error [${err.code}]: ${err.message}`
       : `Error: ${err.message}`;
+    // For workspace ambiguity, include the candidate list and the call to fix it
+    // so Claude can prompt the user without a follow-up tool call.
+    if (err && err.code === 'WorkspaceAmbiguous' && Array.isArray(err.candidates)) {
+      text += '\n\nCandidates:';
+      for (const c of err.candidates) text += `\n  - ${c.id}  (${c.root})`;
+      text += '\n\nNext step: call set_workspace({"workspaceId": "<id>"}) and retry.';
+    }
+    if (err && err.code === 'WorkspaceIdCollision' && Array.isArray(err.roots)) {
+      text += `\n\nworkspaceId "${err.id}" is used by multiple roots:`;
+      for (const r of err.roots) text += `\n  - ${r}`;
+      text += '\n\nFix: set an explicit workspaceId in each .compose/compose.json.';
+    }
+    if (err && err.code === 'WorkspaceUnset') {
+      text += '\n\nNo .compose/ workspace was found. Run `compose init` to scaffold one.';
+    }
     if (err && err.cause && typeof err.cause.message === 'string') {
       text += err.cause.code
         ? `\n  Caused by [${err.cause.code}]: ${err.cause.message}`

package/server/design-routes.js

@@ -468,15 +468,18 @@ Output ONLY the Markdown content, no code fences.`;
       if (scope === 'feature' && featureCode) {
         try {
           const apiBase = `http://127.0.0.1:${process.env.PORT || 4001}`;
+          const wsHeaders = req.workspace?.id ? { 'X-Compose-Workspace-Id': req.workspace.id } : {};
           // Look up the vision item for this featureCode
-          const itemsRes = await fetch(`${apiBase}/api/vision/items?keyword=${encodeURIComponent(featureCode)}`);
+          const itemsRes = await fetch(`${apiBase}/api/vision/items?keyword=${encodeURIComponent(featureCode)}`, {
+            headers: { ...wsHeaders },
+          });
           const itemsData = await itemsRes.json();
           const featureItem = itemsData.items?.find(i =>
             i.title?.startsWith(featureCode) || i.lifecycle?.featureCode === featureCode || i.featureCode === featureCode
           );
           await fetch(`${apiBase}/api/vision/gates`, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: { 'Content-Type': 'application/json', ...wsHeaders },
             body: JSON.stringify({
               flowId: `design-${featureCode}`,
               stepId: 'design_gate',

package/server/index.js

@@ -9,6 +9,8 @@ import { VisionServer } from './vision-server.js';
 import { SessionManager } from './session-manager.js';
 import { scanFeatures, seedFeatures, scanSubPackages, seedSubPackages, seedFromRoadmapGraph } from './feature-scan.js';
 import { attachGraphExportRoutes } from './graph-export.js';
+import { attachWorkspaceRoutes } from './workspace-routes.js';
+import { createWorkspaceMiddleware } from './workspace-middleware.js';
 import { getTargetRoot, getDataDir, ensureDataDir, loadProjectConfig, resolveProjectPath, switchProject } from './project-root.js';
 
 // Load project config and verify stratum capability matches reality
@@ -47,6 +49,9 @@ const app = express();
 app.use(cors({ origin: /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/ }));
 app.use(express.json());
 
+attachWorkspaceRoutes(app);
+app.use(createWorkspaceMiddleware());
+
 app.get('/api/health', (_req, res) => res.json({ ok: true }));
 app.get('/api/status', (_req, res) => res.json({ session: 2, phase: '0.4-brainstorm', upSince: new Date().toISOString() }));
 

package/server/project-root.js

@@ -48,6 +48,10 @@ export function getTargetRoot() { return _targetRoot; }
 /** Data directory for Compose state. Lives in the target project. */
 export function getDataDir() { return _dataDir; }
 
+let _currentWorkspaceId = null;
+export function getCurrentWorkspaceId() { return _currentWorkspaceId; }
+export function setCurrentWorkspaceId(id) { _currentWorkspaceId = id; }
+
 // ---------------------------------------------------------------------------
 // Switch project at runtime
 // ---------------------------------------------------------------------------

package/server/workspace-middleware.js

@@ -0,0 +1,120 @@
+/**
+ * workspace-middleware.js — Express middleware that resolves the per-request
+ * workspace from the `X-Compose-Workspace-Id` header and attaches it as
+ * `req.workspace = { id, root, source, configPath? }`.
+ *
+ * Behavior (v1):
+ *   - Exempt paths (/api/workspace, /api/project/switch, /api/health) bypass
+ *     resolution entirely and get `req.workspace.source = 'exempt'`.
+ *   - Header present + valid → resolveWorkspace() result, source carried through.
+ *   - Header absent + soft fallback enabled → fallback to getTargetRoot() with
+ *     the `X-Compose-Workspace-Fallback: true` response header. Applies to
+ *     ALL methods in v1 (GET and POST alike).
+ *   - Resolver errors map to HTTP via mapResolverErrorToResponse:
+ *       WorkspaceUnknown          → 400 { error, code, id }
+ *       WorkspaceAmbiguous        → 409 { error, code, candidates }
+ *       WorkspaceIdCollision      → 409 { error, code, roots }
+ *       WorkspaceDiscoveryTooBroad → 400 { error, code }
+ *       (anything else)           → 500 { error: '...' }
+ *
+ * Roadmap: COMP-WORKSPACE-HTTP T3.
+ */
+import { getTargetRoot } from './project-root.js';
+import {
+  resolveWorkspace,
+  WorkspaceUnknown,
+  WorkspaceAmbiguous,
+  WorkspaceIdCollision,
+} from '../lib/resolve-workspace.js';
+
+const EXEMPT_PATHS = new Set([
+  '/api/workspace',
+  '/api/project/switch',
+  '/api/health',
+]);
+
+/**
+ * Factory for the Express middleware.
+ *
+ * @param {object} [opts]
+ * @param {boolean} [opts.allowGetFallback=true] — when true, requests without
+ *   the workspace header soft-fallback to the target root with a hint header.
+ *   When false, missing header surfaces as a WorkspaceUnknown(null) → 400.
+ */
+export function createWorkspaceMiddleware({ allowGetFallback = true } = {}) {
+  return function workspaceMiddleware(req, res, next) {
+    if (EXEMPT_PATHS.has(req.path)) {
+      req.workspace = { id: null, root: getTargetRoot(), source: 'exempt' };
+      return next();
+    }
+
+    const headerId = req.headers['x-compose-workspace-id'];
+
+    try {
+      if (!headerId) {
+        if (allowGetFallback) {
+          req.workspace = { id: null, root: getTargetRoot(), source: 'fallback' };
+          res.setHeader('X-Compose-Workspace-Fallback', 'true');
+          return next();
+        }
+        // Hard-fail mode: missing header is treated as an unknown id.
+        throw new WorkspaceUnknown(null);
+      }
+      const resolved = resolveWorkspace({
+        workspaceId: headerId,
+        cwd: getTargetRoot(),
+      });
+      req.workspace = resolved;
+      next();
+    } catch (err) {
+      mapResolverErrorToResponse(err, res, next);
+    }
+  };
+}
+
+/**
+ * Translate a resolver error into a JSON HTTP response.
+ *
+ * @param {Error} err
+ * @param {import('express').Response} res
+ * @param {import('express').NextFunction} [next] — optional; if provided,
+ *   truly unknown errors are forwarded to it instead of generating a 500.
+ */
+export function mapResolverErrorToResponse(err, res, next) {
+  if (err instanceof WorkspaceUnknown || err?.code === 'WorkspaceUnknown') {
+    return res.status(400).json({
+      error: err.message,
+      code: 'WorkspaceUnknown',
+      id: err.id ?? null,
+    });
+  }
+  if (err instanceof WorkspaceAmbiguous || err?.code === 'WorkspaceAmbiguous') {
+    return res.status(409).json({
+      error: err.message,
+      code: 'WorkspaceAmbiguous',
+      candidates: err.candidates ?? [],
+    });
+  }
+  if (err instanceof WorkspaceIdCollision || err?.code === 'WorkspaceIdCollision') {
+    return res.status(409).json({
+      error: err.message,
+      code: 'WorkspaceIdCollision',
+      roots: err.roots ?? [],
+    });
+  }
+  if (err?.code === 'WorkspaceDiscoveryTooBroad') {
+    return res.status(400).json({
+      error: err.message,
+      code: 'WorkspaceDiscoveryTooBroad',
+    });
+  }
+  if (typeof next === 'function') {
+    return next(err);
+  }
+  return res.status(500).json({
+    error: err?.message || 'Internal workspace resolver error',
+    code: err?.code || 'WorkspaceResolverInternalError',
+  });
+}
+
+export { EXEMPT_PATHS };

package/server/workspace-routes.js

@@ -0,0 +1,25 @@
+/**
+ * workspace-routes.js — boot-deterministic workspace identity endpoint.
+ *
+ * Mounts GET /api/workspace, returning the workspace resolved at boot time.
+ * No descendant discovery, no ambiguity check, no resolveWorkspace() call —
+ * this is the bootstrap endpoint the frontend hits BEFORE it has a workspace
+ * id to send (per design SD-2 of COMP-WORKSPACE-HTTP).
+ *
+ * Response shape: { id, root, source: 'boot' }
+ *   - id    — string, derived via deriveId({ root }).id
+ *   - root  — absolute path of the boot target
+ *   - source — always 'boot' for this endpoint
+ */
+import { getTargetRoot } from './project-root.js';
+import { deriveId } from '../lib/discover-workspaces.js';
+
+export function attachWorkspaceRoutes(app) {
+  app.get('/api/workspace', (req, res) => {
+    const root = getTargetRoot();
+    // deriveId returns { id, root, configPath } — destructure the id only.
+    // The route deliberately does NOT leak configPath to the client.
+    const { id } = deriveId({ root });
+    res.json({ id, root, source: 'boot' });
+  });
+}

package/dist/assets/channel-DDkv7DUd.js

@@ -1 +0,0 @@
-import{aq as o,ar as n}from"./index-Ceywghsu.js";const t=(r,a)=>o.lang.round(n.parse(r)[a]);export{t as c};

package/dist/assets/classDiagram-6PBFFD2Q-J6ZTeCbW.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-4TB4RGXK-zdSZGRS2.js";import{_ as i}from"./index-Ceywghsu.js";import"./chunk-FMBD7UC4-CdkRK5Hx.js";import"./chunk-YZCP3GAM-DbNARKip.js";import"./chunk-55IACEB6-6zqzTZQQ.js";import"./chunk-EDXVE4YY-frd1Vwf-.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/assets/classDiagram-v2-HSJHXN6E-J6ZTeCbW.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-4TB4RGXK-zdSZGRS2.js";import{_ as i}from"./index-Ceywghsu.js";import"./chunk-FMBD7UC4-CdkRK5Hx.js";import"./chunk-YZCP3GAM-DbNARKip.js";import"./chunk-55IACEB6-6zqzTZQQ.js";import"./chunk-EDXVE4YY-frd1Vwf-.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/assets/clone-5MVZ89iV.js

@@ -1 +0,0 @@
-import{b as r}from"./graph-orv1XHGx.js";var e=4;function a(o){return r(o,e)}export{a as c};

package/dist/assets/stateDiagram-v2-QKLJ7IA2-CyY84hEA.js

@@ -1 +0,0 @@
-import{s as t,b as r,a,S as s}from"./chunk-OYMX7WX6-C6bMB0cf.js";import{_ as i}from"./index-Ceywghsu.js";import"./chunk-55IACEB6-6zqzTZQQ.js";import"./chunk-EDXVE4YY-frd1Vwf-.js";var l={parser:a,get db(){return new s(2)},renderer:r,styles:t,init:i(e=>{e.state||(e.state={}),e.state.arrowMarkerAbsolute=e.arrowMarkerAbsolute},"init")};export{l as diagram};