@cryptiklemur/lattice 4.0.1 → 5.0.0

package/dist/server/handlers/fs.js

@@ -0,0 +1,234 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo, broadcast } from "../ws/broadcast.js";
+import { getProjectBySlug } from "../project/registry.js";
+import { listDirectory, readFile, writeFile } from "../project/file-browser.js";
+import { readdirSync, existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { loadConfig } from "../config.js";
+var activeProjectByClient = new Map();
+export function setActiveProject(clientId, projectSlug) {
+    activeProjectByClient.set(clientId, projectSlug);
+}
+export function clearActiveProject(clientId) {
+    activeProjectByClient.delete(clientId);
+}
+registerHandler("fs", function (clientId, message) {
+    if (message.type === "fs:list") {
+        var listMsg = message;
+        var projectSlug = activeProjectByClient.get(clientId) || listMsg.projectSlug;
+        if (listMsg.projectSlug) {
+            setActiveProject(clientId, listMsg.projectSlug);
+            projectSlug = listMsg.projectSlug;
+        }
+        if (!projectSlug) {
+            sendTo(clientId, { type: "chat:error", message: "No active project for fs:list" });
+            return;
+        }
+        var project = getProjectBySlug(projectSlug);
+        if (!project) {
+            sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlug });
+            return;
+        }
+        var entries = listDirectory(project.path, listMsg.path);
+        sendTo(clientId, { type: "fs:list_result", path: listMsg.path, entries });
+        return;
+    }
+    if (message.type === "fs:read") {
+        var readMsg = message;
+        var projectSlugRead = activeProjectByClient.get(clientId) || readMsg.projectSlug;
+        if (readMsg.projectSlug) {
+            setActiveProject(clientId, readMsg.projectSlug);
+            projectSlugRead = readMsg.projectSlug;
+        }
+        if (!projectSlugRead) {
+            sendTo(clientId, { type: "chat:error", message: "No active project for fs:read" });
+            return;
+        }
+        var projectRead = getProjectBySlug(projectSlugRead);
+        if (!projectRead) {
+            sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlugRead });
+            return;
+        }
+        var content = readFile(projectRead.path, readMsg.path);
+        if (content === null) {
+            sendTo(clientId, { type: "chat:error", message: "Cannot read file: " + readMsg.path });
+            return;
+        }
+        sendTo(clientId, { type: "fs:read_result", path: readMsg.path, content });
+        return;
+    }
+    if (message.type === "fs:write") {
+        var writeMsg = message;
+        var projectSlugWrite = activeProjectByClient.get(clientId);
+        if (!projectSlugWrite) {
+            sendTo(clientId, { type: "chat:error", message: "No active project for fs:write" });
+            return;
+        }
+        var projectWrite = getProjectBySlug(projectSlugWrite);
+        if (!projectWrite) {
+            sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlugWrite });
+            return;
+        }
+        var ok = writeFile(projectWrite.path, writeMsg.path, writeMsg.content);
+        if (!ok) {
+            sendTo(clientId, { type: "chat:error", message: "Cannot write file: " + writeMsg.path });
+            return;
+        }
+        broadcast({ type: "fs:changed", path: writeMsg.path });
+        return;
+    }
+});
+function resolvePath(path) {
+    if (!path || path === "~")
+        return homedir();
+    if (path.startsWith("~/"))
+        return join(homedir(), path.slice(2));
+    return path;
+}
+function detectProjectName(dirPath) {
+    try {
+        var pkgPath = join(dirPath, "package.json");
+        if (existsSync(pkgPath)) {
+            var pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            if (pkg.name)
+                return pkg.name;
+        }
+    }
+    catch { }
+    try {
+        var cargoPath = join(dirPath, "Cargo.toml");
+        if (existsSync(cargoPath)) {
+            var cargo = readFileSync(cargoPath, "utf-8");
+            var cargoMatch = cargo.match(/\[package\][\s\S]*?name\s*=\s*"([^"]+)"/);
+            if (cargoMatch)
+                return cargoMatch[1];
+        }
+    }
+    catch { }
+    try {
+        var composerPath = join(dirPath, "composer.json");
+        if (existsSync(composerPath)) {
+            var composer = JSON.parse(readFileSync(composerPath, "utf-8"));
+            if (composer.name)
+                return composer.name;
+        }
+    }
+    catch { }
+    try {
+        var pyprojectPath = join(dirPath, "pyproject.toml");
+        if (existsSync(pyprojectPath)) {
+            var pyproject = readFileSync(pyprojectPath, "utf-8");
+            var pyMatch = pyproject.match(/\[project\][\s\S]*?name\s*=\s*"([^"]+)"/);
+            if (pyMatch)
+                return pyMatch[1];
+        }
+    }
+    catch { }
+    try {
+        var goModPath = join(dirPath, "go.mod");
+        if (existsSync(goModPath)) {
+            var goMod = readFileSync(goModPath, "utf-8");
+            var goMatch = goMod.match(/^module\s+(\S+)/m);
+            if (goMatch) {
+                var parts = goMatch[1].split("/");
+                return parts[parts.length - 1];
+            }
+        }
+    }
+    catch { }
+    try {
+        var entries = readdirSync(dirPath);
+        for (var i = 0; i < entries.length; i++) {
+            if (entries[i].endsWith(".sln") || entries[i].endsWith(".csproj")) {
+                return entries[i].replace(/\.[^.]+$/, "");
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+registerHandler("browse", function (clientId, message) {
+    if (message.type === "browse:list") {
+        var browseMsg = message;
+        var resolvedPath = resolvePath(browseMsg.path);
+        var home = homedir();
+        if (!existsSync(resolvedPath)) {
+            sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
+            return;
+        }
+        try {
+            var stat = statSync(resolvedPath);
+            if (!stat.isDirectory()) {
+                sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
+                return;
+            }
+        }
+        catch {
+            sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
+            return;
+        }
+        try {
+            var dirEntries = readdirSync(resolvedPath, { withFileTypes: true });
+            var results = [];
+            for (var i = 0; i < dirEntries.length; i++) {
+                var entry = dirEntries[i];
+                if (!entry.isDirectory())
+                    continue;
+                var entryPath = join(resolvedPath, entry.name);
+                var hasClaudeMd = existsSync(join(entryPath, "CLAUDE.md"));
+                var projectName = detectProjectName(entryPath);
+                results.push({
+                    name: entry.name,
+                    path: entryPath,
+                    hasClaudeMd: hasClaudeMd,
+                    projectName: projectName,
+                });
+            }
+            results.sort(function (a, b) { return a.name.localeCompare(b.name); });
+            sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: results });
+        }
+        catch {
+            sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
+        }
+        return;
+    }
+    if (message.type === "browse:suggestions") {
+        var claudeProjectsDir = join(homedir(), ".claude", "projects");
+        var config = loadConfig();
+        var existingPaths = new Set(config.projects.map(function (p) { return p.path; }));
+        var suggestions = [];
+        if (existsSync(claudeProjectsDir)) {
+            try {
+                var hashDirs = readdirSync(claudeProjectsDir);
+                for (var i = 0; i < hashDirs.length; i++) {
+                    var hashDir = hashDirs[i];
+                    var candidatePath = "/" + hashDir.slice(1).replace(/-/g, "/");
+                    if (!existsSync(candidatePath))
+                        continue;
+                    if (existingPaths.has(candidatePath))
+                        continue;
+                    try {
+                        var stat = statSync(candidatePath);
+                        if (!stat.isDirectory())
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    var hasClaudeMd = existsSync(join(candidatePath, "CLAUDE.md"));
+                    var name = candidatePath.split("/").pop() || hashDir;
+                    suggestions.push({
+                        path: candidatePath,
+                        name: name,
+                        hasClaudeMd: hasClaudeMd,
+                    });
+                }
+            }
+            catch { }
+        }
+        suggestions.sort(function (a, b) { return a.name.localeCompare(b.name); });
+        sendTo(clientId, { type: "browse:suggestions_result", suggestions: suggestions });
+        return;
+    }
+});

package/dist/server/handlers/loop.js

@@ -0,0 +1,33 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { startLoop, stopLoop, getLoopStatus } from "../features/ralph-loop.js";
+registerHandler("loop", function (clientId, message) {
+    if (message.type === "loop:start") {
+        var startMsg = message;
+        var loop = startLoop(startMsg.projectSlug);
+        if (!loop) {
+            sendTo(clientId, { type: "chat:error", message: "No PROMPT.md found in .claude/loops/ for this project" });
+            return;
+        }
+        sendTo(clientId, { type: "loop:started", loop });
+        return;
+    }
+    if (message.type === "loop:stop") {
+        var stopMsg = message;
+        var stopped = stopLoop(stopMsg.loopId);
+        if (!stopped) {
+            sendTo(clientId, { type: "chat:error", message: "Loop not found or not running" });
+        }
+        return;
+    }
+    if (message.type === "loop:status") {
+        var statusMsg = message;
+        var status = getLoopStatus(statusMsg.loopId);
+        if (!status) {
+            sendTo(clientId, { type: "chat:error", message: "Loop not found" });
+            return;
+        }
+        sendTo(clientId, { type: "loop:status_update", loop: status });
+        return;
+    }
+});

package/dist/server/handlers/memory.js

@@ -0,0 +1,181 @@
+import { existsSync, readFileSync, writeFileSync, readdirSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { loadConfig } from "../config.js";
+function getMemoryDir(projectSlug) {
+    if (projectSlug === "__global__") {
+        return join(homedir(), ".claude", "memory");
+    }
+    var config = loadConfig();
+    var project = config.projects.find(function (p) { return p.slug === projectSlug; });
+    if (!project)
+        return null;
+    var hash = "-" + project.path.replace(/\//g, "-").replace(/^-/, "");
+    return join(homedir(), ".claude", "projects", hash, "memory");
+}
+function parseFrontmatter(content) {
+    var match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return { name: "", description: "", type: "" };
+    var yaml = match[1];
+    var name = "";
+    var description = "";
+    var type = "";
+    var lines = yaml.split(/\r?\n/);
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i];
+        var nameMatch = line.match(/^name:\s*(.+)/);
+        if (nameMatch)
+            name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
+        var descMatch = line.match(/^description:\s*(.+)/);
+        if (descMatch)
+            description = descMatch[1].trim().replace(/^["']|["']$/g, "");
+        var typeMatch = line.match(/^type:\s*(.+)/);
+        if (typeMatch)
+            type = typeMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+    return { name, description, type };
+}
+function regenerateIndex(memoryDir) {
+    if (!existsSync(memoryDir))
+        return;
+    var files = readdirSync(memoryDir).filter(function (f) {
+        return f.endsWith(".md") && f !== "MEMORY.md";
+    });
+    var grouped = {};
+    for (var i = 0; i < files.length; i++) {
+        try {
+            var content = readFileSync(join(memoryDir, files[i]), "utf-8");
+            var meta = parseFrontmatter(content);
+            var type = meta.type || "other";
+            if (!grouped[type])
+                grouped[type] = [];
+            grouped[type].push({ filename: files[i], name: meta.name || files[i], description: meta.description || "" });
+        }
+        catch { }
+    }
+    var lines = ["# Memory Index", ""];
+    var types = Object.keys(grouped).sort();
+    for (var t = 0; t < types.length; t++) {
+        lines.push("## " + types[t].charAt(0).toUpperCase() + types[t].slice(1));
+        var entries = grouped[types[t]];
+        for (var e = 0; e < entries.length; e++) {
+            var desc = entries[e].description ? " — " + entries[e].description : "";
+            lines.push("- [" + entries[e].filename + "](" + entries[e].filename + ")" + desc);
+        }
+        lines.push("");
+    }
+    writeFileSync(join(memoryDir, "MEMORY.md"), lines.join("\n"), "utf-8");
+}
+registerHandler("memory", function (clientId, message) {
+    if (message.type === "memory:list") {
+        var listMsg = message;
+        var memDir = getMemoryDir(listMsg.projectSlug);
+        if (!memDir || !existsSync(memDir)) {
+            sendTo(clientId, { type: "memory:list_result", projectSlug: listMsg.projectSlug, memories: [] });
+            return;
+        }
+        var files = readdirSync(memDir).filter(function (f) {
+            return f.endsWith(".md") && f !== "MEMORY.md";
+        });
+        var memories = [];
+        for (var i = 0; i < files.length; i++) {
+            try {
+                var content = readFileSync(join(memDir, files[i]), "utf-8");
+                var meta = parseFrontmatter(content);
+                memories.push({
+                    filename: files[i],
+                    name: meta.name || files[i].replace(/\.md$/, ""),
+                    description: meta.description,
+                    type: meta.type || "other",
+                });
+            }
+            catch { }
+        }
+        memories.sort(function (a, b) { return a.name.localeCompare(b.name); });
+        sendTo(clientId, { type: "memory:list_result", projectSlug: listMsg.projectSlug, memories: memories });
+        return;
+    }
+    if (message.type === "memory:view") {
+        var viewMsg = message;
+        var viewDir = getMemoryDir(viewMsg.projectSlug);
+        if (!viewDir) {
+            sendTo(clientId, { type: "memory:view_result", filename: viewMsg.filename, content: "Project not found." });
+            return;
+        }
+        try {
+            var viewContent = readFileSync(join(viewDir, viewMsg.filename), "utf-8");
+            sendTo(clientId, { type: "memory:view_result", filename: viewMsg.filename, content: viewContent });
+        }
+        catch {
+            sendTo(clientId, { type: "memory:view_result", filename: viewMsg.filename, content: "File not found." });
+        }
+        return;
+    }
+    if (message.type === "memory:save") {
+        var saveMsg = message;
+        var saveDir = getMemoryDir(saveMsg.projectSlug);
+        if (!saveDir) {
+            sendTo(clientId, { type: "memory:save_result", success: false, message: "Project not found." });
+            return;
+        }
+        try {
+            mkdirSync(saveDir, { recursive: true });
+            writeFileSync(join(saveDir, saveMsg.filename), saveMsg.content, "utf-8");
+            regenerateIndex(saveDir);
+            sendTo(clientId, { type: "memory:save_result", success: true });
+            var updatedFiles = readdirSync(saveDir).filter(function (f) { return f.endsWith(".md") && f !== "MEMORY.md"; });
+            var updatedMemories = [];
+            for (var j = 0; j < updatedFiles.length; j++) {
+                try {
+                    var c = readFileSync(join(saveDir, updatedFiles[j]), "utf-8");
+                    var m = parseFrontmatter(c);
+                    updatedMemories.push({ filename: updatedFiles[j], name: m.name || updatedFiles[j].replace(/\.md$/, ""), description: m.description, type: m.type || "other" });
+                }
+                catch { }
+            }
+            updatedMemories.sort(function (a, b) { return a.name.localeCompare(b.name); });
+            sendTo(clientId, { type: "memory:list_result", projectSlug: saveMsg.projectSlug, memories: updatedMemories });
+        }
+        catch (err) {
+            sendTo(clientId, { type: "memory:save_result", success: false, message: "Failed to save: " + String(err) });
+        }
+        return;
+    }
+    if (message.type === "memory:delete") {
+        var delMsg = message;
+        var delDir = getMemoryDir(delMsg.projectSlug);
+        if (!delDir) {
+            sendTo(clientId, { type: "memory:delete_result", success: false, message: "Project not found." });
+            return;
+        }
+        try {
+            var filePath = join(delDir, delMsg.filename);
+            if (!existsSync(filePath)) {
+                sendTo(clientId, { type: "memory:delete_result", success: false, message: "Memory not found." });
+                return;
+            }
+            unlinkSync(filePath);
+            regenerateIndex(delDir);
+            sendTo(clientId, { type: "memory:delete_result", success: true });
+            var remainingFiles = readdirSync(delDir).filter(function (f) { return f.endsWith(".md") && f !== "MEMORY.md"; });
+            var remainingMemories = [];
+            for (var k = 0; k < remainingFiles.length; k++) {
+                try {
+                    var rc = readFileSync(join(delDir, remainingFiles[k]), "utf-8");
+                    var rm = parseFrontmatter(rc);
+                    remainingMemories.push({ filename: remainingFiles[k], name: rm.name || remainingFiles[k].replace(/\.md$/, ""), description: rm.description, type: rm.type || "other" });
+                }
+                catch { }
+            }
+            remainingMemories.sort(function (a, b) { return a.name.localeCompare(b.name); });
+            sendTo(clientId, { type: "memory:list_result", projectSlug: delMsg.projectSlug, memories: remainingMemories });
+        }
+        catch (err) {
+            sendTo(clientId, { type: "memory:delete_result", success: false, message: "Failed to delete: " + String(err) });
+        }
+        return;
+    }
+});