brainclaw 0.29.2 → 1.5.3

package/dist/core/codev-plan-gen.js

@@ -0,0 +1,35 @@
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { listIdeationRounds } from './ideation.js';
+export function generatePlansFromConvergence(threadSlug, cwd) {
+    const root = cwd ?? process.cwd();
+    const rounds = listIdeationRounds(threadSlug, root);
+    const lastRound = rounds[rounds.length - 1];
+    if (!lastRound?.convergences.length) {
+        return { plans: [], skipped: [] };
+    }
+    const plans = [];
+    const skipped = [];
+    for (const text of lastRound.convergences) {
+        try {
+            const out = execFileSync('node', [path.join(root, 'dist/cli.js'), 'plan', 'create', text, '--tag', 'codev', 'auto-generated', '--type', 'feat'], { cwd: root, encoding: 'utf-8' });
+            const id = /\[(pln_[^\]]+)\]/.exec(out)?.[1];
+            if (!id) {
+                skipped.push(text);
+                continue;
+            }
+            plans.push({ id, text });
+        }
+        catch {
+            skipped.push(text);
+        }
+    }
+    return { plans, skipped };
+}
+export function generateSummaryNote(threadSlug, result, cwd) {
+    const root = cwd ?? process.cwd();
+    const ids = result.plans.map((p) => p.id).join(', ') || 'none';
+    const note = `CoDev session ${threadSlug} generated ${result.plans.length} plan(s): ${ids}. Skipped: ${result.skipped.length}.`;
+    execFileSync('node', [path.join(root, 'dist/cli.js'), 'note', note], { cwd: root, encoding: 'utf-8' });
+}
+//# sourceMappingURL=codev-plan-gen.js.map

package/dist/core/codev-prompts.js

@@ -0,0 +1,74 @@
+/**
+ * CoDev v3 prompt builder functions for iterative group discussion model.
+ * Prompts are intentionally short — agents should spend time thinking, not reading.
+ * @module
+ */
+export function truncate(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.slice(0, maxLength - 3) + '...';
+}
+/**
+ * Round 0 — Each agent states their initial position on the topic.
+ */
+export function buildPositionPrompt(persona, exposition, targetDurationSeconds, responseFilePath) {
+    return `[CoDev Round 0 — Position initiale]
+Tu es ${persona.name}: ${persona.focus}
+
+## Sujet
+${truncate(exposition, 800)}
+
+## Consigne
+Donne ta position en 3-5 phrases maximum. Sois direct et concret.
+Durée cible: ${targetDurationSeconds}s.
+
+## Format de réponse
+Écris ta réponse dans le fichier: ${responseFilePath}
+Format: JSON avec { "persona": "${persona.name}", "text": "<ta réponse>" }`;
+}
+/**
+ * Rounds 1-N — Each agent reacts to the previous round's positions.
+ */
+export function buildReactionPrompt(persona, previousPositions, roundNumber, targetDurationSeconds, responseFilePath) {
+    const positionLines = previousPositions
+        .filter((p) => p.persona !== persona.name)
+        .map((p) => `**${p.persona}**: ${truncate(p.text, 200)}`)
+        .join('\n');
+    return `[CoDev Round ${roundNumber} — Réaction]
+Tu es ${persona.name}: ${persona.focus}
+
+## Positions précédentes
+${positionLines}
+
+## Consigne
+Réagis aux positions ci-dessus depuis ton point de vue de ${persona.name}.
+Challenge, renforce ou propose une alternative. 3-5 phrases.
+Durée cible: ${targetDurationSeconds}s.
+
+## Format de réponse
+Écris ta réponse dans le fichier: ${responseFilePath}
+Format: JSON avec { "persona": "${persona.name}", "text": "<ta réponse>" }`;
+}
+/**
+ * Final round — Identify convergence and remaining disagreements.
+ */
+export function buildConvergencePrompt(persona, allPositions, targetDurationSeconds, responseFilePath) {
+    const positionLines = allPositions
+        .map((p) => `[R${p.round}] **${p.persona}**: ${truncate(p.text, 200)}`)
+        .join('\n');
+    return `[CoDev — Convergence]
+Tu es ${persona.name}: ${persona.focus}
+
+## Toutes les positions
+${positionLines}
+
+## Consigne
+Identifie 3 points de convergence et 2 désaccords restants.
+Propose des actions concrètes pour avancer. 3-5 phrases.
+Durée cible: ${targetDurationSeconds}s.
+
+## Format de réponse
+Écris ta réponse dans le fichier: ${responseFilePath}
+Format: JSON avec { "persona": "${persona.name}", "text": "<ta réponse>" }`;
+}
+//# sourceMappingURL=codev-prompts.js.map

