@cryptiklemur/lattice 4.0.2 → 5.0.0

package/dist/server/features/ralph-loop.js

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { broadcast } from "../ws/broadcast.js";
+import { getProjectBySlug } from "../project/registry.js";
+var activeLoops = new Map();
+function readLoopFile(projectPath, filename) {
+    var loopsDir = join(projectPath, ".claude", "loops");
+    var filePath = join(loopsDir, filename);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    return readFileSync(filePath, "utf-8");
+}
+async function runIteration(loopId, prompt, cwd, iterationNum) {
+    var accumulated = "";
+    var stream = query({ prompt, options: { cwd, allowedTools: ["*"], permissionMode: "acceptEdits" } });
+    for await (var msg of stream) {
+        var typedMsg = msg;
+        if (typedMsg.type === "stream_event") {
+            var partial = typedMsg;
+            var evt = partial.event;
+            if (evt.type === "content_block_delta") {
+                var deltaEvt = evt;
+                if (deltaEvt.delta.type === "text_delta" && typeof deltaEvt.delta.text === "string") {
+                    accumulated += deltaEvt.delta.text;
+                    broadcast({ type: "loop:delta", loopId, iteration: iterationNum, text: deltaEvt.delta.text });
+                }
+            }
+        }
+    }
+    return accumulated;
+}
+async function runJudge(judgePrompt, iterationResult, cwd) {
+    var fullPrompt = `${judgePrompt}\n\n<iteration_result>\n${iterationResult}\n</iteration_result>\n\nRespond with PASS or FAIL on the first line, followed by a brief reason.`;
+    var accumulated = "";
+    var stream = query({ prompt: fullPrompt, options: { cwd, allowedTools: [], permissionMode: "acceptEdits" } });
+    for await (var msg of stream) {
+        var typedMsg = msg;
+        if (typedMsg.type === "stream_event") {
+            var partial = typedMsg;
+            var evt = partial.event;
+            if (evt.type === "content_block_delta") {
+                var deltaEvt = evt;
+                if (deltaEvt.delta.type === "text_delta" && typeof deltaEvt.delta.text === "string") {
+                    accumulated += deltaEvt.delta.text;
+                }
+            }
+        }
+    }
+    var firstLine = accumulated.trim().split("\n")[0].toUpperCase();
+    var pass = firstLine.startsWith("PASS");
+    var reason = accumulated.trim().split("\n").slice(1).join("\n").trim() || accumulated.trim();
+    return { pass, reason };
+}
+export function startLoop(projectSlug) {
+    var project = getProjectBySlug(projectSlug);
+    if (!project) {
+        return null;
+    }
+    var prompt = readLoopFile(project.path, "PROMPT.md");
+    if (!prompt) {
+        return null;
+    }
+    var loopId = "loop_" + Date.now() + "_" + randomBytes(3).toString("hex");
+    var loopStatus = {
+        id: loopId,
+        projectSlug,
+        status: "running",
+        iteration: 0,
+        maxIterations: 20,
+        judgeReason: null,
+        startedAt: Date.now(),
+        finishedAt: null,
+    };
+    activeLoops.set(loopId, loopStatus);
+    broadcast({ type: "loop:started", loop: loopStatus });
+    void (async function () {
+        var judgePrompt = readLoopFile(project.path, "JUDGE.md");
+        for (var i = 1; i <= loopStatus.maxIterations; i++) {
+            var current = activeLoops.get(loopId);
+            if (!current || current.status === "stopped") {
+                break;
+            }
+            current.iteration = i;
+            activeLoops.set(loopId, current);
+            broadcast({ type: "loop:status_update", loop: { ...current } });
+            try {
+                var result = await runIteration(loopId, prompt, project.path, i);
+                if (judgePrompt) {
+                    var judgment = await runJudge(judgePrompt, result, project.path);
+                    current.judgeReason = judgment.reason;
+                    activeLoops.set(loopId, current);
+                    if (judgment.pass) {
+                        current.status = "done";
+                        current.finishedAt = Date.now();
+                        activeLoops.set(loopId, current);
+                        broadcast({ type: "loop:status_update", loop: { ...current } });
+                        break;
+                    }
+                }
+            }
+            catch (err) {
+                var errMsg = err instanceof Error ? err.message : String(err);
+                console.error(`[ralph-loop] Iteration ${i} error:`, errMsg);
+                current.status = "error";
+                current.judgeReason = errMsg;
+                current.finishedAt = Date.now();
+                activeLoops.set(loopId, current);
+                broadcast({ type: "loop:status_update", loop: { ...current } });
+                return;
+            }
+        }
+        var final = activeLoops.get(loopId);
+        if (final && final.status === "running") {
+            final.status = "done";
+            final.finishedAt = Date.now();
+            activeLoops.set(loopId, final);
+            broadcast({ type: "loop:status_update", loop: { ...final } });
+        }
+    })();
+    return loopStatus;
+}
+export function stopLoop(loopId) {
+    var loop = activeLoops.get(loopId);
+    if (!loop || loop.status !== "running") {
+        return false;
+    }
+    loop.status = "stopped";
+    loop.finishedAt = Date.now();
+    activeLoops.set(loopId, loop);
+    broadcast({ type: "loop:status_update", loop: { ...loop } });
+    return true;
+}
+export function getLoopStatus(loopId) {
+    return activeLoops.get(loopId) ?? null;
+}

