brainclaw 0.19.2

package/dist/commands/review.js

@@ -0,0 +1,242 @@
+import { memoryExists } from '../core/io.js';
+import { listCandidates, saveCandidate } from '../core/candidates.js';
+import { loadConfig } from '../core/config.js';
+import { detectNewItemContradictions, summarizeContradictions } from '../core/contradictions.js';
+import { buildReputationRankingLookup } from '../core/reputation.js';
+import { checkCircuitBreaker } from '../core/circuit-breaker.js';
+import { loadState } from '../core/state.js';
+import { runAccept } from './accept.js';
+export function runReview(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    let candidates = listCandidates('pending', options.cwd);
+    const config = loadConfig(options.cwd);
+    const slaHours = config.governance?.review_sla_hours ?? 24;
+    const promotionThreshold = config.reflective_memory?.promotion_stars_threshold ?? 3;
+    const promotionUsesThreshold = config.reflective_memory?.promotion_uses_threshold ?? 2;
+    const now = Date.now();
+    const rankingLookup = buildReputationRankingLookup(options.cwd);
+    if (options.type) {
+        candidates = candidates.filter(c => c.type === options.type);
+    }
+    if (options.assignee) {
+        const targetAssignee = options.assignee.toLowerCase();
+        candidates = candidates.filter((c) => getReviewAssignee(c.tags)?.toLowerCase() === targetAssignee);
+    }
+    if (options.forCurator) {
+        const curator = options.forCurator.toLowerCase();
+        candidates = candidates.filter((c) => getReviewAssignee(c.tags)?.toLowerCase() === curator);
+    }
+    if (options.onlyOverdue) {
+        candidates = candidates.filter((c) => {
+            const ageHours = Math.floor((now - Date.parse(c.created_at)) / (1000 * 60 * 60));
+            return ageHours > slaHours;
+        });
+    }
+    if (options.prioritized) {
+        candidates = [...candidates].sort((a, b) => {
+            const starDelta = (b.star_count ?? 0) - (a.star_count ?? 0);
+            if (starDelta !== 0)
+                return starDelta;
+            const aRank = priorityRank(a.type);
+            const bRank = priorityRank(b.type);
+            if (aRank !== bRank)
+                return aRank - bRank;
+            const trustDelta = rankingLookup.getInternalTrust(b.author_id, b.author) - rankingLookup.getInternalTrust(a.author_id, a.author);
+            if (trustDelta !== 0)
+                return trustDelta;
+            return a.created_at.localeCompare(b.created_at);
+        });
+    }
+    else if (options.take && options.take > 0) {
+        candidates = [...candidates].sort((a, b) => a.created_at.localeCompare(b.created_at));
+    }
+    const totalBeforeTake = candidates.length;
+    if (options.take && options.take > 0) {
+        candidates = candidates.slice(0, options.take);
+    }
+    const claimed = [];
+    const skipped = [];
+    // --auto: auto-promote candidates that meet score threshold
+    if (options.auto) {
+        const scoreThreshold = config.reflective_memory?.auto_promote_score_threshold ?? 5;
+        const autoBy = options.autoBy ?? process.env.USER ?? process.env.USERNAME ?? 'auto';
+        const state = loadState(options.cwd);
+        const promoted = [];
+        const autoSkipped = [];
+        for (const c of candidates) {
+            const score = (c.star_count ?? 0) + (c.usage_count ?? 0);
+            if (score >= scoreThreshold ||
+                (c.star_count ?? 0) >= promotionThreshold ||
+                (c.usage_count ?? 0) >= promotionUsesThreshold) {
+                // Circuit-breaker: skip auto-promote if agent has too many recent rejections
+                const breaker = checkCircuitBreaker(c.author_id ?? c.author, options.cwd);
+                if (breaker.tripped) {
+                    autoSkipped.push({ id: c.id, reason: `circuit_breaker:${c.author}(${breaker.rejection_count}/${breaker.threshold} rejections in ${breaker.window_days}d)` });
+                    continue;
+                }
+                const contradictions = detectNewItemContradictions(c.text, c.tags, c.related_paths, state, c.project_id);
+                const blocking = contradictions.filter((item) => item.severity === 'medium' || item.severity === 'high');
+                if (blocking.length > 0) {
+                    saveCandidate({
+                        ...c,
+                        contradictions_detected: contradictions,
+                        contradiction_summary: summarizeContradictions(contradictions),
+                        promotion_blocked_reason: 'contradiction_detected',
+                    }, options.cwd);
+                    autoSkipped.push({ id: c.id, reason: 'contradiction_detected' });
+                    continue;
+                }
+                try {
+                    runAccept(c.id, autoBy, options.cwd);
+                    promoted.push(c.id);
+                }
+                catch {
+                    autoSkipped.push({ id: c.id, reason: 'accept_failed' });
+                }
+            }
+            else {
+                autoSkipped.push({ id: c.id, reason: 'below_threshold' });
+            }
+        }
+        if (options.json) {
+            console.log(JSON.stringify({ auto_promoted: promoted, skipped: autoSkipped }));
+        }
+        else {
+            console.log(`✔ Auto-promoted ${promoted.length} candidate(s). Skipped ${autoSkipped.length}.`);
+        }
+        return;
+    }
+    if (options.claim) {
+        const curator = options.claim.trim();
+        for (const c of candidates) {
+            const existing = getReviewAssignee(c.tags);
+            if (existing && existing.toLowerCase() !== curator.toLowerCase()) {
+                skipped.push({ id: c.id, reason: `already assigned to ${existing}` });
+                continue;
+            }
+            const updated = {
+                ...c,
+                tags: setReviewAssignee(c.tags, curator),
+            };
+            saveCandidate(updated, options.cwd);
+            claimed.push(updated);
+        }
+        candidates = claimed;
+    }
+    if (options.json) {
+        if (options.claim) {
+            console.log(JSON.stringify({
+                claimed: candidates.map((c) => {
+                    const ageHours = Math.floor((now - Date.parse(c.created_at)) / (1000 * 60 * 60));
+                    return {
+                        ...c,
+                        review_assignee: getReviewAssignee(c.tags),
+                        promotion_stars: c.star_count ?? 0,
+                        promotion_threshold: promotionThreshold,
+                        promotion_uses: c.usage_count ?? 0,
+                        promotion_uses_threshold: promotionUsesThreshold,
+                        promotion_recommended: (c.star_count ?? 0) >= promotionThreshold || (c.usage_count ?? 0) >= promotionUsesThreshold,
+                        age_hours: ageHours,
+                        sla_hours: slaHours,
+                        overdue: ageHours > slaHours,
+                    };
+                }),
+                skipped,
+            }, null, 2));
+            return;
+        }
+        const payload = candidates.map((c) => {
+            const ageHours = Math.floor((now - Date.parse(c.created_at)) / (1000 * 60 * 60));
+            return {
+                ...c,
+                review_assignee: getReviewAssignee(c.tags),
+                promotion_stars: c.star_count ?? 0,
+                promotion_threshold: promotionThreshold,
+                promotion_uses: c.usage_count ?? 0,
+                promotion_uses_threshold: promotionUsesThreshold,
+                promotion_recommended: (c.star_count ?? 0) >= promotionThreshold || (c.usage_count ?? 0) >= promotionUsesThreshold,
+                age_hours: ageHours,
+                sla_hours: slaHours,
+                overdue: ageHours > slaHours,
+            };
+        });
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    if (candidates.length === 0) {
+        if (options.claim) {
+            console.log(`No candidates claimed for curator '${options.claim}'.`);
+            if (skipped.length > 0) {
+                console.log(`Skipped ${skipped.length} candidate(s) already assigned to another curator.`);
+            }
+            return;
+        }
+        console.log('No pending candidates.');
+        return;
+    }
+    console.log(`${candidates.length} pending candidate(s):`);
+    console.log('');
+    if (options.prioritized) {
+        console.log(`Priority mode enabled (SLA ${slaHours}h)`);
+        console.log('');
+    }
+    if (options.take && options.take > 0) {
+        console.log(`Showing ${candidates.length} of ${totalBeforeTake} candidate(s) (--take ${options.take})`);
+        console.log('');
+    }
+    if (options.claim) {
+        console.log(`Claimed ${candidates.length} candidate(s) for curator '${options.claim}'.`);
+        if (skipped.length > 0) {
+            console.log(`Skipped ${skipped.length} candidate(s) already assigned to another curator.`);
+        }
+        console.log('');
+    }
+    for (const c of candidates) {
+        const tags = c.tags.length ? ` [${c.tags.join(', ')}]` : '';
+        const extra = c.type === 'handoff' ? ` (${c.from} → ${c.to})` : '';
+        const assignee = getReviewAssignee(c.tags);
+        const assigneePart = assignee ? ` · assignee ${assignee}` : '';
+        const stars = c.star_count ?? 0;
+        const uses = c.usage_count ?? 0;
+        const promote = stars >= promotionThreshold || uses >= promotionUsesThreshold ? ' · PROMOTE?' : '';
+        const ageHours = Math.floor((now - Date.parse(c.created_at)) / (1000 * 60 * 60));
+        const overdue = ageHours > slaHours ? ' OVERDUE' : '';
+        console.log(`  [${c.short_label ?? c.id}] (${c.type}) ${c.text}${extra}${tags}`);
+        console.log(`         by ${c.author} at ${c.created_at}${assigneePart} · stars ${stars}/${promotionThreshold} · uses ${uses}/${promotionUsesThreshold}${promote} · age ${ageHours}h · SLA ${slaHours}h${overdue}`);
+    }
+}
+function setReviewAssignee(tags, assignee) {
+    const next = [];
+    for (const tag of tags) {
+        if (!tag.startsWith('assignee:')) {
+            next.push(tag);
+        }
+    }
+    next.push(`assignee:${assignee}`);
+    return next;
+}
+function getReviewAssignee(tags) {
+    for (const tag of tags) {
+        if (tag.startsWith('assignee:')) {
+            return tag.slice('assignee:'.length).trim() || undefined;
+        }
+    }
+    return undefined;
+}
+function priorityRank(type) {
+    switch (type) {
+        case 'handoff':
+            return 1;
+        case 'constraint':
+            return 2;
+        case 'trap':
+            return 3;
+        case 'decision':
+        default:
+            return 4;
+    }
+}
+//# sourceMappingURL=review.js.map

package/dist/commands/rollback.js

@@ -0,0 +1,156 @@
+import { memoryExists } from '../core/io.js';
+import { readAuditLog } from '../core/audit.js';
+import { loadState, saveState } from '../core/state.js';
+import { loadCandidate, saveCandidate } from '../core/candidates.js';
+import { appendAuditEntry } from '../core/audit.js';
+import { buildOperationalIdentity } from '../core/identity.js';
+export function runRollback(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    if (!options.auditId && !options.itemId) {
+        console.error('Error: provide --audit-id <id> or --item-id <id> to identify what to roll back.');
+        process.exit(1);
+    }
+    let actor;
+    try {
+        actor = buildOperationalIdentity(options.actor);
+    }
+    catch {
+        actor = { agent: options.actor ?? process.env.USER ?? process.env.USERNAME ?? 'unknown', agent_id: undefined };
+    }
+    // Find the target audit entry
+    let entries = readAuditLog();
+    if (options.auditId) {
+        // Look for entry with matching timestamp prefix (first 20 chars are a sortable ISO prefix)
+        entries = entries.filter(e => e.timestamp.startsWith(options.auditId) || e.timestamp === options.auditId);
+    }
+    else if (options.itemId) {
+        // Get most recent audit entry for this item that has a `before` snapshot
+        entries = entries
+            .filter(e => e.item_id === options.itemId && e.before !== undefined)
+            .sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    }
+    if (entries.length === 0) {
+        const result = {
+            ok: false,
+            message: `No audit entry found for ${options.auditId ?? options.itemId}. Cannot roll back.`,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.error(`Error: ${result.message}`);
+        }
+        process.exit(1);
+    }
+    const entry = entries[0];
+    if (entry.before === undefined) {
+        const result = {
+            ok: false,
+            item_id: entry.item_id,
+            message: `Audit entry at ${entry.timestamp} has no 'before' snapshot. Cannot roll back.`,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.error(`Error: ${result.message}`);
+        }
+        process.exit(1);
+    }
+    const result = applyRollback(entry, actor.agent, options);
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (result.ok) {
+        const dryLabel = options.dryRun ? ' (dry run)' : '';
+        console.log(`✔ Rolled back ${result.item_type} [${result.item_id}]${dryLabel}: ${result.message}`);
+    }
+    else {
+        console.error(`Error: ${result.message}`);
+        process.exit(1);
+    }
+}
+function applyRollback(entry, actorName, options) {
+    const { item_id, item_type, before, action } = entry;
+    if (!item_id || !item_type || !before) {
+        return { ok: false, message: 'Audit entry is missing item_id, item_type, or before snapshot.' };
+    }
+    if (options.dryRun) {
+        return {
+            ok: true,
+            audit_entry: entry.timestamp,
+            item_id,
+            item_type,
+            action_reversed: action,
+            message: `Would restore ${item_type} to state before ${action} at ${entry.timestamp}`,
+        };
+    }
+    try {
+        if (item_type === 'candidate') {
+            try {
+                const existing = loadCandidate(item_id);
+                saveCandidate({ ...existing, ...before });
+            }
+            catch {
+                // Candidate may have been deleted — try to recreate from before snapshot
+                saveCandidate(before);
+            }
+        }
+        else if (['constraint', 'decision', 'trap'].includes(item_type)) {
+            const state = loadState();
+            if (item_type === 'constraint') {
+                const idx = state.active_constraints.findIndex(c => c.id === item_id);
+                if (idx >= 0) {
+                    state.active_constraints[idx] = before;
+                }
+                else {
+                    state.active_constraints.push(before);
+                }
+            }
+            else if (item_type === 'decision') {
+                const idx = state.recent_decisions.findIndex(d => d.id === item_id);
+                if (idx >= 0) {
+                    state.recent_decisions[idx] = before;
+                }
+                else {
+                    state.recent_decisions.push(before);
+                }
+            }
+            else if (item_type === 'trap') {
+                const idx = state.known_traps.findIndex(t => t.id === item_id);
+                if (idx >= 0) {
+                    state.known_traps[idx] = before;
+                }
+                else {
+                    state.known_traps.push(before);
+                }
+            }
+            saveState(state);
+        }
+        else {
+            return { ok: false, message: `Rollback not supported for item_type '${item_type}'.` };
+        }
+        appendAuditEntry({
+            actor: actorName,
+            action: 'rollback',
+            item_id,
+            item_type,
+            reason: `Rolled back ${action} at ${entry.timestamp}`,
+        });
+        return {
+            ok: true,
+            audit_entry: entry.timestamp,
+            item_id,
+            item_type,
+            action_reversed: action,
+            message: `Restored to state before '${action}' at ${entry.timestamp}`,
+        };
+    }
+    catch (e) {
+        return { ok: false, message: e instanceof Error ? e.message : String(e) };
+    }
+}
+//# sourceMappingURL=rollback.js.map

package/dist/commands/runtime-note.js

@@ -0,0 +1,144 @@
+import { buildOperationalIdentity } from '../core/identity.js';
+import { memoryExists } from '../core/io.js';
+import { loadConfig } from '../core/config.js';
+import { getAgentTrustLevel, requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
+import { saveRuntimeNote, generateRuntimeNoteId } from '../core/runtime.js';
+import { loadState } from '../core/state.js';
+import { nowISO } from '../core/ids.js';
+import { createCandidateFromInput } from './reflect.js';
+import { suggestCandidateTypes } from './reflect-runtime-note.js';
+import { validateCliInput, validateCliTtl } from '../core/input-validation.js';
+export function runRuntimeNote(text, options) {
+    validateCliInput(text, options.tag);
+    if (options.ttl) {
+        validateCliTtl(options.ttl);
+    }
+    try {
+        return createRuntimeNote(text, options, true);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+export function createRuntimeNote(text, options, printSuccess = false) {
+    if (!memoryExists(options.cwd)) {
+        throw new Error('.brainclaw/ not found. Run `brainclaw init` first.');
+    }
+    const registeredAgent = requireRegisteredAgentIdentity({
+        agentName: options.agent,
+        agentId: options.agentId,
+        cwd: options.cwd,
+        allowCurrent: true,
+        allowEnv: true,
+    });
+    requireMinimumTrustLevel(registeredAgent, 'contributor');
+    const actor = buildOperationalIdentity(registeredAgent.agent_name, options.cwd, {
+        agentId: registeredAgent.agent_id,
+        sessionId: options.sessionId,
+    });
+    const state = loadState(options.cwd);
+    const plan = options.plan ? state.plan_items.find((item) => item.id === options.plan) : undefined;
+    if (options.plan && !plan) {
+        throw new Error(`Plan item '${options.plan}' not found.`);
+    }
+    const id = generateRuntimeNoteId();
+    const visibility = options.visibility ?? 'shared';
+    const hostId = options.host ?? actor.host_id;
+    const expiresAt = options.ttl ? parseTtl(options.ttl) : undefined;
+    const note = {
+        id,
+        agent: actor.agent,
+        agent_id: actor.agent_id,
+        project_id: actor.project_id,
+        session_id: actor.session_id,
+        text,
+        created_at: nowISO(),
+        project: options.project ?? plan?.project,
+        plan_id: options.plan,
+        tags: options.tag ?? [],
+        visibility,
+        host_id: hostId,
+        expires_at: expiresAt,
+        note_type: 'observation',
+    };
+    saveRuntimeNote(note, options.cwd);
+    const result = maybeAutoReflectRuntimeNote(note, options);
+    const scopeInfo = visibility === 'shared' ? 'shared' : `${visibility}:${hostId}`;
+    const ttlInfo = expiresAt ? ` (expires ${expiresAt})` : '';
+    if (printSuccess) {
+        console.log(`✔ Runtime note added: [${id}] (${actor.agent}, ${scopeInfo}) ${text}${ttlInfo}`);
+        if (result.autoReflectAttempted) {
+            if (result.promotedItemId) {
+                console.log(`  Auto-reflect: promoted ${result.detectedType} via candidate [${result.candidateId}] -> [${result.promotedItemId}]`);
+            }
+            else if (result.candidateId) {
+                console.log(`  Auto-reflect: created pending ${result.detectedType} candidate [${result.candidateId}]`);
+            }
+            else if (result.skipReason) {
+                console.log(`  Auto-reflect skipped: ${result.skipReason}`);
+            }
+        }
+    }
+    return {
+        noteId: id,
+        agent: actor.agent,
+        sessionId: actor.session_id,
+        scopeInfo,
+        expiresAt,
+        ...result,
+    };
+}
+function maybeAutoReflectRuntimeNote(note, options) {
+    const config = loadConfig(options.cwd);
+    const trustLevel = getAgentTrustLevel(note.agent_id ?? note.agent, options.cwd);
+    const autoReflectRequested = Boolean(options.autoReflect)
+        || (config.auto_reflect_notes === true && (trustLevel === 'trusted' || trustLevel === 'curator'));
+    if (!autoReflectRequested) {
+        return { autoReflectAttempted: false };
+    }
+    if (trustLevel === 'observer') {
+        return { autoReflectAttempted: true, skipReason: 'observer_not_allowed' };
+    }
+    const suggestions = suggestCandidateTypes(note.text, note.tags);
+    const detected = suggestions.find((entry) => entry.type !== 'handoff');
+    if (!detected || detected.score < 4) {
+        return { autoReflectAttempted: true, skipReason: 'low_confidence' };
+    }
+    const creation = createCandidateFromInput(note.text, detected.type, {
+        tag: note.tags,
+        author: note.agent,
+        authorId: note.agent_id,
+        projectId: note.project_id,
+        hostId: note.host_id,
+        sessionId: note.session_id,
+        source: `runtime-note:${note.agent}:${note.id}`,
+        cwd: options.cwd,
+    }, false, false, true);
+    return {
+        autoReflectAttempted: true,
+        detectedType: detected.type,
+        candidateId: creation.candidateId,
+        promotedItemId: creation.promotedItemId,
+        contradictionsDetected: creation.contradictionsDetected?.map((item) => ({
+            severity: item.severity,
+            reason: item.reason,
+            conflicts_with: item.conflicts_with,
+        })),
+        contradictionSummary: creation.contradictionSummary,
+        promotionBlockedReason: creation.promotionBlockedReason,
+    };
+}
+/** 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=runtime-note.js.map

package/dist/commands/runtime-status.js

@@ -0,0 +1,49 @@
+import { resolveCurrentHostId } from '../core/host.js';
+import { memoryExists } from '../core/io.js';
+import { listRuntimeNotes } from '../core/runtime.js';
+export function runRuntimeStatus(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const currentHost = resolveCurrentHostId();
+    const notes = listRuntimeNotes({
+        agent: options.agent,
+        visibility: options.visibility,
+        hostId: options.host,
+        includeAllHosts: options.allHosts,
+    }, options.cwd);
+    const filtered = options.plan ? notes.filter((note) => note.plan_id === options.plan) : notes;
+    if (options.json) {
+        console.log(JSON.stringify(filtered, null, 2));
+        return;
+    }
+    if (filtered.length === 0) {
+        console.log('No runtime notes.');
+        return;
+    }
+    // Group by agent
+    const byAgent = new Map();
+    for (const n of filtered) {
+        const list = byAgent.get(n.agent) ?? [];
+        list.push(n);
+        byAgent.set(n.agent, list);
+    }
+    const scopeLabel = options.visibility ? ` visibility=${options.visibility}` : ' visibility=shared+machine(current-host)';
+    const hostLabel = options.allHosts ? ' host=all' : ` host=${options.host ?? currentHost}`;
+    console.log(`${filtered.length} runtime note(s) from ${byAgent.size} agent(s):${scopeLabel}${hostLabel}`);
+    console.log('');
+    for (const [agent, agentNotes] of byAgent) {
+        console.log(`  ${agent}:`);
+        for (const n of agentNotes.slice(-5)) {
+            const tags = n.tags.length ? ` [${n.tags.join(', ')}]` : '';
+            const plan = n.plan_id ? ` (plan ${n.plan_id})` : '';
+            const scope = n.visibility === 'shared' ? ' [shared]' : ` [${n.visibility}:${n.host_id ?? 'unknown-host'}]`;
+            console.log(`    [${n.id}] ${n.text}${plan}${scope}${tags}`);
+        }
+        if (agentNotes.length > 5) {
+            console.log(`    ... and ${agentNotes.length - 5} more`);
+        }
+    }
+}
+//# sourceMappingURL=runtime-status.js.map

package/dist/commands/search.js

@@ -0,0 +1,36 @@
+import { memoryExists } from '../core/io.js';
+import { search } from '../core/search.js';
+export function runSearch(query, options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const results = search({
+        query,
+        section: options.section,
+        since: options.since,
+        tags: options.tag,
+        includePending: options.pending,
+        maxResults: options.maxResults ?? 20,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    if (results.length === 0) {
+        console.log(`No results for "${query}".`);
+        return;
+    }
+    console.log(`Found ${results.length} result(s) for "${query}":\n`);
+    for (const r of results) {
+        const tags = r.tags.length > 0 ? ` [${r.tags.join(', ')}]` : '';
+        const paths = r.related_paths && r.related_paths.length > 0 ? ` (${r.related_paths.join(', ')})` : '';
+        const score = r.score > 0 ? ` (score: ${r.score})` : '';
+        console.log(`  [${r.id}] <${r.section}>${tags}${paths}${score}`);
+        console.log(`    ${r.text}`);
+        if (r.author)
+            console.log(`    — ${r.author}, ${r.created_at.slice(0, 10)}`);
+        console.log();
+    }
+}
+//# sourceMappingURL=search.js.map