brainclaw 0.19.2

package/dist/core/claims.js

@@ -0,0 +1,72 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import { ClaimSchema } from './schema.js';
+import { resolveEntityDir } from './io.js';
+import { nowISO } from './ids.js';
+import { JsonStore } from './json-store.js';
+function claimsDir(cwd, mode = 'read') {
+    return resolveEntityDir('claims', cwd ?? process.cwd(), mode);
+}
+export function ensureClaimsDir(cwd) {
+    const dir = claimsDir(cwd, 'write');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function claimStore(cwd) {
+    return new JsonStore({
+        dirPath: claimsDir(cwd, 'read'),
+        documentType: 'claim',
+        getId: (claim) => claim.id,
+        sort: (a, b) => a.created_at.localeCompare(b.created_at),
+    });
+}
+export function saveClaim(claim, cwd) {
+    ensureClaimsDir(cwd);
+    const writeStore = new JsonStore({
+        dirPath: claimsDir(cwd, 'write'),
+        documentType: 'claim',
+        getId: (c) => c.id,
+        sort: (a, b) => a.created_at.localeCompare(b.created_at),
+    });
+    writeStore.save(ClaimSchema.parse(claim));
+}
+export function loadClaim(id, cwd) {
+    return claimStore(cwd).load(id);
+}
+export function listClaims(cwd) {
+    return claimStore(cwd).list();
+}
+export function releaseClaim(id, cwd) {
+    const claim = loadClaim(id, cwd);
+    claim.status = 'released';
+    claim.released_at = nowISO();
+    saveClaim(claim, cwd);
+    return claim;
+}
+export function generateClaimId() {
+    const rand = crypto.randomBytes(4).toString('hex');
+    return `clm_${rand}`;
+}
+export function isClaimExpired(claim) {
+    if (!claim.expires_at)
+        return false;
+    return new Date(claim.expires_at) < new Date();
+}
+/** Mark active claims past their expires_at as released. Returns count of expired claims. */
+export function expireStaleActiveClaims(cwd) {
+    const store = claimStore(cwd);
+    const all = store.list();
+    let count = 0;
+    const now = nowISO();
+    for (const claim of all) {
+        if (claim.status === 'active' && isClaimExpired(claim)) {
+            claim.status = 'released';
+            claim.released_at = now;
+            store.save(claim);
+            count++;
+        }
+    }
+    return count;
+}
+//# sourceMappingURL=claims.js.map

package/dist/core/config.js

@@ -0,0 +1,86 @@
+import { ConfigSchema } from './schema.js';
+import { memoryPath } from './io.js';
+import { loadVersionedYamlFile, saveVersionedYamlFile } from './migration.js';
+const CONFIG_FILE = 'config.yaml';
+export function defaultConfig(projectName, options = {}) {
+    return {
+        schema_version: 2,
+        version: 1,
+        project_name: projectName,
+        project_id: options.projectId,
+        current_agent: options.currentAgent,
+        current_agent_id: options.currentAgentId,
+        storage_dir: options.storageDir ?? '.brainclaw',
+        topology: options.topology ?? 'embedded',
+        ignore_strategy: options.ignoreStrategy ?? 'none',
+        project_mode: options.projectMode ?? 'auto',
+        projects: {
+            strategy: options.projectStrategy ?? 'manual',
+            known: [],
+        },
+        profile: 'dev',
+        target_audience: 'human',
+        openclaw_bridge: false,
+        telemetry: false,
+        allow_network: false,
+        redaction: {
+            enabled: true,
+            patterns: [
+                '(?i)api[_-]?key',
+                '(?i)secret',
+                '(?i)token',
+                '(?i)password',
+            ],
+        },
+        sensitive_paths: ['.env', 'secrets/', '.git/', 'node_modules/'],
+        security: {
+            mode: 'warn',
+            strict_redaction: false,
+            block_sensitive_paths: true,
+        },
+        markdown: {
+            max_items_per_section: 20,
+            compact_mode: false,
+        },
+        reflective_memory: {
+            enabled: true,
+            auto_accept: false,
+            max_pending: 50,
+            promotion_stars_threshold: 3,
+            promotion_uses_threshold: 2,
+            prune_rejected_after_days: 30,
+            auto_promote_trusted: false,
+            auto_promote_score_threshold: 5,
+            circuit_breaker_threshold: 5,
+            circuit_breaker_window_days: 7,
+        },
+        governance: {
+            approval_policy: 'review',
+            curators: [],
+            review_sla_hours: 24,
+        },
+        reputation: {
+            enabled: false,
+            visibility: 'internal-only',
+            decay_days: 30,
+            ranking_weight: 0.15,
+            resume_weight: 0.35,
+            mcp_exposure: false,
+        },
+        agent_integrations: {
+            declarations: [],
+        },
+        cross_project_links: [],
+        implicit_session_ttl: '4h',
+        auto_reflect_notes: false,
+    };
+}
+export function loadConfig(cwd, preferredDirName) {
+    const filepath = memoryPath(CONFIG_FILE, cwd, preferredDirName);
+    return loadVersionedYamlFile('config', filepath).document;
+}
+export function saveConfig(config, cwd, preferredDirName) {
+    const filepath = memoryPath(CONFIG_FILE, cwd, preferredDirName);
+    saveVersionedYamlFile('config', filepath, ConfigSchema.parse(config));
+}
+//# sourceMappingURL=config.js.map

package/dist/core/context-diff.js

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readAuditLog } from './audit.js';
+import { listCandidates } from './candidates.js';
+import { readContextMarker } from './freshness.js';
+import { memoryDir, resolveEntityDir } from './io.js';
+import { logger } from './logger.js';
+import { loadVersionedJsonFile } from './migration.js';
+import { SessionSnapshotSchema } from './schema.js';
+import { loadState } from './state.js';
+export function resolveContextDiffSince(options) {
+    if (options.since) {
+        return { since: options.since };
+    }
+    if (options.session) {
+        const snapshot = loadSessionSnapshot(options.session, options.cwd);
+        if (snapshot?.started_at) {
+            return { since: snapshot.started_at, since_session: options.session };
+        }
+        const sessionEntry = readAuditLog({ action: 'session_start', itemId: options.session }, options.cwd)[0];
+        if (sessionEntry?.timestamp) {
+            return { since: sessionEntry.timestamp, since_session: options.session };
+        }
+        return { since_session: options.session };
+    }
+    const marker = readContextMarker(options.cwd);
+    if (marker?.read_at) {
+        return { since: marker.read_at };
+    }
+    return {};
+}
+function loadSessionSnapshot(sessionId, cwd) {
+    const snapshotPath = path.join(resolveEntityDir('sessions', cwd ?? process.cwd(), 'read'), `${sessionId}.json`);
+    if (!fs.existsSync(snapshotPath)) {
+        return undefined;
+    }
+    try {
+        return SessionSnapshotSchema.parse(loadVersionedJsonFile('session_snapshot', snapshotPath).document);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function buildContextDiff(options = {}) {
+    const resolved = resolveContextDiffSince(options);
+    if (!resolved.since) {
+        return undefined;
+    }
+    const state = loadState(options.cwd);
+    const pendingCandidates = listCandidates('pending', options.cwd).filter((item) => item.created_at >= resolved.since);
+    const constraints = state.active_constraints.filter((item) => item.created_at >= resolved.since);
+    const decisions = state.recent_decisions.filter((item) => item.created_at >= resolved.since);
+    const traps = state.known_traps.filter((item) => item.created_at >= resolved.since);
+    const handoffs = state.open_handoffs.filter((item) => item.created_at >= resolved.since);
+    const changedItems = options.includeItems
+        ? [
+            ...constraints.map((item) => toChangedItem('constraint', item)),
+            ...decisions.map((item) => toChangedItem('decision', item)),
+            ...traps.map((item) => toChangedItem('trap', item)),
+            ...handoffs.map((item) => toChangedItem('handoff', item)),
+            ...pendingCandidates.map((item) => toChangedItem('candidate', item)),
+        ].sort((a, b) => b.created_at.localeCompare(a.created_at))
+        : undefined;
+    const counts = {
+        constraints: constraints.length,
+        decisions: decisions.length,
+        traps: traps.length,
+        handoffs: handoffs.length,
+        pending_candidates: pendingCandidates.length,
+        total: constraints.length + decisions.length + traps.length + handoffs.length + pendingCandidates.length,
+    };
+    return {
+        since: resolved.since,
+        since_session: resolved.since_session,
+        summary: buildContextDiffSummary(counts),
+        counts,
+        changed_items: changedItems,
+    };
+}
+export function readLastContextTimestamp(cwd) {
+    const marker = readContextMarker(cwd);
+    if (marker?.read_at) {
+        return marker.read_at;
+    }
+    const markerPath = path.join(memoryDir(cwd), '.last-context');
+    if (fs.existsSync(markerPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(markerPath, 'utf-8'));
+            return parsed.read_at;
+        }
+        catch (error) {
+            logger.debug('Failed to parse context marker fallback:', error);
+        }
+    }
+    return undefined;
+}
+export function buildContextDiffSummary(counts) {
+    if (counts.total === 0) {
+        return 'No memory changes detected';
+    }
+    const parts = [];
+    if (counts.constraints > 0)
+        parts.push(`${counts.constraints} constraint${counts.constraints > 1 ? 's' : ''}`);
+    if (counts.decisions > 0)
+        parts.push(`${counts.decisions} decision${counts.decisions > 1 ? 's' : ''}`);
+    if (counts.traps > 0)
+        parts.push(`${counts.traps} trap${counts.traps > 1 ? 's' : ''}`);
+    if (counts.handoffs > 0)
+        parts.push(`${counts.handoffs} handoff${counts.handoffs > 1 ? 's' : ''}`);
+    if (counts.pending_candidates > 0)
+        parts.push(`${counts.pending_candidates} pending candidate${counts.pending_candidates > 1 ? 's' : ''}`);
+    return parts.join(', ');
+}
+function toChangedItem(section, item) {
+    return {
+        section,
+        id: item.id,
+        text: item.text,
+        created_at: item.created_at,
+    };
+}
+//# sourceMappingURL=context-diff.js.map