@nandansai08/personal-ai 0.8.0

package/dist/memory/intent.js

@@ -0,0 +1,113 @@
+// MIT License — personal-ai
+// Explicit memory-intent detection and fact normalization.
+// "remember i am studying CSE at IIT Dhanbad" → structured, normalized memory.
+// Trigger phrases — anchored to the start of the message (after pleasantries)
+const TRIGGER_RE = /^(?:hey|hi|ok|okay|please|also|and)?[,!\s]*(remember(?:\s+(?:that|this))?|don'?t\s+forget(?:\s+that)?|save\s+this|keep\s+in\s+mind(?:\s+that)?|you\s+should\s+know(?:\s+that)?|note\s+that)\b[:,\s]*/i;
+/**
+ * Detect explicit memory intent. Returns null for normal chat messages.
+ */
+export function detectMemoryIntent(message) {
+    const match = TRIGGER_RE.exec(message.trim());
+    if (!match)
+        return null;
+    const raw = message.trim().slice(match[0].length).trim();
+    if (raw.length < 3)
+        return null;
+    const fact = normalizeFact(raw);
+    const type = categorizeFact(fact);
+    const tags = extractTags(fact, type);
+    const importance = type === 'personal' || /name is/i.test(fact) ? 9 : 8;
+    return {
+        fact, type, tags, importance,
+        confirmation: `✓ I've remembered that ${toConfirmation(fact)}.`,
+    };
+}
+/**
+ * Rewrite first-person statements into third-person facts.
+ *   "my name is Nandan"            → "User's name is Nandan"
+ *   "i am studying CSE at IIT"     → "User studies CSE at IIT"
+ *   "my favorite language is TS"   → "User's favorite language is TS"
+ */
+export function normalizeFact(raw) {
+    let s = raw.trim().replace(/\s+/g, ' ').replace(/[.!?]+$/, '');
+    const rules = [
+        [/^my name is\s+/i, 'User\'s name is '],
+        [/^my favorite\s+/i, 'User\'s favorite '],
+        [/^my\s+/i, 'User\'s '],
+        [/^i am studying\s+|^i'?m studying\s+|^i study\s+/i, 'User studies '],
+        [/^i am working (?:at|on)\s+/i, 'User works at '],
+        [/^i work (?:at|for)\s+/i, 'User works at '],
+        [/^i am a\s+|^i'?m a\s+/i, 'User is a '],
+        [/^i am an\s+|^i'?m an\s+/i, 'User is an '],
+        [/^i am\s+|^i'?m\s+/i, 'User is '],
+        [/^i prefer\s+/i, 'User prefers '],
+        [/^i like\s+/i, 'User likes '],
+        [/^i hate\s+|^i dislike\s+/i, 'User dislikes '],
+        [/^i live in\s+/i, 'User lives in '],
+        [/^i have\s+|^i'?ve got\s+/i, 'User has '],
+        [/^i use\s+/i, 'User uses '],
+        [/^i want\s+/i, 'User wants '],
+    ];
+    for (const [re, replacement] of rules) {
+        if (re.test(s)) {
+            s = s.replace(re, replacement);
+            break;
+        }
+    }
+    // Mid-sentence first-person cleanup: "…and i am…" → "…and is…"
+    s = s
+        .replace(/\bmy\b/gi, 'their')
+        .replace(/\bi am\b|\bi'?m\b/gi, 'is')
+        .replace(/(?<!User's name )\bis Nandan\b/g, 'is Nandan') // keep names intact
+        .replace(/\bi\b/g, 'they');
+    if (!/^User/.test(s))
+        s = `User: ${s}`;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+const EDUCATION_RE = /\b(stud(?:y|ies|ying)|college|university|iit|nit|b\.?tech|m\.?tech|degree|semester|year student|2nd year|3rd year|school|cse|ece|engineering)\b/i;
+const CAREER_RE = /\b(works? at|job|career|intern(?:ship)?|company|salary|hired|employer)\b/i;
+const PROJECT_RE = /\b(project|building|repo|app i|side.?project|startup)\b/i;
+const PREF_RE = /\b(favorite|prefers?|likes?|dislikes?|hates?|loves?)\b/i;
+const PERSONAL_RE = /\b(name is|birthday|lives? in|age|family|brother|sister|married)\b/i;
+export function categorizeFact(fact) {
+    if (PERSONAL_RE.test(fact))
+        return 'personal';
+    if (EDUCATION_RE.test(fact))
+        return 'education';
+    if (CAREER_RE.test(fact))
+        return 'career';
+    if (PROJECT_RE.test(fact))
+        return 'project';
+    if (PREF_RE.test(fact))
+        return 'preference';
+    return 'fact';
+}
+const TAG_PATTERNS = [
+    [/\biit\s+(\w+)/i, 'iit-$1'],
+    [/\bcse\b/i, 'cse'],
+    [/\bece\b/i, 'ece'],
+    [/\bcollege|university\b/i, 'college'],
+    [/\btypescript\b/i, 'typescript'],
+    [/\bjavascript\b/i, 'javascript'],
+    [/\bpython\b/i, 'python'],
+    [/\bcricket\b/i, 'cricket'],
+];
+export function extractTags(fact, type) {
+    const tags = new Set([type]);
+    for (const [re, tag] of TAG_PATTERNS) {
+        const m = re.exec(fact);
+        if (m)
+            tags.add(tag.replace('$1', (m[1] ?? '').toLowerCase()));
+    }
+    return [...tags];
+}
+/** "User's name is Nandan" → "your name is Nandan" for the confirmation line. */
+function toConfirmation(fact) {
+    return fact
+        .replace(/^User's\s+/i, 'your ')
+        .replace(/^User is\s+/i, "you're ")
+        .replace(/^User (\w+s)\s+/i, (_m, verb) => `you ${verb.replace(/s$/, '')} `)
+        .replace(/^User:\s*/i, '')
+        .replace(/\btheir\b/g, 'your')
+        .replace(/\bthey\b/g, 'you');
+}

package/dist/memory/long-term.js

@@ -0,0 +1,312 @@
+// MIT License — personal-ai
+import Database from 'better-sqlite3';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+import { eventBus } from '../core/events.js';
+import { logger } from '../core/logger.js';
+import { MEMORY_TYPES } from './types.js';
+import { VectorStore } from './vector-store.js';
+/** Cosine similarity above which two memories count as near-duplicates. */
+const NEAR_DUP_THRESHOLD = 0.92;
+/** Hybrid retrieval weights: semantic 70%, importance 20%, recency 10%. */
+const W_SEMANTIC = 0.7;
+const W_IMPORTANCE = 0.2;
+const W_RECENCY = 0.1;
+const DB_DIR = path.join(os.homedir(), '.personal-ai');
+const DB_PATH = path.join(DB_DIR, 'memory.db');
+function rowToMemory(row) {
+    return {
+        id: row.id,
+        content: row.content,
+        type: row.type,
+        tags: JSON.parse(row.tags),
+        importance: row.importance,
+        access_count: row.access_count,
+        created_at: row.created_at,
+        last_accessed: row.last_accessed,
+        archived: row.archived === 1,
+    };
+}
+export class LongTermMemory {
+    db;
+    vectors;
+    embedder;
+    constructor(dbPath = DB_PATH) {
+        if (!fs.existsSync(DB_DIR))
+            fs.mkdirSync(DB_DIR, { recursive: true });
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.migrate();
+        // VectorStore creates its side table on demand — existing DBs migrate
+        // transparently and keep working without vectors.
+        this.vectors = new VectorStore(this.db);
+        logger.debug('memory', `SQLite opened: ${dbPath}`);
+    }
+    /** Enable semantic indexing/retrieval. Without an embedder, keyword search is used. */
+    setEmbedder(embedder) {
+        this.embedder = embedder;
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id           TEXT PRIMARY KEY,
+        content      TEXT NOT NULL,
+        type         TEXT NOT NULL DEFAULT 'fact',
+        tags         TEXT NOT NULL DEFAULT '[]',
+        importance   INTEGER NOT NULL DEFAULT 5,
+        access_count INTEGER NOT NULL DEFAULT 0,
+        created_at   TEXT NOT NULL,
+        last_accessed TEXT NOT NULL,
+        archived     INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS idx_type     ON memories(type);
+      CREATE INDEX IF NOT EXISTS idx_archived ON memories(archived);
+      CREATE INDEX IF NOT EXISTS idx_importance ON memories(importance);
+    `);
+    }
+    /** Save new memory. Normalizes whitespace; never duplicates (case-insensitive). */
+    save(input) {
+        const now = new Date().toISOString();
+        const id = randomUUID();
+        const tags = JSON.stringify(input.tags ?? []);
+        const importance = input.importance ?? 5;
+        // Normalize: trim + collapse internal whitespace so "a  b" === "a b"
+        const content = input.content.trim().replace(/\s+/g, ' ');
+        // Upsert by content (case-insensitive) — update importance if exists
+        const existing = this.db
+            .prepare('SELECT * FROM memories WHERE LOWER(content) = LOWER(?) AND archived = 0')
+            .get(content);
+        if (existing) {
+            this.db.prepare(`
+        UPDATE memories SET importance = MAX(importance, ?), last_accessed = ? WHERE id = ?
+      `).run(importance, now, existing.id);
+            logger.debug('memory', `updated existing: ${existing.id}`);
+            return rowToMemory({ ...existing, importance: Math.max(existing.importance, importance), last_accessed: now });
+        }
+        this.db.prepare(`
+      INSERT INTO memories (id, content, type, tags, importance, access_count, created_at, last_accessed)
+      VALUES (?, ?, ?, ?, ?, 0, ?, ?)
+    `).run(id, content, input.type, tags, importance, now, now);
+        eventBus.emit('memory_saved', { type: input.type, importance });
+        logger.debug('memory', `saved [${input.type}] importance=${importance}: ${input.content.slice(0, 60)}`);
+        const row = this.db.prepare('SELECT * FROM memories WHERE id = ?').get(id);
+        return rowToMemory(row);
+    }
+    /**
+     * Tokenized LIKE search: splits the query into words and ranks rows by how
+     * many words match. A whole-sentence LIKE almost never matches, so this is
+     * what makes retrieval actually work for conversational queries.
+     */
+    search(query, limit = 8) {
+        const words = query
+            .toLowerCase()
+            .split(/[^a-z0-9]+/i)
+            .filter(w => w.length >= 3) // skip stopword-length noise
+            .slice(0, 12); // cap clause count
+        if (words.length === 0)
+            return this.getRecent(limit);
+        const clauses = words.map(() => '(CASE WHEN content LIKE ? THEN 1 ELSE 0 END)').join(' + ');
+        const params = words.map(w => `%${w}%`);
+        const rows = this.db.prepare(`
+      SELECT * FROM (
+        SELECT *, (${clauses}) AS hits FROM memories WHERE archived = 0
+      ) WHERE hits > 0
+      ORDER BY hits DESC, importance DESC, last_accessed DESC
+      LIMIT ?
+    `).all(...params, limit);
+        const results = rows.map(rowToMemory);
+        if (results.length > 0)
+            this.incrementAccessBatch(results.map(m => m.id));
+        eventBus.emit('memory_retrieved', { query, count: results.length });
+        logger.debug('memory', `search "${query}" → ${results.length} results`);
+        return results;
+    }
+    getByType(type, limit = 20) {
+        const rows = this.db.prepare(`
+      SELECT * FROM memories WHERE type = ? AND archived = 0
+      ORDER BY importance DESC, last_accessed DESC LIMIT ?
+    `).all(type, limit);
+        logger.debug('memory', `getByType ${type} → ${rows.length}`);
+        return rows.map(rowToMemory);
+    }
+    getRecent(limit = 10) {
+        const rows = this.db.prepare(`
+      SELECT * FROM memories WHERE archived = 0
+      ORDER BY created_at DESC, ROWID DESC LIMIT ?
+    `).all(limit);
+        logger.debug('memory', `getRecent → ${rows.length}`);
+        return rows.map(rowToMemory);
+    }
+    getAll(limit = 100) {
+        const rows = this.db.prepare(`
+      SELECT * FROM memories WHERE archived = 0
+      ORDER BY importance DESC, last_accessed DESC LIMIT ?
+    `).all(limit);
+        return rows.map(rowToMemory);
+    }
+    /** Soft-delete — never hard delete per spec. */
+    archive(id) {
+        this.db.prepare('UPDATE memories SET archived = 1 WHERE id = ?').run(id);
+        logger.debug('memory', `archived: ${id}`);
+    }
+    incrementAccess(id) {
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      UPDATE memories SET access_count = access_count + 1, last_accessed = ? WHERE id = ?
+    `).run(now, id);
+    }
+    incrementAccessBatch(ids) {
+        const now = new Date().toISOString();
+        const update = this.db.prepare('UPDATE memories SET access_count = access_count + 1, last_accessed = ? WHERE id = ?');
+        const tx = this.db.transaction((list) => {
+            for (const id of list)
+                update.run(now, id);
+        });
+        tx(ids);
+    }
+    getStats() {
+        const total = this.db.prepare('SELECT COUNT(*) as n FROM memories WHERE archived = 0').get().n;
+        const byTypeRows = this.db.prepare(`
+      SELECT type, COUNT(*) as n FROM memories WHERE archived = 0 GROUP BY type
+    `).all();
+        const byType = Object.fromEntries(MEMORY_TYPES.map(t => [t, 0]));
+        for (const r of byTypeRows)
+            byType[r.type] = r.n;
+        const avgRow = this.db.prepare('SELECT AVG(importance) as avg FROM memories WHERE archived = 0').get();
+        const topRow = this.db.prepare(`
+      SELECT * FROM memories WHERE archived = 0 ORDER BY access_count DESC LIMIT 1
+    `).get();
+        return {
+            total,
+            byType,
+            avgImportance: Math.round((avgRow.avg ?? 0) * 10) / 10,
+            mostAccessed: topRow ? rowToMemory(topRow) : null,
+        };
+    }
+    getById(id) {
+        const row = this.db.prepare('SELECT * FROM memories WHERE id = ?').get(id);
+        return row ? rowToMemory(row) : null;
+    }
+    // ── Semantic layer (M-embeddings) ───────────────────────────────────────
+    /**
+     * Save with semantic dedup: a new memory whose embedding is ≥ 0.92 cosine
+     * similar to an existing one merges into it (importance max-merged) instead
+     * of creating a near-identical row. Falls back to plain save() when no
+     * embedder is available.
+     */
+    async saveSmart(input) {
+        if (!this.embedder)
+            return { memory: this.save(input), deduped: false };
+        const vector = await this.embedder.embed(input.content);
+        if (!vector)
+            return { memory: this.save(input), deduped: false };
+        const [nearest] = this.vectors.search(vector, 1);
+        if (nearest && nearest.similarity >= NEAR_DUP_THRESHOLD) {
+            const existing = this.getById(nearest.memoryId);
+            if (existing) {
+                const importance = Math.max(existing.importance, input.importance ?? 5);
+                this.db.prepare('UPDATE memories SET importance = ?, last_accessed = ? WHERE id = ?')
+                    .run(importance, new Date().toISOString(), existing.id);
+                logger.debug('memory', `near-dup (${nearest.similarity.toFixed(3)}) merged into ${existing.id}`);
+                return { memory: { ...existing, importance }, deduped: true };
+            }
+        }
+        const memory = this.save(input);
+        this.vectors.put(memory.id, vector, this.embedder.name);
+        return { memory, deduped: false };
+    }
+    /**
+     * Hybrid semantic search: 70% cosine similarity, 20% importance, 10% recency.
+     * Falls back to tokenized keyword search when embeddings are unavailable.
+     */
+    async searchSemantic(query, limit = 8) {
+        if (!this.embedder || this.vectors.count() === 0)
+            return this.search(query, limit);
+        const queryVec = await this.embedder.embed(query);
+        if (!queryVec)
+            return this.search(query, limit);
+        const candidates = this.vectors.search(queryVec, limit * 3);
+        const now = Date.now();
+        const scored = candidates
+            .map(c => {
+            const memory = this.getById(c.memoryId);
+            if (!memory || memory.archived)
+                return null;
+            const ageDays = (now - new Date(memory.last_accessed).getTime()) / 86_400_000;
+            const recency = Math.exp(-ageDays / 30);
+            const score = W_SEMANTIC * c.similarity
+                + W_IMPORTANCE * (memory.importance / 10)
+                + W_RECENCY * recency;
+            return { memory, score };
+        })
+            .filter((x) => x !== null)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+        const results = scored.map(s => s.memory);
+        if (results.length > 0)
+            this.incrementAccessBatch(results.map(m => m.id));
+        eventBus.emit('memory_retrieved', { query, count: results.length });
+        logger.debug('memory', `semantic search "${query.slice(0, 40)}" → ${results.length}`);
+        return results;
+    }
+    /** Semantic when available, keyword otherwise — the engine's entry point. */
+    async searchSmart(query, limit = 8) {
+        if (this.embedder && this.vectors.count() > 0)
+            return this.searchSemantic(query, limit);
+        return this.search(query, limit);
+    }
+    /** Re-embed every active memory. Returns how many were indexed. */
+    async rebuildIndex(onProgress) {
+        if (!this.embedder)
+            return 0;
+        const all = this.getAll(10_000);
+        let done = 0;
+        for (const m of all) {
+            const vec = await this.embedder.embed(m.content);
+            if (vec) {
+                this.vectors.put(m.id, vec, this.embedder.name);
+                done++;
+            }
+            onProgress?.(done, all.length);
+        }
+        logger.debug('memory', `rebuilt vector index: ${done}/${all.length}`);
+        return done;
+    }
+    /** Vector index stats for /memory stats. */
+    getIndexStats() {
+        return { indexed: this.vectors.count(), embedder: this.embedder?.name ?? null };
+    }
+    /**
+     * Summarize low-value memories (importance ≤ 3, never accessed) into a
+     * single summary memory and archive the originals. `generate` is any
+     * text-in/text-out function — provider-blind by design.
+     */
+    async summarizeLowValue(generate, opts = {}) {
+        const minCount = opts.minCount ?? 10;
+        const maxImportance = opts.maxImportance ?? 3;
+        const rows = this.db.prepare(`
+      SELECT * FROM memories
+      WHERE archived = 0 AND importance <= ? AND access_count = 0
+      ORDER BY created_at ASC
+    `).all(maxImportance);
+        if (rows.length < minCount)
+            return { summarized: 0, summary: null };
+        const list = rows.map(r => `- ${r.content}`).join('\n');
+        const prompt = `Summarize these minor facts about the user into one short paragraph. Keep every distinct fact:\n${list}`;
+        const text = (await generate(prompt)).trim();
+        if (!text)
+            return { summarized: 0, summary: null };
+        const summary = this.save({ content: text, type: 'context', importance: 5, tags: ['summary'] });
+        const archive = this.db.prepare('UPDATE memories SET archived = 1 WHERE id = ?');
+        const tx = this.db.transaction((ids) => { for (const id of ids)
+            archive.run(id); });
+        tx(rows.map(r => r.id));
+        logger.debug('memory', `summarized ${rows.length} low-value memories into ${summary.id}`);
+        return { summarized: rows.length, summary };
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/memory/short-term.js

@@ -0,0 +1,63 @@
+import { normalizeFact, categorizeFact } from './intent.js';
+const TRIGGERS = [
+    { pattern: /my name is .+/i, type: 'fact', importance: 9 },
+    { pattern: /i work at .+/i, type: 'fact', importance: 8 },
+    { pattern: /i live in .+/i, type: 'fact', importance: 8 },
+    { pattern: /i(?:'m| am) a .+/i, type: 'fact', importance: 7 },
+    { pattern: /i prefer .+/i, type: 'preference', importance: 7 },
+    { pattern: /i always .+/i, type: 'preference', importance: 6 },
+    { pattern: /i usually .+/i, type: 'preference', importance: 6 },
+    { pattern: /my favorite .+/i, type: 'preference', importance: 7 },
+    { pattern: /i like .+/i, type: 'preference', importance: 5 },
+    { pattern: /i hate .+/i, type: 'preference', importance: 6 },
+    { pattern: /remember that .+/i, type: 'context', importance: 8 },
+    { pattern: /you should know .+/i, type: 'context', importance: 8 },
+];
+/** Ring buffer for short-term context window. */
+export class CircularBuffer {
+    maxSize;
+    buf = [];
+    pos = 0;
+    constructor(maxSize = 30) {
+        this.maxSize = maxSize;
+    }
+    push(item) {
+        if (this.buf.length < this.maxSize) {
+            this.buf.push(item);
+        }
+        else {
+            this.buf[this.pos] = item;
+            this.pos = (this.pos + 1) % this.maxSize;
+        }
+    }
+    getAll() {
+        if (this.buf.length < this.maxSize)
+            return [...this.buf];
+        return [...this.buf.slice(this.pos), ...this.buf.slice(0, this.pos)];
+    }
+    clear() { this.buf = []; this.pos = 0; }
+    get size() { return this.buf.length; }
+}
+/**
+ * Scan text for memory-worthy sentences based on trigger patterns.
+ * Returns candidates sorted by importance desc.
+ */
+export function extractMemoryCandidates(text) {
+    const sentences = text
+        .split(/[.!?\n]+/)
+        .map(s => s.trim())
+        .filter(s => s.length > 5);
+    const candidates = [];
+    for (const sentence of sentences) {
+        for (const { pattern, type, importance } of TRIGGERS) {
+            if (pattern.test(sentence)) {
+                // Store normalized third-person facts, not raw first-person sentences
+                const content = normalizeFact(sentence);
+                const refined = categorizeFact(content);
+                candidates.push({ content, type: refined === 'fact' ? type : refined, importance });
+                break; // one trigger per sentence
+            }
+        }
+    }
+    return candidates.sort((a, b) => b.importance - a.importance);
+}

package/dist/memory/types.js

@@ -0,0 +1,5 @@
+// MIT License — personal-ai
+export const MEMORY_TYPES = [
+    'fact', 'preference', 'context', 'episodic',
+    'education', 'career', 'project', 'personal',
+];

package/dist/memory/vector-store.js

@@ -0,0 +1,57 @@
+// MIT License — personal-ai
+// SQLite-backed vector store. Vectors live in a side table keyed by memory id
+// — existing databases keep working; the table is created on demand.
+import { cosineSimilarity } from './embeddings.js';
+export class VectorStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_vectors (
+        memory_id TEXT PRIMARY KEY,
+        model     TEXT NOT NULL,
+        dims      INTEGER NOT NULL,
+        vector    BLOB NOT NULL
+      );
+    `);
+    }
+    put(memoryId, vector, model) {
+        const buf = Buffer.from(new Float32Array(vector).buffer);
+        this.db.prepare(`
+      INSERT INTO memory_vectors (memory_id, model, dims, vector)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(memory_id) DO UPDATE SET model = excluded.model, dims = excluded.dims, vector = excluded.vector
+    `).run(memoryId, model, vector.length, buf);
+    }
+    get(memoryId) {
+        const row = this.db.prepare('SELECT vector FROM memory_vectors WHERE memory_id = ?')
+            .get(memoryId);
+        if (!row)
+            return null;
+        return new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4);
+    }
+    delete(memoryId) {
+        this.db.prepare('DELETE FROM memory_vectors WHERE memory_id = ?').run(memoryId);
+    }
+    count() {
+        return this.db.prepare('SELECT COUNT(*) AS n FROM memory_vectors').get().n;
+    }
+    /**
+     * Brute-force cosine search over all stored vectors. Fine for a personal
+     * assistant's scale (thousands of memories); swap for sqlite-vec if it
+     * ever becomes a bottleneck.
+     */
+    search(queryVector, limit = 16) {
+        const rows = this.db.prepare(`
+      SELECT v.memory_id, v.vector
+      FROM memory_vectors v
+      JOIN memories m ON m.id = v.memory_id AND m.archived = 0
+    `).all();
+        const scored = rows.map(r => ({
+            memoryId: r.memory_id,
+            similarity: cosineSimilarity(queryVector, new Float32Array(r.vector.buffer, r.vector.byteOffset, r.vector.byteLength / 4)),
+        }));
+        scored.sort((a, b) => b.similarity - a.similarity);
+        return scored.slice(0, limit);
+    }
+}

package/dist/persona/loader.js

@@ -0,0 +1,56 @@
+// MIT License — personal-ai
+import fs from 'node:fs';
+import yaml from 'js-yaml';
+import chokidar from 'chokidar';
+import { logger } from '../core/logger.js';
+import { PersonaConfigSchema, ProfilesConfigSchema, } from './types.js';
+function readYaml(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return yaml.load(raw);
+}
+/** Load and validate persona.yaml. */
+export function loadPersona(filePath) {
+    const raw = readYaml(filePath);
+    const result = PersonaConfigSchema.safeParse(raw);
+    if (!result.success) {
+        logger.warn('persona', `Invalid persona config: ${result.error.message}`);
+        return PersonaConfigSchema.parse({ name: 'AI', expertise: [], avoid: [] });
+    }
+    logger.debug('persona', `Loaded persona: ${result.data.name}`);
+    return result.data;
+}
+/** Load and validate profiles.yaml. */
+export function loadProfiles(filePath) {
+    const raw = readYaml(filePath);
+    const result = ProfilesConfigSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`Invalid profiles config: ${result.error.message}`);
+    }
+    logger.debug('persona', `Loaded ${Object.keys(result.data.profiles).length} profiles`);
+    return result.data;
+}
+/** Watch file for changes, call onChange with reparsed data. Returns cleanup fn. */
+export function watchPersona(filePath, onChange) {
+    const watcher = chokidar.watch(filePath, { ignoreInitial: true });
+    watcher.on('change', () => {
+        try {
+            onChange(loadPersona(filePath));
+        }
+        catch (e) {
+            logger.warn('persona', `watch reload failed: ${String(e)}`);
+        }
+    });
+    return () => { void watcher.close(); };
+}
+export function watchProfiles(filePath, onChange) {
+    const watcher = chokidar.watch(filePath, { ignoreInitial: true });
+    watcher.on('change', () => {
+        try {
+            onChange(loadProfiles(filePath));
+        }
+        catch (e) {
+            logger.warn('persona', `watch reload failed: ${String(e)}`);
+        }
+    });
+    return () => { void watcher.close(); };
+}

package/dist/persona/profiles.js

@@ -0,0 +1,51 @@
+// MIT License — personal-ai
+import { logger } from '../core/logger.js';
+export class ProfileManager {
+    config;
+    active;
+    profiles;
+    constructor(config) {
+        this.config = config;
+        this.active = config.active;
+        this.profiles = config.profiles;
+        // Fallback to 'assistant' if active doesn't exist
+        if (!this.profiles[this.active]) {
+            const first = Object.keys(this.profiles)[0];
+            this.active = first ?? 'assistant';
+            logger.debug('profile', `Active profile "${config.active}" not found, using "${this.active}"`);
+        }
+    }
+    getActive() {
+        return this.profiles[this.active];
+    }
+    getActiveName() {
+        return this.active;
+    }
+    setActive(name) {
+        if (!this.profiles[name]) {
+            throw new Error(`Profile "${name}" not found. Available: ${Object.keys(this.profiles).join(', ')}`);
+        }
+        this.active = name;
+        logger.debug('profile', `switched to: ${name}`);
+    }
+    getAll() {
+        return this.profiles;
+    }
+    getPromptAddon() {
+        return this.getActive().system_addon ?? '';
+    }
+    getPreferredModel() {
+        return this.getActive().preferred_model;
+    }
+    getTemperature() {
+        return this.getActive().temperature;
+    }
+    /** Hot-reload when config file changes. */
+    reload(config) {
+        this.profiles = config.profiles;
+        if (!this.profiles[this.active]) {
+            this.active = config.active;
+        }
+        logger.debug('profile', `reloaded — active: ${this.active}`);
+    }
+}