@cryptiklemur/lattice 1.1.0 → 1.2.0

package/server/src/handlers/fs.ts

@@ -3,6 +3,10 @@ import { registerHandler } from "../ws/router";
 import { sendTo, broadcast } from "../ws/broadcast";
 import { getProjectBySlug } from "../project/registry";
 import { listDirectory, readFile, writeFile } from "../project/file-browser";
+import { readdirSync, existsSync, readFileSync, statSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { loadConfig } from "../config";
 
 var activeProjectByClient = new Map<string, string>();
 
@@ -82,3 +86,158 @@ registerHandler("fs", function (clientId: string, message: ClientMessage) {
     return;
   }
 });
+
+function resolvePath(path: string): string {
+  if (!path || path === "~") return homedir();
+  if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+  return path;
+}
+
+function detectProjectName(dirPath: string): string | null {
+  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: string, message: ClientMessage) {
+  if (message.type === "browse:list") {
+    var browseMsg = message as { type: "browse:list"; path: string };
+    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: Array<{ name: string; path: string; hasClaudeMd: boolean; projectName: string | null }> = [];
+
+      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: Array<{ path: string; name: string; hasClaudeMd: boolean }> = [];
+
+    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/server/src/handlers/memory.ts

@@ -0,0 +1,179 @@
+import { existsSync, readFileSync, writeFileSync, readdirSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { ClientMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { loadConfig } from "../config";
+
+function getMemoryDir(projectSlug: string): string | null {
+  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: string): { name: string; description: string; type: string } {
+  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: string): void {
+  if (!existsSync(memoryDir)) return;
+  var files = readdirSync(memoryDir).filter(function (f) {
+    return f.endsWith(".md") && f !== "MEMORY.md";
+  });
+
+  var grouped: Record<string, Array<{ filename: string; name: string; description: string }>> = {};
+
+  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: string[] = ["# 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: string, message: ClientMessage) {
+  if (message.type === "memory:list") {
+    var listMsg = message as { type: "memory:list"; projectSlug: string };
+    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: Array<{ filename: string; name: string; description: string; type: string }> = [];
+    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 as { type: "memory:view"; projectSlug: string; filename: string };
+    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 as { type: "memory:save"; projectSlug: string; filename: string; content: string };
+    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: Array<{ filename: string; name: string; description: string; type: string }> = [];
+      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 as { type: "memory:delete"; projectSlug: string; filename: string };
+    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: Array<{ filename: string; name: string; description: string; type: string }> = [];
+      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;
+  }
+});

package/server/src/handlers/settings.ts

@@ -2,7 +2,7 @@ import type { ClientMessage, SettingsGetMessage, SettingsUpdateMessage } from "@
 import { registerHandler } from "../ws/router";
 import { sendTo, broadcast } from "../ws/broadcast";
 import { loadConfig, saveConfig } from "../config";
-import { addProject } from "../project/registry";
+import { addProject, removeProject } from "../project/registry";
 import type { LatticeConfig } from "@lattice/shared";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -63,6 +63,11 @@ registerHandler("settings", function (clientId: string, message: ClientMessage)
       delete incoming.mcpServers;
     }
 
+    if (typeof incoming.removeProject === "string") {
+      removeProject(incoming.removeProject as string);
+      delete incoming.removeProject;
+    }
+
     var incomingProjects = incoming.projects as Array<{ path: string; slug?: string; title: string; env?: Record<string, string> }> | undefined;
     if (incomingProjects && incomingProjects.length > 0) {
       for (var i = 0; i < incomingProjects.length; i++) {

package/shared/src/messages.ts

@@ -223,6 +223,39 @@ export interface SkillsUpdateMessage {
   source: string;
 }
 
+export interface BrowseListMessage {
+  type: "browse:list";
+  path: string;
+}
+
+export interface MemoryListMessage {
+  type: "memory:list";
+  projectSlug: string;
+}
+
+export interface MemoryViewMessage {
+  type: "memory:view";
+  projectSlug: string;
+  filename: string;
+}
+
+export interface MemorySaveMessage {
+  type: "memory:save";
+  projectSlug: string;
+  filename: string;
+  content: string;
+}
+
+export interface MemoryDeleteMessage {
+  type: "memory:delete";
+  projectSlug: string;
+  filename: string;
+}
+
+export interface BrowseSuggestionsMessage {
+  type: "browse:suggestions";
+}
+
 export interface ProjectSettingsGetMessage {
   type: "project-settings:get";
   projectSlug: string;
@@ -289,7 +322,13 @@ export type ClientMessage =
   | SkillsInstallMessage
   | SkillsViewMessage
   | SkillsDeleteMessage
-  | SkillsUpdateMessage;
+  | SkillsUpdateMessage
+  | BrowseListMessage
+  | MemoryListMessage
+  | MemoryViewMessage
+  | MemorySaveMessage
+  | MemoryDeleteMessage
+  | BrowseSuggestionsMessage;
 
 export interface SessionListMessage {
   type: "session:list";
@@ -548,6 +587,56 @@ export interface SkillsDeleteResultMessage {
   message?: string;
 }
 
+export interface BrowseListResultMessage {
+  type: "browse:list_result";
+  path: string;
+  homedir: string;
+  entries: Array<{
+    name: string;
+    path: string;
+    hasClaudeMd: boolean;
+    projectName: string | null;
+  }>;
+}
+
+export interface MemoryListResultMessage {
+  type: "memory:list_result";
+  projectSlug: string;
+  memories: Array<{
+    filename: string;
+    name: string;
+    description: string;
+    type: string;
+  }>;
+}
+
+export interface MemoryViewResultMessage {
+  type: "memory:view_result";
+  filename: string;
+  content: string;
+}
+
+export interface MemorySaveResultMessage {
+  type: "memory:save_result";
+  success: boolean;
+  message?: string;
+}
+
+export interface MemoryDeleteResultMessage {
+  type: "memory:delete_result";
+  success: boolean;
+  message?: string;
+}
+
+export interface BrowseSuggestionsResultMessage {
+  type: "browse:suggestions_result";
+  suggestions: Array<{
+    path: string;
+    name: string;
+    hasClaudeMd: boolean;
+  }>;
+}
+
 export type ServerMessage =
   | SessionListMessage
   | SessionCreatedMessage
@@ -592,7 +681,13 @@ export type ServerMessage =
   | SkillsSearchResultsMessage
   | SkillsInstallResultMessage
   | SkillsViewResultMessage
-  | SkillsDeleteResultMessage;
+  | SkillsDeleteResultMessage
+  | BrowseListResultMessage
+  | MemoryListResultMessage
+  | MemoryViewResultMessage
+  | MemorySaveResultMessage
+  | MemoryDeleteResultMessage
+  | BrowseSuggestionsResultMessage;
 
 export interface MeshHelloMessage {
   type: "mesh:hello";

package/shared/src/project-settings.ts

@@ -15,7 +15,7 @@ export type McpServerConfig =
   | { type: "sse"; url: string; headers?: Record<string, string> };
 
 export type ProjectSettingsSection =
-  | "general" | "claude" | "environment" | "mcp" | "skills" | "rules" | "permissions";
+  | "general" | "claude" | "environment" | "mcp" | "skills" | "rules" | "permissions" | "memory";
 
 export interface ProjectSettings {
   title: string;