@cryptiklemur/lattice 4.0.1 → 5.0.0

package/dist/server/handlers/project-settings.js

@@ -0,0 +1,166 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { loadConfig, saveConfig, invalidateConfigCache } from "../config.js";
+import { getProjectBySlug } from "../project/registry.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readProjectClaudeMd, writeProjectClaudeMd, readProjectClaudeSettings, mergeProjectClaudeSettings, readProjectRules, writeProjectRules, readProjectMcpServers, writeProjectMcpServers, readProjectSkills, readGlobalRules, readGlobalPermissions, readGlobalMcpServers, readGlobalSkills, } from "../project/project-files.js";
+function loadGlobalClaudeMd() {
+    var mdPath = join(homedir(), ".claude", "CLAUDE.md");
+    if (existsSync(mdPath)) {
+        try {
+            return readFileSync(mdPath, "utf-8");
+        }
+        catch { }
+    }
+    return "";
+}
+function buildProjectSettings(projectSlug) {
+    var project = getProjectBySlug(projectSlug);
+    if (!project) {
+        return { error: "Project not found" };
+    }
+    if (!existsSync(project.path)) {
+        return { error: "Project path does not exist on disk" };
+    }
+    var claudeMd = readProjectClaudeMd(project.path);
+    var claudeSettings = readProjectClaudeSettings(project.path);
+    var lattice = (claudeSettings.lattice ?? {});
+    var permissions = (claudeSettings.permissions ?? { allow: [], deny: [] });
+    var rules = readProjectRules(project.path);
+    var mcpServers = readProjectMcpServers(project.path);
+    var skills = readProjectSkills(project.path);
+    var config = loadConfig();
+    var settings = {
+        title: project.title,
+        path: project.path,
+        icon: project.icon,
+        claudeMd,
+        defaultModel: lattice.defaultModel || undefined,
+        defaultEffort: lattice.defaultEffort || undefined,
+        thinking: lattice.thinking,
+        permissionMode: lattice.defaultPermissionMode || undefined,
+        permissions: {
+            allow: Array.isArray(permissions.allow) ? permissions.allow : [],
+            deny: Array.isArray(permissions.deny) ? permissions.deny : [],
+        },
+        env: project.env ?? {},
+        mcpServers,
+        rules,
+        skills,
+        disabledPlugins: Array.isArray(lattice.disabledPlugins) ? lattice.disabledPlugins : [],
+        global: {
+            claudeMd: loadGlobalClaudeMd(),
+            defaultModel: "",
+            defaultEffort: "",
+            env: config.globalEnv ?? {},
+            permissions: readGlobalPermissions(),
+            rules: readGlobalRules(),
+            mcpServers: readGlobalMcpServers(),
+            skills: readGlobalSkills(),
+        },
+    };
+    return settings;
+}
+registerHandler("project-settings", function (clientId, message) {
+    if (message.type === "project-settings:get") {
+        var getMsg = message;
+        var result = buildProjectSettings(getMsg.projectSlug);
+        if ("error" in result) {
+            sendTo(clientId, { type: "project-settings:error", projectSlug: getMsg.projectSlug, message: result.error });
+            return;
+        }
+        sendTo(clientId, { type: "project-settings:data", projectSlug: getMsg.projectSlug, settings: result });
+        return;
+    }
+    if (message.type === "project-settings:update") {
+        var updateMsg = message;
+        var projectSlug = updateMsg.projectSlug;
+        var section = updateMsg.section;
+        var settings = updateMsg.settings;
+        var project = getProjectBySlug(projectSlug);
+        if (!project) {
+            sendTo(clientId, { type: "project-settings:error", projectSlug, message: "Project not found" });
+            return;
+        }
+        if (!existsSync(project.path)) {
+            sendTo(clientId, { type: "project-settings:error", projectSlug, message: "Project path does not exist on disk" });
+            return;
+        }
+        try {
+            if (section === "general") {
+                invalidateConfigCache();
+                var config = loadConfig();
+                var idx = config.projects.findIndex(function (p) { return p.slug === projectSlug; });
+                if (idx !== -1) {
+                    if (typeof settings.title === "string") {
+                        config.projects[idx].title = settings.title;
+                    }
+                    if (settings.icon !== undefined) {
+                        config.projects[idx].icon = settings.icon;
+                    }
+                    saveConfig(config);
+                }
+            }
+            else if (section === "claude") {
+                if (typeof settings.claudeMd === "string") {
+                    writeProjectClaudeMd(project.path, settings.claudeMd);
+                }
+                var latticeUpdates = {};
+                if (settings.defaultModel !== undefined)
+                    latticeUpdates.defaultModel = settings.defaultModel;
+                if (settings.defaultEffort !== undefined)
+                    latticeUpdates.defaultEffort = settings.defaultEffort;
+                if (settings.thinking !== undefined)
+                    latticeUpdates.thinking = settings.thinking;
+                if (settings.defaultPermissionMode !== undefined)
+                    latticeUpdates.defaultPermissionMode = settings.defaultPermissionMode;
+                if (Object.keys(latticeUpdates).length > 0) {
+                    mergeProjectClaudeSettings(project.path, { lattice: latticeUpdates });
+                }
+            }
+            else if (section === "environment") {
+                invalidateConfigCache();
+                var config = loadConfig();
+                var idx = config.projects.findIndex(function (p) { return p.slug === projectSlug; });
+                if (idx !== -1) {
+                    config.projects[idx].env = settings.env ?? {};
+                    saveConfig(config);
+                }
+            }
+            else if (section === "mcp") {
+                writeProjectMcpServers(project.path, settings.mcpServers ?? {});
+            }
+            else if (section === "rules") {
+                writeProjectRules(project.path, settings.rules ?? []);
+            }
+            else if (section === "plugins") {
+                var disabledPlugins = Array.isArray(settings.disabledPlugins) ? settings.disabledPlugins : [];
+                mergeProjectClaudeSettings(project.path, {
+                    lattice: { disabledPlugins: disabledPlugins },
+                });
+            }
+            else if (section === "permissions") {
+                mergeProjectClaudeSettings(project.path, {
+                    permissions: {
+                        allow: settings.allow ?? [],
+                        deny: settings.deny ?? [],
+                    },
+                });
+            }
+        }
+        catch (err) {
+            var errMsg = err instanceof Error ? err.message : String(err);
+            sendTo(clientId, { type: "project-settings:error", projectSlug, message: errMsg });
+            return;
+        }
+        var updated = buildProjectSettings(projectSlug);
+        if ("error" in updated) {
+            sendTo(clientId, { type: "project-settings:error", projectSlug, message: updated.error });
+            return;
+        }
+        sendTo(clientId, { type: "project-settings:data", projectSlug, settings: updated });
+        return;
+    }
+});

