@smartmemory/compose 0.2.37-beta → 0.2.39-beta

package/lib/deps.js

@@ -73,7 +73,14 @@ export function checkExternalSkills(deps, home = homedir()) {
 
   const bareInstalled = new Set()
   const namespacedInstalled = new Set()
-  const addNs = (ns, leaf) => namespacedInstalled.add(`${ns}:${leaf}`)
+  // Leaf names of namespaced (plugin-provided) skills. Claude Code surfaces many
+  // plugin skills under their bare leaf name (e.g. coder-config's `refactor`),
+  // so a bare manifest dep is satisfied by a same-leaf plugin skill.
+  const namespacedLeaves = new Set()
+  const addNs = (ns, leaf) => {
+    namespacedInstalled.add(`${ns}:${leaf}`)
+    namespacedLeaves.add(leaf)
+  }
 
   // Helpers: list only entries of a given dirent kind, swallow scandir errors.
   const listDirs = (path) => {
@@ -139,7 +146,12 @@ export function checkExternalSkills(deps, home = homedir()) {
   const missing = []
   for (const dep of deps.external_skills) {
     const isNamespaced = dep.id.includes(':')
-    const found = isNamespaced ? namespacedInstalled.has(dep.id) : bareInstalled.has(dep.id)
+    // Namespaced dep: require the exact <plugin>:<skill> match.
+    // Bare dep: a user skill at ~/.claude/skills/<id>/ OR any plugin skill whose
+    // leaf name is <id> (Claude Code exposes those under the bare name).
+    const found = isNamespaced
+      ? namespacedInstalled.has(dep.id)
+      : (bareInstalled.has(dep.id) || namespacedLeaves.has(dep.id))
     if (found) present.push(dep); else missing.push(dep)
   }
 

package/lib/discover-workspaces.js

@@ -2,8 +2,13 @@
  * 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
+ * subtree to MAX_DEPTH for `.compose/` markers. The scan prunes aggressively —
+ * a workspace root is never a dot-directory (`.foo`) or a vendor/build/cache dir,
+ * so those whole subtrees are skipped. This keeps the visit count proportional to
+ * real source directories (a large monorepo scans in tens of ms), not to incidental
+ * tooling cruft. A generous MAX_VISITED cap remains as a backstop against
+ * pathological roots (e.g. $HOME); over-cap throws code='WorkspaceDiscoveryTooBroad',
+ * which resolveWorkspace degrades to the nearest enclosing workspace. Permission
  * errors during readdir are skipped silently — discovery is best-effort, not
  * authoritative for individual subtrees.
  *
@@ -17,9 +22,27 @@ 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']);
+// Non-dot directories that never contain a workspace root but are often huge.
+// (Dot-directories are pruned separately — see shouldSkipDir.)
+export const SKIP_DIRS = new Set([
+  'node_modules', 'dist', 'build', 'out', 'coverage',
+  'vendor', 'target', '__pycache__', 'venv',
+]);
 export const MAX_DEPTH = 3;
-export const MAX_VISITED = 500;
+// Generous backstop, not a tuning knob. With dot/vendor pruning the visit count
+// tracks real source dirs (~1.5k for a large monorepo, scanned in tens of ms),
+// so this only trips on pathological roots like $HOME.
+export const MAX_VISITED = 10000;
+
+/**
+ * A workspace root is always a normal project directory — never a dot-directory
+ * (`.git`, `.venv`, `.playwright-mcp`, …) and never a vendor/build/cache dir.
+ * Pruning these whole subtrees is both correct (no marker can live there) and
+ * the single biggest cost lever for discovery on real repos.
+ */
+export function shouldSkipDir(name) {
+  return name.startsWith('.') || SKIP_DIRS.has(name);
+}
 
 /**
  * Walk upward from startDir; return the first directory containing any
@@ -75,7 +98,7 @@ function walkDescendants(dir, depth, out, visited) {
     return;
   }
   for (const entry of entries) {
-    if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
+    if (!entry.isDirectory() || shouldSkipDir(entry.name)) continue;
     const child = path.join(dir, entry.name);
     if (fs.existsSync(path.join(child, WORKSPACE_MARKER))) {
       out.push({ root: child });

package/lib/resolve-workspace.js

@@ -5,7 +5,9 @@
  *   1. explicit hint.workspaceId  (cheap upward walk first; falls back to discovery)
  *   2. COMPOSE_TARGET env         (absolute path bypasses discovery; id routes through it)
  *   3. hint.getBinding() (MCP binding)
- *   4. discovery (auto-pick when exactly one candidate; throws otherwise)
+ *   4. discovery (auto-pick when exactly one candidate; throws otherwise) —
+ *      degrades to the nearest-enclosing workspace if the subtree is too broad
+ *      to enumerate within the visit bound.
  *
  * Throws structured errors with `.code`: WorkspaceUnknown, WorkspaceAmbiguous,
  * WorkspaceIdCollision, WorkspaceUnset. The CLI's dieOnWorkspaceError consumes them.
@@ -13,6 +15,14 @@
  * Design intent: explicit-flag path uses findWorkspaceById (cheap upward walk)
  * BEFORE invoking discoverWorkspaces — this lets users escape WorkspaceDiscoveryTooBroad
  * by passing --workspace=<ancestor-id>. A descendant id still routes through discovery.
+ *
+ * The no-hint path mirrors that instinct only when the descendant scan can't
+ * enumerate the subtree (WorkspaceDiscoveryTooBroad): rather than failing, it
+ * falls back to the nearest enclosing `.compose` ancestor (upward walk), so
+ * running from a large workspace root resolves instead of dying. A tractable
+ * tree is still enumerated in full — genuine nested-workspace ambiguity (a
+ * parent workspace with a child below it) deliberately surfaces and forces an
+ * explicit --workspace.
  */
 import path from 'node:path';
 import fs from 'node:fs';
@@ -96,8 +106,26 @@ export function resolveWorkspace(hint = {}) {
     }
   }
 
-  // 4. Discovery — collisions matter because we're auto-picking.
-  const { candidates } = discoverWorkspaces(cwd);
+  // 4. Discovery — fan out under the anchor; collisions/ambiguity matter
+  //    because we're auto-picking. A normal tree enumerates fine, so genuine
+  //    nested-workspace ambiguity (e.g. a parent workspace with a child below)
+  //    still surfaces as WorkspaceAmbiguous and forces an explicit --workspace.
+  let candidates;
+  try {
+    ({ candidates } = discoverWorkspaces(cwd));
+  } catch (err) {
+    // The subtree was too large to enumerate within the visit bound. That cap
+    // is a cost guard, not a verdict — if cwd is itself inside a workspace, the
+    // nearest enclosing `.compose` ancestor is the unambiguous answer, so we
+    // degrade to it instead of failing (best-effort, same philosophy as the
+    // scan silently skipping EACCES subtrees). Only when cwd is inside NO
+    // workspace must the caller disambiguate explicitly — then we rethrow.
+    if (err.code === 'WorkspaceDiscoveryTooBroad') {
+      const enclosing = findEnclosingWorkspace(cwd);
+      if (enclosing) return { ...deriveId({ root: enclosing }), source: 'discovery' };
+    }
+    throw err;
+  }
   detectCollisions(candidates);
   if (candidates.length === 0) throw new WorkspaceUnset();
   if (candidates.length === 1) return { ...candidates[0], source: 'discovery' };
@@ -124,6 +152,25 @@ function findWorkspaceById(startDir, targetId) {
   }
 }
 
+/**
+ * Cheap upward-only lookup: walk ancestors from startDir and return the first
+ * directory containing a `.compose/` marker, or null if none exists before the
+ * filesystem root. This is the no-hint "nearest enclosing workspace" resolver —
+ * identical walk to findWorkspaceById but id-agnostic (returns the closest
+ * workspace regardless of its derived id).
+ */
+function findEnclosingWorkspace(startDir) {
+  let dir = path.resolve(startDir);
+  const { root } = path.parse(dir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, '.compose'))) return dir;
+    if (dir === root) return null;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
 function resolveByIdScopedCollisionCheck(id, candidates, source) {
   const matching = candidates.filter((c) => c.id === id);
   if (matching.length === 0) throw new WorkspaceUnknown(id);

package/package.json

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