brainclaw 0.29.2 → 1.5.3

package/dist/core/facade-schema.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export const ExecutionStatusSchema = z.enum(['delivered_and_started', 'command_ready_manual', 'inbox_only']);
+export const WorkIntentSchema = z.enum(['execute', 'consult', 'resume', 'review']);
+// pln#492 phase 2.c — 'ideate' opens an ideation loop with a proposal seed
+// artifact. The handler does NOT yet dispatch turns (driver wire-up is
+// phase 2.d). Callers receive loop_id and may drive the loop manually via
+// bclaw_loop intent='turn' / 'advance' until the dispatch path lands.
+export const CoordinateIntentSchema = z.enum(['assign', 'consult', 'review', 'reroute', 'summarize', 'ideate']);
+export const WorkRequestSchema = z.object({
+    intent: WorkIntentSchema,
+    scope: z.string().optional(),
+    planId: z.string().optional(),
+    task: z.string().optional(),
+    messageId: z.string().optional(),
+    contextTarget: z.string().optional(),
+    compact: z.boolean().optional().default(true),
+});
+export const CoordinateRequestSchema = z.object({
+    intent: CoordinateIntentSchema,
+    task: z.string(),
+    scope: z.string().optional(),
+    targetAgents: z.array(z.string()).optional(),
+    constraints: z.record(z.string(), z.unknown()).optional(),
+    threadId: z.string().optional(),
+    autoExecute: z.boolean().optional(),
+    /**
+     * When intent=review and open_loop=true, a review Loop is opened on top of
+     * the review candidate: author slot = caller, reviewer slots = targetAgents.
+     * The candidate is linked as a change_summary artifact and the loop is
+     * advanced to `findings`, emitting a `turn_assigned` event for each
+     * reviewer slot. Default false for strict backward compatibility with
+     * existing `review` callers. See docs/concepts/loop-engine.md §Automation.
+     */
+    open_loop: z.boolean().optional(),
+    /**
+     * Optional override: asymmetric (classical author→reviewer handoff) or
+     * symmetric (each reviewer turn may apply fixes, halving round-trips).
+     * Ignored when open_loop is false. Defaults to asymmetric.
+     */
+    review_mode: z.enum(['asymmetric', 'symmetric']).optional(),
+    /**
+     * Caller-minted ULID/UUIDv7 for idempotent retries. Today this is observed
+     * on intent='review' + open_loop=true: a retry with the same
+     * client_request_id returns the cached {candidate_id, loop_id} response
+     * without creating a duplicate candidate + loop. Safe to pass on other
+     * intents — silently ignored.
+     */
+    client_request_id: z.string().min(1).optional(),
+    /**
+     * pln#359 phase 1b — route the dispatch into a linked project. When set,
+     * claim, assignment, and inbox message all land in the target project
+     * (resolved via resolveProjectCwd against cross_project_links + workspace
+     * store-chain children). Auto-spawn is disabled when project is set —
+     * the target agent picks up the brief async via its own bclaw_work.
+     */
+    project: z.string().optional(),
+});
+export const FacadeArtifactSchema = z.object({
+    type: z.string(),
+    id: z.string(),
+    path: z.string().optional(),
+});
+export const FacadeSideEffectSchema = z.object({
+    action: z.string(),
+    entity: z.string(),
+    id: z.string(),
+});
+export const FacadeResponseSchema = z.object({
+    status: z.enum(['ok', 'error', 'partial']),
+    intent: z.string(),
+    result: z.unknown(),
+    artifacts: z.array(FacadeArtifactSchema),
+    side_effects: z.array(FacadeSideEffectSchema),
+    error: z.string().optional(),
+    duration_ms: z.number().optional(),
+    claim_status: z.enum(['created', 'existing', 'none']).optional(),
+    session_id: z.string().optional(),
+    warnings: z.array(z.string()),
+    execution_status: ExecutionStatusSchema.optional(),
+});
+//# sourceMappingURL=facade-schema.js.map

package/dist/core/federation-cloud.js

