brainclaw 0.28.0 → 1.5.3

package/dist/core/brainclaw-version.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { BrainclawLocalReleaseManifestSchema, } from './schema.js';
+import { AgentReleaseNotesSchema, BrainclawLocalReleaseManifestSchema, } from './schema.js';
 export const DEFAULT_LOCAL_RELEASES_DIR = '.releases';
 export const DEFAULT_LOCAL_RELEASE_MANIFEST_PATH = `${DEFAULT_LOCAL_RELEASES_DIR}/brainclaw-local.json`;
 export const DEFAULT_NPM_UPDATE_PACKAGE = 'brainclaw';
@@ -15,7 +15,75 @@ const DEFAULT_NPM_UPDATE_SOURCE = {
     package_name: DEFAULT_NPM_UPDATE_PACKAGE,
     dist_tag: DEFAULT_NPM_UPDATE_DIST_TAG,
 };
+/**
+ * Scan PATH for all brainclaw installations and their versions.
+ * Detects when multiple versions are installed (e.g. global + user-local)
+ * which causes confusion about which version is actually running.
+ */
+export function detectConcurrentInstallations() {
+    const currentVersion = getInstalledBrainclawVersion();
+    const installations = [];
+    const seen = new Set();
+    // On Windows, `where` returns all matches. On Unix, `which -a` does.
+    const isWindows = os.platform() === 'win32';
+    const result = isWindows
+        ? spawnSync('where', ['brainclaw'], { encoding: 'utf-8', timeout: 5000 })
+        : spawnSync('which', ['-a', 'brainclaw'], { encoding: 'utf-8', timeout: 5000 });
+    if (result.status !== 0)
+        return [];
+    const paths = result.stdout.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+    for (const binPath of paths) {
+        // Normalize to avoid duplicates from symlinks
+        let realPath;
+        try {
+            realPath = isWindows ? binPath : fs.realpathSync(binPath);
+        }
+        catch {
+            realPath = binPath;
+        }
+        if (seen.has(realPath))
+            continue;
+        seen.add(realPath);
+        // Get version by running the binary
+        let version = 'unknown';
+        try {
+            const vResult = spawnSync(binPath, ['--version'], { encoding: 'utf-8', timeout: 5000 });
+            if (vResult.status === 0) {
+                version = vResult.stdout.trim().split(/\r?\n/)[0]?.trim() ?? 'unknown';
+            }
+        }
+        catch { /* ignore */ }
+        installations.push({
+            path: binPath,
+            version,
+            isCurrent: version === currentVersion,
+        });
+    }
+    return installations;
+}
 let cachedCliVersion;