package/dist/core/codev-responses.js

@@ -0,0 +1,62 @@
+import { memoryDir } from './io.js';
+import fs from 'node:fs';
+import path from 'node:path';
+function syncSleep(ms) {
+    if (ms <= 0)
+        return;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function sanitizeForPath(slug) {
+    return slug.replace(/[<>:"/\\|?*]/g, '_');
+}
+export function responseDir(threadSlug, cwd) {
+    return path.join(memoryDir(cwd), 'coordination', 'ideation', sanitizeForPath(threadSlug), 'responses');
+}
+export function responseFilePath(threadSlug, roundNumber, persona, cwd) {
+    return path.join(responseDir(threadSlug, cwd), `round_${roundNumber}_${persona}.json`);
+}
+export function writeResponse(threadSlug, roundNumber, persona, agent, text, cwd) {
+    const filePath = responseFilePath(threadSlug, roundNumber, persona, cwd);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const payload = { persona, agent, text, created_at: new Date().toISOString() };
+    fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8');
+}
+export function readResponse(threadSlug, roundNumber, persona, cwd) {
+    const filePath = responseFilePath(threadSlug, roundNumber, persona, cwd);
+    if (!fs.existsSync(filePath))
+        return undefined;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+export function collectResponses(threadSlug, roundNumber, personas, cwd) {
+    const responses = [];
+    for (const persona of personas) {
+        const response = readResponse(threadSlug, roundNumber, persona, cwd);
+        if (response)
+            responses.push(response);
+    }
+    return responses;
+}
+export function awaitAllResponses(threadSlug, roundNumber, personas, cwd, pollIntervalMs = 10000) {
+    const startedAt = Date.now();
+    const pending = new Set(personas);
+    const received = new Map();
+    while (pending.size > 0) {
+        for (const persona of pending) {
+            const response = readResponse(threadSlug, roundNumber, persona, cwd);
+            if (response) {
+                received.set(persona, { ...response, duration_ms: Date.now() - startedAt });
+            }
+        }
+        for (const persona of received.keys()) {
+            pending.delete(persona);
+        }
+        if (pending.size === 0)
+            break;
+        console.log(`Waiting for responses: ${received.size}/${personas.length} received...`);
+        syncSleep(pollIntervalMs);
+    }
+    return personas
+        .map((persona) => received.get(persona))
+        .filter((response) => Boolean(response));
+}
+//# sourceMappingURL=codev-responses.js.map

package/dist/core/codev-rounds.js

@@ -0,0 +1,218 @@
+/**
+ * CoDev v3 — Round protocol engine.
+ * Orchestrates prompt generation, agent spawning, response collection,
+ * metrics recording, and ideation round persistence.
+ * @module
+ */
+import { saveIdeationRound, loadIdeationRound, listIdeationRounds } from './ideation.js';
+import { recordResponse } from './codev-metrics.js';
+import { buildPositionPrompt, buildReactionPrompt, buildConvergencePrompt } from './codev-prompts.js';
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+// ── Helpers ───────────────────────────────────────────────────
+function sanitizeForPath(slug) {
+    return slug.replace(/[<>:"/\\|?*]/g, '_');
+}
+function responseFilePath(threadSlug, roundNumber, personaName) {
+    return path.join(os.tmpdir(), 'brainclaw-codev', sanitizeForPath(threadSlug), `round_${roundNumber}`, `${personaName}.json`);
+}
+function sleepSync(ms) {
+    if (process.platform === 'win32') {
+        spawnSync('powershell', ['-NonInteractive', '-Command', `Start-Sleep -Milliseconds ${ms}`], { stdio: 'ignore' });
+    }
+    else {
+        spawnSync('sleep', [`${ms / 1000}`], { stdio: 'ignore' });
+    }
+}
+function spawnAgent(binaryPath, agentName, prompt, personaName, cwd, outputFile, modelOverride) {
+    const tmpDir = path.join(os.tmpdir(), 'brainclaw-codev');
+    fs.mkdirSync(tmpDir, { recursive: true });
+    const promptFile = path.join(tmpDir, `${personaName}-${Date.now()}.md`);
+    fs.writeFileSync(promptFile, prompt, 'utf-8');
+    // Capture stdout → response file. The agent just responds normally;
+    // the facilitator writes its output to the expected response path.
+    fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+    const outFd = fs.openSync(outputFile + '.partial', 'w');
+    // Build agent-specific command
+    let shellCmd;
+    if (agentName === 'codex') {
+        // Codex: reads from stdin via '-', uses exec --full-auto
+        shellCmd = `cat "${promptFile}" | "${binaryPath}" exec --full-auto - ; rm -f "${promptFile}"`;
+    }
+    else if (agentName === 'antigravity') {
+        // Gemini CLI: -p flag, optional -m for model
+        const modelFlag = modelOverride ? ` -m "${modelOverride}"` : '';
+        shellCmd = `"${binaryPath}"${modelFlag} -p "$(cat "${promptFile}")" ; rm -f "${promptFile}"`;
+    }
+    else {
+        // Claude Code and others: -p flag with --allowedTools, optional --model
+        const modelFlag = modelOverride ? ` --model "${modelOverride}"` : '';
+        shellCmd = `"${binaryPath}" -p "$(cat "${promptFile}")"${modelFlag} --allowedTools "Read,Glob,Grep,Bash" ; rm -f "${promptFile}"`;
+    }
+    const child = spawn('sh', ['-c', shellCmd], {
+        detached: true,
+        stdio: ['ignore', outFd, 'ignore'],
+        cwd,
+    });
+    child.on('error', (err) => {
+        console.warn(`  ⚠ Spawn error for ${agentName}/${personaName}: ${err.message}`);
+    });
+    child.on('exit', () => {
+        try {
+            fs.closeSync(outFd);
+        }
+        catch { /* already closed */ }
+        // Rename .partial → .json to signal completion atomically
+        try {
+            const raw = fs.readFileSync(outputFile + '.partial', 'utf-8').trim();
+            const response = { persona: personaName, agent: agentName, text: raw, created_at: new Date().toISOString() };
+            fs.writeFileSync(outputFile, JSON.stringify(response, null, 2), 'utf-8');
+        }
+        catch { /* best effort */ }
+    });
+    child.unref();
+}
+// ── Main export ───────────────────────────────────────────────
+export function executeRound(config) {
+    const { threadSlug, roundNumber, roundType, personas, agents, exposition, targetDurationSeconds, cwd, quorum, modelOverrides } = config;
+    const quorumTarget = quorum != null && quorum > 0 ? Math.min(quorum, personas.length) : personas.length;
+    const dispatchedAt = new Date();
+    const collected = [];
+    try {
+        // a. Generate prompts and spawn agents (round-robin)
+        for (let i = 0; i < personas.length; i++) {
+            const persona = personas[i];
+            const agent = agents[i % agents.length];
+            const respFile = responseFilePath(threadSlug, roundNumber, persona.name);
+            fs.mkdirSync(path.dirname(respFile), { recursive: true });
+            let prompt;
+            if (roundType === 'position') {
+                prompt = buildPositionPrompt(persona, exposition, targetDurationSeconds, respFile);
+            }
+            else if (roundType === 'reaction') {
+                const prev = loadIdeationRound(threadSlug, roundNumber - 1, cwd);
+                const previousPositions = (prev?.positions ?? []).map(p => ({ persona: p.persona, text: p.text }));
+                prompt = buildReactionPrompt(persona, previousPositions, roundNumber, targetDurationSeconds, respFile);
+            }
+            else {
+                const allRounds = listIdeationRounds(threadSlug, cwd);
+                const allPositions = allRounds.flatMap(r => r.positions.map(p => ({ persona: p.persona, text: p.text, round: r.round_number })));
+                prompt = buildConvergencePrompt(persona, allPositions, targetDurationSeconds, respFile);
+            }
+            spawnAgent(agent.binaryPath, agent.name, prompt, persona.name, cwd, respFile, modelOverrides?.[persona.name]);
+            console.log(`  → [R${roundNumber}] ${persona.name} → ${agent.name}${modelOverrides?.[persona.name] ? ` (model: ${modelOverrides[persona.name]})` : ''}`);
+        }
+        // b. Poll for responses — no hard timeout
+        // Check both .json (final) and .partial (stdout capture still in progress).
+        // A .partial is considered done when its size is >0 and stable across 2 polls.
+        const pending = new Set(personas.map(p => p.name));
+        const partialSizes = new Map();
+        if (quorumTarget < personas.length) {
+            console.log(`Polling for ${pending.size} response(s) (round ${roundNumber}, quorum=${quorumTarget})...`);
+        }
+        else {
+            console.log(`Polling for ${pending.size} response(s) (round ${roundNumber})...`);
+        }
+        while (pending.size > 0) {
+            sleepSync(10_000);
+            for (const personaName of [...pending]) {
+                const respFile = responseFilePath(threadSlug, roundNumber, personaName);
+                // Check final .json first (written by exit handler)
+                let raw;
+                if (fs.existsSync(respFile)) {
+                    try {
+                        raw = JSON.parse(fs.readFileSync(respFile, 'utf-8'));
+                    }
+                    catch { /* not ready */ }
+                }
+                // Fallback: check .partial stdout capture — stable size means agent finished
+                if (!raw) {
+                    const partialFile = respFile + '.partial';
+                    if (!fs.existsSync(partialFile))
+                        continue;
+                    try {
+                        const stat = fs.statSync(partialFile);
+                        if (stat.size === 0)
+                            continue;
+                        const prevSize = partialSizes.get(personaName) ?? 0;
+                        if (stat.size === prevSize && prevSize > 0) {
+                            // Stable — agent is done writing, read it
+                            const text = fs.readFileSync(partialFile, 'utf-8').trim();
+                            if (text.length > 0) {
+                                raw = { persona: personaName, text };
+                            }
+                        }
+                        partialSizes.set(personaName, stat.size);
+                        if (!raw)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                try {
+                    const respondedAt = new Date();
+                    const agentIdx = personas.findIndex(p => p.name === personaName);
+                    const agentName = agents[agentIdx % agents.length].name;
+                    const duration_ms = respondedAt.getTime() - dispatchedAt.getTime();
+                    recordResponse(threadSlug, {
+                        thread_id: threadSlug,
+                        round: roundNumber,
+                        persona: personaName,
+                        agent_name: agentName,
+                        dispatched_at: dispatchedAt.toISOString(),
+                        responded_at: respondedAt.toISOString(),
+                        duration_ms,
+                    }, cwd);
+                    collected.push({ persona: personaName, agent: agentName, text: raw.text, duration_ms });
+                    pending.delete(personaName);
+                    console.log(`  ✓ ${personaName} responded (${Math.round(duration_ms / 1000)}s)`);
+                    // Quorum: advance once enough responses have been collected
+                    if (collected.length >= quorumTarget) {
+                        if (pending.size > 0) {
+                            console.log(`  Quorum reached (${collected.length}/${personas.length}) — advancing round.`);
+                        }
+                        pending.clear();
+                    }
+                }
+                catch {
+                    // File may be partially written — retry on next poll
+                }
+            }
+            if (pending.size > 0)
+                console.log(`  Waiting for: ${[...pending].join(', ')}`);
+        }
+        // c. Build and persist the IdeationRound artifact
+        const round = {
+            schema_version: 1,
+            thread_id: threadSlug,
+            round_number: roundNumber,
+            round_type: roundType,
+            positions: collected,
+            tensions: [],
+            convergences: [],
+            created_at: new Date().toISOString(),
+        };
+        saveIdeationRound(threadSlug, round, cwd);
+        return round;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Round ${roundNumber} failed: ${message}`);
+        const failedRound = {
+            schema_version: 1,
+            thread_id: threadSlug,
+            round_number: roundNumber,
+            round_type: roundType,
+            positions: collected,
+            tensions: [`Round ${roundNumber} failed: ${message}`],
+            convergences: [],
+            created_at: new Date().toISOString(),
+        };
+        saveIdeationRound(threadSlug, failedRound, cwd);
+        return failedRound;
+    }
+}
+//# sourceMappingURL=codev-rounds.js.map

package/dist/core/config.js

@@ -73,6 +73,10 @@ export function defaultConfig(projectName, options = {}) {
         cross_project_links: [],
         implicit_session_ttl: '4h',
         auto_reflect_notes: false,
+        auto_refresh_live: true,
+        claims: {
+            auto_release_after_hours: 24,
+        },
     };
 }
 export function loadConfig(cwd, preferredDirName) {