package/dist/server/features/scheduler.js

@@ -0,0 +1,260 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { getLatticeHome } from "../config.js";
+import { broadcast } from "../ws/broadcast.js";
+var schedulesFile = "";
+var tasks = [];
+var timerId = null;
+var lastTriggeredMinute = {};
+var CHECK_INTERVAL = 30 * 1000;
+function getSchedulesPath() {
+    if (!schedulesFile) {
+        schedulesFile = join(getLatticeHome(), "schedules.json");
+    }
+    return schedulesFile;
+}
+function parseCronField(field, min, max) {
+    var values = [];
+    var parts = field.split(",");
+    for (var i = 0; i < parts.length; i++) {
+        var part = parts[i].trim();
+        if (part.indexOf("/") !== -1) {
+            var slashParts = part.split("/");
+            var step = parseInt(slashParts[1], 10);
+            var rangeStr = slashParts[0];
+            var rangeMin = min;
+            var rangeMax = max;
+            if (rangeStr !== "*") {
+                var rp = rangeStr.split("-");
+                rangeMin = parseInt(rp[0], 10);
+                rangeMax = rp.length > 1 ? parseInt(rp[1], 10) : rangeMin;
+            }
+            for (var v = rangeMin; v <= rangeMax; v += step) {
+                values.push(v);
+            }
+            continue;
+        }
+        if (part === "*") {
+            for (var v = min; v <= max; v++) {
+                values.push(v);
+            }
+            continue;
+        }
+        if (part.indexOf("-") !== -1) {
+            var rangeParts = part.split("-");
+            var from = parseInt(rangeParts[0], 10);
+            var to = parseInt(rangeParts[1], 10);
+            for (var v = from; v <= to; v++) {
+                values.push(v);
+            }
+            continue;
+        }
+        values.push(parseInt(part, 10));
+    }
+    return values;
+}
+function parseCron(expr) {
+    var fields = expr.trim().split(/\s+/);
+    if (fields.length !== 5) {
+        return null;
+    }
+    return {
+        minutes: parseCronField(fields[0], 0, 59),
+        hours: parseCronField(fields[1], 0, 23),
+        daysOfMonth: parseCronField(fields[2], 1, 31),
+        months: parseCronField(fields[3], 1, 12),
+        daysOfWeek: parseCronField(fields[4], 0, 6),
+    };
+}
+function cronMatches(parsed, date) {
+    return (parsed.minutes.indexOf(date.getMinutes()) !== -1 &&
+        parsed.hours.indexOf(date.getHours()) !== -1 &&
+        parsed.daysOfMonth.indexOf(date.getDate()) !== -1 &&
+        parsed.months.indexOf(date.getMonth() + 1) !== -1 &&
+        parsed.daysOfWeek.indexOf(date.getDay()) !== -1);
+}
+function nextRunTime(cronExpr, after) {
+    var parsed = parseCron(cronExpr);
+    if (!parsed) {
+        return null;
+    }
+    var d = new Date(after || Date.now());
+    d.setSeconds(0, 0);
+    d.setMinutes(d.getMinutes() + 1);
+    var limit = 366 * 24 * 60;
+    for (var i = 0; i < limit; i++) {
+        if (cronMatches(parsed, d)) {
+            return d.getTime();
+        }
+        d.setMinutes(d.getMinutes() + 1);
+    }
+    return null;
+}
+export function loadSchedules() {
+    var path = getSchedulesPath();
+    if (!existsSync(path)) {
+        tasks = [];
+        return;
+    }
+    try {
+        var raw = readFileSync(path, "utf-8");
+        var parsed = JSON.parse(raw);
+        tasks = parsed.tasks || [];
+        for (var i = 0; i < tasks.length; i++) {
+            var task = tasks[i];
+            if (task.enabled && task.cron) {
+                task.nextRunAt = nextRunTime(task.cron);
+            }
+        }
+    }
+    catch (err) {
+        console.error("[scheduler] Failed to load schedules:", err);
+        tasks = [];
+    }
+}
+function saveSchedules() {
+    var path = getSchedulesPath();
+    var dir = join(path, "..");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    var tmp = path + ".tmp";
+    try {
+        writeFileSync(tmp, JSON.stringify({ tasks }, null, 2));
+        renameSync(tmp, path);
+    }
+    catch (err) {
+        console.error("[scheduler] Failed to save schedules:", err);
+    }
+}
+function tick() {
+    var now = Date.now();
+    var nowMinuteKey = Math.floor(now / 60000);
+    for (var i = 0; i < tasks.length; i++) {
+        var task = tasks[i];
+        if (!task.enabled || !task.nextRunAt) {
+            continue;
+        }
+        if (task.nextRunAt > now) {
+            continue;
+        }
+        var triggerKey = task.id + "_" + nowMinuteKey;
+        if (lastTriggeredMinute[triggerKey]) {
+            continue;
+        }
+        lastTriggeredMinute[triggerKey] = true;
+        var keys = Object.keys(lastTriggeredMinute);
+        for (var k = 0; k < keys.length; k++) {
+            var keyParts = keys[k].split("_");
+            var keyMinute = parseInt(keyParts[keyParts.length - 1], 10);
+            if (keyMinute < nowMinuteKey - 1) {
+                delete lastTriggeredMinute[keys[k]];
+            }
+        }
+        task.lastRunAt = now;
+        task.nextRunAt = nextRunTime(task.cron, now);
+        task.updatedAt = now;
+        saveSchedules();
+        console.log("[scheduler] Triggering task:", task.name, "(", task.id, ")");
+        broadcast({ type: "scheduler:tasks", tasks: tasks.slice() });
+    }
+}
+export function startScheduler() {
+    loadSchedules();
+    if (timerId) {
+        return;
+    }
+    timerId = setInterval(function () {
+        tick();
+    }, CHECK_INTERVAL);
+    tick();
+}
+export function stopScheduler() {
+    if (timerId) {
+        clearInterval(timerId);
+        timerId = null;
+    }
+}
+export function listTasks() {
+    return tasks.slice();
+}
+export function createTask(data) {
+    var parsed = parseCron(data.cron);
+    if (!parsed) {
+        return null;
+    }
+    var now = Date.now();
+    var task = {
+        id: "task_" + now + "_" + randomBytes(3).toString("hex"),
+        name: data.name,
+        prompt: data.prompt,
+        cron: data.cron,
+        enabled: true,
+        projectSlug: data.projectSlug,
+        createdAt: now,
+        updatedAt: now,
+        lastRunAt: null,
+        nextRunAt: nextRunTime(data.cron),
+    };
+    tasks.push(task);
+    saveSchedules();
+    return task;
+}
+export function updateTask(taskId, data) {
+    var task = null;
+    for (var i = 0; i < tasks.length; i++) {
+        if (tasks[i].id === taskId) {
+            task = tasks[i];
+            break;
+        }
+    }
+    if (!task)
+        return null;
+    if (data.cron && data.cron !== task.cron) {
+        var parsed = parseCron(data.cron);
+        if (!parsed)
+            return null;
+        task.cron = data.cron;
+        task.nextRunAt = task.enabled ? nextRunTime(data.cron) : null;
+    }
+    if (data.name !== undefined)
+        task.name = data.name;
+    if (data.prompt !== undefined)
+        task.prompt = data.prompt;
+    task.updatedAt = Date.now();
+    saveSchedules();
+    return task;
+}
+export function deleteTask(taskId) {
+    var idx = -1;
+    for (var i = 0; i < tasks.length; i++) {
+        if (tasks[i].id === taskId) {
+            idx = i;
+            break;
+        }
+    }
+    if (idx === -1) {
+        return false;
+    }
+    tasks.splice(idx, 1);
+    saveSchedules();
+    return true;
+}
+export function toggleTask(taskId) {
+    var task = null;
+    for (var i = 0; i < tasks.length; i++) {
+        if (tasks[i].id === taskId) {
+            task = tasks[i];
+            break;
+        }
+    }
+    if (!task) {
+        return null;
+    }
+    task.enabled = !task.enabled;
+    task.updatedAt = Date.now();
+    task.nextRunAt = task.enabled ? nextRunTime(task.cron) : null;
+    saveSchedules();
+    return task;
+}

