brainclaw 0.28.0 → 1.5.3

package/dist/commands/switch.js

@@ -1,12 +1,90 @@
 import path from 'node:path';
 import { loadActiveProject, saveActiveProject, clearActiveProject } from '../core/active-project.js';
+import { loadCurrentSession, saveCurrentSession } from '../core/identity.js';
 import { memoryExists } from '../core/io.js';
-import { resolveProjectRef, resolveWorkspaceRoot } from '../core/store-resolution.js';
+import { resolveProjectRef } from '../core/store-resolution.js';
 import { scanNestedBrainclawProjects } from '../core/workspace-projects.js';
 import { loadConfig } from '../core/config.js';
+/**
+ * Switch to a project programmatically.
+ * When sessionOnly=true (default for MCP), ONLY writes to the session state.
+ * This prevents agents from cross-contaminating each other's active project.
+ */
+export function switchProject(projectRef, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const wsRoot = findOutermostWorkspaceRoot(cwd);
+    if (!wsRoot) {
+        throw new Error('No brainclaw workspace found. Run `brainclaw init` first.');
+    }
+    const resolved = resolveProjectRef(projectRef, cwd);
+    if (!resolved) {
+        throw new Error(`Cannot resolve project "${projectRef}". Use bclaw_switch with list=true to see available projects.`);
+    }
+    let projectName;
+    try {
+        const config = loadConfig(resolved);
+        projectName = config.project_name;
+    }
+    catch { /* name is optional */ }
+    const now = new Date().toISOString();
+    const session = loadCurrentSession(cwd);
+    const sessionOnly = options.sessionOnly ?? true;
+    if (session && sessionOnly) {
+        saveCurrentSession({
+            ...session,
+            active_project: { path: resolved, name: projectName, switched_at: now },
+        }, cwd);
+        return { switched: true, path: resolved, name: projectName, scope: 'session', workspace_root: wsRoot };
+    }
+    if (session) {
+        // Also write to session even when not sessionOnly
+        saveCurrentSession({
+            ...session,
+            active_project: { path: resolved, name: projectName, switched_at: now },
+        }, cwd);
+    }
+    saveActiveProject(wsRoot, {
+        path: resolved,
+        name: projectName,
+        switched_at: now,
+        switched_by: process.env.BRAINCLAW_AGENT_NAME ?? process.env.USER ?? 'unknown',
+    });
+    return { switched: true, path: resolved, name: projectName, scope: 'global', workspace_root: wsRoot };
+}
+/**
+ * List available projects in the workspace.
+ */
+export function listAvailableProjects(cwd) {
+    const wsRoot = findOutermostWorkspaceRoot(cwd ?? process.cwd());
+    if (!wsRoot) {
+        throw new Error('No brainclaw workspace found.');
+    }
+    const active = loadActiveProject(wsRoot);
+    const projects = [];
+    if (memoryExists(wsRoot)) {
+        try {
+            const config = loadConfig(wsRoot);
+            projects.push({ name: config.project_name, path: wsRoot, relative_path: '.', active: active?.path === wsRoot });
+        }
+        catch {
+            projects.push({ path: wsRoot, relative_path: '.', active: active?.path === wsRoot });
+        }
+    }
+    const children = scanNestedBrainclawProjects(wsRoot, 7);
+    for (const child of children) {
+        const childPath = path.resolve(child.path);
+        if (childPath === wsRoot)
+            continue;
+        const rel = path.relative(wsRoot, childPath) || '.';
+        projects.push({ name: child.project_name, path: childPath, relative_path: rel, active: active?.path === childPath });
+    }
+    return { workspace_root: wsRoot, projects };
+}
 export function runSwitch(projectRef, options = {}) {
+    // Use real cwd, not effective cwd — switch must see the full workspace
     const cwd = options.cwd ?? process.cwd();
-    const wsRoot = resolveWorkspaceRoot(cwd);
+    // Walk up from real cwd to find the outermost .brainclaw/ (workspace root)
+    const wsRoot = findOutermostWorkspaceRoot(cwd);
     if (!wsRoot) {
         console.error('Error: no brainclaw workspace found. Run `brainclaw init` first.');
         process.exit(1);
@@ -18,6 +96,11 @@ export function runSwitch(projectRef, options = {}) {
     }
     // --clear: remove active project
     if (options.clear) {
+        const session = loadCurrentSession(cwd);
+        if (session?.active_project) {
+            const { active_project: _removed, ...rest } = session;
+            saveCurrentSession(rest, cwd);
+        }
         clearActiveProject(wsRoot);
         if (options.json) {
             console.log(JSON.stringify({ cleared: true }));
@@ -47,18 +130,35 @@ export function runSwitch(projectRef, options = {}) {
     catch {
         // name is optional
     }
-    saveActiveProject(wsRoot, {
-        path: resolved,
-        name: projectName,
-        switched_at: new Date().toISOString(),
-        switched_by: process.env.BRAINCLAW_AGENT_NAME ?? process.env.USER ?? 'unknown',
-    });
+    const now = new Date().toISOString();
+    const session = loadCurrentSession(cwd);
+    const scopedToSession = options.session ?? !!session;
+    let scope;
+    if (scopedToSession && session) {
+        // Write to session state — only this agent sees this switch
+        saveCurrentSession({
+            ...session,
+            active_project: { path: resolved, name: projectName, switched_at: now },
+        }, cwd);
+        scope = 'session';
+    }
+    else {
+        // Fall back to global active-project.json
+        saveActiveProject(wsRoot, {
+            path: resolved,
+            name: projectName,
+            switched_at: now,
+            switched_by: process.env.BRAINCLAW_AGENT_NAME ?? process.env.USER ?? 'unknown',
+        });
+        scope = 'global';
+    }
     if (options.json) {
-        console.log(JSON.stringify({ switched: true, path: resolved, name: projectName }));
+        console.log(JSON.stringify({ switched: true, path: resolved, name: projectName, scope }));
     }
     else {
         const rel = path.relative(wsRoot, resolved) || '.';
-        console.log(`✔ Switched to ${projectName ? `"${projectName}" (${rel})` : rel}`);
+        const scopeHint = scope === 'session' ? ' (session-scoped)' : '';
+        console.log(`✔ Switched to ${projectName ? `"${projectName}" (${rel})` : rel}${scopeHint}`);
     }
 }
 function showCurrent(wsRoot, json) {
@@ -138,4 +238,25 @@ function listProjects(wsRoot, json) {
         console.log('\nNo active project. Use `brainclaw switch <project>` to set one.');
     }
 }
+/**
+ * Find the outermost .brainclaw/ workspace root by walking UP from cwd.
+ * Unlike resolveWorkspaceRoot which may return the closest store,
+ * this returns the farthest one — the true multi-project workspace root.
+ */
+function findOutermostWorkspaceRoot(startDir) {
+    let dir = path.resolve(startDir);
+    const root = path.parse(dir).root;
+    const home = process.env.HOME || process.env.USERPROFILE || root;
+    let outermost;
+    while (dir !== root && dir !== home) {
+        if (memoryExists(dir)) {
+            outermost = dir; // keep going — we want the outermost
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return outermost;
+}
 //# sourceMappingURL=switch.js.map

package/dist/commands/trap.js

@@ -1,19 +1,14 @@
-import { loadState, persistState } from '../core/state.js';
 import { resolveCurrentAgentName } from '../core/agent-registry.js';
 import { resolveCurrentHostId } from '../core/host.js';
 import { loadConfig } from '../core/config.js';
-import { nowISO } from '../core/ids.js';
 import { scanText } from '../core/security.js';
-import { memoryExists } from '../core/io.js';
-import { generateTrapIdWithLabel, saveOperationalTrap } from '../core/traps.js';
+import { requireInitialized } from '../core/guards.js';
 import { validateCliInput, validateCliTtl } from '../core/input-validation.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
+import { createTrap } from '../core/operations/memory-write.js';
 export function runTrap(text, options = {}) {
     const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
-    if (!memoryExists(cwd)) {
-        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
-        process.exit(1);
-    }
+    requireInitialized(cwd);
     validateCliInput(text, options.tag);
     if (options.ttl) {
         validateCliTtl(options.ttl);
@@ -27,35 +22,23 @@ export function runTrap(text, options = {}) {
             process.exit(1);
         }
     }
-    const state = loadState(cwd);
-    const { id, short_label } = generateTrapIdWithLabel();
     const visibility = options.visibility ?? 'shared';
     const hostId = visibility === 'shared' ? undefined : resolveCurrentHostId(options.host);
-    const entry = {
-        id,
-        short_label,
+    const result = createTrap({
         text,
-        created_at: nowISO(),
         author: options.author ?? resolveCurrentAgentName(cwd),
-        status: options.status ?? 'active',
-        severity: options.severity ?? 'medium',
-        tags: options.tag ?? [],
-        related_paths: options.path,
-        plan_id: options.plan,
+        status: options.status,
+        severity: options.severity,
+        tags: options.tag,
+        relatedPaths: options.path,
+        planId: options.plan,
         visibility,
-        host_id: hostId,
-        expires_at: options.ttl ? parseTtl(options.ttl) : undefined,
-    };
-    if (visibility === 'shared') {
-        state.known_traps.push(entry);
-        persistState(state, cwd);
-    }
-    else {
-        saveOperationalTrap(entry, cwd);
-    }
-    const scopeInfo = visibility === 'shared' ? 'shared' : `${visibility}:${hostId}`;
+        hostId,
+        expiresAt: options.ttl ? parseTtl(options.ttl) : undefined,
+    }, cwd);
+    const scopeInfo = result.visibility === 'shared' ? 'shared' : `${result.visibility}:${result.hostId}`;
     const storeLabel = options.store && options.store !== 'local' ? ` [store:${options.store}]` : '';
-    console.log(`✔ Trap added: [${id}] (${scopeInfo}) ${text}${storeLabel}`);
+    console.log(`✔ Trap added: [${result.id}] (${scopeInfo}) ${text}${storeLabel}`);
 }
 /** Parse a TTL string like "30m", "2h", "7d" and return an ISO expiry timestamp. */
 function parseTtl(ttl) {

package/dist/commands/update-handoff.js

@@ -1,5 +1,67 @@
 import { loadState, persistState } from '../core/state.js';
 import { memoryExists } from '../core/io.js';
+import { nowISO } from '../core/ids.js';
+export function applyHandoffUpdates(handoff, options = {}) {
+    if (options.status)
+        handoff.status = options.status;
+    if (options.to !== undefined)
+        handoff.to = options.to;
+    if (options.narrative !== undefined)
+        handoff.narrative = options.narrative;
+    const contractUpdates = {};
+    for (const key of ['files_touched', 'pre_conditions', 'post_conditions', 'tests_to_verify', 'linked_plans']) {
+        const value = options[key];
+        if (Array.isArray(value)) {
+            contractUpdates[key] = value;
+        }
+    }
+    if (Object.keys(contractUpdates).length > 0) {
+        handoff.contract = { ...handoff.contract, ...contractUpdates };
+    }
+    const hasReviewUpdate = options.reviewer !== undefined ||
+        options.requester !== undefined ||
+        options.requested_at !== undefined ||
+        options.review_thread_id !== undefined ||
+        options.review_message_id !== undefined ||
+        options.review_verdict !== undefined ||
+        options.reviewed_by !== undefined ||
+        options.review_summary !== undefined ||
+        options.blocking_issues !== undefined ||
+        options.suggestions !== undefined;
+    if (hasReviewUpdate) {
+        const review = { ...(handoff.review ?? {}) };
+        if (options.reviewer !== undefined)
+            review.reviewer = options.reviewer;
+        if (options.requester !== undefined)
+            review.requester = options.requester;
+        if (options.requested_at !== undefined)
+            review.requested_at = options.requested_at;
+        if (options.review_thread_id !== undefined)
+            review.thread_id = options.review_thread_id;
+        if (options.review_message_id !== undefined)
+            review.message_id = options.review_message_id;
+        if (options.review_verdict !== undefined)
+            review.verdict = options.review_verdict;
+        if (options.reviewed_by !== undefined)
+            review.reviewed_by = options.reviewed_by;
+        if (options.review_summary !== undefined)
+            review.summary = options.review_summary;
+        if (options.blocking_issues !== undefined)
+            review.blocking_issues = options.blocking_issues;
+        if (options.suggestions !== undefined)
+            review.suggestions = options.suggestions;
+        const reviewCompleted = options.review_verdict !== undefined ||
+            options.reviewed_by !== undefined ||
+            options.review_summary !== undefined ||
+            options.blocking_issues !== undefined ||
+            options.suggestions !== undefined;
+        if (reviewCompleted) {
+            review.reviewed_at = nowISO();
+        }
+        handoff.review = review;
+    }
+    return handoff;
+}
 export function runUpdateHandoff(id, options = {}) {
     if (!memoryExists()) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
@@ -11,10 +73,7 @@ export function runUpdateHandoff(id, options = {}) {
         console.error(`Error: Handoff '${id}' not found.`);
         process.exit(1);
     }
-    if (options.status)
-        handoff.status = options.status;
-    if (options.to !== undefined)
-        handoff.to = options.to;
+    applyHandoffUpdates(handoff, options);
     persistState(state);
     console.log(`✔ Handoff updated: [${handoff.id}] ${handoff.from} → ${handoff.to} (${handoff.status})`);
 }

package/dist/commands/update-plan.js

@@ -1,35 +1,28 @@
-import { loadState, persistState } from '../core/state.js';
-import { memoryExists } from '../core/io.js';
-import { nowISO } from '../core/ids.js';
+import { requireInitialized } from '../core/guards.js';
+import { updatePlan } from '../core/operations/plan.js';
 export function runUpdatePlan(id, options = {}) {
-    if (!memoryExists(options.cwd)) {
-        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+    const cwd = options.cwd ?? process.cwd();
+    requireInitialized(cwd);
+    if (id.startsWith('stp_')) {
+        console.error(`Error: '${id}' looks like a step ID, not a plan ID.`);
+        console.error('  Use: brainclaw complete-step <planId> <stepId>');
+        console.error('  Inspect the parent plan with: brainclaw plan show <planId>');
         process.exit(1);
     }
-    const state = loadState(options.cwd);
-    const plan = state.plan_items.find((item) => item.id === id);
-    if (!plan) {
-        console.error(`Error: Plan item '${id}' not found.`);
-        process.exit(1);
+    try {
+        const result = updatePlan({
+            id,
+            status: options.status,
+            assignee: options.assignee,
+            priority: options.priority,
+            actualEffort: options.actualEffort,
+        }, cwd);
+        console.log(`✔ Plan item updated: [${result.id}] ${result.text}`);
     }
-    const timestamp = nowISO();
-    if (options.status) {
-        plan.status = options.status;
-        if (options.status === 'in_progress' && !plan.started_at)
-            plan.started_at = timestamp;
-        if (options.status === 'done' && !plan.completed_at)
-            plan.completed_at = timestamp;
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
     }
-    if (options.assignee !== undefined)
-        plan.assignee = options.assignee;
-    if (options.project !== undefined)
-        plan.project = options.project;
-    if (options.priority)
-        plan.priority = options.priority;
-    if (options.actualEffort)
-        plan.actual_effort = options.actualEffort;
-    plan.updated_at = timestamp;
-    persistState(state, options.cwd);
-    console.log(`✔ Plan item updated: [${plan.id}] ${plan.text}`);
 }
 //# sourceMappingURL=update-plan.js.map

package/dist/commands/update-step.js

@@ -0,0 +1,37 @@
+import { requireInitialized } from '../core/guards.js';
+import { updateStep } from '../core/operations/plan.js';
+export function runUpdateStep(planId, stepId, options) {
+    requireInitialized(process.cwd());
+    const validStatuses = ['todo', 'in_progress', 'testing', 'done', 'blocked'];
+    if (options.status && !validStatuses.includes(options.status)) {
+        console.error(`Error: Invalid status '${options.status}'. Valid: ${validStatuses.join(', ')}`);
+        process.exit(1);
+    }
+    try {
+        const result = updateStep({
+            planId,
+            stepId,
+            status: options.status,
+            text: options.text,
+            assignee: options.assign,
+        });
+        const changes = [];
+        if (options.status)
+            changes.push(`status=${options.status}`);
+        if (options.text)
+            changes.push('text updated');
+        if (options.assign !== undefined)
+            changes.push(`assignee=${options.assign || 'unassigned'}`);
+        console.log(`✔ Step updated: [${result.stepId}] ${changes.join(', ')}`);
+        console.log(`  Plan [${result.planId}] progress: ${result.doneSteps}/${result.totalSteps} steps done`);
+        if (result.planAutoCompleted) {
+            console.log(`  All steps done — plan auto-completed.`);
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=update-step.js.map