package/dist/server/handlers/scheduler.js

@@ -0,0 +1,52 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { listTasks, createTask, deleteTask, toggleTask, updateTask } from "../features/scheduler.js";
+registerHandler("scheduler", function (clientId, message) {
+    if (message.type === "scheduler:list") {
+        sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+        return;
+    }
+    if (message.type === "scheduler:create") {
+        var createMsg = message;
+        var task = createTask({
+            name: createMsg.name,
+            prompt: createMsg.prompt,
+            cron: createMsg.cron,
+            projectSlug: createMsg.projectSlug,
+        });
+        if (!task) {
+            sendTo(clientId, { type: "chat:error", message: "Invalid cron expression" });
+            return;
+        }
+        sendTo(clientId, { type: "scheduler:task_created", task });
+        sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+        return;
+    }
+    if (message.type === "scheduler:delete") {
+        var deleteMsg = message;
+        deleteTask(deleteMsg.taskId);
+        sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+        return;
+    }
+    if (message.type === "scheduler:toggle") {
+        var toggleMsg = message;
+        toggleTask(toggleMsg.taskId);
+        sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+        return;
+    }
+    if (message.type === "scheduler:update") {
+        var updateMsg = message;
+        var updated = updateTask(updateMsg.taskId, {
+            name: updateMsg.name,
+            prompt: updateMsg.prompt,
+            cron: updateMsg.cron,
+        });
+        if (!updated) {
+            sendTo(clientId, { type: "chat:error", message: "Failed to update task" });
+            return;
+        }
+        sendTo(clientId, { type: "scheduler:task_updated", task: updated });
+        sendTo(clientId, { type: "scheduler:tasks", tasks: listTasks() });
+        return;
+    }
+});

package/dist/server/handlers/session.js

