@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/memory/enhanced-memory.js

@@ -46,6 +46,7 @@ export class EnhancedMemory extends EventEmitter {
     dbRepository = null;
     embeddingProvider = null;
     bayesianQualifier = new BayesianQualifier();
+    disposed = false;
     constructor(config = {}) {
         super();
         this.config = { ...DEFAULT_CONFIG, ...config };
@@ -98,8 +99,11 @@ export class EnhancedMemory extends EventEmitter {
                 logger.error(`Failed to load bayesian-state: ${err.message}`);
             }
         }
+        if (this.disposed)
+            return;
         // Start decay timer
         this.decayIntervalId = setInterval(() => this.applyDecay(), 3600000); // Every hour
+        this.decayIntervalId.unref?.();
     }
     /**
      * Load memories from disk or SQLite
@@ -370,8 +374,11 @@ export class EnhancedMemory extends EventEmitter {
                 results = results
                     .map(m => {
                     const features = this.extractMemoryFeatures(m, queryEmbedding);
-                    const { mean } = this.bayesianQualifier.predict(features);
-                    return { memory: m, score: mean };
+                    const { mean, std } = this.bayesianQualifier.predict(features);
+                    // Bayesian Active Learning: Upper Confidence Bound (UCB)
+                    const explorationFactor = options.explorationFactor ?? 0.05;
+                    const score = mean + (explorationFactor * std);
+                    return { memory: m, score };
                 })
                     .filter(r => r.score > 0.3)
                     .sort((a, b) => b.score - a.score)
@@ -749,6 +756,7 @@ export class EnhancedMemory extends EventEmitter {
      * Dispose
      */
     dispose() {
+        this.disposed = true;
         // Clear decay interval timer
         if (this.decayIntervalId) {
             clearInterval(this.decayIntervalId);
@@ -789,6 +797,29 @@ export class EnhancedMemory extends EventEmitter {
         const { mean, std } = this.bayesianQualifier.predict(features);
         return { score: mean, uncertainty: std };
     }
+    /**
+     * Active Learning: Retrieve memories with the highest uncertainty (BALD score)
+     * so the system can solicit user feedback and improve its relevance model.
+     */
+    async getActiveLearningTargets(limit = 5, query) {
+        if (!this.bayesianQualifier || !this.bayesianQualifier.isTrained) {
+            return [];
+        }
+        const queryEmbedding = query && this.config.embeddingEnabled
+            ? await this.generateEmbedding(query)
+            : undefined;
+        const allMemories = Array.from(this.memories.values());
+        return allMemories
+            .map(m => {
+            const features = this.extractMemoryFeatures(m, queryEmbedding);
+            const baldScore = this.bayesianQualifier.getAcquisitionScore(features);
+            return { memory: m, baldScore };
+        })
+            // Only keep entries with non-trivial uncertainty
+            .filter(r => r.baldScore > 0.01)
+            .sort((a, b) => b.baldScore - a.baldScore)
+            .slice(0, limit);
+    }
 }
 // Singleton
 let memoryInstance = null;

package/dist/memory/index.d.ts

@@ -6,7 +6,9 @@
  * - EnhancedMemory: SQLite-backed with embeddings and semantic search
  * - ProspectiveMemory: Task/goal management with triggers
  */
-export { PersistentMemoryManager, getMemoryManager, initializeMemory, type Memory, type MemoryCategory, } from "./persistent-memory.js";
+export { PersistentMemoryManager, getMemoryManager, initializeMemory, type Memory, type MemoryCategory, type MemoryScope, type MemoryUsage, type MemoryWriteResult, MemoryWriteRejectedError, } from "./persistent-memory.js";
+export { MemoryCandidateQueue, getMemoryCandidateQueue, resetMemoryCandidateQueues, MEMORY_CANDIDATE_SCHEMA_VERSION, type MemoryCandidate, type MemoryCandidateCitation, type MemoryCandidateSource, type MemoryCandidateStatus, type MemoryCandidateStats, type ProposeMemoryCandidateInput, type ProposeMemoryCandidateResult, type AcceptMemoryCandidateInput, type AcceptMemoryCandidateResult, type RejectMemoryCandidateInput, } from "./memory-candidate-queue.js";
+export { proposeMemoryCandidatesFromSession, buildMemoryCitations, extractHeuristicMemoryCandidates, } from "./memory-auto-proposer.js";
 export { EnhancedMemory, getEnhancedMemory, resetEnhancedMemory, type MemoryEntry, type MemoryType, type MemoryConfig, type ProjectMemory, type CodeConvention, type ConversationSummary, type UserProfile, type UserPreferences, type SkillLevel, type UserHistory, type MemorySearchOptions, } from "./enhanced-memory.js";
 export { ProspectiveMemory, getProspectiveMemory, resetProspectiveMemory, initializeProspectiveMemory, type ProspectiveTask, type Goal, type Reminder, type TaskPriority, type TaskStatus, type TriggerType, type TaskTrigger, type TaskContext, type SubTask, type Milestone, type ProspectiveMemoryConfig, } from "./prospective-memory.js";
 export { AutoCaptureManager, getAutoCaptureManager, resetAutoCaptureManager, type CapturePattern, type CaptureResult, type AutoCaptureConfig, type MemoryRecallResult, } from "./auto-capture.js";

package/dist/memory/index.js

@@ -7,7 +7,10 @@
  * - ProspectiveMemory: Task/goal management with triggers
  */
 // Persistent Memory (markdown files)
-export { PersistentMemoryManager, getMemoryManager, initializeMemory, } from "./persistent-memory.js";
+export { PersistentMemoryManager, getMemoryManager, initializeMemory, MemoryWriteRejectedError, } from "./persistent-memory.js";
+// Review-gated long-term memory candidates
+export { MemoryCandidateQueue, getMemoryCandidateQueue, resetMemoryCandidateQueues, MEMORY_CANDIDATE_SCHEMA_VERSION, } from "./memory-candidate-queue.js";
+export { proposeMemoryCandidatesFromSession, buildMemoryCitations, extractHeuristicMemoryCandidates, } from "./memory-auto-proposer.js";
 // Enhanced Memory (SQLite + embeddings)
 export { EnhancedMemory, getEnhancedMemory, resetEnhancedMemory, } from "./enhanced-memory.js";
 // Prospective Memory (tasks, goals, reminders)

package/dist/memory/memory-auto-proposer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Session transcript -> review-gated long-term memory candidates.
+ *
+ * This mirrors modern assistant memory systems: the model may infer durable
+ * facts from a conversation, but those facts are queued with evidence and only
+ * become prompt-injected memory after explicit acceptance.
+ */
+import { CodeBuddyClient } from '../codebuddy/client.js';
+import type { ChatEntry } from '../agent/types.js';
+import { type MemoryCandidate, type MemoryCandidateCitation } from './memory-candidate-queue.js';
+import type { MemoryCategory, MemoryScope } from './persistent-memory.js';
+interface NormalizedMemoryCandidate {
+    key: string;
+    value: string;
+    scope: MemoryScope;
+    category: MemoryCategory;
+    confidence?: number;
+    rationale?: string;
+}
+export declare function buildMemoryCitations(history: ChatEntry[], needle: string, sessionId?: string, maxCitations?: number): MemoryCandidateCitation[];
+export declare function extractHeuristicMemoryCandidates(history: ChatEntry[]): NormalizedMemoryCandidate[];
+export declare function proposeMemoryCandidatesFromSession(chatHistory: ChatEntry[], workDir?: string, client?: CodeBuddyClient, sessionId?: string): Promise<MemoryCandidate[]>;
+export {};

package/dist/memory/memory-auto-proposer.js

@@ -0,0 +1,308 @@
+/**
+ * Session transcript -> review-gated long-term memory candidates.
+ *
+ * This mirrors modern assistant memory systems: the model may infer durable
+ * facts from a conversation, but those facts are queued with evidence and only
+ * become prompt-injected memory after explicit acceptance.
+ */
+import { CodeBuddyClient } from '../codebuddy/client.js';
+import { scanForSecrets } from '../fleet/privacy-lint.js';
+import { logger } from '../utils/logger.js';
+import { detectProviderFromEnv } from '../utils/provider-detector.js';
+import { getMemoryCandidateQueue, } from './memory-candidate-queue.js';
+const VALID_CATEGORIES = [
+    'project',
+    'preferences',
+    'decisions',
+    'patterns',
+    'context',
+    'custom',
+];
+const SYSTEM_PROMPT = `You extract durable declarative long-term memory candidates for an AI coding assistant.
+
+Return only facts that are useful in future sessions. Skip transient task narration, guesses, secrets, PII, credentials, and anything that merely repeats the assistant's own plan.
+
+Output ONLY a raw JSON array matching:
+Array<{
+  key: string;
+  value: string;
+  scope: 'project'|'user';
+  category: 'project'|'preferences'|'decisions'|'patterns'|'context'|'custom';
+  confidence?: number;
+  rationale?: string;
+}>
+
+Rules:
+- 0 to 6 candidates. Return [] when nothing durable is present.
+- "user" scope is only for stable user preferences/profile; most repo facts are "project".
+- key must be short kebab-case.
+- value must be a concise self-contained sentence under 220 characters.`;
+export function buildMemoryCitations(history, needle, sessionId, maxCitations = 2) {
+    const terms = compactText(needle)
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .split(/[^a-z0-9_@./:-]+/g)
+        .filter((token) => token.length >= 4)
+        .slice(0, 6);
+    const matches = [];
+    for (let index = 0; index < history.length; index++) {
+        const entry = history[index];
+        if (!entry?.content || entry.type === 'tool_call' || entry.type === 'reasoning')
+            continue;
+        const compact = compactText(entry.content);
+        if (!compact)
+            continue;
+        const lower = compact
+            .normalize('NFKD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLowerCase();
+        let score = 0;
+        for (const term of terms) {
+            if (lower.includes(term))
+                score++;
+        }
+        if (score > 0 || terms.length === 0) {
+            matches.push({ score, index, entry, compact });
+        }
+    }
+    if (matches.length > 0) {
+        return matches
+            .sort((a, b) => {
+            if (b.score !== a.score)
+                return b.score - a.score;
+            if (a.entry.type === 'user' && b.entry.type !== 'user')
+                return -1;
+            if (b.entry.type === 'user' && a.entry.type !== 'user')
+                return 1;
+            return a.index - b.index;
+        })
+            .slice(0, maxCitations)
+            .map((match) => ({
+            ...(sessionId ? { sessionId } : {}),
+            messageIndex: match.index + 1,
+            role: match.entry.type,
+            snippet: snippetAround(match.compact, terms),
+        }));
+    }
+    const reversed = [...history].reverse();
+    const fallback = reversed.find((entry) => entry.type === 'user' && entry.content.trim())
+        ?? reversed.find((entry) => entry.type === 'assistant' && entry.content.trim());
+    if (!fallback)
+        return [];
+    return [{
+            ...(sessionId ? { sessionId } : {}),
+            messageIndex: history.indexOf(fallback) + 1,
+            role: fallback.type,
+            snippet: compactText(fallback.content).slice(0, 220),
+        }];
+}
+export function extractHeuristicMemoryCandidates(history) {
+    const candidates = [];
+    for (const entry of history) {
+        if (entry.type !== 'user' && entry.type !== 'assistant')
+            continue;
+        const text = compactText(entry.content);
+        if (text.length < 20)
+            continue;
+        const userOnly = entry.type === 'user';
+        const patterns = [
+            {
+                regex: /\b(?:remember|note|keep in memory|garde en memoire|souviens-toi)(?:\s+that|\s+que)?\s+([^.!?\n]{20,220})/i,
+                scope: 'project',
+                category: 'context',
+                keyPrefix: 'remember',
+                confidence: 0.68,
+            },
+            {
+                regex: /\b(?:i|we|je|nous)\s+(?:prefer|prefere|preferons|always prefer)\s+([^.!?\n]{10,180})/i,
+                scope: 'user',
+                category: 'preferences',
+                keyPrefix: 'preference',
+                confidence: 0.72,
+            },
+            {
+                regex: /\b(?:this repo|the project|codebase|ce projet|le projet)\s+(?:uses|is using|runs on|utilise|tourne sur)\s+([^.!?\n]{10,180})/i,
+                scope: 'project',
+                category: 'project',
+                keyPrefix: 'project',
+                confidence: 0.7,
+            },
+            {
+                regex: /\b(?:we decided|decision:|decided to|nous avons decide|on a decide)\s+([^.!?\n]{10,180})/i,
+                scope: 'project',
+                category: 'decisions',
+                keyPrefix: 'decision',
+                confidence: 0.74,
+            },
+        ];
+        for (const pattern of patterns) {
+            if (!userOnly && pattern.scope === 'user')
+                continue;
+            const match = text.match(pattern.regex);
+            const captured = match?.[1]?.trim();
+            if (!captured)
+                continue;
+            candidates.push({
+                key: makeKey(pattern.keyPrefix, captured),
+                value: captured,
+                scope: pattern.scope,
+                category: pattern.category,
+                confidence: pattern.confidence,
+                rationale: 'deterministic transcript pattern',
+            });
+        }
+    }
+    return dedupeCandidates(candidates).slice(0, 6);
+}
+export async function proposeMemoryCandidatesFromSession(chatHistory, workDir = process.cwd(), client, sessionId) {
+    if (!chatHistory || chatHistory.length === 0)
+        return [];
+    const rawCandidates = await extractWithLlm(chatHistory, client);
+    const normalized = rawCandidates.length > 0
+        ? rawCandidates
+        : extractHeuristicMemoryCandidates(chatHistory);
+    if (normalized.length === 0)
+        return [];
+    const queue = getMemoryCandidateQueue(workDir);
+    const proposed = [];
+    for (const candidate of normalized) {
+        const lint = scanForSecrets(`${candidate.key}\n${candidate.value}\n${candidate.rationale ?? ''}`);
+        if (lint.hasSecrets) {
+            logger.warn('[memory-auto-proposer] candidate dropped: contains secret/PII material', {
+                kinds: lint.matches.map((match) => match.kind),
+            });
+            continue;
+        }
+        try {
+            const result = queue.propose({
+                ...candidate,
+                source: 'session_end',
+                citations: buildMemoryCitations(chatHistory, `${candidate.key} ${candidate.value}`, sessionId),
+            });
+            proposed.push(result.candidate);
+        }
+        catch (err) {
+            logger.debug('[memory-auto-proposer] propose failed', { err });
+        }
+    }
+    return proposed;
+}
+async function extractWithLlm(chatHistory, client) {
+    let llm = client ?? null;
+    if (!llm) {
+        if (process.env.NODE_ENV === 'test' || process.env.VITEST)
+            return [];
+        const detected = detectProviderFromEnv();
+        if (!detected)
+            return [];
+        llm = new CodeBuddyClient(detected.apiKey, detected.defaultModel, detected.baseURL);
+    }
+    try {
+        const res = await llm.chat([
+            { role: 'system', content: SYSTEM_PROMPT },
+            { role: 'user', content: `Session transcript:\n\n${formatTranscript(chatHistory)}` },
+        ]);
+        const reply = res.choices[0]?.message?.content || '';
+        return parseMemoryCandidates(reply);
+    }
+    catch (err) {
+        logger.debug('[memory-auto-proposer] LLM call failed', { err });
+        return [];
+    }
+}
+function parseMemoryCandidates(reply) {
+    let text = reply.trim();
+    const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const fenced = fence?.[1];
+    if (fenced !== undefined)
+        text = fenced.trim();
+    const start = text.indexOf('[');
+    const end = text.lastIndexOf(']');
+    if (start === -1 || end === -1 || end <= start)
+        return [];
+    try {
+        const parsed = JSON.parse(text.slice(start, end + 1));
+        if (!Array.isArray(parsed))
+            return [];
+        return dedupeCandidates(parsed.map(normalizeRawCandidate).filter(isCandidate));
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeRawCandidate(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const item = raw;
+    const key = makeSafeKey(item.key ?? '');
+    const value = compactText(item.value ?? '').slice(0, 240);
+    const scope = item.scope === 'user' ? 'user' : 'project';
+    const category = VALID_CATEGORIES.includes(item.category)
+        ? item.category
+        : 'context';
+    if (!key || !value)
+        return null;
+    return {
+        key,
+        value,
+        scope,
+        category,
+        ...(typeof item.confidence === 'number' ? { confidence: Math.max(0, Math.min(1, item.confidence)) } : {}),
+        ...(item.rationale?.trim() ? { rationale: compactText(item.rationale).slice(0, 240) } : {}),
+    };
+}
+function isCandidate(candidate) {
+    return candidate !== null;
+}
+function formatTranscript(history) {
+    return history
+        .slice(-80)
+        .map((entry, index) => {
+        const role = entry.type === 'tool_result'
+            ? `[${entry.toolCall?.function?.name || 'tool'}]`
+            : entry.type;
+        return `${index + 1}. ${role}: ${compactText(entry.content).slice(0, 800)}`;
+    })
+        .join('\n');
+}
+function dedupeCandidates(candidates) {
+    const seen = new Set();
+    const unique = [];
+    for (const candidate of candidates) {
+        const key = `${candidate.scope}:${candidate.key}:${candidate.value}`.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(candidate);
+    }
+    return unique;
+}
+function compactText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function snippetAround(text, terms, maxLength = 220) {
+    const lower = text.toLowerCase();
+    const indexes = terms
+        .map((term) => lower.indexOf(term))
+        .filter((index) => index >= 0);
+    const first = indexes.length > 0 ? Math.min(...indexes) : 0;
+    const start = Math.max(0, first - 60);
+    const end = Math.min(text.length, start + maxLength);
+    return `${start > 0 ? '...' : ''}${text.slice(start, end)}${end < text.length ? '...' : ''}`;
+}
+function makeKey(prefix, text) {
+    const base = makeSafeKey(text).split('-').slice(0, 5).join('-') || prefix;
+    return `${prefix}-${base}`.slice(0, 72);
+}
+function makeSafeKey(text) {
+    return text
+        .normalize('NFKD')
+        .replace(/[^\p{L}\p{N}\s_-]/gu, '')
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .slice(0, 72);
+}
+//# sourceMappingURL=memory-auto-proposer.js.map

package/dist/memory/memory-candidate-queue.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Review-gated long-term memory candidates.
+ *
+ * Declarative memories are more dangerous than procedural lessons because they
+ * are injected into future prompts as "facts". The safe loop is therefore:
+ * infer -> enqueue with evidence -> human accepts/rejects -> write bounded
+ * persistent memory. Proposing a candidate never mutates CODEBUDDY_MEMORY.md.
+ */
+import { PersistentMemoryManager, type MemoryCategory, type MemoryScope, type MemoryWriteResult } from './persistent-memory.js';
+export declare const MEMORY_CANDIDATE_SCHEMA_VERSION = 1;
+export type MemoryCandidateStatus = 'pending' | 'accepted' | 'rejected';
+export type MemoryCandidateSource = 'self_observed' | 'manual' | 'session_end' | 'precompaction';
+export interface MemoryCandidateCitation {
+    sessionId?: string;
+    messageId?: number;
+    messageIndex?: number;
+    role?: string;
+    snippet: string;
+}
+export interface MemoryCandidateWriteSummary {
+    status: MemoryWriteResult['status'];
+    usage: MemoryWriteResult['usage'];
+}
+export interface MemoryCandidate {
+    id: string;
+    key: string;
+    value: string;
+    scope: MemoryScope;
+    category: MemoryCategory;
+    status: MemoryCandidateStatus;
+    createdAt: number;
+    source: MemoryCandidateSource;
+    confidence?: number;
+    rationale?: string;
+    citations?: MemoryCandidateCitation[];
+    reviewedAt?: number;
+    reviewedBy?: string;
+    reviewNote?: string;
+    write?: MemoryCandidateWriteSummary;
+}
+export interface ProposeMemoryCandidateInput {
+    key: string;
+    value: string;
+    scope?: MemoryScope;
+    category?: MemoryCategory;
+    source?: MemoryCandidateSource;
+    confidence?: number;
+    rationale?: string;
+    citations?: MemoryCandidateCitation[];
+}
+export interface ProposeMemoryCandidateResult {
+    candidate: MemoryCandidate;
+    deduped: boolean;
+}
+export interface AcceptMemoryCandidateInput {
+    reviewedBy: string;
+    key?: string;
+    value?: string;
+    scope?: MemoryScope;
+    category?: MemoryCategory;
+    reviewNote?: string;
+}
+export interface AcceptMemoryCandidateResult {
+    candidate: MemoryCandidate;
+    write: MemoryWriteResult;
+}
+export interface RejectMemoryCandidateInput {
+    reviewedBy?: string;
+    reason?: string;
+}
+export interface MemoryCandidateStats {
+    total: number;
+    byStatus: Record<MemoryCandidateStatus, number>;
+}
+export declare function getMemoryCandidateQueue(workDir?: string): MemoryCandidateQueue;
+export declare function resetMemoryCandidateQueues(): void;
+export declare class MemoryCandidateQueue {
+    private workDir;
+    private memoryManager?;
+    private filePath;
+    private candidates;
+    private loaded;
+    constructor(workDir?: string, memoryManager?: PersistentMemoryManager | undefined);
+    propose(input: ProposeMemoryCandidateInput): ProposeMemoryCandidateResult;
+    list(status?: MemoryCandidateStatus): MemoryCandidate[];
+    get(id: string): MemoryCandidate | null;
+    accept(id: string, input: AcceptMemoryCandidateInput): Promise<AcceptMemoryCandidateResult>;
+    reject(id: string, input?: RejectMemoryCandidateInput): MemoryCandidate;
+    getStats(): MemoryCandidateStats;
+    private load;
+    private save;
+}