@cryptiklemur/lattice 5.9.0 → 5.10.0

package/dist/server/handlers/hooks.js

@@ -0,0 +1,233 @@
+import { resolve } from "node:path";
+import { ContextAnalyzer } from "../features/context-analyzer.js";
+import { broadcast } from "../ws/broadcast.js";
+import { loadConfig } from "../config.js";
+import { log } from "../logger.js";
+import { upsertFromSnapshot, addToolEventToHistory, markSessionEnded } from "../features/session-history.js";
+var sessionProjectMap = new Map();
+function matchCwdToProject(cwd) {
+    var config = loadConfig();
+    var resolved = resolve(cwd);
+    for (var i = 0; i < config.projects.length; i++) {
+        var p = config.projects[i];
+        var projectPath = resolve(p.path);
+        if (resolved === projectPath || resolved.startsWith(projectPath + "/")) {
+            return { projectName: p.title, projectSlug: p.slug };
+        }
+    }
+    return null;
+}
+const sessionAnalyzers = new Map();
+function getOrCreateAnalyzer(sessionId) {
+    let analyzer = sessionAnalyzers.get(sessionId);
+    if (!analyzer) {
+        analyzer = new ContextAnalyzer(function (msg) {
+            broadcast({ ...msg, hookSessionId: sessionId });
+        });
+        sessionAnalyzers.set(sessionId, analyzer);
+    }
+    return analyzer;
+}
+function cleanupSession(sessionId) {
+    sessionAnalyzers.delete(sessionId);
+}
+export function handleHookStatusline(req, res) {
+    const body = req.body;
+    if (!body.session_id) {
+        res.status(400).json({ status: "error", message: "missing session_id" });
+        return;
+    }
+    const cw = body.context_window || {};
+    const cost = body.cost || {};
+    const model = body.model || {};
+    const inputTokens = cw.total_input_tokens || 0;
+    const outputTokens = cw.total_output_tokens || 0;
+    const cacheReadTokens = cw.cache_read_input_tokens || 0;
+    const cacheCreationTokens = cw.cache_creation_input_tokens || 0;
+    const contextWindow = cw.context_window_size || 0;
+    const usedPercent = cw.used_percentage || 0;
+    const costUsd = cost.total_cost_usd || 0;
+    const durationMs = cost.total_duration_ms || 0;
+    const modelId = model.id || "";
+    const modelName = model.display_name || "";
+    const analyzer = getOrCreateAnalyzer(body.session_id);
+    analyzer.updateUsage({
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreationTokens,
+    }, contextWindow);
+    var statusProject = sessionProjectMap.get(body.session_id) || null;
+    broadcast({
+        type: "context:statusline",
+        hookSessionId: body.session_id,
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreationTokens,
+        contextWindow,
+        usedPercent,
+        costUsd,
+        durationMs,
+        modelId,
+        modelName,
+        timestamp: Date.now(),
+        projectName: statusProject?.projectName || null,
+        projectSlug: statusProject?.projectSlug || null,
+    });
+    upsertFromSnapshot(body.session_id, {
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheCreationTokens,
+        contextWindow,
+        usedPercent,
+        costUsd,
+        durationMs,
+        modelId,
+        modelName,
+        projectName: statusProject?.projectName || null,
+        projectSlug: statusProject?.projectSlug || null,
+    });
+    res.status(202).json({ status: "accepted" });
+}
+export function handleHookEvent(req, res) {
+    const body = req.body;
+    if (!body.session_id || !body.event_type) {
+        res.status(400).json({ status: "error", message: "missing session_id or event_type" });
+        return;
+    }
+    const analyzer = getOrCreateAnalyzer(body.session_id);
+    switch (body.event_type) {
+        case "PostToolUse": {
+            if (body.tool_name) {
+                const toolId = body.session_id + "-" + body.timestamp_ms;
+                analyzer.onToolStart(toolId, body.tool_name);
+                // For hook-based flow, the tool already ran. Mark result immediately.
+                // The next statusline snapshot will trigger the delta computation.
+                analyzer.onToolResult(toolId);
+            }
+            break;
+        }
+        case "Stop": {
+            cleanupSession(body.session_id);
+            markSessionEnded(body.session_id);
+            broadcast({
+                type: "context:session_ended",
+                hookSessionId: body.session_id,
+                timestamp: body.timestamp_ms || Date.now(),
+            });
+            break;
+        }
+        case "SessionStart": {
+            // Reset analyzer for fresh session
+            cleanupSession(body.session_id);
+            getOrCreateAnalyzer(body.session_id);
+            broadcast({
+                type: "context:session_started",
+                hookSessionId: body.session_id,
+                timestamp: body.timestamp_ms || Date.now(),
+            });
+            break;
+        }
+        case "PreCompact": {
+            broadcast({
+                type: "context:compact",
+                hookSessionId: body.session_id,
+                phase: "pre",
+                timestamp: body.timestamp_ms || Date.now(),
+            });
+            break;
+        }
+        case "PostCompact": {
+            broadcast({
+                type: "context:compact",
+                hookSessionId: body.session_id,
+                phase: "post",
+                timestamp: body.timestamp_ms || Date.now(),
+            });
+            break;
+        }
+        default:
+            break;
+    }
+    log.server("Hook event: %s for session %s", body.event_type, body.session_id.slice(0, 8));
+    res.status(202).json({ status: "accepted" });
+}
+function estimateTokens(value) {
+    if (value == null)
+        return 0;
+    var text = typeof value === "string" ? value : JSON.stringify(value);
+    return Math.ceil(text.length / 4);
+}
+function summarizeInput(toolName, input) {
+    if (input == null)
+        return "";
+    if (typeof input === "string")
+        return input.slice(0, 120);
+    if (typeof input === "object") {
+        var obj = input;
+        if (obj.command)
+            return String(obj.command).slice(0, 120);
+        if (obj.file_path)
+            return String(obj.file_path);
+        if (obj.pattern)
+            return String(obj.pattern).slice(0, 120);
+        if (obj.query)
+            return String(obj.query).slice(0, 120);
+        if (obj.prompt)
+            return String(obj.prompt).slice(0, 120);
+        var keys = Object.keys(obj);
+        if (keys.length > 0)
+            return keys.slice(0, 3).join(", ");
+    }
+    return "";
+}
+export function handleHookToolUse(req, res) {
+    var body = req.body;
+    if (!body.session_id) {
+        res.status(400).json({ status: "error", message: "missing session_id" });
+        return;
+    }
+    var toolName = body.tool_name || "unknown";
+    var inputSummary = summarizeInput(toolName, body.tool_input);
+    var estInput = estimateTokens(body.tool_input);
+    var estOutput = estimateTokens(body.tool_response);
+    var now = Date.now();
+    if (body.cwd && !sessionProjectMap.has(body.session_id)) {
+        var match = matchCwdToProject(body.cwd);
+        if (match) {
+            sessionProjectMap.set(body.session_id, match);
+        }
+    }
+    var sessionProject = sessionProjectMap.get(body.session_id) || null;
+    var analyzer = getOrCreateAnalyzer(body.session_id);
+    var toolId = body.session_id + "-" + now;
+    analyzer.onToolStart(toolId, toolName);
+    analyzer.onToolResult(toolId);
+    broadcast({
+        type: "context:tool_event",
+        hookSessionId: body.session_id,
+        toolName,
+        inputSummary,
+        estimatedInputTokens: estInput,
+        estimatedOutputTokens: estOutput,
+        estimatedTotalTokens: estInput + estOutput,
+        timestamp: now,
+        projectName: sessionProject?.projectName || null,
+        projectSlug: sessionProject?.projectSlug || null,
+    });
+    addToolEventToHistory(body.session_id, {
+        toolName,
+        inputSummary,
+        estimatedInputTokens: estInput,
+        estimatedOutputTokens: estOutput,
+        estimatedTotalTokens: estInput + estOutput,
+        timestamp: now,
+    });
+    log.server("Hook tool_use: %s %s for session %s", toolName, inputSummary.slice(0, 40), body.session_id.slice(0, 8));
+    res.status(202).json({ status: "accepted" });
+}
+export function getHookSessionAnalyzers() {
+    return sessionAnalyzers;
+}

