clementine-agent 1.0.2 → 1.0.3

package/README.md

@@ -85,6 +85,8 @@ bash install.sh
 
 The install script handles everything: system dependencies (redis, libomp, build tools), npm packages, TypeScript build, global CLI install, and launches the setup wizard. Safe to re-run — skips anything already installed.
 
+The setup wizard auto-generates a Discord bot invite URL from your token and offers to open it in your browser — no need to visit the Developer Portal manually.
+
 After setup:
 
 ```bash
@@ -324,6 +326,11 @@ clementine tools               List available MCP tools, plugins, and channels
 clementine config setup        Interactive configuration wizard
 clementine config set KEY VAL  Set a single config value
 clementine config get KEY      Read a config value
+clementine config edit         Open .env in your editor ($EDITOR)
+clementine memory search <q>   Search memory from the terminal (FTS5)
+clementine projects list       Show all linked projects
+clementine projects add <path> Link a project directory (-d desc, -k keywords)
+clementine projects remove <p> Unlink a project directory
 clementine cron list           List all cron jobs and last run status
 clementine cron run <job>      Run a specific cron job
 clementine cron run-due        Run all due jobs (for OS scheduler)

package/dist/cli/chat.js

@@ -198,17 +198,35 @@ export async function cmdChat(opts) {
         }
         // ── Send message ──────────────────────────────────────────
         process.stdout.write(`\n${DIM}thinking...${RESET}\r`);
+        let firstToken = true;
+        let streamedLen = 0;
         try {
-            const response = await gateway.handleMessage(sessionKey, effectiveText, undefined, oneOffModel);
-            // Clear "thinking..." line
-            process.stdout.write('\x1b[2K\r');
-            // Show active project if auto-matched
-            const matched = gateway.getLastMatchedProject(sessionKey);
-            if (matched) {
-                console.log(`\x1b[0;90m[project: ${path.basename(matched.path)}]\x1b[0m`);
+            const response = await gateway.handleMessage(sessionKey, effectiveText, async (token) => {
+                if (firstToken) {
+                    // Clear "thinking..." and show project context on first real token
+                    process.stdout.write('\x1b[2K\r');
+                    const matched = gateway.getLastMatchedProject(sessionKey);
+                    if (matched) {
+                        process.stdout.write(`${DIM}[project: ${path.basename(matched.path)}]${RESET}\n`);
+                    }
+                    firstToken = false;
+                }
+                process.stdout.write(token);
+                streamedLen += token.length;
+            }, oneOffModel);
+            // If we streamed, just add a newline. Otherwise fall back to full render.
+            if (streamedLen > 0) {
+                process.stdout.write('\n\n');
+            }
+            else {
+                process.stdout.write('\x1b[2K\r');
+                const matched = gateway.getLastMatchedProject(sessionKey);
+                if (matched) {
+                    console.log(`${DIM}[project: ${path.basename(matched.path)}]${RESET}`);
+                }
+                console.log(renderMarkdown(response));
+                console.log();
             }
-            console.log(renderMarkdown(response));
-            console.log();
         }
         catch (err) {
             process.stdout.write('\x1b[2K\r');

package/dist/config.d.ts

@@ -117,8 +117,8 @@ export declare const LINK_EXTRACT_MAX_URLS = 3;
 export declare const LINK_EXTRACT_MAX_CHARS = 4000;
 export declare const MEMORY_DB_PATH: string;
 export declare const GRAPH_DB_DIR: string;
-export declare const SEARCH_CONTEXT_LIMIT = 3;
-export declare const SEARCH_RECENCY_LIMIT = 3;
+export declare const SEARCH_CONTEXT_LIMIT = 6;
+export declare const SEARCH_RECENCY_LIMIT = 4;
 export declare const SYSTEM_PROMPT_MAX_CONTEXT_CHARS = 12000;
 export declare const SESSION_EXCHANGE_HISTORY_SIZE = 10;
 export declare const SESSION_EXCHANGE_MAX_CHARS = 2000;

package/dist/config.js

@@ -239,8 +239,8 @@ export const LINK_EXTRACT_MAX_CHARS = 4000;
 // ── Memory / Search ──────────────────────────────────────────────────
 export const MEMORY_DB_PATH = path.join(VAULT_DIR, '.memory.db');
 export const GRAPH_DB_DIR = path.join(BASE_DIR, '.graph.db');
-export const SEARCH_CONTEXT_LIMIT = 3;
-export const SEARCH_RECENCY_LIMIT = 3;
+export const SEARCH_CONTEXT_LIMIT = 6;
+export const SEARCH_RECENCY_LIMIT = 4;
 export const SYSTEM_PROMPT_MAX_CONTEXT_CHARS = 12000;
 // ── Session Persistence ──────────────────────────────────────────────
 export const SESSION_EXCHANGE_HISTORY_SIZE = 10;

package/dist/index.js

@@ -545,6 +545,33 @@ async function asyncMain() {
     // Agent layer
     const { PersonalAssistant } = await import('./agent/assistant.js');
     const assistant = new PersonalAssistant();
+    // Memory maintenance — startup + periodic (non-blocking)
+    let maintenanceInterval;
+    {
+        const memStore = assistant.getMemoryStore();
+        if (memStore) {
+            const { runStartupMaintenance, startPeriodicMaintenance } = await import('./memory/maintenance.js');
+            // Fire-and-forget startup maintenance
+            runStartupMaintenance(memStore).catch(() => { });
+            // Periodic maintenance every 6 hours (consolidation needs an LLM caller)
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            const llmCall = async (prompt) => {
+                try {
+                    let result = '';
+                    const stream = query({ prompt, options: { model: 'claude-haiku-4-5-20251001', maxTurns: 1, systemPrompt: 'You are a memory consolidation assistant. Be concise.' } });
+                    for await (const msg of stream) {
+                        if (msg.type === 'result')
+                            result = msg.result ?? '';
+                    }
+                    return result;
+                }
+                catch {
+                    return '';
+                }
+            };
+            maintenanceInterval = startPeriodicMaintenance(memStore, llmCall);
+        }
+    }
     // Gateway layer
     const { Gateway } = await import('./gateway/router.js');
     const gateway = new Gateway(assistant);
@@ -833,6 +860,8 @@ async function asyncMain() {
     clearInterval(timerInterval);
     clearInterval(teamDeliveryInterval);
     clearInterval(sourceEditInterval);
+    if (maintenanceInterval)
+        clearInterval(maintenanceInterval);
     // Close graph store FIRST — FalkorDBLite's cleanup.js registers an
     // uncaughtException handler that re-throws errors.  If a Redis socket
     // drops during the drain wait, that handler crashes the process.

package/dist/memory/maintenance.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Clementine TypeScript — Automatic Memory Maintenance.
+ *
+ * Runs startup and periodic maintenance so the memory store stays healthy
+ * without manual intervention. New users get this out of the box.
+ *
+ * Startup: decay salience, prune stale data, backfill embeddings
+ * Periodic (every 6h): full consolidation cycle + embedding rebuild
+ */
+/**
+ * Run one-time maintenance at daemon startup.
+ * Non-blocking — errors are logged but never thrown.
+ */
+export declare function runStartupMaintenance(store: any): Promise<void>;
+/**
+ * Start periodic maintenance on a 6-hour interval.
+ * Returns the interval handle for cleanup on shutdown.
+ */
+export declare function startPeriodicMaintenance(store: any, llmCall?: (prompt: string) => Promise<string>): ReturnType<typeof setInterval>;
+//# sourceMappingURL=maintenance.d.ts.map

package/dist/memory/maintenance.js

@@ -0,0 +1,121 @@
+/**
+ * Clementine TypeScript — Automatic Memory Maintenance.
+ *
+ * Runs startup and periodic maintenance so the memory store stays healthy
+ * without manual intervention. New users get this out of the box.
+ *
+ * Startup: decay salience, prune stale data, backfill embeddings
+ * Periodic (every 6h): full consolidation cycle + embedding rebuild
+ */
+import pino from 'pino';
+const logger = pino({ name: 'clementine.maintenance' });
+const PERIODIC_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+/**
+ * Run one-time maintenance at daemon startup.
+ * Non-blocking — errors are logged but never thrown.
+ */
+export async function runStartupMaintenance(store) {
+    const start = Date.now();
+    logger.info('Starting memory maintenance (startup)');
+    try {
+        const decayed = store.decaySalience?.();
+        if (decayed)
+            logger.info({ decayed }, 'Salience decay applied');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Salience decay failed');
+    }
+    try {
+        const pruned = store.pruneStaleData?.();
+        if (pruned)
+            logger.info(pruned, 'Stale data pruned');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Stale data pruning failed');
+    }
+    try {
+        const embedded = store.buildEmbeddings?.();
+        if (embedded)
+            logger.info(embedded, 'Embeddings built/backfilled');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Embedding backfill failed');
+    }
+    // Prune old extraction logs (keep active extractions regardless of age)
+    try {
+        const conn = store.conn;
+        if (conn) {
+            const result = conn.prepare(`DELETE FROM memory_extractions
+         WHERE extracted_at < datetime('now', '-90 days')
+         AND status != 'active'`).run();
+            if (result.changes > 0) {
+                logger.info({ pruned: result.changes }, 'Old extraction logs pruned');
+            }
+        }
+    }
+    catch {
+        // Table may not exist yet — non-fatal
+    }
+    logger.info({ durationMs: Date.now() - start }, 'Startup maintenance complete');
+}
+/**
+ * Start periodic maintenance on a 6-hour interval.
+ * Returns the interval handle for cleanup on shutdown.
+ */
+export function startPeriodicMaintenance(store, llmCall) {
+    const runCycle = async () => {
+        const start = Date.now();
+        logger.info('Starting periodic memory maintenance');
+        // 1. Decay + prune
+        try {
+            store.decaySalience?.();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic decay failed');
+        }
+        try {
+            store.pruneStaleData?.();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic prune failed');
+        }
+        // 2. Rebuild vocab + backfill embeddings
+        try {
+            store.buildEmbeddings?.();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic embedding build failed');
+        }
+        // 3. Consolidation (dedup, summarize, extract principles)
+        if (llmCall) {
+            try {
+                const { runConsolidation } = await import('./consolidation.js');
+                const result = await runConsolidation(store, llmCall);
+                logger.info(result, 'Consolidation cycle complete');
+            }
+            catch (err) {
+                logger.warn({ err }, 'Consolidation failed');
+            }
+            // 4. Re-backfill embeddings for any new summary chunks from consolidation
+            try {
+                store.buildEmbeddings?.();
+            }
+            catch (err) {
+                logger.warn({ err }, 'Post-consolidation embedding build failed');
+            }
+        }
+        // 5. Extraction log pruning
+        try {
+            const conn = store.conn;
+            if (conn) {
+                conn.prepare(`DELETE FROM memory_extractions
+           WHERE extracted_at < datetime('now', '-90 days')
+           AND status != 'active'`).run();
+            }
+        }
+        catch { /* non-fatal */ }
+        logger.info({ durationMs: Date.now() - start }, 'Periodic maintenance complete');
+    };
+    return setInterval(runCycle, PERIODIC_INTERVAL_MS);
+}
+//# sourceMappingURL=maintenance.js.map

package/dist/memory/store.js

@@ -748,9 +748,7 @@ export class MemoryStore {
         const rows = this.conn
             .prepare(`SELECT id, source_file, section, content, chunk_type, embedding, salience, agent_slug, updated_at, category, topic
          FROM chunks
-         WHERE embedding IS NOT NULL AND consolidated = 0
-         ORDER BY updated_at DESC
-         LIMIT 500`)
+         WHERE embedding IS NOT NULL`)
             .all();
         const scored = [];
         for (const row of rows) {
@@ -1616,10 +1614,18 @@ export class MemoryStore {
      */
     insertSummaryChunk(sourceFile, section, content) {
         const hash = createHash('sha256').update(content).digest('hex').slice(0, 16);
-        this.conn
+        const result = this.conn
             .prepare(`INSERT INTO chunks (source_file, section, content, chunk_type, content_hash, salience, consolidated)
          VALUES (?, ?, ?, 'summary', ?, 0.8, 0)`)
             .run(sourceFile, section, content, hash);
+        // Immediately compute embedding so the summary is vector-searchable right away
+        if (embeddingsModule.isReady()) {
+            const vec = embeddingsModule.embed(content);
+            if (vec) {
+                this.conn.prepare('UPDATE chunks SET embedding = ? WHERE id = ?')
+                    .run(embeddingsModule.serializeEmbedding(vec), result.lastInsertRowid);
+            }
+        }
     }
     // ── SDR Operational Data ─────────────────────────────────────────
     // -- Leads --
@@ -1912,17 +1918,17 @@ export class MemoryStore {
     buildEmbeddings() {
         // Gather all chunk contents for vocabulary building
         const rows = this.conn
-            .prepare('SELECT id, content FROM chunks WHERE consolidated = 0')
+            .prepare('SELECT id, content FROM chunks')
             .all();
         if (rows.length === 0)
             return { vocabSize: 0, backfilled: 0 };
-        // Build vocabulary from corpus
+        // Build vocabulary from entire corpus (including consolidated summaries)
         embeddingsModule.buildVocab(rows.map((r) => r.content));
         if (!embeddingsModule.isReady())
             return { vocabSize: 0, backfilled: 0 };
-        // Backfill embeddings for chunks that don't have one
+        // Backfill embeddings for all chunks that don't have one
         const missing = this.conn
-            .prepare('SELECT id, content FROM chunks WHERE embedding IS NULL AND consolidated = 0')
+            .prepare('SELECT id, content FROM chunks WHERE embedding IS NULL')
             .all();
         const updateStmt = this.conn.prepare('UPDATE chunks SET embedding = ? WHERE id = ?');
         let backfilled = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",