brainclaw 0.19.2

package/dist/commands/sync.js

@@ -0,0 +1,159 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { memoryExists } from '../core/io.js';
+import { loadState } from '../core/state.js';
+import { listCandidates } from '../core/candidates.js';
+import { listClaims } from '../core/claims.js';
+import { listRuntimeNotes } from '../core/runtime.js';
+import { listOperationalTraps } from '../core/traps.js';
+import { pullRemoteMemory, pushRemoteMemory } from '../core/sync-remote.js';
+export function runSync(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    // --remote: pull + show summary + push
+    if (options.remote) {
+        console.log('Remote sync: pull → summarize → push');
+        console.log('');
+        const pullResult = pullRemoteMemory({});
+        if (pullResult.success) {
+            console.log(`  Pull: ✔ ${pullResult.message}`);
+        }
+        else {
+            console.error(`  Pull: ✗ ${pullResult.message}`);
+            process.exit(1);
+        }
+        const pushResult = pushRemoteMemory({});
+        if (pushResult.success) {
+            console.log(`  Push: ✔ ${pushResult.message}`);
+        }
+        else {
+            console.error(`  Push: ✗ ${pushResult.message}`);
+            process.exit(1);
+        }
+        return;
+    }
+    // Summarize current memory state
+    const state = loadState(options.cwd);
+    const pending = listCandidates('pending', options.cwd);
+    const claims = listClaims(options.cwd).filter(c => c.status === 'active');
+    const sharedNotes = listRuntimeNotes({ visibility: 'shared' }, options.cwd);
+    const machineNotes = listRuntimeNotes({ visibility: 'machine' }, options.cwd);
+    const privateNotes = listRuntimeNotes({ visibility: 'private' }, options.cwd);
+    const machineTraps = listOperationalTraps({ visibility: 'machine' }, options.cwd);
+    const privateTraps = listOperationalTraps({ visibility: 'private' }, options.cwd);
+    const activePlans = state.plan_items.filter((plan) => plan.status !== 'done' && plan.status !== 'dropped');
+    console.log('Memory sync summary:');
+    console.log('');
+    console.log(`  State: ${activePlans.length} plans, ${state.active_constraints.length} constraints, ${state.recent_decisions.length} decisions, ${state.known_traps.length} traps, ${state.open_handoffs.length} handoffs`);
+    console.log(`  Pending candidates: ${pending.length}`);
+    console.log(`  Active claims: ${claims.length}`);
+    console.log(`  Runtime notes: ${sharedNotes.length} shared, ${machineNotes.length} machine-local, ${privateNotes.length} private`);
+    console.log(`  Local traps: ${machineTraps.length} machine-local, ${privateTraps.length} private`);
+    const scopePaths = resolveScopePaths(options.scope, options.includeMachineRuntime ?? false, options.cwd);
+    const pathSpec = scopePaths.join(' ');
+    console.log(`  Sync scope: ${pathSpec}`);
+    if (options.summaryOnly) {
+        console.log('');
+        console.log('  Summary-only mode enabled; skipping git status and commit checks.');
+        return;
+    }
+    // Check git status of .brainclaw/
+    let gitStatus = '';
+    try {
+        gitStatus = execSync(`git status --porcelain ${pathSpec}`, {
+            encoding: 'utf-8',
+            cwd: options.cwd ?? process.cwd(),
+            timeout: 5000,
+        }).trim();
+    }
+    catch {
+        console.log('');
+        console.log('  (not a git repo or git not available — skipping git status)');
+        return;
+    }
+    if (!gitStatus) {
+        console.log('');
+        console.log('  No uncommitted changes in .brainclaw/');
+        return;
+    }
+    const changed = gitStatus.split('\n').length;
+    console.log('');
+    console.log(`  ${changed} file(s) changed in .brainclaw/`);
+    if (options.commit) {
+        const msg = options.message ?? `chore: sync brainclaw (${new Date().toISOString().slice(0, 10)})`;
+        try {
+            execSync(`git add ${pathSpec}`, {
+                cwd: options.cwd ?? process.cwd(),
+                timeout: 5000,
+            });
+            execSync(`git commit -m "${msg.replace(/"/g, '\\"')}"`, {
+                encoding: 'utf-8',
+                cwd: options.cwd ?? process.cwd(),
+                timeout: 10000,
+            });
+            console.log(`✔ Committed .brainclaw/ changes: "${msg}"`);
+            console.log('  (not pushed — run `git push` when ready)');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error: failed to commit .brainclaw/ changes. ${message}`);
+            process.exit(1);
+        }
+    }
+    else {
+        console.log('  Run with --commit to create a local git commit.');
+    }
+}
+export function resolveScopePaths(scope, includeMachineRuntime = false, cwd) {
+    switch ((scope ?? 'all').toLowerCase()) {
+        case 'all':
+            return existingScopePaths([
+                '.brainclaw/config.yaml',
+                '.brainclaw/project.md',
+                '.brainclaw/memory/constraints/',
+                '.brainclaw/memory/decisions/',
+                '.brainclaw/memory/traps/',
+                '.brainclaw/coordination/handoffs/',
+                '.brainclaw/coordination/plans/',
+                '.brainclaw/memory/instructions/',
+                '.brainclaw/coordination/inbox/',
+                '.brainclaw/archive/',
+                '.brainclaw/coordination/claims/',
+                '.brainclaw/coordination/runtime/',
+                ...(includeMachineRuntime ? ['.brainclaw/coordination/runtime-hosts/', '.brainclaw/coordination/runtime-private/'] : []),
+            ], cwd);
+        case 'state':
+            return existingScopePaths([
+                '.brainclaw/memory/constraints/',
+                '.brainclaw/memory/decisions/',
+                '.brainclaw/memory/traps/',
+                '.brainclaw/coordination/handoffs/',
+            ], cwd);
+        case 'config':
+            return existingScopePaths(['.brainclaw/config.yaml'], cwd);
+        case 'project':
+            return existingScopePaths(['.brainclaw/project.md'], cwd);
+        case 'inbox':
+            return existingScopePaths(['.brainclaw/coordination/inbox/'], cwd);
+        case 'archive':
+            return existingScopePaths(['.brainclaw/archive/'], cwd);
+        case 'claims':
+            return existingScopePaths(['.brainclaw/coordination/claims/'], cwd);
+        case 'runtime':
+            return existingScopePaths(['.brainclaw/coordination/runtime/'], cwd);
+        case 'runtime-local':
+            return existingScopePaths(['.brainclaw/coordination/runtime-hosts/', '.brainclaw/coordination/runtime-private/'], cwd);
+        case 'trap-local':
+            return existingScopePaths(['.brainclaw/memory/traps-hosts/', '.brainclaw/memory/traps-private/'], cwd);
+        default:
+            console.warn(`⚠ Unknown sync scope "${scope}"; defaulting to .brainclaw/`);
+            return resolveScopePaths('all', includeMachineRuntime, cwd);
+    }
+}
+function existingScopePaths(paths, cwd) {
+    return paths.filter((scopePath) => fs.existsSync(cwd ? path.join(cwd, scopePath) : scopePath));
+}
+//# sourceMappingURL=sync.js.map

package/dist/commands/tool.js

@@ -0,0 +1,126 @@
+import { loadState, saveState } from '../core/state.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { generateIdWithLabel, nowISO } from '../core/ids.js';
+import { loadConfig } from '../core/config.js';
+import { scanText } from '../core/security.js';
+import { validateCliInput } from '../core/input-validation.js';
+import { resolveTargetStore } from '../core/store-resolution.js';
+export function runTool(subcommand, args, 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);
+    }
+    if (subcommand === 'list') {
+        runToolList(cwd);
+    }
+    else if (subcommand === 'add') {
+        const name = args[0];
+        const description = args[1];
+        if (!name || !description) {
+            console.error('Error: tool add requires <name> <description>');
+            process.exit(1);
+        }
+        runToolAdd(name, description, options, cwd);
+    }
+    else if (subcommand === 'describe') {
+        const toolId = args[0];
+        if (!toolId) {
+            console.error('Error: tool describe requires <id>');
+            process.exit(1);
+        }
+        runToolDescribe(toolId, cwd);
+    }
+    else if (subcommand === 'search') {
+        const query = args[0];
+        if (!query) {
+            console.error('Error: tool search requires <query>');
+            process.exit(1);
+        }
+        runToolSearch(query, cwd);
+    }
+    else {
+        console.error(`Unknown tool subcommand: ${subcommand}`);
+        process.exit(1);
+    }
+}
+function runToolList(cwd) {
+    const state = loadState(cwd);
+    const tools = state.recent_decisions
+        .filter((d) => d.tags.includes('tool'))
+        .map((d) => ({ id: d.id, name: d.text.split('\n')[0], type: d.tags.find((t) => t !== 'tool') }));
+    if (tools.length === 0) {
+        console.log('No tools registered yet.');
+        return;
+    }
+    console.log(`\n${tools.length} tool(s):\n`);
+    tools.forEach((tool) => {
+        console.log(`  [${tool.id}] ${tool.name}`);
+        if (tool.type) {
+            console.log(`      type: ${tool.type}`);
+        }
+    });
+    console.log('');
+}
+function runToolAdd(name, description, options, cwd) {
+    validateCliInput(name + ' ' + description, options.tag);
+    const config = loadConfig(cwd);
+    const warnings = scanText(name + ': ' + description, config);
+    for (const w of warnings) {
+        console.warn(`⚠ ${w.message}`);
+        if (w.level === 'block') {
+            console.error('Blocked: strict redaction is enabled. Entry not added.');
+            process.exit(1);
+        }
+    }
+    const state = loadState(cwd);
+    const { id, short_label } = generateIdWithLabel('recent_decisions');
+    const toolType = options.type ?? 'utility';
+    const entry = {
+        id,
+        short_label,
+        text: name,
+        created_at: nowISO(),
+        author: options.author ?? resolveCurrentAgentName(cwd),
+        tags: ['tool', toolType, ...(options.tag ?? [])],
+    };
+    // For now, store as decision to avoid schema migration
+    // Will migrate to separate tool storage in v0.16
+    state.recent_decisions.push(entry);
+    saveState(state, cwd);
+    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state));
+    console.log(`✔ Tool added: [${id}] ${name}`);
+    console.log('  (Stored in decisions for now; will move to dedicated registry in v0.16)');
+}
+function runToolDescribe(toolId, cwd) {
+    const state = loadState(cwd);
+    const decision = state.recent_decisions.find((d) => d.id === toolId || d.short_label === toolId);
+    if (!decision) {
+        console.error(`Error: tool '${toolId}' not found`);
+        process.exit(1);
+    }
+    console.log(`\nTool: ${decision.text}`);
+    console.log(`ID: ${decision.id}`);
+    console.log(`Type: ${decision.tags.find((t) => t !== 'tool')}`);
+    console.log(`Author: ${decision.author}`);
+    console.log(`Created: ${decision.created_at}`);
+    console.log('');
+}
+function runToolSearch(query, cwd) {
+    const state = loadState(cwd);
+    const tools = state.recent_decisions.filter((d) => d.tags.includes('tool'));
+    const results = tools.filter((tool) => tool.text.toLowerCase().includes(query.toLowerCase()) ||
+        tool.tags.some((tag) => tag.toLowerCase().includes(query.toLowerCase())));
+    if (results.length === 0) {
+        console.log(`No tools found matching '${query}'`);
+        return;
+    }
+    console.log(`\n${results.length} tool(s) matching '${query}':\n`);
+    results.forEach((result) => {
+        console.log(`  [${result.id}] ${result.text.split('\n')[0]}`);
+    });
+    console.log('');
+}
+//# sourceMappingURL=tool.js.map

package/dist/commands/trap.js

@@ -0,0 +1,74 @@
+import { loadState, saveState } from '../core/state.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+import { resolveCurrentHostId } from '../core/host.js';
+import { loadConfig } from '../core/config.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { nowISO } from '../core/ids.js';
+import { scanText } from '../core/security.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { generateTrapIdWithLabel, saveOperationalTrap } from '../core/traps.js';
+import { validateCliInput, validateCliTtl } from '../core/input-validation.js';
+import { resolveTargetStore } from '../core/store-resolution.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);
+    }
+    validateCliInput(text, options.tag);
+    if (options.ttl) {
+        validateCliTtl(options.ttl);
+    }
+    const config = loadConfig(cwd);
+    const warnings = scanText(text, config);
+    for (const w of warnings) {
+        console.warn(`⚠ ${w.message}`);
+        if (w.level === 'block') {
+            console.error('Blocked: strict redaction is enabled. Entry not added.');
+            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,
+        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,
+        visibility,
+        host_id: hostId,
+        expires_at: options.ttl ? parseTtl(options.ttl) : undefined,
+    };
+    if (visibility === 'shared') {
+        state.known_traps.push(entry);
+        saveState(state, cwd);
+        writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+    }
+    else {
+        saveOperationalTrap(entry, cwd);
+    }
+    const scopeInfo = visibility === 'shared' ? 'shared' : `${visibility}:${hostId}`;
+    const storeLabel = options.store && options.store !== 'local' ? ` [store:${options.store}]` : '';
+    console.log(`✔ Trap added: [${id}] (${scopeInfo}) ${text}${storeLabel}`);
+}
+/** Parse a TTL string like "30m", "2h", "7d" and return an ISO expiry timestamp. */
+function parseTtl(ttl) {
+    const match = /^(\d+)([mhd])$/.exec(ttl.trim().toLowerCase());
+    if (!match)
+        return undefined;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    const ms = unit === 'm' ? value * 60_000
+        : unit === 'h' ? value * 3_600_000
+            : value * 86_400_000;
+    return new Date(Date.now() + ms).toISOString();
+}
+//# sourceMappingURL=trap.js.map

package/dist/commands/update-handoff.js

@@ -0,0 +1,23 @@
+import { loadState, saveState } from '../core/state.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { generateMarkdown } from '../core/markdown.js';
+export function runUpdateHandoff(id, options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const state = loadState();
+    const handoff = state.open_handoffs.find((item) => item.id === id);
+    if (!handoff) {
+        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;
+    saveState(state);
+    writeFileAtomic(memoryPath('project.md'), generateMarkdown(state));
+    console.log(`✔ Handoff updated: [${handoff.id}] ${handoff.from} → ${handoff.to} (${handoff.status})`);
+}
+//# sourceMappingURL=update-handoff.js.map

package/dist/commands/update-plan.js

@@ -0,0 +1,37 @@
+import { loadState, saveState } from '../core/state.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { nowISO } from '../core/ids.js';
+export function runUpdatePlan(id, options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        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);
+    }
+    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;
+    }
+    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;
+    saveState(state, options.cwd);
+    writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+    console.log(`✔ Plan item updated: [${plan.id}] ${plan.text}`);
+}
+//# sourceMappingURL=update-plan.js.map