package/dist/server/features/sticky-notes.js

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { getLatticeHome } from "../config.js";
+var notesFile = "";
+var notes = [];
+function getNotesPath() {
+    if (!notesFile) {
+        notesFile = join(getLatticeHome(), "notes.jsonl");
+    }
+    return notesFile;
+}
+export function loadNotes() {
+    var path = getNotesPath();
+    if (!existsSync(path)) {
+        notes = [];
+        return;
+    }
+    try {
+        var raw = readFileSync(path, "utf-8");
+        var lines = raw.trim().split("\n");
+        notes = [];
+        for (var i = 0; i < lines.length; i++) {
+            var line = lines[i].trim();
+            if (!line) {
+                continue;
+            }
+            try {
+                var note = JSON.parse(line);
+                notes.push(note);
+            }
+            catch {
+                // skip malformed line
+            }
+        }
+    }
+    catch (err) {
+        console.error("[sticky-notes] Failed to load notes:", err);
+        notes = [];
+    }
+}
+function saveNotes() {
+    var path = getNotesPath();
+    var dir = join(path, "..");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    var tmp = path + ".tmp";
+    try {
+        var lines = [];
+        for (var i = 0; i < notes.length; i++) {
+            lines.push(JSON.stringify(notes[i]));
+        }
+        writeFileSync(tmp, lines.join("\n") + (lines.length > 0 ? "\n" : ""));
+        renameSync(tmp, path);
+    }
+    catch (err) {
+        console.error("[sticky-notes] Failed to save notes:", err);
+    }
+}
+export function listNotes(projectSlug) {
+    if (!projectSlug)
+        return notes.slice();
+    return notes.filter(function (n) { return n.projectSlug === projectSlug; });
+}
+export function createNote(content, projectSlug) {
+    var now = Date.now();
+    var note = {
+        id: "note_" + now + "_" + randomBytes(3).toString("hex"),
+        content,
+        createdAt: now,
+        updatedAt: now,
+        projectSlug,
+    };
+    notes.push(note);
+    saveNotes();
+    return note;
+}
+export function updateNote(id, content) {
+    for (var i = 0; i < notes.length; i++) {
+        if (notes[i].id === id) {
+            notes[i].content = content;
+            notes[i].updatedAt = Date.now();
+            saveNotes();
+            return notes[i];
+        }
+    }
+    return null;
+}
+export function deleteNote(id) {
+    for (var i = 0; i < notes.length; i++) {
+        if (notes[i].id === id) {
+            notes.splice(i, 1);
+            saveNotes();
+            return true;
+        }
+    }
+    return false;
+}

