@cryptiklemur/lattice 5.8.3 → 5.10.0

package/dist/server/features/session-history.js

@@ -0,0 +1,127 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { getLatticeHome } from "../config.js";
+import { log } from "../logger.js";
+function getSessionDir() {
+    const dir = join(getLatticeHome(), "session-history");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+function sessionPath(hookSessionId) {
+    const safe = hookSessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return join(getSessionDir(), safe + ".json");
+}
+const sessionCache = new Map();
+let indexLoaded = false;
+export function loadSessionHistory() {
+    if (indexLoaded)
+        return Array.from(sessionCache.values());
+    const dir = getSessionDir();
+    try {
+        const files = readdirSync(dir).filter(function (f) { return f.endsWith(".json"); });
+        for (const file of files) {
+            try {
+                const raw = readFileSync(join(dir, file), "utf-8");
+                const session = JSON.parse(raw);
+                if (session.hookSessionId) {
+                    sessionCache.set(session.hookSessionId, session);
+                }
+            }
+            catch {
+                log.server("Failed to read session history file: %s", file);
+            }
+        }
+        indexLoaded = true;
+        log.server("Loaded %d historical sessions", sessionCache.size);
+    }
+    catch {
+        indexLoaded = true;
+    }
+    return Array.from(sessionCache.values());
+}
+export function saveSession(session) {
+    sessionCache.set(session.hookSessionId, session);
+    try {
+        const path = sessionPath(session.hookSessionId);
+        writeFileSync(path, JSON.stringify(session), "utf-8");
+    }
+    catch (err) {
+        log.server("Failed to save session history: %s", String(err));
+    }
+}
+export function getSession(hookSessionId) {
+    return sessionCache.get(hookSessionId) || null;
+}
+export function upsertFromSnapshot(hookSessionId, snapshot) {
+    let existing = sessionCache.get(hookSessionId);
+    if (!existing) {
+        existing = {
+            hookSessionId,
+            ...snapshot,
+            timestamp: Date.now(),
+            endedAt: null,
+            active: true,
+            toolEvents: [],
+            toolDeltas: [],
+            anomalyCount: 0,
+        };
+    }
+    else {
+        existing.inputTokens = snapshot.inputTokens;
+        existing.outputTokens = snapshot.outputTokens;
+        existing.cacheReadTokens = snapshot.cacheReadTokens;
+        existing.cacheCreationTokens = snapshot.cacheCreationTokens;
+        existing.contextWindow = snapshot.contextWindow;
+        existing.usedPercent = snapshot.usedPercent;
+        existing.costUsd = snapshot.costUsd;
+        existing.durationMs = snapshot.durationMs;
+        existing.modelId = snapshot.modelId || existing.modelId;
+        existing.modelName = snapshot.modelName || existing.modelName;
+        existing.projectName = snapshot.projectName || existing.projectName;
+        existing.projectSlug = snapshot.projectSlug || existing.projectSlug;
+        existing.timestamp = Date.now();
+    }
+    saveSession(existing);
+}
+export function addToolEventToHistory(hookSessionId, event) {
+    const existing = sessionCache.get(hookSessionId);
+    if (!existing)
+        return;
+    if (existing.toolEvents.length >= 500) {
+        existing.toolEvents = existing.toolEvents.slice(-499);
+    }
+    existing.toolEvents.push(event);
+}
+export function addToolDeltaToHistory(hookSessionId, delta) {
+    const existing = sessionCache.get(hookSessionId);
+    if (!existing)
+        return;
+    if (existing.toolDeltas.length >= 500) {
+        existing.toolDeltas = existing.toolDeltas.slice(-499);
+    }
+    existing.toolDeltas.push(delta);
+}
+export function markSessionEnded(hookSessionId) {
+    const existing = sessionCache.get(hookSessionId);
+    if (!existing)
+        return;
+    existing.active = false;
+    existing.endedAt = Date.now();
+    saveSession(existing);
+}
+export function listSessions(options) {
+    let sessions = Array.from(sessionCache.values());
+    if (options?.projectSlug) {
+        sessions = sessions.filter(function (s) { return s.projectSlug === options.projectSlug; });
+    }
+    if (options?.active !== undefined) {
+        sessions = sessions.filter(function (s) { return s.active === options.active; });
+    }
+    sessions.sort(function (a, b) { return b.timestamp - a.timestamp; });
+    if (options?.limit) {
+        sessions = sessions.slice(0, options.limit);
+    }
+    return sessions;
+}

package/dist/server/features/specs.js

@@ -197,7 +197,92 @@ export function deleteSpec(id) {
     }
     return false;
 }