@@ -0,0 +1,194 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { loadConfig } from "../config.js";
+import { createSession, deleteSession, findProjectSlugForSession, getSessionPreview, getSessionTitle, getSessionUsage, listSessions, invalidateSessionCache, invalidateHistoryCache, getSessionHistoryPage, loadSessionHistory, renameSession, getSessionFileSizeBytes, } from "../project/session.js";
+import { getContextBreakdown } from "../project/context-breakdown.js";
+import { setActiveSession, getActiveSession } from "./chat.js";
+import { setActiveProject } from "./fs.js";
+import { wasSessionInterrupted, clearInterruptedFlag } from "../project/sdk-bridge.js";
+import { log } from "../logger.js";
+registerHandler("session", function (clientId, message) {
+    if (message.type === "session:list_request") {
+        var listReqMsg = message;
+        var offset = listReqMsg.offset || 0;
+        var limit = listReqMsg.limit || 0;
+        var t0 = Date.now();
+        void listSessions(listReqMsg.projectSlug, { offset, limit }).then(function (result) {
+            log.session("session:list_request for %s took %dms (%d sessions)", listReqMsg.projectSlug, Date.now() - t0, result.sessions.length);
+            sendTo(clientId, {
+                type: "session:list",
+                projectSlug: listReqMsg.projectSlug,
+                sessions: result.sessions,
+                totalCount: result.totalCount,
+                offset,
+            });
+        });
+        return;
+    }
+    if (message.type === "session:preview_request") {
+        var previewMsg = message;
+        void getSessionPreview(previewMsg.projectSlug, previewMsg.sessionId).then(function (preview) {
+            if (preview) {
+                sendTo(clientId, { type: "session:preview", sessionId: previewMsg.sessionId, preview });
+            }
+        });
+        return;
+    }
+    if (message.type === "session:list_all_request") {
+        var config = loadConfig();
+        var allPromises = config.projects.map(function (p) {
+            return listSessions(p.slug, { limit: 20 });
+        });
+        void Promise.all(allPromises).then(function (results) {
+            var merged = [];
+            for (var i = 0; i < results.length; i++) {
+                for (var j = 0; j < results[i].sessions.length; j++) {
+                    merged.push(results[i].sessions[j]);
+                }
+            }
+            merged.sort(function (a, b) { return b.updatedAt - a.updatedAt; });
+            sendTo(clientId, {
+                type: "session:list_all",
+                sessions: merged.slice(0, 20),
+            });
+        });
+        return;
+    }
+    if (message.type === "session:history_page") {
+        var pageMsg = message;
+        var activeSession = getActiveSession(clientId);
+        void getSessionHistoryPage(pageMsg.sessionId, pageMsg.before, pageMsg.limit, activeSession?.projectSlug).then(function (page) {
+            sendTo(clientId, {
+                type: "session:history_page_result",
+                sessionId: pageMsg.sessionId,
+                messages: page.messages,
+                hasMore: page.hasMore,
+                totalMessages: page.totalMessages,
+            });
+        });
+        return;
+    }
+    if (message.type === "session:create") {
+        var createMsg = message;
+        var session = createSession(createMsg.projectSlug);
+        sendTo(clientId, { type: "session:created", session });
+        return;
+    }
+    if (message.type === "session:activate") {
+        var activateMsg = message;
+        setActiveSession(clientId, activateMsg.projectSlug, activateMsg.sessionId);
+        setActiveProject(clientId, activateMsg.projectSlug);
+        invalidateHistoryCache(activateMsg.sessionId);
+        var fileSize = getSessionFileSizeBytes(activateMsg.projectSlug, activateMsg.sessionId);
+        sendTo(clientId, { type: "session:loading_progress", sessionId: activateMsg.sessionId, fileSize });
+        var activateT0 = Date.now();
+        void loadSessionHistory(activateMsg.projectSlug, activateMsg.sessionId).then(function (historyResult) {
+            log.session("session:activate history: %dms", Date.now() - activateT0);
+            var title = null;
+            var interrupted = wasSessionInterrupted(activateMsg.sessionId);
+            if (interrupted) {
+                clearInterruptedFlag(activateMsg.sessionId);
+            }
+            sendTo(clientId, {
+                type: "session:history",
+                projectSlug: activateMsg.projectSlug,
+                sessionId: activateMsg.sessionId,
+                messages: historyResult.messages,
+                title: title,
+                interrupted: interrupted || undefined,
+                totalMessages: historyResult.totalMessages,
+                hasMore: historyResult.hasMore,
+            });
+        }).catch(function (err) {
+            log.session("Error sending session history: %O", err);
+            sendTo(clientId, { type: "chat:error", message: "Failed to load session history" });
+        });
+        setTimeout(function () {
+            void getSessionTitle(activateMsg.projectSlug, activateMsg.sessionId).then(function (sessionTitle) {
+                if (sessionTitle) {
+                    sendTo(clientId, { type: "session:history", projectSlug: activateMsg.projectSlug, sessionId: activateMsg.sessionId, messages: [], title: sessionTitle });
+                }
+            }).catch(function () { });
+            void Promise.all([
+                getSessionUsage(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
+                getContextBreakdown(activateMsg.projectSlug, activateMsg.sessionId).catch(function () { return null; }),
+            ]).then(function (results) {
+                try {
+                    var usage = results[0];
+                    if (usage) {
+                        sendTo(clientId, {
+                            type: "chat:context_usage",
+                            inputTokens: usage.inputTokens,
+                            outputTokens: usage.outputTokens,
+                            cacheReadTokens: usage.cacheReadTokens,
+                            cacheCreationTokens: usage.cacheCreationTokens,
+                            contextWindow: usage.contextWindow,
+                        });
+                    }
+                }
+                catch (err) {
+                    log.session("Error sending context usage: %O", err);
+                }
+                try {
+                    var breakdown = results[1];
+                    if (breakdown) {
+                        sendTo(clientId, {
+                            type: "chat:context_breakdown",
+                            segments: breakdown.segments,
+                            contextWindow: breakdown.contextWindow,
+                            autocompactAt: breakdown.autocompactAt,
+                        });
+                    }
+                }
+                catch (err) {
+                    log.session("Error sending context breakdown: %O", err);
+                }
+            }).catch(function (err) {
+                log.session("Failed to activate session: %O", err);
+                sendTo(clientId, { type: "chat:error", message: "Failed to activate session" });
+            });
+        }, 50);
+        return;
+    }
+    if (message.type === "session:rename") {
+        var renameMsg = message;
+        void findProjectSlugForSession(renameMsg.sessionId).then(function (projectSlug) {
+            if (!projectSlug) {
+                sendTo(clientId, { type: "chat:error", message: "Session not found" });
+                return;
+            }
+            void renameSession(projectSlug, renameMsg.sessionId, renameMsg.title).then(function () {
+                invalidateSessionCache(projectSlug);
+                void listSessions(projectSlug, { limit: 40 }).then(function (result) {
+                    sendTo(clientId, {
+                        type: "session:list",
+                        projectSlug,
+                        sessions: result.sessions,
+                        totalCount: result.totalCount,
+                    });
+                });
+            });
+        });
+        return;
+    }
+    if (message.type === "session:delete") {
+        var deleteMsg = message;
+        void findProjectSlugForSession(deleteMsg.sessionId).then(function (deleteProjectSlug) {
+            if (!deleteProjectSlug) {
+                sendTo(clientId, { type: "chat:error", message: "Session not found" });
+                return;
+            }
+            void deleteSession(deleteProjectSlug, deleteMsg.sessionId).then(function () {
+                invalidateSessionCache(deleteProjectSlug);
+                void listSessions(deleteProjectSlug, { limit: 40 }).then(function (result) {
+                    sendTo(clientId, {
+                        type: "session:list",
+                        projectSlug: deleteProjectSlug,
+                        sessions: result.sessions,
+                        totalCount: result.totalCount,
+                    });
+                });
+            });
+        });
+    }
+});

package/dist/server/handlers/settings.js

@@ -0,0 +1,148 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo, broadcast } from "../ws/broadcast.js";
+import { loadConfig, saveConfig } from "../config.js";
+import { addProject, removeProject } from "../project/registry.js";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readGlobalMcpServers, writeGlobalMcpServers, readGlobalSkills, readGlobalRules } from "../project/project-files.js";
+import { sendBudgetStatus } from "./chat.js";
+import { buildNodesMessage } from "./mesh.js";
+export function detectIdeProjectName(projectPath) {
+    try {
+        var ideDir = join(projectPath, ".idea");
+        if (!existsSync(ideDir))
+            return undefined;
+        var ideNameFile = join(ideDir, ".name");
+        if (existsSync(ideNameFile)) {
+            var name = readFileSync(ideNameFile, "utf-8").trim();
+            if (name)
+                return name;
+        }
+        return projectPath.split("/").pop() || undefined;
+    }
+    catch { }
+    return undefined;
+}
+import { loadOrCreateIdentity } from "../identity.js";
+function loadGlobalClaudeMd() {
+    var mdPath = join(homedir(), ".claude", "CLAUDE.md");
+    if (existsSync(mdPath)) {
+        try {
+            return readFileSync(mdPath, "utf-8");
+        }
+        catch { }
+    }
+    return "";
+}
+function saveGlobalClaudeMd(content) {
+    var claudeDir = join(homedir(), ".claude");
+    if (!existsSync(claudeDir)) {
+        mkdirSync(claudeDir, { recursive: true });
+    }
+    writeFileSync(join(claudeDir, "CLAUDE.md"), content, "utf-8");
+}
+function loadSpinnerVerbs() {
+    var claudeSettingsPath = join(homedir(), ".claude", "settings.json");
+    var defaultVerbs = ["Thinking", "Analyzing", "Processing", "Computing", "Evaluating", "Considering", "Examining", "Reviewing"];
+    try {
+        var claudeSettings = JSON.parse(readFileSync(claudeSettingsPath, "utf-8"));
+        if (claudeSettings.spinnerVerbs) {
+            if (claudeSettings.spinnerVerbs.mode === "replace") {
+                return claudeSettings.spinnerVerbs.verbs || [];
+            }
+            return [...defaultVerbs, ...(claudeSettings.spinnerVerbs.verbs || [])];
+        }
+    }
+    catch { }
+    return defaultVerbs;
+}
+registerHandler("settings", function (clientId, message) {
+    if (message.type === "settings:get") {
+        var config = loadConfig();
+        var identity = loadOrCreateIdentity();
+        var configWithClaudeMd = { ...config, claudeMd: loadGlobalClaudeMd() };
+        sendTo(clientId, {
+            type: "settings:data",
+            config: configWithClaudeMd,
+            mcpServers: readGlobalMcpServers(),
+            globalSkills: readGlobalSkills(),
+            globalRules: readGlobalRules(),
+            spinnerVerbs: loadSpinnerVerbs(),
+            wslDistro: process.env.WSL_DISTRO_NAME || undefined,
+        });
+        sendTo(clientId, {
+            type: "projects:list",
+            projects: config.projects.map(function (p) {
+                return { slug: p.slug, path: p.path, title: p.title, nodeId: identity.id, nodeName: config.name, isRemote: false, ideProjectName: detectIdeProjectName(p.path) };
+            }),
+        });
+        sendTo(clientId, { type: "mesh:nodes", nodes: buildNodesMessage() });
+        sendBudgetStatus(clientId);
+        return;
+    }
+    if (message.type === "settings:update") {
+        var updateMsg = message;
+        var current = loadConfig();
+        var incoming = updateMsg.settings;
+        if (typeof incoming.claudeMd === "string") {
+            saveGlobalClaudeMd(incoming.claudeMd);
+            delete incoming.claudeMd;
+        }
+        if (incoming.mcpServers != null) {
+            writeGlobalMcpServers(incoming.mcpServers);
+            delete incoming.mcpServers;
+        }
+        if (typeof incoming.removeProject === "string") {
+            removeProject(incoming.removeProject);
+            delete incoming.removeProject;
+        }
+        var incomingProjects = incoming.projects;
+        if (incomingProjects && incomingProjects.length > 0) {
+            for (var i = 0; i < incomingProjects.length; i++) {
+                var proj = incomingProjects[i];
+                addProject(proj.path, proj.title);
+            }
+        }
+        var refreshed = loadConfig();
+        var updated = {
+            ...refreshed,
+            ...incoming,
+            globalEnv: {
+                ...refreshed.globalEnv,
+                ...(incoming.globalEnv ?? {}),
+            },
+            projects: refreshed.projects,
+        };
+        if ("costBudget" in incoming && incoming.costBudget == null) {
+            delete updated.costBudget;
+        }
+        saveConfig(updated);
+        var updatedWithClaudeMd = { ...updated, claudeMd: loadGlobalClaudeMd() };
+        sendTo(clientId, {
+            type: "settings:data",
+            config: updatedWithClaudeMd,
+            mcpServers: readGlobalMcpServers(),
+            globalSkills: readGlobalSkills(),
+            globalRules: readGlobalRules(),
+            spinnerVerbs: loadSpinnerVerbs(),
+            wslDistro: process.env.WSL_DISTRO_NAME || undefined,
+        });
+        var updatedIdentity = loadOrCreateIdentity();
+        broadcast({
+            type: "projects:list",
+            projects: updated.projects.map(function (p) {
+                return { slug: p.slug, path: p.path, title: p.title, nodeId: updatedIdentity.id, nodeName: updated.name, isRemote: false };
+            }),
+        });
+        sendBudgetStatus(clientId);
+        return;
+    }
+    if (message.type === "settings:restart") {
+        console.log("[lattice] Restart requested by client");
+        setTimeout(function () {
+            process.exit(0);
+        }, 200);
+        return;
+    }
+});