@@ -0,0 +1,99 @@
+import { loadConfig } from './config.js';
+import { logger } from './logger.js';
+const DEFAULT_API_URL = 'https://app.brainclaw.dev';
+function resolveCloudConfig(cwd) {
+    // Check env vars first
+    const apiUrl = process.env.BRAINCLAW_CLOUD_URL ?? DEFAULT_API_URL;
+    const apiKey = process.env.BRAINCLAW_CLOUD_API_KEY;
+    if (apiKey) {
+        return { apiUrl, apiKey };
+    }
+    // Check config.yaml
+    try {
+        const config = loadConfig(cwd);
+        const cloud = config.cloud;
+        if (cloud?.api_key) {
+            return { apiUrl: cloud.api_url ?? apiUrl, apiKey: cloud.api_key };
+        }
+    }
+    catch {
+        // No config — cloud not configured
+    }
+    return undefined;
+}
+export async function pushSignalToCloud(message, cwd) {
+    const cloud = resolveCloudConfig(cwd);
+    if (!cloud) {
+        logger.debug('Cloud not configured — skipping push');
+        return false;
+    }
+    try {
+        const response = await fetch(`${cloud.apiUrl}/api/v1/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-Key': cloud.apiKey,
+            },
+            body: JSON.stringify(message),
+        });
+        if (!response.ok) {
+            logger.debug(`Cloud push failed: ${response.status} ${response.statusText}`);
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        logger.debug('Cloud push error:', err);
+        return false;
+    }
+}
+export async function pullSignalsFromCloud(agentName, options, cwd) {
+    const cloud = resolveCloudConfig(cwd);
+    if (!cloud) {
+        return [];
+    }
+    try {
+        const params = new URLSearchParams();
+        if (options?.since)
+            params.set('since', options.since);
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        const url = `${cloud.apiUrl}/api/v1/inbox/${encodeURIComponent(agentName)}?${params}`;
+        const response = await fetch(url, {
+            headers: { 'X-API-Key': cloud.apiKey },
+        });
+        if (!response.ok) {
+            logger.debug(`Cloud pull failed: ${response.status}`);
+            return [];
+        }
+        const data = (await response.json());
+        return data.messages ?? [];
+    }
+    catch (err) {
+        logger.debug('Cloud pull error:', err);
+        return [];
+    }
+}
+export async function pushBoardToCloud(projectName, boardData, cwd) {
+    const cloud = resolveCloudConfig(cwd);
+    if (!cloud)
+        return false;
+    try {
+        const response = await fetch(`${cloud.apiUrl}/api/v1/board/${encodeURIComponent(projectName)}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-Key': cloud.apiKey,
+            },
+            body: JSON.stringify(boardData),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export function isCloudConfigured(cwd) {
+    return resolveCloudConfig(cwd) !== undefined;
+}
+//# sourceMappingURL=federation-cloud.js.map

package/dist/core/federation-message.js

@@ -0,0 +1,52 @@
+import crypto from 'node:crypto';
+import { z } from 'zod';
+import { generateId, nowISO } from './ids.js';
+export const FederationMessageSchema = z.object({
+    schema_version: z.literal(1),
+    id: z.string(),
+    version: z.number().int().min(1),
+    idempotency_key: z.string(),
+    from: z.object({
+        project_id: z.string().optional(),
+        project_name: z.string(),
+        project_path: z.string(),
+        agent_name: z.string(),
+        agent_id: z.string().optional(),
+        host_id: z.string().optional(),
+    }),
+    to: z.object({
+        project_name: z.string(),
+        project_path: z.string(),
+        agent_name: z.string().optional(),
+    }),
+    type: z.enum(['signal', 'handoff', 'candidate', 'runtime_note', 'board_snapshot']),
+    payload: z.unknown(),
+    created_at: z.string(),
+    causal_parent: z.string().optional(),
+});
+function computeIdempotencyKey(msg) {
+    const data = JSON.stringify({ from: msg.from, to: msg.to, type: msg.type, payload: msg.payload });
+    return crypto.createHash('sha256').update(data).digest('hex').slice(0, 16);
+}
+export function createFederationMessage(input) {
+    return {
+        ...input,
+        schema_version: 1,
+        id: generateId('msg'),
+        created_at: nowISO(),
+        idempotency_key: computeIdempotencyKey(input),
+    };
+}
+export function validateMessage(raw) {
+    return FederationMessageSchema.parse(raw);
+}
+export function serializeMessage(msg) {
+    return JSON.stringify(msg, null, 2);
+}
+export function deserializeMessage(raw) {
+    return validateMessage(JSON.parse(raw));
+}
+export function isDuplicate(existing, incoming) {
+    return existing.some((m) => m.idempotency_key === incoming.idempotency_key);
+}
+//# sourceMappingURL=federation-message.js.map

package/dist/core/federation-transport.js

@@ -0,0 +1,65 @@
+import { validateMessage, serializeMessage, deserializeMessage, } from './federation-message.js';
+import { loadConfig } from './config.js';
+import { memoryDir } from './io.js';
+import fs from 'node:fs';
+import path from 'node:path';
+function signalInboxDir(projectPath) {
+    return path.join(memoryDir(projectPath), 'coordination', 'inbox', 'cross-project');
+}
+export function pushSignal(targetProjectPath, message) {
+    validateMessage(message);
+    const dir = signalInboxDir(targetProjectPath);
+    const filepath = path.join(dir, `${message.id}.json`);
+    if (fs.existsSync(filepath))
+        return;
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filepath, serializeMessage(message) + '\n', 'utf-8');
+}
+export function pullSignals(sourceProjectPath, options) {
+    const dir = signalInboxDir(sourceProjectPath);
+    if (!fs.existsSync(dir))
+        return [];
+    const messages = [];
+    for (const entry of fs.readdirSync(dir)) {
+        if (!entry.endsWith('.json'))
+            continue;
+        try {
+            const msg = deserializeMessage(fs.readFileSync(path.join(dir, entry), 'utf-8'));
+            if (options?.since && msg.created_at <= options.since)
+                continue;
+            messages.push(msg);
+        }
+        catch { /* skip invalid files */ }
+    }
+    return messages.sort((a, b) => a.created_at.localeCompare(b.created_at));
+}
+export function pullSignalsFromLinkedProjects(cwd) {
+    let config;
+    try {
+        config = loadConfig(cwd);
+    }
+    catch {
+        return [];
+    }
+    const baseCwd = cwd ?? process.cwd();
+    const all = [];
+    for (const link of config.cross_project_links ?? []) {
+        if (link.role !== 'subscriber' && link.role !== 'publisher')
+            continue;
+        const absolutePath = path.isAbsolute(link.path)
+            ? link.path
+            : path.resolve(baseCwd, link.path);
+        try {
+            all.push(...pullSignals(absolutePath));
+        }
+        catch { /* unavailable project — skip */ }
+    }
+    return all.sort((a, b) => a.created_at.localeCompare(b.created_at));
+}
+export function markSignalProcessed(projectPath, messageId) {
+    const dir = signalInboxDir(projectPath);
+    const processedDir = path.join(dir, '.processed');
+    fs.mkdirSync(processedDir, { recursive: true });
+    fs.renameSync(path.join(dir, `${messageId}.json`), path.join(processedDir, `${messageId}.json`));
+}
+//# sourceMappingURL=federation-transport.js.map