@tspappsen/elamax 1.2.3

package/dist/copilot/orchestrator.js

@@ -0,0 +1,459 @@
+import { approveAll } from "@github/copilot-sdk";
+import { createTools } from "./tools.js";
+import { createWatchdogTools } from "./watchdog-tools.js";
+import { getOrchestratorSystemMessage } from "./system-message.js";
+import { config, DEFAULT_MODEL } from "../config.js";
+import { loadMcpConfig } from "./mcp-config.js";
+import { getSkillDirectories } from "./skills.js";
+import { resetClient } from "./client.js";
+import { logConversation, getState, setState, deleteState, getMemorySummary, getRecentConversation } from "../store/db.js";
+import { IS_WATCHDOG, INSTRUCTIONS_DIR, SESSIONS_DIR } from "../paths.js";
+import { resolveModel } from "./router.js";
+import { watchInstructions, seedDefaultInstructions } from "./workspace-instructions.js";
+const MAX_RETRIES = 3;
+const RECONNECT_DELAYS_MS = [1_000, 3_000, 10_000];
+const HEALTH_CHECK_INTERVAL_MS = 30_000;
+const ORCHESTRATOR_SESSION_KEY = "orchestrator_session_id";
+let logMessage = () => { };
+export function setMessageLogger(fn) {
+    logMessage = fn;
+}
+let proactiveNotifyFn;
+export function setProactiveNotify(fn) {
+    proactiveNotifyFn = fn;
+}
+let copilotClient;
+const workers = new Map();
+let healthCheckTimer;
+// Router state — tracks model across the session
+let currentSessionModel;
+let recentTiers = [];
+let lastRouteResult;
+export function getLastRouteResult() {
+    return lastRouteResult;
+}
+// Persistent orchestrator session
+let orchestratorSession;
+// Coalesces concurrent ensureOrchestratorSession calls
+let sessionCreatePromise;
+let sessionGeneration = 0;
+const messageQueue = [];
+let processing = false;
+let currentCallback;
+/** The channel currently being processed — tools use this to tag new workers. */
+let currentSourceChannel;
+let currentSourceChannelId;
+let currentSourceThreadId;
+/** Get the channel that originated the message currently being processed. */
+export function getCurrentSourceChannel() {
+    return currentSourceChannel;
+}
+export function getCurrentSourceChannelId() {
+    return currentSourceChannelId;
+}
+export function getCurrentSourceThreadId() {
+    return currentSourceThreadId;
+}
+function getSessionConfig() {
+    if (IS_WATCHDOG) {
+        const tools = createWatchdogTools();
+        return { tools, mcpServers: {}, skillDirectories: [] };
+    }
+    const tools = createTools({
+        client: copilotClient,
+        workers,
+        onWorkerComplete: feedBackgroundResult,
+    });
+    const mcpServers = loadMcpConfig();
+    const skillDirectories = getSkillDirectories();
+    return { tools, mcpServers, skillDirectories };
+}
+/** Feed a background worker result into the orchestrator as a new turn. */
+export function feedBackgroundResult(workerName, result, isFailure) {
+    const worker = workers.get(workerName);
+    const channel = worker?.originChannel;
+    const discordChannelId = worker?.originChannelId;
+    const discordThreadId = worker?.originThreadId;
+    const failureSuffix = isFailure
+        ? `\n\n---\nThis worker failed. If the failure reveals a reusable lesson — a tool quirk, environment gotcha, API behavior, setup requirement, or pattern worth remembering — extract it and call learn_skill to save it as a skill (slug: lesson-<topic>). If the failure is task-specific with no transferable insight, skip it.`
+        : "";
+    const prompt = `[Background task completed] Worker '${workerName}' ${isFailure ? "FAILED" : "finished"}:\n\n${result}${failureSuffix}`;
+    sendToOrchestrator(prompt, { type: "background" }, (_text, done) => {
+        if (done && proactiveNotifyFn) {
+            proactiveNotifyFn(_text, channel, discordChannelId, discordThreadId);
+        }
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function invalidateSession() {
+    sessionGeneration += 1;
+    orchestratorSession = undefined;
+    sessionCreatePromise = undefined;
+    currentSessionModel = undefined;
+    lastRouteResult = undefined;
+    deleteState(ORCHESTRATOR_SESSION_KEY);
+}
+/** Ensure the SDK client is connected, resetting if necessary. Coalesces concurrent resets. */
+let resetPromise;
+async function ensureClient() {
+    if (copilotClient && copilotClient.getState() === "connected") {
+        return copilotClient;
+    }
+    if (!resetPromise) {
+        console.log(`[max] Client not connected (state: ${copilotClient?.getState() ?? "null"}), resetting…`);
+        resetPromise = resetClient().then((c) => {
+            console.log(`[max] Client reset successful, state: ${c.getState()}`);
+            copilotClient = c;
+            return c;
+        }).finally(() => { resetPromise = undefined; });
+    }
+    return resetPromise;
+}
+/** Start periodic health check that proactively reconnects the client. */
+function startHealthCheck() {
+    if (healthCheckTimer)
+        return;
+    healthCheckTimer = setInterval(async () => {
+        if (!copilotClient)
+            return;
+        try {
+            const state = copilotClient.getState();
+            if (state !== "connected") {
+                console.log(`[max] Health check: client state is '${state}', resetting…`);
+                await ensureClient();
+                // Session may need recovery after client reset
+                orchestratorSession = undefined;
+                currentSessionModel = undefined;
+            }
+        }
+        catch (err) {
+            console.error(`[max] Health check error:`, err instanceof Error ? err.message : err);
+        }
+    }, HEALTH_CHECK_INTERVAL_MS);
+}
+/** Create or resume the persistent orchestrator session. */
+async function ensureOrchestratorSession() {
+    if (orchestratorSession)
+        return orchestratorSession;
+    // Coalesce concurrent callers — wait for an in-flight creation
+    if (sessionCreatePromise)
+        return sessionCreatePromise;
+    const generation = sessionGeneration;
+    sessionCreatePromise = createOrResumeSession();
+    try {
+        const session = await sessionCreatePromise;
+        if (generation !== sessionGeneration) {
+            session.destroy().catch(() => { });
+            throw new Error("Orchestrator session was invalidated during creation");
+        }
+        orchestratorSession = session;
+        return session;
+    }
+    finally {
+        if (generation === sessionGeneration) {
+            sessionCreatePromise = undefined;
+        }
+    }
+}
+/** Internal: actually create or resume a session (not concurrency-safe — use ensureOrchestratorSession). */
+async function createOrResumeSession() {
+    const client = await ensureClient();
+    const { tools, mcpServers, skillDirectories } = getSessionConfig();
+    const memorySummary = IS_WATCHDOG ? undefined : getMemorySummary();
+    const infiniteSessions = {
+        enabled: true,
+        backgroundCompactionThreshold: 0.80,
+        bufferExhaustionThreshold: 0.95,
+    };
+    // Try to resume a previous session
+    const savedSessionId = getState(ORCHESTRATOR_SESSION_KEY);
+    if (savedSessionId) {
+        try {
+            console.log(`[max] Resuming orchestrator session ${savedSessionId.slice(0, 8)}…`);
+            const session = await client.resumeSession(savedSessionId, {
+                model: config.copilotModel,
+                configDir: SESSIONS_DIR,
+                streaming: true,
+                systemMessage: {
+                    content: getOrchestratorSystemMessage(memorySummary || undefined, { selfEditEnabled: config.selfEditEnabled }),
+                },
+                tools,
+                mcpServers,
+                skillDirectories,
+                onPermissionRequest: approveAll,
+                infiniteSessions,
+            });
+            console.log(`[max] Resumed orchestrator session successfully`);
+            currentSessionModel = config.copilotModel;
+            return session;
+        }
+        catch (err) {
+            console.log(`[max] Could not resume session: ${err instanceof Error ? err.message : err}. Creating new.`);
+            deleteState(ORCHESTRATOR_SESSION_KEY);
+        }
+    }
+    // Create a fresh session
+    console.log(`[max] Creating new persistent orchestrator session`);
+    const session = await client.createSession({
+        model: config.copilotModel,
+        configDir: SESSIONS_DIR,
+        streaming: true,
+        systemMessage: {
+            content: getOrchestratorSystemMessage(memorySummary || undefined, { selfEditEnabled: config.selfEditEnabled }),
+        },
+        tools,
+        mcpServers,
+        skillDirectories,
+        onPermissionRequest: approveAll,
+        infiniteSessions,
+    });
+    // Persist the session ID for future restarts
+    setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
+    console.log(`[max] Created orchestrator session ${session.sessionId.slice(0, 8)}…`);
+    // Recover conversation context if available (session was lost, not first run)
+    const recentHistory = getRecentConversation(10);
+    if (recentHistory) {
+        console.log(`[max] Injecting recent conversation context into new session`);
+        try {
+            await session.sendAndWait({
+                prompt: `[System: Session recovered] Your previous session was lost. Here's the recent conversation for context — do NOT respond to these messages, just absorb the context silently:\n\n${recentHistory}\n\n(End of recovery context. Wait for the next real message.)`,
+            }, 60_000);
+        }
+        catch (err) {
+            console.log(`[max] Context recovery injection failed (non-fatal): ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    currentSessionModel = config.copilotModel;
+    return session;
+}
+export async function initOrchestrator(client) {
+    copilotClient = client;
+    const { mcpServers, skillDirectories } = getSessionConfig();
+    // Validate configured model against available models
+    try {
+        const models = await client.listModels();
+        const configured = config.copilotModel;
+        const isAvailable = models.some((m) => m.id === configured);
+        if (!isAvailable) {
+            console.log(`[max] ⚠️ Configured model '${configured}' is not available. Falling back to '${DEFAULT_MODEL}'.`);
+            config.copilotModel = DEFAULT_MODEL;
+        }
+    }
+    catch (err) {
+        console.log(`[max] Could not validate model (will use '${config.copilotModel}' as-is): ${err instanceof Error ? err.message : err}`);
+    }
+    console.log(`[max] Loading ${Object.keys(mcpServers).length} MCP server(s): ${Object.keys(mcpServers).join(", ") || "(none)"}`);
+    console.log(`[max] Skill directories: ${skillDirectories.join(", ") || "(none)"}`);
+    console.log(`[max] Persistent session mode — conversation history maintained by SDK`);
+    startHealthCheck();
+    // Seed default instruction templates if missing, then watch for changes
+    if (!IS_WATCHDOG) {
+        seedDefaultInstructions();
+        watchInstructions(() => {
+            console.log(`[max] Workspace instructions changed — rebuilding session`);
+            invalidateSession();
+        });
+        console.log(`[max] Watching ${INSTRUCTIONS_DIR} for workspace instructions`);
+    }
+    // Eagerly create/resume the orchestrator session
+    try {
+        await ensureOrchestratorSession();
+    }
+    catch (err) {
+        console.error(`[max] Failed to create initial session (will retry on first message):`, err instanceof Error ? err.message : err);
+    }
+}
+/** Send a prompt on the persistent session, return the response. */
+async function executeOnSession(prompt, callback, attachments) {
+    const session = await ensureOrchestratorSession();
+    currentCallback = callback;
+    let accumulated = "";
+    let toolCallExecuted = false;
+    const unsubToolDone = session.on("tool.execution_complete", () => {
+        toolCallExecuted = true;
+    });
+    const unsubDelta = session.on("assistant.message_delta", (event) => {
+        // After a tool call completes, ensure a line break separates the text blocks
+        // so they don't visually run together in the TUI.
+        if (toolCallExecuted && accumulated.length > 0 && !accumulated.endsWith("\n")) {
+            accumulated += "\n";
+        }
+        toolCallExecuted = false;
+        accumulated += event.data.deltaContent;
+        callback(accumulated, false);
+    });
+    try {
+        const result = await session.sendAndWait({ prompt, attachments }, 300_000);
+        const finalContent = result?.data?.content || accumulated || "(No response)";
+        return finalContent;
+    }
+    catch (err) {
+        // If the session is broken, invalidate it so it's recreated on next attempt
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/closed|destroy|disposed|invalid|expired|not found/i.test(msg)) {
+            console.log(`[max] Session appears dead, will recreate: ${msg}`);
+            invalidateSession();
+        }
+        throw err;
+    }
+    finally {
+        unsubDelta();
+        unsubToolDone();
+        currentCallback = undefined;
+    }
+}
+/** Process the message queue one at a time. */
+async function processQueue() {
+    if (processing) {
+        if (messageQueue.length > 0) {
+            console.log(`[max] Message queued (${messageQueue.length} waiting — orchestrator is busy)`);
+        }
+        return;
+    }
+    processing = true;
+    while (messageQueue.length > 0) {
+        const item = messageQueue.shift();
+        currentSourceChannel = item.sourceChannel;
+        currentSourceChannelId = item.sourceChannelId;
+        currentSourceThreadId = item.sourceThreadId;
+        try {
+            if (item.attachments && item.attachments.length > 0) {
+                // Preserve the currently selected model for attachment turns so image analysis
+                // isn't auto-routed to a non-vision model mid-request.
+                lastRouteResult = {
+                    model: currentSessionModel || config.copilotModel,
+                    tier: null,
+                    switched: false,
+                    routerMode: "manual",
+                };
+            }
+            else {
+                const routeResult = await resolveModel(item.prompt, currentSessionModel || config.copilotModel, recentTiers, copilotClient);
+                if (routeResult.switched) {
+                    console.log(`[max] Auto: switching to ${routeResult.model} (${routeResult.overrideName || routeResult.tier})`);
+                    config.copilotModel = routeResult.model;
+                    invalidateSession();
+                }
+                if (routeResult.tier) {
+                    recentTiers.push(routeResult.tier);
+                    if (recentTiers.length > 5)
+                        recentTiers = recentTiers.slice(-5);
+                }
+                lastRouteResult = routeResult;
+            }
+            const result = await executeOnSession(item.prompt, item.callback, item.attachments);
+            item.resolve(result);
+        }
+        catch (err) {
+            item.reject(err);
+        }
+        currentSourceChannel = undefined;
+        currentSourceChannelId = undefined;
+        currentSourceThreadId = undefined;
+    }
+    processing = false;
+}
+function isRecoverableError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /timeout|disconnect|connection|EPIPE|ECONNRESET|ECONNREFUSED|socket|closed|ENOENT|spawn|not found|expired|stale/i.test(msg);
+}
+export async function sendToOrchestrator(prompt, source, callback, options) {
+    const sourceLabel = source.type === "telegram" ? "telegram" :
+        source.type === "discord" ? "discord" :
+            source.type === "tui" ? "tui" : "background";
+    logMessage("in", sourceLabel, prompt);
+    // Tag the prompt with its source channel
+    const taggedPrompt = source.type === "background"
+        ? prompt
+        : `[via ${sourceLabel}] ${prompt}`;
+    // Log role: background events are "system", user messages are "user"
+    const logRole = source.type === "background" ? "system" : "user";
+    // Determine the source channel for worker origin tracking
+    const sourceChannel = source.type === "telegram" ? "telegram" :
+        source.type === "discord" ? "discord" :
+            source.type === "tui" ? "tui" : undefined;
+    // Enqueue and process
+    return (async () => {
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const finalContent = await new Promise((resolve, reject) => {
+                    messageQueue.push({
+                        prompt: taggedPrompt,
+                        attachments: options?.attachments,
+                        callback,
+                        sourceChannel,
+                        sourceChannelId: source.type === "discord" ? source.channelId : undefined,
+                        sourceThreadId: source.type === "discord" ? source.threadId : undefined,
+                        resolve,
+                        reject,
+                    });
+                    processQueue();
+                });
+                // Deliver response to user FIRST, then log best-effort
+                callback(finalContent, true);
+                try {
+                    logMessage("out", sourceLabel, finalContent);
+                }
+                catch { /* best-effort */ }
+                // Log both sides of the conversation after delivery
+                try {
+                    logConversation(logRole, prompt, sourceLabel);
+                }
+                catch { /* best-effort */ }
+                try {
+                    logConversation("assistant", finalContent, sourceLabel);
+                }
+                catch { /* best-effort */ }
+                return;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                // Don't retry cancelled messages
+                if (/cancelled|abort/i.test(msg)) {
+                    return;
+                }
+                if (isRecoverableError(err) && attempt < MAX_RETRIES) {
+                    const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
+                    console.error(`[max] Recoverable error: ${msg}. Retry ${attempt + 1}/${MAX_RETRIES} after ${delay}ms…`);
+                    await sleep(delay);
+                    // Reset client before retry in case the connection is stale
+                    try {
+                        await ensureClient();
+                    }
+                    catch { /* will fail again on next attempt */ }
+                    continue;
+                }
+                console.error(`[max] Error processing message: ${msg}`);
+                callback(`Error: ${msg}`, true);
+                return;
+            }
+        }
+    })();
+}
+/** Cancel the in-flight message and drain the queue. */
+export async function cancelCurrentMessage() {
+    // Drain any queued messages
+    const drained = messageQueue.length;
+    while (messageQueue.length > 0) {
+        const item = messageQueue.shift();
+        item.reject(new Error("Cancelled"));
+    }
+    // Abort the active session request
+    if (orchestratorSession && currentCallback) {
+        try {
+            await orchestratorSession.abort();
+            console.log(`[max] Aborted in-flight request`);
+            return true;
+        }
+        catch (err) {
+            console.error(`[max] Abort failed:`, err instanceof Error ? err.message : err);
+        }
+    }
+    return drained > 0;
+}
+export function getWorkers() {
+    return workers;
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/copilot/router.js

@@ -0,0 +1,147 @@
+import { getState, setState } from "../store/db.js";
+import { classifyWithLLM } from "./classifier.js";
+import { parseJSON } from "../utils/parseJSON.js";
+// ---------------------------------------------------------------------------
+// Default configuration
+// ---------------------------------------------------------------------------
+const DEFAULT_CONFIG = {
+    enabled: false,
+    tierModels: {
+        fast: "gpt-4.1",
+        standard: "claude-sonnet-4.6",
+        premium: "claude-opus-4.6",
+    },
+    overrides: [
+        {
+            name: "design",
+            keywords: [
+                "design", "ui", "ux", "css", "layout", "styling", "visual",
+                "mockup", "wireframe", "frontend design", "tailwind", "responsive",
+            ],
+            model: "claude-opus-4.6",
+        },
+    ],
+    cooldownMessages: 2,
+};
+// ---------------------------------------------------------------------------
+// Module-level state
+// ---------------------------------------------------------------------------
+let messagesSinceSwitch = Infinity;
+// Short replies that should inherit the previous turn's tier
+const FOLLOW_UP_PATTERNS = [
+    "yes", "no", "do it", "go ahead", "sure", "sounds good", "looks good",
+    "perfect", "+1", "please", "yep", "yup", "nope", "nah", "ok", "okay",
+    "got it", "cool", "nice", "great", "alright", "right",
+];
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Strip channel prefixes and trim whitespace. */
+function sanitize(prompt) {
+    return prompt
+        .replace(/^\[via telegram\]\s*/i, "")
+        .replace(/^\[via discord\]\s*/i, "")
+        .replace(/^\[via tui\]\s*/i, "")
+        .trim();
+}
+/** Word-boundary match that avoids partial-word hits (e.g. "ui" ≠ "fruit"). */
+function wordMatch(text, keyword) {
+    const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`\\b${escaped}\\b`, "i").test(text);
+}
+// ---------------------------------------------------------------------------
+// Config management
+// ---------------------------------------------------------------------------
+export function getRouterConfig() {
+    const stored = getState("router_config");
+    if (stored) {
+        try {
+            return { ...DEFAULT_CONFIG, ...(parseJSON(stored) ?? {}) };
+        }
+        catch {
+            return { ...DEFAULT_CONFIG };
+        }
+    }
+    return { ...DEFAULT_CONFIG };
+}
+export function updateRouterConfig(partial) {
+    const current = getRouterConfig();
+    const merged = {
+        ...current,
+        ...partial,
+        tierModels: {
+            ...current.tierModels,
+            ...(partial.tierModels ?? {}),
+        },
+        overrides: partial.overrides ?? current.overrides,
+    };
+    setState("router_config", JSON.stringify(merged));
+    return merged;
+}
+// ---------------------------------------------------------------------------
+// Classification
+// ---------------------------------------------------------------------------
+/**
+ * Classify a message using GPT-4.1. Falls back to "standard" if the LLM
+ * is unavailable. Background tasks and follow-ups are handled deterministically.
+ */
+async function classifyMessage(prompt, recentTiers, client) {
+    const text = sanitize(prompt);
+    const lower = text.toLowerCase();
+    // Background tasks → always standard
+    if (lower.startsWith("[background task completed]"))
+        return "standard";
+    // Short follow-ups inherit the previous tier
+    if (text.length < 20 && recentTiers.length > 0) {
+        const isFollowUp = FOLLOW_UP_PATTERNS.some((p) => lower === p || lower === p + ".");
+        if (isFollowUp)
+            return recentTiers[0];
+    }
+    // LLM classification
+    if (client) {
+        const tier = await classifyWithLLM(client, text);
+        if (tier) {
+            console.log(`[max] Classifier: ${tier}`);
+            return tier;
+        }
+    }
+    // Fallback — standard is always safe
+    console.log(`[max] Classifier (fallback): standard`);
+    return "standard";
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+export async function resolveModel(prompt, currentModel, recentTiers, client) {
+    const config = getRouterConfig();
+    // Router disabled → manual mode
+    if (!config.enabled) {
+        messagesSinceSwitch = Infinity;
+        return { model: currentModel, tier: null, switched: false, routerMode: "manual" };
+    }
+    const text = sanitize(prompt);
+    // 1. Check overrides first — they bypass cooldown
+    for (const rule of config.overrides) {
+        if (rule.keywords.some((kw) => wordMatch(text, kw))) {
+            const switched = rule.model !== currentModel;
+            if (switched)
+                messagesSinceSwitch = 0;
+            return { model: rule.model, tier: null, overrideName: rule.name, switched, routerMode: "auto" };
+        }
+    }
+    // 2. Classify the message
+    const tier = await classifyMessage(prompt, recentTiers, client);
+    const targetModel = config.tierModels[tier];
+    const wouldSwitch = targetModel !== currentModel;
+    // 3. Cooldown — prevent rapid switching
+    if (wouldSwitch && messagesSinceSwitch < config.cooldownMessages) {
+        messagesSinceSwitch++;
+        return { model: currentModel, tier, switched: false, routerMode: "auto" };
+    }
+    if (wouldSwitch)
+        messagesSinceSwitch = 0;
+    else
+        messagesSinceSwitch++;
+    return { model: targetModel, tier, switched: wouldSwitch, routerMode: "auto" };
+}
+//# sourceMappingURL=router.js.map