-export function linkSession(specId, sessionId, note) {
+export function populateSpec(id, fields, sessionId) {
+    for (var i = 0; i < specs.length; i++) {
+        if (specs[i].id !== id)
+            continue;
+        var spec = specs[i];
+        if (fields.title && typeof fields.title === "string")
+            spec.title = fields.title;
+        if (fields.tagline && typeof fields.tagline === "string")
+            spec.tagline = fields.tagline;
+        if (fields.priority && typeof fields.priority === "string")
+            spec.priority = fields.priority;
+        if (fields.estimatedEffort && typeof fields.estimatedEffort === "string")
+            spec.estimatedEffort = fields.estimatedEffort;
+        if (fields.tags && Array.isArray(fields.tags))
+            spec.tags = fields.tags;
+        if (fields.summary && typeof fields.summary === "string")
+            spec.sections.summary = fields.summary;
+        if (fields.currentState && typeof fields.currentState === "string")
+            spec.sections.currentState = fields.currentState;
+        if (fields.requirements && typeof fields.requirements === "string")
+            spec.sections.requirements = fields.requirements;
+        if (fields.implementationPlan && typeof fields.implementationPlan === "string")
+            spec.sections.implementationPlan = fields.implementationPlan;
+        if (fields.testing && typeof fields.testing === "string")
+            spec.sections.testing = fields.testing;
+        spec.updatedAt = Date.now();
+        spec.activity.push({
+            timestamp: Date.now(),
+            type: "ai-note",
+            detail: "Spec populated from brainstorm session",
+            sessionId,
+        });
+        saveSpecs();
+        return spec;
+    }
+    return null;
+}
+export function parseSpecPopulate(text) {
+    var startTag = "<spec-populate>";
+    var endTag = "</spec-populate>";
+    var startIdx = text.indexOf(startTag);
+    var endIdx = text.indexOf(endTag);
+    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx)
+        return null;
+    var jsonStr = text.slice(startIdx + startTag.length, endIdx).trim();
+    try {
+        return JSON.parse(jsonStr);
+    }
+    catch {
+        return null;
+    }
+}
+export function parsePlanContent(text) {
+    var startTag = "<plan-content>";
+    var endTag = "</plan-content>";
+    var startIdx = text.indexOf(startTag);
+    var endIdx = text.indexOf(endTag);
+    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx)
+        return null;
+    return text.slice(startIdx + startTag.length, endIdx).trim();
+}
+export function parseSpecActivity(text) {
+    var startTag = "<spec-activity>";
+    var endTag = "</spec-activity>";
+    var startIdx = text.indexOf(startTag);
+    var endIdx = text.indexOf(endTag);
+    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx)
+        return null;
+    var jsonStr = text.slice(startIdx + startTag.length, endIdx).trim();
+    try {
+        return JSON.parse(jsonStr);
+    }
+    catch {
+        return null;
+    }
+}
+export function findSpecBySession(sessionId) {
+    for (var i = 0; i < specs.length; i++) {
+        for (var j = 0; j < specs[i].linkedSessions.length; j++) {
+            if (specs[i].linkedSessions[j].sessionId === sessionId)
+                return specs[i];
+        }
+    }
+    return null;
+}
+export function linkSession(specId, sessionId, note, sessionType) {
     for (var i = 0; i < specs.length; i++) {
         if (specs[i].id !== specId)
             continue;
@@ -207,6 +292,7 @@ export function linkSession(specId, sessionId, note) {
             sessionId,
             linkedAt: now,
             note,
+            sessionType,
         });
         spec.activity.push({
             timestamp: now,

package/dist/server/features/superpowers.js

@@ -0,0 +1,173 @@
+import { existsSync, readFileSync, watch } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { log } from "../logger.js";
+var TRACKED_SKILLS = [
+    "brainstorming",
+    "writing-plans",
+    "subagent-driven-development",
+    "executing-plans",
+];
+var installed = false;
+var version = null;
+var installPath = null;
+var skillContent = new Map();
+var watcher = null;
+function getPluginsFilePath() {
+    return join(homedir(), ".claude", "plugins", "installed_plugins.json");
+}
+function detectSuperpowers() {
+    var pluginsFile = getPluginsFilePath();
+    if (!existsSync(pluginsFile)) {
+        installed = false;
+        version = null;
+        installPath = null;
+        skillContent.clear();
+        return;
+    }
+    try {
+        var raw = readFileSync(pluginsFile, "utf-8");
+        var data = JSON.parse(raw);
+        var plugins = data.plugins || {};
+        var found = false;
+        for (var key of Object.keys(plugins)) {
+            if (key.startsWith("superpowers@")) {
+                var entries = plugins[key];
+                if (Array.isArray(entries) && entries.length > 0) {
+                    var entry = entries[0];
+                    installed = true;
+                    version = entry.version || null;
+                    installPath = entry.installPath || null;
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            installed = false;
+            version = null;
+            installPath = null;
+            skillContent.clear();
+            return;
+        }
+        loadSkills();
+    }
+    catch (err) {
+        log.superpowers("Failed to read plugins file: %O", err);
+        installed = false;
+        version = null;
+        installPath = null;
+        skillContent.clear();
+    }
+}
+function loadSkills() {
+    skillContent.clear();
+    if (!installPath)
+        return;
+    for (var name of TRACKED_SKILLS) {
+        var skillPath = join(installPath, "skills", name, "SKILL.md");
+        if (existsSync(skillPath)) {
+            try {
+                var content = readFileSync(skillPath, "utf-8");
+                skillContent.set(name, content);
+            }
+            catch (err) {
+                log.superpowers("Failed to read skill %s: %O", name, err);
+            }
+        }
+    }
+    log.superpowers("Superpowers v%s detected with %d skills", version, skillContent.size);
+}
+export function initSuperpowers() {
+    detectSuperpowers();
+    var pluginsDir = join(homedir(), ".claude", "plugins");
+    if (existsSync(pluginsDir)) {
+        try {
+            watcher = watch(pluginsDir, function (_eventType, filename) {
+                if (filename === "installed_plugins.json") {
+                    detectSuperpowers();
+                }
+            });
+        }
+        catch (err) {
+            log.superpowers("Failed to watch plugins directory: %O", err);
+        }
+    }
+}
+export function isSuperpowersInstalled() {
+    return installed;
+}
+export function getSuperpowersVersion() {
+    return version;
+}
+export function getSkillContent(skillName) {
+    return skillContent.get(skillName) ?? null;
+}
+export function getAvailableSkills() {
+    return Array.from(skillContent.keys());
+}
+export function buildBrainstormPrompt(spec, projectSlug) {
+    var content = getSkillContent("brainstorming");
+    if (!content)
+        return "";
+    var append = content + "\n\n---\n\n";
+    append += "## Lattice Integration Instructions\n\n";
+    append += "You are helping design a spec in the Lattice project management tool.\n\n";
+    append += "**Project:** " + projectSlug + "\n";
+    append += "**Spec ID:** " + spec.id + "\n\n";
+    append += "When you reach the 'write design doc' phase, instead of writing a file to disk, ";
+    append += "output the design as a JSON block inside `<spec-populate>` tags. The JSON should contain ";
+    append += "any of these fields that you have determined from the conversation:\n\n";
+    append += "```json\n";
+    append += '{\n  "title": "Spec title",\n  "tagline": "One-line summary",\n';
+    append += '  "summary": "Full summary section content",\n';
+    append += '  "currentState": "What exists today",\n';
+    append += '  "requirements": "What needs to change",\n';
+    append += '  "implementationPlan": "High-level approach",\n';
+    append += '  "testing": "How to verify",\n';
+    append += '  "priority": "high|medium|low",\n';
+    append += '  "estimatedEffort": "small|medium|large|xl",\n';
+    append += '  "tags": ["tag1", "tag2"]\n}\n```\n\n';
+    append += "Lattice will automatically populate the spec fields from this output.\n";
+    append += "After outputting the spec-populate block, suggest that the user can now write an implementation plan from the spec editor.\n";
+    return append;
+}
+export function buildWritePlanPrompt(spec, projectSlug) {
+    var content = getSkillContent("writing-plans");
+    if (!content)
+        return "";
+    var append = content + "\n\n---\n\n";
+    append += "## Lattice Integration Instructions\n\n";
+    append += "You are writing an implementation plan for a spec in Lattice.\n\n";
+    append += "**Project:** " + projectSlug + "\n";
+    append += "**Spec:** " + spec.title + "\n\n";
+    append += "### Spec Content\n\n";
+    if (spec.sections.summary)
+        append += "**Summary:** " + spec.sections.summary + "\n\n";
+    if (spec.sections.currentState)
+        append += "**Current State:** " + spec.sections.currentState + "\n\n";
+    if (spec.sections.requirements)
+        append += "**Requirements:** " + spec.sections.requirements + "\n\n";
+    if (spec.sections.testing)
+        append += "**Testing:** " + spec.sections.testing + "\n\n";
+    append += "When you have finished writing the plan, output it inside `<plan-content>` tags.\n";
+    append += "Lattice will store it in the spec's implementation plan section.\n";
+    return append;
+}
+export function buildExecutePrompt(spec, projectSlug) {
+    var content = getSkillContent("subagent-driven-development") || getSkillContent("executing-plans");
+    if (!content)
+        return "";
+    var append = content + "\n\n---\n\n";
+    append += "## Lattice Integration Instructions\n\n";
+    append += "You are executing an implementation plan from a Lattice spec.\n\n";
+    append += "**Project:** " + projectSlug + "\n";
+    append += "**Spec:** " + spec.title + "\n\n";
+    append += "### Implementation Plan\n\n";
+    if (spec.sections.implementationPlan) {
+        append += spec.sections.implementationPlan + "\n\n";
+    }
+    append += "As you complete milestones, report progress by outputting `<spec-activity>` blocks:\n";
+    append += '```\n<spec-activity>{"type": "ai-note", "detail": "Completed task N: description"}</spec-activity>\n```\n';
+    return append;
+}

package/dist/server/handlers/chat.js

@@ -8,6 +8,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { getDailySpend } from "../analytics/engine.js";
 import { log } from "../logger.js";
+import { findSpecBySession } from "../features/specs.js";
 function formatSdkRule(rule) {
     if (!rule.ruleContent)
         return rule.toolName;
@@ -176,6 +177,7 @@ registerHandler("chat", function (clientId, message) {
         var attachments = sendMsg.attachmentIds
             ? getAttachments(clientId, sendMsg.attachmentIds)
             : [];
+        var linkedSpec = findSpecBySession(active.sessionId);
         startChatStream({
             projectSlug: active.projectSlug,
             sessionId: active.sessionId,
@@ -186,6 +188,8 @@ registerHandler("chat", function (clientId, message) {
             env: Object.keys(env).length > 0 ? env : undefined,
             model: sendMsg.model,
             effort: sendMsg.effort,
+            systemPrompt: sendMsg.systemPrompt,
+            specId: linkedSpec ? linkedSpec.id : undefined,
         });
         return;
     }

package/dist/server/handlers/context-hooks.js

@@ -0,0 +1,171 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, chmodSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { getLatticeHome } from "../config.js";
+import { log } from "../logger.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HOOKS_SRC_DIR = join(__dirname, "..", "hooks");
+function getClaudeSettingsPath() {
+    return process.env.CLAUDE_SETTINGS_PATH || join(homedir(), ".claude", "settings.json");
+}
+function getHooksInstallDir() {
+    return resolve(join(getLatticeHome(), "hooks"));
+}
+function readClaudeSettings() {
+    const path = getClaudeSettingsPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeClaudeSettings(settings) {
+    const path = getClaudeSettingsPath();
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+}
+function buildHookEntry(command) {
+    return {
+        matcher: "",
+        hooks: [{
+                type: "command",
+                command,
+                timeout: 5,
+            }],
+    };
+}
+function installHookScripts() {
+    const installDir = getHooksInstallDir();
+    if (!existsSync(installDir))
+        mkdirSync(installDir, { recursive: true });
+    const scripts = ["post_tool_use.sh", "event_forward.sh", "statusline.sh"];
+    for (const script of scripts) {
+        const src = join(HOOKS_SRC_DIR, script);
+        const dest = join(installDir, script);
+        if (existsSync(src)) {
+            copyFileSync(src, dest);
+            chmodSync(dest, 0o755);
+        }
+    }
+    return installDir;
+}
+export function installHooks() {
+    try {
+        const hooksDir = installHookScripts();
+        const settings = readClaudeSettings();
+        const postToolUse = join(hooksDir, "post_tool_use.sh");
+        const eventForward = join(hooksDir, "event_forward.sh");
+        const statusline = join(hooksDir, "statusline.sh");
+        // Merge hooks without overwriting existing non-Lattice hooks
+        const existingHooks = (settings.hooks || {});
+        function addLatticeHook(eventType, command) {
+            const entries = existingHooks[eventType] || [];
+            // Remove any existing Lattice hooks
+            const filtered = entries.filter(function (e) {
+                return !e.hooks.some(function (h) { return h.command.includes("lattice") || h.command.includes(hooksDir); });
+            });
+            filtered.push(buildHookEntry(command));
+            existingHooks[eventType] = filtered;
+        }
+        addLatticeHook("PostToolUse", '"' + postToolUse + '"');
+        addLatticeHook("SessionStart", '"' + eventForward + '" SessionStart');
+        addLatticeHook("Stop", '"' + eventForward + '" Stop');
+        addLatticeHook("PreCompact", '"' + eventForward + '" PreCompact');
+        addLatticeHook("PostCompact", '"' + eventForward + '" PostCompact');
+        settings.hooks = existingHooks;
+        // Add statusLine entry
+        settings.statusLine = {
+            type: "command",
+            command: '"' + statusline + '"',
+        };
+        writeClaudeSettings(settings);
+        log.server("Context analyzer hooks installed to %s", hooksDir);
+        return { success: true, message: "Hooks installed. Claude Code will now report context data to Lattice." };
+    }
+    catch (err) {
+        log.server("Failed to install hooks: %O", err);
+        return { success: false, message: "Failed to install hooks: " + (err.message || String(err)) };
+    }
+}
+function uninstallHooks() {
+    try {
+        const hooksDir = getHooksInstallDir();
+        const settings = readClaudeSettings();
+        const existingHooks = (settings.hooks || {});
+        // Remove Lattice hooks from each event type
+        for (const eventType of Object.keys(existingHooks)) {
+            existingHooks[eventType] = existingHooks[eventType].filter(function (e) {
+                return !e.hooks.some(function (h) { return h.command.includes("lattice") || h.command.includes(hooksDir); });
+            });
+            if (existingHooks[eventType].length === 0) {
+                delete existingHooks[eventType];
+            }
+        }
+        settings.hooks = existingHooks;
+        if (Object.keys(existingHooks).length === 0) {
+            delete settings.hooks;
+        }
+        // Remove statusLine if it points to our script
+        const sl = settings.statusLine;
+        if (sl && sl.command && (sl.command.includes("lattice") || sl.command.includes(hooksDir))) {
+            delete settings.statusLine;
+        }
+        writeClaudeSettings(settings);
+        log.server("Context analyzer hooks uninstalled");
+        return { success: true, message: "Hooks removed from Claude Code settings." };
+    }
+    catch (err) {
+        return { success: false, message: "Failed to uninstall hooks: " + (err.message || String(err)) };
+    }
+}
+export function checkHooksInstalled() {
+    try {
+        const hooksDir = getHooksInstallDir();
+        const settings = readClaudeSettings();
+        const existingHooks = (settings.hooks || {});
+        const postToolUse = existingHooks["PostToolUse"] || [];
+        return postToolUse.some(function (e) {
+            return e.hooks.some(function (h) { return h.command.includes("lattice") || h.command.includes(hooksDir); });
+        });
+    }
+    catch {
+        return false;
+    }
+}
+registerHandler("context", function (clientId, message) {
+    const msg = message;
+    const action = msg.action;
+    if (action === "install_hooks") {
+        const result = installHooks();
+        sendTo(clientId, {
+            type: "context:hooks_status",
+            installed: result.success ? true : checkHooksInstalled(),
+            message: result.message,
+        });
+        return;
+    }
+    if (action === "uninstall_hooks") {
+        const result = uninstallHooks();
+        sendTo(clientId, {
+            type: "context:hooks_status",
+            installed: checkHooksInstalled(),
+            message: result.message,
+        });
+        return;
+    }
+    if (action === "check_hooks") {
+        sendTo(clientId, {
+            type: "context:hooks_status",
+            installed: checkHooksInstalled(),
+        });
+        return;
+    }
+});