package/dist/server/handlers/analytics.js

@@ -0,0 +1,28 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { streamAnalyticsSections } from "../analytics/engine.js";
+registerHandler("analytics", function (clientId, message) {
+    if (message.type === "analytics:request") {
+        var msg = message;
+        streamAnalyticsSections(msg.scope, msg.period, msg.projectSlug, msg.sessionId, msg.forceRefresh, function (sectionName, sectionData) {
+            sendTo(clientId, {
+                type: "analytics:section",
+                requestId: msg.requestId,
+                section: sectionName,
+                data: sectionData,
+            });
+        }).then(function () {
+            sendTo(clientId, {
+                type: "analytics:complete",
+                requestId: msg.requestId,
+            });
+        }).catch(function (err) {
+            sendTo(clientId, {
+                type: "analytics:error",
+                scope: msg.scope,
+                message: err instanceof Error ? err.message : "Analytics computation failed",
+            });
+        });
+        return;
+    }
+});

package/dist/server/handlers/attachment.js

@@ -0,0 +1,158 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+var MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024;
+var stores = new Map();
+var completed = new Map();
+var TTL_MS = 5 * 60 * 1000;
+var CLEANUP_INTERVAL_MS = 60 * 1000;
+function getClientStore(clientId) {
+    var store = stores.get(clientId);
+    if (!store) {
+        store = new Map();
+        stores.set(clientId, store);
+    }
+    return store;
+}
+function getClientCompleted(clientId) {
+    var store = completed.get(clientId);
+    if (!store) {
+        store = new Map();
+        completed.set(clientId, store);
+    }
+    return store;
+}
+registerHandler("attachment", function (clientId, message) {
+    if (message.type === "attachment:chunk") {
+        var msg = message;
+        var store = getClientStore(clientId);
+        var pending = store.get(msg.attachmentId);
+        if (!pending) {
+            pending = {
+                chunks: new Map(),
+                totalChunks: msg.totalChunks,
+                receivedCount: 0,
+                totalBytes: 0,
+                createdAt: Date.now(),
+            };
+            store.set(msg.attachmentId, pending);
+        }
+        if (pending.chunks.has(msg.chunkIndex)) {
+            sendTo(clientId, {
+                type: "attachment:error",
+                attachmentId: msg.attachmentId,
+                error: "Duplicate chunk index: " + msg.chunkIndex,
+            });
+            return;
+        }
+        var chunkBuffer = Buffer.from(msg.data, "base64");
+        if (pending.totalBytes + chunkBuffer.length > MAX_ATTACHMENT_SIZE) {
+            store.delete(msg.attachmentId);
+            sendTo(clientId, {
+                type: "attachment:error",
+                attachmentId: msg.attachmentId,
+                error: "Attachment exceeds maximum size of " + (MAX_ATTACHMENT_SIZE / 1024 / 1024) + "MB",
+            });
+            return;
+        }
+        pending.chunks.set(msg.chunkIndex, chunkBuffer);
+        pending.receivedCount++;
+        pending.totalBytes += chunkBuffer.length;
+        sendTo(clientId, {
+            type: "attachment:progress",
+            attachmentId: msg.attachmentId,
+            received: pending.receivedCount,
+            total: pending.totalChunks,
+        });
+        return;
+    }
+    if (message.type === "attachment:complete") {
+        var completeMsg = message;
+        var completeStore = getClientStore(clientId);
+        var completePending = completeStore.get(completeMsg.attachmentId);
+        if (!completePending) {
+            sendTo(clientId, {
+                type: "attachment:error",
+                attachmentId: completeMsg.attachmentId,
+                error: "No chunks received for this attachment",
+            });
+            return;
+        }
+        if (completePending.receivedCount !== completePending.totalChunks) {
+            sendTo(clientId, {
+                type: "attachment:error",
+                attachmentId: completeMsg.attachmentId,
+                error: "Missing chunks: received " + completePending.receivedCount + " of " + completePending.totalChunks,
+            });
+            return;
+        }
+        var buffers = [];
+        for (var ci = 0; ci < completePending.totalChunks; ci++) {
+            var chunk = completePending.chunks.get(ci);
+            if (!chunk) {
+                sendTo(clientId, {
+                    type: "attachment:error",
+                    attachmentId: completeMsg.attachmentId,
+                    error: "Missing chunk at index " + ci,
+                });
+                return;
+            }
+            buffers.push(chunk);
+        }
+        var assembled = Buffer.concat(buffers);
+        var isText = completeMsg.attachmentType === "paste" || isTextMimeType(completeMsg.mimeType);
+        var content = isText ? assembled.toString("utf-8") : assembled.toString("base64");
+        var attachment = {
+            type: completeMsg.attachmentType,
+            name: completeMsg.name,
+            content,
+            mimeType: completeMsg.mimeType,
+            size: completeMsg.size,
+            lineCount: completeMsg.lineCount,
+        };
+        var finishedStore = getClientCompleted(clientId);
+        finishedStore.set(completeMsg.attachmentId, attachment);
+        completeStore.delete(completeMsg.attachmentId);
+        return;
+    }
+});
+function isTextMimeType(mime) {
+    if (mime.startsWith("text/"))
+        return true;
+    var textTypes = [
+        "application/json",
+        "application/xml",
+        "application/javascript",
+        "application/typescript",
+        "application/x-yaml",
+        "application/yaml",
+        "image/svg+xml",
+    ];
+    return textTypes.indexOf(mime) !== -1;
+}
+export function getAttachments(clientId, ids) {
+    var store = getClientCompleted(clientId);
+    var result = [];
+    for (var i = 0; i < ids.length; i++) {
+        var att = store.get(ids[i]);
+        if (att) {
+            result.push(att);
+            store.delete(ids[i]);
+        }
+    }
+    return result;
+}
+export function cleanupClient(clientId) {
+    stores.delete(clientId);
+    completed.delete(clientId);
+}
+var ttlCleanupInterval = setInterval(function () {
+    var now = Date.now();
+    stores.forEach(function (store) {
+        store.forEach(function (pending, id) {
+            if (now - pending.createdAt > TTL_MS) {
+                store.delete(id);
+            }
+        });
+    });
+}, CLEANUP_INTERVAL_MS);
+ttlCleanupInterval.unref();