brainclaw 0.22.0 → 0.22.1

package/dist/core/repo-analysis.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import YAML from 'yaml';
 import { MEMORY_DIR } from './io.js';
 const MULTI_PROJECT_MARKERS = [
     'pnpm-workspace.yaml',
@@ -11,6 +12,32 @@ const MULTI_PROJECT_MARKERS = [
 const MULTI_PROJECT_DIRS = ['apps', 'packages', 'services'];
 export function analyzeRepository(cwd) {
     const reasons = [];
+    // ── Signal 1: Existing brainclaw config already declares multi-project ──
+    const configPath = path.join(cwd, MEMORY_DIR, 'config.yaml');
+    if (fs.existsSync(configPath)) {
+        try {
+            const raw = YAML.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (raw) {
+                const mode = raw.project_mode;
+                const projects = raw.projects;
+                const strategy = projects?.strategy ?? 'manual';
+                const knownCount = Array.isArray(projects?.known) ? projects.known.length : 0;
+                if (mode === 'multi-project' || strategy === 'folder' || knownCount > 0) {
+                    reasons.push(`Existing brainclaw config: project_mode=${mode ?? 'auto'}, strategy=${strategy}` +
+                        (knownCount > 0 ? `, ${knownCount} known project(s)` : ''));
+                }
+            }
+        }
+        catch {
+            // Config unreadable — fall through to heuristic detection.
+        }
+    }
+    // ── Signal 2: Child brainclaw stores (subdirectories with .brainclaw/) ──
+    const scan = scanChildStoresShallow(cwd);
+    if (scan.length > 0) {
+        reasons.push(`Found ${scan.length} child brainclaw store(s): ${scan.join(', ')}`);
+    }
+    // ── Signal 3: Classic monorepo / workspace markers ──
     for (const marker of MULTI_PROJECT_MARKERS) {
         if (fs.existsSync(path.join(cwd, marker))) {
             reasons.push(`Found workspace marker: ${marker}`);
@@ -46,6 +73,33 @@ export function analyzeRepository(cwd) {
         reasons: ['No monorepo or multi-project markers detected'],
     };
 }
+/**
+ * Quick depth-1 scan for subdirectories that contain a .brainclaw/ store.
+ * Returns relative paths of child stores found.
+ */
+function scanChildStoresShallow(cwd) {
+    const childStores = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(cwd, { withFileTypes: true });
+    }
+    catch {
+        return childStores;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (SKIP_DIRS.has(entry.name))
+            continue;
+        if (entry.name.startsWith('.'))
+            continue;
+        const childBrainclaw = path.join(cwd, entry.name, MEMORY_DIR);
+        if (fs.existsSync(childBrainclaw)) {
+            childStores.push(entry.name);
+        }
+    }
+    return childStores;
+}
 /** Markers whose presence indicates a service/project boundary worth initialising. */
 const SERVICE_MARKERS = [
     'package.json',

package/dist/core/store-resolution.js

@@ -104,6 +104,13 @@ export function resolveContextStoreCwd(cwd = process.cwd(), target) {
     if (!absoluteTarget) {
         return cwd;
     }
+    // ── Fast path: walk from target upward to cwd looking for a child store ──
+    // This works regardless of project_mode or strategy configuration.
+    const childStore = findClosestStoreBelow(absoluteTarget, primary.cwd);
+    if (childStore) {
+        return childStore;
+    }
+    // ── Fallback: use workspace project discovery (folder mode, registry, etc.) ──
     let config;
     try {
         config = loadConfig(primary.cwd);
@@ -127,6 +134,37 @@ export function resolveContextStoreCwd(cwd = process.cwd(), target) {
     }
     return cwd;
 }
+/**
+ * Walk from `target` upward toward `ceiling` (exclusive), returning the first
+ * directory that contains a `.brainclaw/config.yaml`.  Returns undefined when
+ * no child store is found between target and ceiling.
+ *
+ * This deliberately bypasses workspace project discovery so that child stores
+ * are resolved even when the parent config is set to auto/manual mode.
+ */
+function findClosestStoreBelow(target, ceiling) {
+    const resolvedCeiling = path.resolve(ceiling);
+    // If target is a file, start from its parent directory
+    let current;
+    try {
+        current = fs.statSync(target).isDirectory() ? path.resolve(target) : path.resolve(path.dirname(target));
+    }
+    catch {
+        // Target doesn't exist on disk — try its parent as a directory
+        current = path.resolve(path.dirname(target));
+    }
+    while (current !== resolvedCeiling) {
+        const configPath = path.join(current, MEMORY_DIR, 'config.yaml');
+        if (fs.existsSync(configPath)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break; // filesystem root
+        current = parent;
+    }
+    return undefined;
+}
 /**
  * Return true if `dir` is at or below `ancestor` in the filesystem hierarchy.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainclaw",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "Shared project memory for humans and coding agents.",
   "type": "module",
   "bin": {