@noorm/marie-cli 0.1.18 → 0.1.25

package/dist/monolith/runtime/MarieRuntime.js

@@ -1,552 +1,129 @@
-import { ToolRegistry } from "../infrastructure/tools/ToolRegistry.js";
-import { ConfigService } from "../infrastructure/config/ConfigService.js";
 import { MarieEngine } from "../infrastructure/ai/core/MarieEngine.js";
-import { MarieProgressTracker } from "../infrastructure/ai/core/MarieProgressTracker.js";
-import { MarieResponse } from "../infrastructure/ai/core/MarieResponse.js";
-import { NoormmeEngine } from "../infrastructure/persistence/NoormmeEngine.js";
-import { StringUtils } from "../plumbing/utils/StringUtils.js";
-import { MarieMutex } from "../plumbing/utils/MutexUtils.js";
+import { MarieMutex } from "../plumbing/utils/PlumbingCore.js";
+import { plan, processSessionEnd, renderMessage } from "../services/MarieServices.js";
 export class MarieRuntime {
     options;
     provider;
-    lastProviderKey;
-    toolRegistry;
     currentSessionId = "default";
     messages = [];
-    sequenceNumber = 0;
     abortController = null;
-    currentRun;
     initPromise;
-    pendingApprovals = new Map();
     processingMutex = new MarieMutex("ProcessingLock");
-    persistenceMutex = new MarieMutex("PersistenceLock");
-    onStateChangedCallbacks = [];
     constructor(options) {
         this.options = options;
-        this.toolRegistry = new ToolRegistry();
-        this.options.toolRegistrar(this.toolRegistry, this.options.automationService);
+        this.options.toolRegistrar(this.options.automationService);
         this.initPromise = this.initialize();
     }
     async initialize() {
-        this.currentSessionId =
-            (await this.options.sessionStore.getCurrentSessionId()) || "default";
-        await this.loadHistory();
-    }
-    async ensureInitialized() {
-        await this.initPromise;
-    }
-    createProvider(providerType) {
-        const typedProvider = providerType;
-        const key = this.options.config.getApiKey(typedProvider) || "";
-        return this.options.providerFactory(typedProvider, key);
+        this.currentSessionId = (await this.options.sessionStore.getCurrentSessionId()) || "default";
+        const historyMap = await this.options.sessionStore.getSessions();
+        this.messages = historyMap[this.currentSessionId] || [];
     }
+    ensureInitialized() { return this.initPromise; }
     initializeProvider() {
         const providerType = this.options.config.getAiProvider();
         const key = this.options.config.getApiKey(providerType) || "";
-        const cacheKey = `${providerType}:${key}`;
-        if (this.provider && this.lastProviderKey === cacheKey) {
-            return;
-        }
-        this.lastProviderKey = cacheKey;
         this.provider = this.options.providerFactory(providerType, key);
     }
-    async loadHistory() {
-        const historyMap = await this.options.sessionStore.getSessions();
-        this.messages = historyMap[this.currentSessionId] || [];
-    }
-    onStateChanged(callback) {
-        this.onStateChangedCallbacks.push(callback);
-        return () => {
-            this.onStateChangedCallbacks = this.onStateChangedCallbacks.filter((c) => c !== callback);
-        };
-    }
-    emitStateChanged() {
-        const state = {
-            messages: [...this.messages],
-            currentSessionId: this.currentSessionId,
-            sequenceNumber: ++this.sequenceNumber,
-        };
-        for (const callback of this.onStateChangedCallbacks) {
-            try {
-                callback(state);
-            }
-            catch (e) {
-                console.error("[MarieRuntime] Error in state change callback", e);
-            }
-        }
-    }
-    async saveHistoryInternal(telemetry, specificSessionId, runStartTime) {
-        if (this.messages.length > 50) {
-            this.messages = this.messages.slice(this.messages.length - 50);
-        }
-        const sid = specificSessionId || this.currentSessionId;
-        const historyMap = await this.options.sessionStore.getSessions();
-        const currentSessionMatches = sid === this.currentSessionId;
-        const isSessionStillValid = runStartTime ? true : currentSessionMatches;
-        if (sid === this.currentSessionId && isSessionStillValid) {
-            historyMap[sid] = this.messages;
-        }
-        else {
-            if (!historyMap[sid]) {
-                historyMap[sid] = [];
-            }
-        }
-        await this.options.sessionStore.saveSessions(historyMap);
-        const sessionMetadata = await this.options.sessionStore.getSessionMetadata();
-        const index = sessionMetadata.findIndex((s) => s.id === sid);
-        const targetMessages = sid === this.currentSessionId ? this.messages : historyMap[sid];
-        const firstMsg = targetMessages && targetMessages.length > 0
-            ? targetMessages[0].content
-            : "";
-        const title = targetMessages && targetMessages.length > 0
-            ? this.generateSessionTitle(firstMsg)
-            : "New Session";
-        if (index >= 0) {
-            sessionMetadata[index].lastModified = Date.now();
-            if (sessionMetadata[index].title === "New Session") {
-                sessionMetadata[index].title = title;
-            }
-        }
-        else if (sid !== "default") {
-            sessionMetadata.unshift({
-                id: sid,
-                title,
-                lastModified: Date.now(),
-                isPinned: false,
-            });
-        }
-        await this.options.sessionStore.saveSessionMetadata(sessionMetadata);
-        if (sid === this.currentSessionId) {
-            await this.options.sessionStore.setCurrentSessionId(sid);
-        }
-        if (telemetry !== undefined) {
-            await this.options.sessionStore.setLastTelemetry(telemetry === null ? undefined : telemetry);
-        }
-        if (sid === this.currentSessionId) {
-            this.emitStateChanged();
-        }
-    }
-    async saveHistory(telemetry, specificSessionId, runStartTime) {
-        const unlock = await this.persistenceMutex.acquire();
-        try {
-            await this.saveHistoryInternal(telemetry, specificSessionId, runStartTime);
-        }
-        finally {
-            unlock();
-        }
-    }
-    generateSessionTitle(firstMessage) {
-        const response = MarieResponse.wrap(firstMessage);
-        const text = response.getText();
-        const goalMatch = text.match(/(?:Goal|Objective|Task):\s*([^\n.]+)/i);
-        if (goalMatch && goalMatch[1].trim()) {
-            return this.formatTitle(goalMatch[1].trim());
-        }
-        const lines = text
-            .split("\n")
-            .map((l) => l.trim())
-            .filter((l) => l.length > 5);
-        if (lines.length > 0 && lines[0].length < 60) {
-            return this.formatTitle(lines[0]);
-        }
-        const summary = text.trim() || "New Session";
-        return this.formatTitle(summary);
-    }
-    formatTitle(text) {
-        const clean = text.replace(/^[#\-*\s]+/, "").trim();
-        if (clean.length > 30) {
-            return clean.substring(0, 27) + "...";
-        }
-        return clean || "New Session";
-    }
-    async createSession() {
-        await this.ensureInitialized();
-        const unlock = await this.persistenceMutex.acquire();
-        try {
-            this.currentSessionId = `session_${Date.now()}`;
-            this.messages = [];
-            await this.saveHistoryInternal();
-            return this.currentSessionId;
-        }
-        finally {
-            unlock();
-        }
-    }
-    async listSessions() {
-        await this.ensureInitialized();
-        return this.options.sessionStore.getSessionMetadata();
-    }
-    async loadSession(id) {
-        await this.ensureInitialized();
-        const unlock = await this.persistenceMutex.acquire();
-        try {
-            this.stopGeneration();
-            this.currentSessionId = id;
-            await this.loadHistory();
-            await this.options.sessionStore.setCurrentSessionId(id);
-            this.emitStateChanged();
-            return this.currentSessionId;
-        }
-        finally {
-            unlock();
-        }
-    }
-    async deleteSession(id) {
-        await this.ensureInitialized();
-        let firstSessionId;
-        let shouldLoadFirst = false;
-        let shouldCreateNew = false;
-        const unlock = await this.persistenceMutex.acquire();
-        try {
-            if (this.currentSessionId === id) {
-                this.stopGeneration();
-            }
-            const historyMap = await this.options.sessionStore.getSessions();
-            delete historyMap[id];
-            await this.options.sessionStore.saveSessions(historyMap);
-            const sessionMetadata = await this.options.sessionStore.getSessionMetadata();
-            const filteredMetadata = sessionMetadata.filter((s) => s.id !== id);
-            await this.options.sessionStore.saveSessionMetadata(filteredMetadata);
-            if (this.currentSessionId === id) {
-                if (filteredMetadata.length > 0) {
-                    shouldLoadFirst = true;
-                    firstSessionId = filteredMetadata[0].id;
-                }
-                else {
-                    shouldCreateNew = true;
-                }
-            }
-            if (shouldLoadFirst && firstSessionId) {
-                this.currentSessionId = firstSessionId;
-                await this.loadHistory();
-                await this.options.sessionStore.setCurrentSessionId(this.currentSessionId);
-                this.emitStateChanged();
-            }
-            else if (shouldCreateNew) {
-                this.currentSessionId = `session_${Date.now()}`;
-                this.messages = [];
-                await this.saveHistoryInternal();
-            }
-        }
-        finally {
-            unlock();
-        }
-    }
-    async renameSession(id, newTitle) {
-        const unlock = await this.persistenceMutex.acquire();
-        try {
-            await this.ensureInitialized();
-            const sessionMetadata = await this.options.sessionStore.getSessionMetadata();
-            const index = sessionMetadata.findIndex((s) => s.id === id);
-            if (index >= 0) {
-                sessionMetadata[index].title = newTitle;
-                await this.options.sessionStore.saveSessionMetadata(sessionMetadata);
-                this.emitStateChanged();
-            }
-        }
-        finally {
-            unlock();
-        }
-    }
-    async togglePinSession(id) {
-        const unlock = await this.persistenceMutex.acquire();
-        try {
-            await this.ensureInitialized();
-            const sessionMetadata = await this.options.sessionStore.getSessionMetadata();
-            const index = sessionMetadata.findIndex((s) => s.id === id);
-            if (index >= 0) {
-                sessionMetadata[index].isPinned = !sessionMetadata[index].isPinned;
-                await this.options.sessionStore.saveSessionMetadata(sessionMetadata);
-                this.emitStateChanged();
-            }
-        }
-        finally {
-            unlock();
-        }
-    }
     async handleMessage(text, callbacks) {
-        let unlock;
-        let attempts = 0;
-        const maxAttempts = 3;
-        while (attempts < maxAttempts) {
-            try {
-                unlock = await this.processingMutex.acquire(10000); // 10s timeout per attempt
-                break;
-            }
-            catch (e) {
-                attempts++;
-                if (attempts >= maxAttempts) {
-                    return `Error: System is currently busy with another task. Please wait a moment and try again. (Mutex Timeout)`;
-                }
-                console.warn(`[MarieRuntime] Mutex acquisition attempt ${attempts} failed, retrying...`);
-                await new Promise((resolve) => setTimeout(resolve, 1000));
-            }
-        }
+        const unlock = await this.processingMutex.acquire(100000);
         try {
             await this.ensureInitialized();
             this.initializeProvider();
-            if (!this.provider) {
-                return "Please configure your API key for the selected provider.";
-            }
+            if (!this.provider)
+                return "Please configure your API key.";
             const lastTelemetry = await this.options.sessionStore.getLastTelemetry();
-            const originatingSessionId = this.currentSessionId;
             const run = {
                 runId: `run_${Date.now()}`,
                 startedAt: Date.now(),
                 steps: 0,
                 tools: 0,
-                objectives: [
-                    {
-                        id: "understand_request",
-                        label: "Understand request",
-                        status: "in_progress",
-                    },
-                    { id: "execute_plan", label: "Execute plan", status: "pending" },
-                    { id: "deliver_result", label: "Deliver result", status: "pending" },
-                ],
-                activeObjectiveId: "understand_request",
+                objectives: [],
                 achieved: [],
-                currentPass: lastTelemetry?.currentPass,
-                totalPasses: lastTelemetry?.totalPasses,
-                passFocus: lastTelemetry?.passFocus,
                 isResuming: !!lastTelemetry,
-                originatingSessionId,
+                originatingSessionId: this.currentSessionId,
             };
-            const tracker = new MarieProgressTracker({
-                ...callbacks,
-                onStream: (chunk) => callbacks?.onStream?.(chunk, run.runId, originatingSessionId),
-                onTool: (tool) => callbacks?.onTool?.(tool, run.runId, originatingSessionId),
-                onToolDelta: (delta) => callbacks?.onToolDelta?.(delta, run.runId, originatingSessionId),
-                onEvent: (event) => {
-                    event.originatingSessionId = originatingSessionId;
-                    if (event.type === "progress_update" ||
-                        event.type === "session_persistence_update" ||
-                        event.type === "file_stream_delta") {
-                        this.options.onProgressEvent?.(event);
-                    }
-                    callbacks?.onEvent?.(event);
-                },
-            }, run);
-            this.currentRun = run;
-            this.options.automationService.setCurrentRun(run);
-            const approvalRequester = async (name, input, diff) => {
-                if (this.options.shouldBypassApprovals?.()) {
-                    return true;
-                }
-                const request = {
-                    id: `approval_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
-                    toolName: name,
-                    toolInput: input,
-                    diff,
-                };
-                const hasHandlers = Boolean(callbacks?.onApprovalRequest || this.options.onApprovalRequest);
-                if (!hasHandlers) {
+            const cortexPlan = await plan(text, this.messages);
+            this.messages.push({ role: "user", content: text, timestamp: Date.now() });
+            const engine = new MarieEngine(this.provider, undefined, async (name, input) => {
+                if (this.options.shouldBypassApprovals?.())
                     return true;
-                }
-                const approvalPromise = new Promise((resolve) => {
-                    this.pendingApprovals.set(request.id, {
-                        resolve,
-                        toolName: name,
-                        timestamp: Date.now(),
-                    });
-                });
-                callbacks?.onApprovalRequest?.(request, run.runId, originatingSessionId);
                 if (this.options.onApprovalRequest) {
-                    void this.options.onApprovalRequest(request).then((approved) => {
-                        this.resolveApproval(request.id, approved);
-                    });
-                }
-                return approvalPromise;
-            };
-            const engine = new MarieEngine(this.provider, this.toolRegistry, approvalRequester, this.createProvider.bind(this), this.options.fs, this.options.ghostPort);
-            tracker.emitEvent({
-                type: "run_started",
-                runId: run.runId,
-                startedAt: run.startedAt,
-            });
-            tracker.emitProgressUpdate("Thinking...");
-            this.messages.push({
-                role: "user",
-                content: text,
-                timestamp: Date.now(),
-            });
-            await this.saveHistory();
-            if (this.abortController) {
-                this.abortController.abort();
-            }
-            this.abortController = new AbortController();
-            const runStartTime = Date.now();
-            try {
-                const response = await engine.chatLoop(this.messages, tracker, (t) => this.saveHistory(t, originatingSessionId, runStartTime), this.abortController.signal);
-                if (this.messages.length >= 6 && this.messages.length <= 10) {
-                    const sessionMetadata = await this.options.sessionStore.getSessionMetadata();
-                    const session = sessionMetadata.find((s) => s.id === this.currentSessionId);
-                    if (session &&
-                        (session.title === "New Session" || session.title.length > 50)) {
-                        this.summarizeSession(this.currentSessionId).catch(console.error);
-                    }
+                    return await this.options.onApprovalRequest({ id: `req_${Date.now()}`, toolName: name, toolInput: input });
                 }
-                return response;
-            }
-            catch (error) {
-                tracker.emitEvent({
-                    type: "run_error",
-                    runId: run.runId,
-                    elapsedMs: tracker.elapsedMs(),
-                    message: String(error),
-                });
-                return `Error: ${error}`;
+                return true;
+            }, this.options.providerFactory);
+            const response = await engine.chatLoop(this.messages, run, callbacks || {}, async (t) => await this.options.sessionStore.setLastTelemetry(t));
+            if (this.messages.length > 5) {
+                processSessionEnd(this.currentSessionId, this.messages, this.options.providerFactory, this.options.config).catch(() => { });
             }
+            return renderMessage(response);
         }
         finally {
-            this.abortController = null;
-            this.currentRun = undefined;
-            if (unlock)
-                unlock();
-        }
-    }
-    async summarizeSession(id) {
-        this.initializeProvider();
-        if (!this.provider)
-            return;
-        const historyMap = await this.options.sessionStore.getSessions();
-        const messages = historyMap[id] || [];
-        if (messages.length < 2)
-            return;
-        const engine = new MarieEngine(this.provider, this.toolRegistry, async () => true);
-        // 1. Title Generation
-        const prompt = "Based on our conversation so far, generate a very concise (3-5 words) and descriptive title for this session. Respond ONLY with the title. No quotes, no intro.";
-        try {
-            const summary = await engine.chatLoop([...messages, { role: "user", content: prompt }], { emitProgressUpdate: () => { }, emitEvent: () => { } }, async () => { });
-            if (summary && typeof summary === "string" && summary.length < 60) {
-                await this.renameSession(id, summary.trim().replace(/^"|"$/g, ""));
-            }
-            else if (summary && String(summary).length < 60) {
-                const text = StringUtils.extractText(summary).trim();
-                await this.renameSession(id, text.replace(/^"|"$/g, ""));
-            }
-            // 2. Knowledge Distillation
-            const knowledgePrompt = "Extract 3-5 key structured facts or entities from our conversation. Format each as 'Entity | Fact'. One per line. Only output the facts.";
-            const factsResponse = await engine.chatLoop([...messages, { role: "user", content: knowledgePrompt }], { emitProgressUpdate: () => { }, emitEvent: () => { } }, async () => { });
-            if (factsResponse) {
-                const db = await NoormmeEngine.getInstance();
-                const lines = factsResponse.split("\n").filter(l => l.includes("|"));
-                for (const line of lines) {
-                    const [entity, fact] = line.split("|").map(s => s.trim());
-                    if (entity && fact) {
-                        await db.agent.cortex.knowledge.distill(entity, fact, 0.8, // confidence
-                        id, // sourceSessionId
-                        ["automated-distillation"]);
-                    }
-                }
-                console.log(`[MarieRuntime] Distilled ${lines.length} facts from session ${id}`);
-                // PHASE 8.2: Hive Pulse Synchronization & Hardening
-                try {
-                    await db.agent.cortex.hive.broadcastKnowledge();
-                    await db.agent.cortex.hive.broadcastSkills();
-                    // Action Refinement: Learn from failures
-                    const recommendations = await db.agent.cortex.refiner.refineActions();
-                    if (recommendations.length > 0) {
-                        console.log(`[MarieRuntime] ActionRefiner proposed ${recommendations.length} improvements.`);
-                    }
-                    // Mind Compression: Ablation Pruning (Every 5th session approx or just let it run)
-                    await db.agent.cortex.ablation.pruneZombies(30); // Prune 30-day-old zombies
-                    // PHASE 8.3: Recursive Consciousness & Narrative
-                    // 1. Complete Narrative Episode
-                    try {
-                        const recentEpisodes = await db.agent.cortex.episodes.getSessionEpisodes(id, { limit: 1 });
-                        if (recentEpisodes.length > 0 && recentEpisodes[0].status === 'active') {
-                            await db.agent.cortex.episodes.completeEpisode(recentEpisodes[0].id, `Session concluded with ${lines.length} facts distilled. Overall success in objective: ${name}.`);
-                        }
-                    }
-                    catch (e) {
-                        console.warn("[MarieRuntime] Narrative completion failed", e);
-                    }
-                    // 2. Recursive Paradox & Lesson Synthesis
-                    try {
-                        const paradoxes = await db.agent.cortex.reasoner.detectContradictions();
-                        if (paradoxes.length > 0) {
-                            console.warn(`[MarieRuntime] ⚠️ LOGICAL PARADOXES DETECTED: \n- ${paradoxes.join("\n- ")}`);
-                        }
-                        const lessons = await db.agent.cortex.reasoner.synthesizeLessons();
-                        const totalLessons = Object.values(lessons).reduce((acc, curr) => acc + curr.length, 0);
-                        console.log(`[MarieRuntime] Recursive synthesis complete. Clustered ${totalLessons} lessons across your history.`);
-                    }
-                    catch (e) {
-                        console.warn("[MarieRuntime] Recursive reasoning failed", e);
-                    }
-                    console.log(`[MarieRuntime] Phase 3 Recursive Consciousness complete for session ${id}`);
-                    // 3. Autonomous Self-Experimentation (Ablation)
-                    try {
-                        if (ConfigService.getAutonomyMode() === "ascension") {
-                            console.log("[MarieRuntime] Initiating autonomous ablation experiment...");
-                            const dbInternal = db.agent.cortex.ablation.db;
-                            const randomItem = await dbInternal
-                                .selectFrom(db.agent.cortex.ablation.knowledgeTable)
-                                .select("id")
-                                .limit(1)
-                                .executeTakeFirst();
-                            if (randomItem) {
-                                await db.agent.cortex.ablation.testAblation(randomItem.id);
-                            }
-                        }
-                    }
-                    catch (e) {
-                        console.warn("[MarieRuntime] Ablation experiment failed", e);
-                    }
-                    console.log(`[MarieRuntime] Phase 4 Sovereign Reliability pass complete for session ${id}`);
-                }
-                catch (e) {
-                    console.warn("[MarieRuntime] Phase 4 Pass failed", e);
-                }
-            }
-        }
-        catch (e) {
-            console.error("Failed to summarize or distill session", e);
+            unlock();
         }
     }
-    async clearCurrentSession() {
+    async createSession() {
         await this.ensureInitialized();
+        this.currentSessionId = `session_${Date.now()}`;
         this.messages = [];
-        await this.saveHistory();
-    }
-    stopGeneration() {
-        if (this.abortController) {
-            this.abortController.abort();
-            this.abortController = null;
-        }
-    }
-    updateSettings() {
-        this.initializeProvider();
+        await this.options.sessionStore.setCurrentSessionId(this.currentSessionId);
+        return this.currentSessionId;
     }
-    async getModels() {
+    async listSessions() {
         await this.ensureInitialized();
-        this.initializeProvider();
-        return this.provider?.listModels() || [];
-    }
-    getMessages() {
-        return this.messages;
+        return await this.options.sessionStore.getSessionMetadata();
     }
-    getCurrentSessionId() {
-        return this.currentSessionId;
+    async loadSession(id) {
+        await this.ensureInitialized();
+        this.currentSessionId = id;
+        const historyMap = await this.options.sessionStore.getSessions();
+        this.messages = historyMap[id] || [];
+        await this.options.sessionStore.setCurrentSessionId(id);
+        return id;
     }
-    getSequenceNumber() {
-        return this.sequenceNumber;
+    async togglePinSession(id) {
+        await this.ensureInitialized();
+        const metadata = await this.options.sessionStore.getSessionMetadata();
+        const item = metadata.find(m => m.id === id);
+        if (item) {
+            item.isPinned = !item.isPinned;
+            await this.options.sessionStore.saveSessionMetadata(metadata);
+        }
     }
-    getCurrentRun() {
-        return this.currentRun;
+    async renameSession(id, name) {
+        await this.ensureInitialized();
+        const metadata = await this.options.sessionStore.getSessionMetadata();
+        const item = metadata.find(m => m.id === id);
+        if (item) {
+            item.title = name;
+            await this.options.sessionStore.saveSessionMetadata(metadata);
+        }
     }
-    resolveApproval(requestId, approved) {
-        const entry = this.pendingApprovals.get(requestId);
-        if (!entry)
-            return false;
-        this.pendingApprovals.delete(requestId);
-        entry.resolve(approved);
-        return true;
+    async deleteSession(id) {
+        await this.ensureInitialized();
+        const historyMap = await this.options.sessionStore.getSessions();
+        delete historyMap[id];
+        await this.options.sessionStore.saveSessions(historyMap);
     }
-    dispose() {
-        this.stopGeneration();
-        this.options.automationService.dispose?.();
+    async clearCurrentSession() {
+        await this.ensureInitialized();
+        this.messages = [];
     }
+    stopGeneration() { this.abortController?.abort(); }
+    setMode(mode) { }
+    getMode() { return global.MARIE_MODE || "meditative"; }
+    updateSettings() { }
+    async getModels() { return []; }
+    getMessages() { return this.messages; }
+    getCurrentSessionId() { return this.currentSessionId; }
+    getSequenceNumber() { return this.messages.length; }
+    getCurrentRun() { return this.options.automationService.getCurrentRun(); }
+    resolveApproval(id, approved) { }
+    onStateChanged(cb) {
+        cb({ messages: this.messages, currentSessionId: this.currentSessionId });
+        return () => { };
+    }
+    dispose() { this.options.automationService.dispose?.(); }
 }
 //# sourceMappingURL=MarieRuntime.js.map