+let cachedPackageJsonPath;
+/**
+ * Read the brainclaw version from disk (package.json), bypassing the in-memory cache.
+ * Used by the MCP server to detect when a new version has been installed while the
+ * long-running MCP process is still running with old code.
+ */
+export function readDiskBrainclawVersion() {
+    if (cachedPackageJsonPath === undefined) {
+        cachedPackageJsonPath = findOwnPackageJson() ?? '';
+    }
+    if (!cachedPackageJsonPath)
+        return '0.0.0';
+    try {
+        const parsed = JSON.parse(fs.readFileSync(cachedPackageJsonPath, 'utf-8'));
+        return typeof parsed.version === 'string' && parsed.version.trim().length > 0
+            ? parsed.version.trim()
+            : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
 export function getInstalledBrainclawVersion() {
     if (cachedCliVersion) {
         return cachedCliVersion;
@@ -126,7 +194,23 @@ export function renderBrainclawInstallableUpdateNotice(updateCheck) {
     if (updateCheck.install_command) {
         lines.push(`Install: ${updateCheck.install_command}`);
     }
-    if (updateCheck.release_notes) {
+    const arn = updateCheck.agent_release_notes;
+    if (arn) {
+        lines.push(`Summary: ${arn.summary}`);
+        if (arn.breaking_risk && arn.breaking_risk !== 'none') {
+            lines.push(`Breaking risk: ${arn.breaking_risk}`);
+        }
+        if (arn.highlights && arn.highlights.length > 0) {
+            lines.push('Highlights:');
+            for (const h of arn.highlights) {
+                lines.push(`  • ${h}`);
+            }
+        }
+        if (arn.action_recommendation) {
+            lines.push(`Action: ${arn.action_recommendation}`);
+        }
+    }
+    else if (updateCheck.release_notes) {
         lines.push(`Why update: ${updateCheck.release_notes}`);
     }
     return lines.join('\n');
@@ -161,6 +245,9 @@ export function publishLocalBrainclawRelease(cwd, options = {}) {
     const projectManifestPath = toPortablePath(path.relative(cwd, manifestPath));
     const installCommand = `npm install -g "${projectArtifactPath}"`;
     const releaseNotes = options.releaseNotes?.trim() || null;
+    const agentReleaseNotes = options.agentReleaseNotes
+        ? AgentReleaseNotesSchema.parse(options.agentReleaseNotes)
+        : null;
     const manifest = BrainclawLocalReleaseManifestSchema.parse({
         version: 1,
         channel: 'local-pack',
@@ -170,6 +257,7 @@ export function publishLocalBrainclawRelease(cwd, options = {}) {
         artifact_path: manifestArtifactPath,
         install_command: installCommand,
         release_notes: releaseNotes ?? undefined,
+        agent_release_notes: agentReleaseNotes ?? undefined,
     });
     fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8');
     return {
@@ -179,6 +267,7 @@ export function publishLocalBrainclawRelease(cwd, options = {}) {
         artifact_path: projectArtifactPath,
         install_command: installCommand,
         release_notes: releaseNotes,
+        agent_release_notes: agentReleaseNotes,
     };
 }
 function checkNpmInstallableUpdate(source, config, cwd, options, defaultSource) {
@@ -343,6 +432,7 @@ function checkLocalPackInstallableUpdate(manifestPath, config, cwd) {
         const installCommand = manifest.install_command?.trim()
             || (artifactPath ? `npm install -g "${artifactPath}"` : config?.brainclaw_upgrade_command?.trim() || null);
         const releaseNotes = manifest.release_notes?.trim() || config?.brainclaw_upgrade_message?.trim() || null;
+        const agentReleaseNotes = manifest.agent_release_notes ?? null;
         const installedVersion = getInstalledBrainclawVersion();
         if (compareVersions(installedVersion, latestVersion) < 0) {
             return {
@@ -353,6 +443,7 @@ function checkLocalPackInstallableUpdate(manifestPath, config, cwd) {
                 artifact_path: artifactPath,
                 install_command: installCommand,
                 release_notes: releaseNotes,
+                agent_release_notes: agentReleaseNotes,
                 status: 'update_available',
                 message: `A newer installable brainclaw build is available: ${latestVersion} (installed ${installedVersion}).`,
                 default_source: false,
@@ -366,6 +457,7 @@ function checkLocalPackInstallableUpdate(manifestPath, config, cwd) {
             artifact_path: artifactPath,
             install_command: installCommand,
             release_notes: releaseNotes,
+            agent_release_notes: agentReleaseNotes,
             status: 'up_to_date',
             message: `Installed brainclaw ${installedVersion} is up to date for the configured local-pack channel.`,
             default_source: false,

package/dist/core/candidates.js

@@ -6,6 +6,39 @@ import { resolveEntityDir } from './io.js';
 import { mutate } from './mutation-pipeline.js';
 import { nowISO, getNextShortLabel } from './ids.js';
 import { JsonStore } from './json-store.js';
+import { refreshLiveCompanions } from '../commands/export.js';
+/**
+ * Return the effective source for a candidate.
+ *
+ * Resolution order:
+ *   1. Explicit `source` field if set to a valid enum value ('auto'|'agent'|'human').
+ *   2. Inferred from `origin` free-text pattern (e.g. 'runtime-note:...' → 'agent',
+ *      'session-end:...' → 'auto', 'mcp:...' / 'cross-project:...' → 'agent').
+ *   3. Default 'human' for legacy items without any provenance.
+ *
+ * This default is only applied in memory — no files are rewritten.
+ */
+export function resolvedSource(candidate) {
+    if (candidate.source)
+        return candidate.source;
+    return inferSourceFromOrigin(candidate.origin);
+}
+/** Infer the enum `source` from a free-text `origin` pattern. */
+export function inferSourceFromOrigin(origin) {
+    if (!origin)
+        return 'human';
+    if (origin.startsWith('session-end:'))
+        return 'auto';
+    if (origin.startsWith('runtime-note:'))
+        return 'agent';
+    if (origin.startsWith('mcp:'))
+        return 'agent';
+    if (origin.startsWith('cross-project:'))
+        return 'agent';
+    // Unknown origin pattern — treat as agent since something explicit was set,
+    // but not matching an auto pattern. Human sources typically have no origin.
+    return 'agent';
+}
 function inboxDir(cwd, mode = 'read') {
     return resolveEntityDir('inbox', cwd ?? process.cwd(), mode);
 }
@@ -39,6 +72,11 @@ export function saveCandidate(candidate, cwd) {
     mutate({ cwd }, () => {
         ensureInboxDirs(cwd);
         candidateStore('pending', cwd).save(CandidateSchema.parse(candidate));
+        // Auto-refresh live companions after candidate changes (non-fatal)
+        try {
+            refreshLiveCompanions(cwd);
+        }
+        catch { /* best-effort */ }
     });
 }
 export function loadCandidate(id, cwd) {
@@ -47,15 +85,36 @@ export function loadCandidate(id, cwd) {
 export function updateCandidate(candidate, cwd) {
     saveCandidate(candidate, cwd);
 }
-export function listCandidates(status, cwd) {
+export function listCandidates(status, cwd, filter) {
     const candidates = candidateStore('pending', cwd).list();
-    return status ? candidates.filter((candidate) => candidate.status === status) : candidates;
+    const byStatus = status ? candidates.filter((candidate) => candidate.status === status) : candidates;
+    return applySourceFilter(byStatus, filter);
+}
+function applySourceFilter(candidates, filter) {
+    if (!filter)
+        return candidates;
+    let result = candidates;
+    if (filter.source !== undefined) {
+        result = result.filter((c) => resolvedSource(c) === filter.source);
+    }
+    if (filter.auto_generated === false) {
+        result = result.filter((c) => resolvedSource(c) !== 'auto');
+    }
+    else if (filter.auto_generated === true) {
+        result = result.filter((c) => resolvedSource(c) === 'auto');
+    }
+    return result;
 }
 export function archiveCandidate(candidate, dest, cwd) {
     mutate({ cwd }, () => {
         ensureInboxDirs(cwd);
         candidateStore(dest, cwd).save(CandidateSchema.parse(candidate));
         candidateStore('pending', cwd).delete(candidate.id);
+        // Auto-refresh live companions after candidate archive (non-fatal)
+        try {
+            refreshLiveCompanions(cwd);
+        }
+        catch { /* best-effort */ }
     });
 }
 export function listArchivedCandidates(dest, cwd) {
@@ -70,6 +129,38 @@ export function deleteArchivedCandidate(id, dest, cwd) {
     }
     return false;
 }
+export function cleanupStaleCandidates(options = {}) {
+    const maxAgeDays = options.maxAgeDays ?? 30;
+    const source = options.source ?? 'auto';
+    const cutoffMs = Date.now() - maxAgeDays * 86_400_000;
+    const candidates = listCandidates('pending', options.cwd).filter((candidate) => {
+        if (resolvedSource(candidate) !== source)
+            return false;
+        return Date.parse(candidate.created_at) <= cutoffMs;
+    });
+    if (options.dryRun || candidates.length === 0) {
+        return {
+            matched: candidates.length,
+            deleted: 0,
+            candidates,
+        };
+    }
+    mutate({ cwd: options.cwd }, () => {
+        const store = candidateStore('pending', options.cwd);
+        for (const candidate of candidates) {
+            store.delete(candidate.id);
+        }
+        try {
+            refreshLiveCompanions(options.cwd);
+        }
+        catch { /* best-effort */ }
+    });
+    return {
+        matched: candidates.length,
+        deleted: candidates.length,
+        candidates,
+    };
+}
 export function addCandidateStar(id, by, cwd) {
     const candidate = loadCandidate(id, cwd);
     if (candidate.status !== 'pending') {