package/dist/server/handlers/session.js

@@ -70,7 +70,7 @@ registerHandler("session", async function (clientId, message) {
     }
     if (message.type === "session:create") {
         var createMsg = message;
-        var session = createSession(createMsg.projectSlug);
+        var session = createSession(createMsg.projectSlug, createMsg.sessionType);
         updateSessionInIndex(createMsg.projectSlug, session);
         sendTo(clientId, { type: "session:created", session });
         broadcastToProject(createMsg.projectSlug, {

package/dist/server/handlers/specs.js

@@ -1,6 +1,8 @@
 import { registerHandler } from "../ws/router.js";
 import { sendTo, broadcastToProject } from "../ws/broadcast.js";
 import { listSpecs, getSpec, createSpec, updateSpec, deleteSpec, linkSession, unlinkSession, addActivity, } from "../features/specs.js";
+import { createSession, updateSessionInIndex } from "../project/session.js";
+import { buildBrainstormPrompt, buildWritePlanPrompt, buildExecutePrompt } from "../features/superpowers.js";
 registerHandler("specs", function (clientId, message) {
     if (message.type === "specs:list") {
         var listMsg = message;
@@ -31,6 +33,61 @@ registerHandler("specs", function (clientId, message) {
         broadcastToProject(created.projectSlug, { type: "specs:created", spec: created });
         return;
     }
+    if (message.type === "specs:create-with-brainstorm") {
+        var brainstormMsg = message;
+        var slug = brainstormMsg.projectSlug;
+        var newSpec = createSpec({ projectSlug: slug, title: "New Spec" });
+        var brainstormSession = createSession(slug, "brainstorm");
+        updateSessionInIndex(slug, brainstormSession);
+        linkSession(newSpec.id, brainstormSession.id, "Brainstorm session", "brainstorm");
+        var brainstormPrompt = buildBrainstormPrompt(newSpec, slug);
+        sendTo(clientId, {
+            type: "specs:brainstorm-started",
+            spec: newSpec,
+            sessionId: brainstormSession.id,
+            systemPrompt: { type: "preset", preset: "claude_code", append: brainstormPrompt },
+        });
+        broadcastToProject(slug, { type: "specs:created", spec: newSpec });
+        return;
+    }
+    if (message.type === "specs:start-plan") {
+        var planMsg = message;
+        var planSpec = getSpec(planMsg.specId);
+        if (!planSpec) {
+            sendTo(clientId, { type: "chat:error", message: "Spec not found" });
+            return;
+        }
+        var planSession = createSession(planMsg.projectSlug, "write-plan");
+        updateSessionInIndex(planMsg.projectSlug, planSession);
+        linkSession(planSpec.id, planSession.id, "Write plan session", "write-plan");
+        var planPrompt = buildWritePlanPrompt(planSpec, planMsg.projectSlug);
+        sendTo(clientId, {
+            type: "specs:plan-started",
+            spec: planSpec,
+            sessionId: planSession.id,
+            systemPrompt: { type: "preset", preset: "claude_code", append: planPrompt },
+        });
+        return;
+    }
+    if (message.type === "specs:start-execute") {
+        var execMsg = message;
+        var execSpec = getSpec(execMsg.specId);
+        if (!execSpec) {
+            sendTo(clientId, { type: "chat:error", message: "Spec not found" });
+            return;
+        }
+        var execSession = createSession(execMsg.projectSlug, "execute");
+        updateSessionInIndex(execMsg.projectSlug, execSession);
+        linkSession(execSpec.id, execSession.id, "Execute session", "execute");
+        var execPrompt = buildExecutePrompt(execSpec, execMsg.projectSlug);
+        sendTo(clientId, {
+            type: "specs:execute-started",
+            spec: execSpec,
+            sessionId: execSession.id,
+            systemPrompt: { type: "preset", preset: "claude_code", append: execPrompt },
+        });
+        return;
+    }
     if (message.type === "specs:update") {
         var updateMsg = message;
         var updated = updateSpec(updateMsg.id, {

package/dist/server/handlers/superpowers.js

@@ -0,0 +1,13 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { isSuperpowersInstalled, getSuperpowersVersion, getAvailableSkills } from "../features/superpowers.js";
+registerHandler("superpowers", function (clientId, message) {
+    if (message.type === "superpowers:status_request") {
+        sendTo(clientId, {
+            type: "superpowers:status",
+            installed: isSuperpowersInstalled(),
+            version: getSuperpowersVersion(),
+            skillsAvailable: getAvailableSkills(),
+        });
+    }
+});

package/dist/server/logger.js

@@ -17,4 +17,5 @@ export var log = {
     update: createDebug("lattice:update"),
     terminal: createDebug("lattice:terminal"),
     settings: createDebug("lattice:settings"),
+    superpowers: createDebug("lattice:superpowers"),
 };

package/dist/server/project/sdk-bridge.js

@@ -2,7 +2,7 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
-import { sendTo, broadcast } from "../ws/broadcast.js";
+import { sendTo, broadcast, broadcastToProject } from "../ws/broadcast.js";
 import { syncSessionToPeers } from "../mesh/session-sync.js";
 import { resolveSkillContent } from "../handlers/skills.js";
 import { getPluginMcpServers } from "../handlers/plugins.js";
@@ -13,6 +13,8 @@ import { getDailySpend, invalidateDailySpendCache } from "../analytics/engine.js
 import { getWarmupModels, cacheRateLimitEntry } from "./warmup.js";
 import { execSync } from "node:child_process";
 import { sendPush } from "../push.js";
+import { parseSpecPopulate, parsePlanContent, parseSpecActivity, populateSpec, updateSpec as updateSpecData, addActivity } from "../features/specs.js";
+import { ContextAnalyzer } from "../features/context-analyzer.js";
 var HIDDEN_TOOLS = new Set([
     "TaskUpdate", "TaskCreate", "TaskGet", "TaskList", "TaskOutput", "TaskStop",
     "TodoWrite", "TodoRead",
@@ -640,6 +642,9 @@ export function startChatStream(options) {
     if (env) {
         queryOptions.env = env;
     }
+    if (options.systemPrompt) {
+        queryOptions.systemPrompt = options.systemPrompt;
+    }
     var prompt = resolvePromptText(text);
     sendTo(clientId, {
         type: "chat:user_message",
@@ -666,6 +671,13 @@ export function startChatStream(options) {
         turnDoneSent: false,
         messageUUIDs: [],
         ended: false,
+        accumulatedText: "",
+        specId: options.specId,
+        analyzer: new ContextAnalyzer(function (msg) {
+            var ss = sessionStreams.get(sessionId);
+            if (ss)
+                sendTo(ss.clientId, msg);
+        }),
     };
     sessionStreams.set(sessionId, sessionStream);
     persistStreamState();
@@ -728,6 +740,38 @@ export function startChatStream(options) {
         }
     })();
 }
+function processStructuredOutput(ss) {
+    var text = ss.accumulatedText;
+    var specId = ss.specId;
+    var specFields = parseSpecPopulate(text);
+    if (specFields) {
+        var updated = populateSpec(specId, specFields, ss.sessionId);
+        if (updated) {
+            broadcastToProject(ss.projectSlug, { type: "specs:updated", spec: updated });
+        }
+    }
+    var planContent = parsePlanContent(text);
+    if (planContent) {
+        var updatedPlan = updateSpecData(specId, {
+            sections: { implementationPlan: planContent },
+        });
+        if (updatedPlan) {
+            broadcastToProject(ss.projectSlug, { type: "specs:updated", spec: updatedPlan });
+        }
+    }
+    var searchText = text;
+    var activityData = parseSpecActivity(searchText);
+    while (activityData) {
+        var updatedActivity = addActivity(specId, activityData.type, activityData.detail, ss.sessionId);
+        if (updatedActivity) {
+            broadcastToProject(ss.projectSlug, { type: "specs:activity_added", spec: updatedActivity });
+        }
+        var endIdx = searchText.indexOf("</spec-activity>");
+        searchText = searchText.slice(endIdx + "</spec-activity>".length);
+        activityData = parseSpecActivity(searchText);
+    }
+    ss.accumulatedText = "";
+}
 function processMessage(ss, msg) {
     var sessionId = ss.sessionId;
     if (msg.type === "system") {
@@ -743,14 +787,21 @@ function processMessage(ss, msg) {
         var assistantMsg = msg;
         var msgUsage = assistantMsg.message.usage;
         if (msgUsage && msgUsage.input_tokens != null) {
+            var ctxWindow = guessContextWindow(assistantMsg.message.model || "");
             sendTo(ss.clientId, {
                 type: "chat:context_usage",
                 inputTokens: msgUsage.input_tokens || 0,
                 outputTokens: msgUsage.output_tokens || 0,
                 cacheReadTokens: msgUsage.cache_read_input_tokens || 0,
                 cacheCreationTokens: msgUsage.cache_creation_input_tokens || 0,
-                contextWindow: guessContextWindow(assistantMsg.message.model || ""),
+                contextWindow: ctxWindow,
             });
+            ss.analyzer.updateUsage({
+                inputTokens: msgUsage.input_tokens || 0,
+                outputTokens: msgUsage.output_tokens || 0,
+                cacheReadTokens: msgUsage.cache_read_input_tokens || 0,
+                cacheCreationTokens: msgUsage.cache_creation_input_tokens || 0,
+            }, ctxWindow);
         }
         return;
     }
@@ -762,6 +813,7 @@ function processMessage(ss, msg) {
             var idx = evt.index;
             if (block.type === "tool_use" && block.id && block.name) {
                 ss.activeToolBlocks[idx] = { id: block.id, name: block.name, inputJson: "" };
+                ss.analyzer.onToolStart(block.id, block.name);
                 if (HIDDEN_TOOLS.has(block.name)) {
                     ss.hiddenToolIds.add(block.id);
                 }
@@ -781,6 +833,9 @@ function processMessage(ss, msg) {
             var blockIdx = deltaEvt.index;
             if (deltaEvt.delta.type === "text_delta" && typeof deltaEvt.delta.text === "string") {
                 sendTo(ss.clientId, { type: "chat:delta", text: deltaEvt.delta.text });
+                if (ss.specId) {
+                    ss.accumulatedText += deltaEvt.delta.text;
+                }
             }
             else if (deltaEvt.delta.type === "input_json_delta" && ss.activeToolBlocks[blockIdx]) {
                 ss.activeToolBlocks[blockIdx].inputJson += deltaEvt.delta.partial_json || "";
@@ -836,6 +891,7 @@ function processMessage(ss, msg) {
             for (var i = 0; i < content.length; i++) {
                 var item = content[i];
                 if (item.type === "tool_result" && item.tool_use_id) {
+                    ss.analyzer.onToolResult(item.tool_use_id);
                     if (ss.hiddenToolIds.has(item.tool_use_id))
                         continue;
                     var resultContent = typeof item.content === "string"
@@ -908,6 +964,15 @@ function processMessage(ss, msg) {
                 cacheCreationTokens: resultMsg.usage.cache_creation_input_tokens || 0,
                 contextWindow: contextWindow,
             });
+            ss.analyzer.updateUsage({
+                inputTokens: resultMsg.usage.input_tokens || 0,
+                outputTokens: resultMsg.usage.output_tokens || 0,
+                cacheReadTokens: resultMsg.usage.cache_read_input_tokens || 0,
+                cacheCreationTokens: resultMsg.usage.cache_creation_input_tokens || 0,
+            }, contextWindow);
+        }
+        if (ss.specId && ss.accumulatedText) {
+            processStructuredOutput(ss);
         }
         ss.turnDoneSent = true;
         sendTo(ss.clientId, { type: "chat:done", cost: cost, duration: dur });

package/dist/server/project/session.js

@@ -727,7 +727,7 @@ export async function getSessionHistoryPage(sessionId, beforeIndex, limit, proje
     var page = cached.messages.slice(startIdx, endIdx);
     return { messages: page, hasMore: startIdx > 0, totalMessages: total };
 }
-export function createSession(projectSlug) {
+export function createSession(projectSlug, sessionType) {
     var sessionId = randomUUID();
     var now = Date.now();
     return {
@@ -736,6 +736,7 @@ export function createSession(projectSlug) {
         title: "Session " + new Date(now).toLocaleString(),
         createdAt: now,
         updatedAt: now,
+        sessionType: (sessionType || "chat"),
     };
 }
 export async function renameSession(projectSlug, sessionId, title) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "5.9.0",
+  "version": "5.10.0",
   "description": "Multi-machine agentic dashboard for Claude Code. Monitor sessions, manage MCP servers and skills, orchestrate across mesh-networked nodes.",
   "license": "MIT",
   "author": "Aaron Scherer <me@aaronscherer.me>",