@cryptiklemur/lattice 0.0.0

package/server/src/project/context-breakdown.ts

@@ -0,0 +1,289 @@
+import { encodingForModel } from "js-tiktoken";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { ContextBreakdownSegment } from "@lattice/shared";
+import { guessContextWindow } from "./session";
+import { loadConfig } from "../config";
+
+var encoder = encodingForModel("gpt-4o");
+
+function countTokens(text: string): number {
+  if (!text) return 0;
+  return encoder.encode(text).length;
+}
+
+function readFileSafe(path: string): string {
+  try {
+    if (existsSync(path)) return readFileSync(path, "utf-8");
+  } catch {}
+  return "";
+}
+
+function readDirFiles(dirPath: string): string {
+  try {
+    if (!existsSync(dirPath)) return "";
+    var files = readdirSync(dirPath, { withFileTypes: true });
+    var content = "";
+    for (var i = 0; i < files.length; i++) {
+      if (files[i].isFile()) {
+        content += readFileSafe(join(dirPath, files[i].name)) + "\n";
+      }
+    }
+    return content;
+  } catch {}
+  return "";
+}
+
+function projectPathToHash(projectPath: string): string {
+  return projectPath.replace(/\//g, "-");
+}
+
+function getProjectPath(projectSlug: string): string | null {
+  var config = loadConfig();
+  var project = config.projects.find(function (p) { return p.slug === projectSlug; });
+  return project ? project.path : null;
+}
+
+// Known built-in Claude Code tools with approximate per-tool token counts
+// These are the tool definitions sent in every API request
+var BUILTIN_TOOLS: Record<string, number> = {
+  "Read": 350,
+  "Write": 300,
+  "Edit": 400,
+  "Bash": 500,
+  "Glob": 250,
+  "Grep": 450,
+  "Agent": 600,
+  "WebFetch": 400,
+  "WebSearch": 300,
+  "TodoWrite": 300,
+  "NotebookEdit": 350,
+  "AskUserQuestion": 400,
+  "Skill": 350,
+  "TaskOutput": 200,
+  "TaskStop": 150,
+  "EnterPlanMode": 200,
+  "ExitPlanMode": 150,
+  "EnterWorktree": 200,
+  "ExitWorktree": 150,
+  "CronCreate": 250,
+  "CronDelete": 200,
+  "CronList": 150,
+  "ToolSearch": 250,
+};
+
+// Average tokens per MCP tool definition (name + description + JSON schema)
+var MCP_TOOL_AVG_TOKENS = 250;
+
+interface ToolCounts {
+  builtinTools: string[];
+  mcpTools: Map<string, string[]>; // server name -> tool names
+}
+
+function extractToolsFromSession(lines: string[]): ToolCounts {
+  var builtinSet = new Set<string>();
+  var mcpMap = new Map<string, Set<string>>();
+
+  // First: check compact boundary metadata for preCompactDiscoveredTools
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    if (!line || !line.includes("compactMetadata")) continue;
+    try {
+      var parsed = JSON.parse(line);
+      var tools = parsed.compactMetadata?.preCompactDiscoveredTools;
+      if (Array.isArray(tools)) {
+        for (var t = 0; t < tools.length; t++) {
+          categorizeToolName(tools[t], builtinSet, mcpMap);
+        }
+      }
+    } catch {}
+  }
+
+  // Second: scan tool_use blocks from assistant messages for any we missed
+  for (var j = 0; j < lines.length; j++) {
+    var aLine = lines[j].trim();
+    if (!aLine || !aLine.includes("tool_use")) continue;
+    try {
+      var aParsed = JSON.parse(aLine);
+      if (aParsed.type === "assistant" && aParsed.message && Array.isArray(aParsed.message.content)) {
+        for (var k = 0; k < aParsed.message.content.length; k++) {
+          var block = aParsed.message.content[k];
+          if (block.type === "tool_use" && block.name) {
+            categorizeToolName(block.name, builtinSet, mcpMap);
+          }
+        }
+      }
+    } catch {}
+  }
+
+  // If we found no tools at all, use the default known set
+  if (builtinSet.size === 0 && mcpMap.size === 0) {
+    return {
+      builtinTools: Object.keys(BUILTIN_TOOLS),
+      mcpTools: new Map(),
+    };
+  }
+
+  return {
+    builtinTools: Array.from(builtinSet),
+    mcpTools: new Map(Array.from(mcpMap.entries()).map(function (entry) {
+      return [entry[0], Array.from(entry[1])];
+    })),
+  };
+}
+
+function categorizeToolName(name: string, builtinSet: Set<string>, mcpMap: Map<string, Set<string>>): void {
+  if (name.startsWith("mcp__")) {
+    var parts = name.split("__");
+    var serverName = parts[1] || "unknown";
+    if (!mcpMap.has(serverName)) {
+      mcpMap.set(serverName, new Set());
+    }
+    mcpMap.get(serverName)!.add(name);
+  } else {
+    builtinSet.add(name);
+  }
+}
+
+function estimateBuiltinToolTokens(toolNames: string[]): number {
+  var total = 0;
+  for (var i = 0; i < toolNames.length; i++) {
+    total += BUILTIN_TOOLS[toolNames[i]] || 300;
+  }
+  // Also include tools that are always sent but might not appear in usage
+  var knownKeys = Object.keys(BUILTIN_TOOLS);
+  for (var j = 0; j < knownKeys.length; j++) {
+    if (toolNames.indexOf(knownKeys[j]) === -1) {
+      total += BUILTIN_TOOLS[knownKeys[j]];
+    }
+  }
+  return total;
+}
+
+export interface ContextBreakdownResult {
+  segments: ContextBreakdownSegment[];
+  contextWindow: number;
+  autocompactAt: number;
+}
+
+export async function getContextBreakdown(projectSlug: string, sessionId: string): Promise<ContextBreakdownResult | null> {
+  var projectPath = getProjectPath(projectSlug);
+  if (!projectPath) return null;
+
+  var home = homedir();
+  var hash = projectPathToHash(projectPath);
+  var sessionFile = join(home, ".claude", "projects", hash, sessionId + ".jsonl");
+  if (!existsSync(sessionFile)) return null;
+
+  // Read instruction files
+  var globalClaudeMd = readFileSafe(join(home, ".claude", "CLAUDE.md"));
+  var globalRulesContent = readDirFiles(join(home, ".claude", "rules"));
+  var projectClaudeMd = readFileSafe(join(projectPath, "CLAUDE.md"));
+  var projectLocalClaudeMd = readFileSafe(join(home, ".claude", "projects", hash, "CLAUDE.md"));
+
+  var memoryContent = readDirFiles(join(home, ".claude", "projects", hash, "memory"));
+  var memoryIndex = readFileSafe(join(home, ".claude", "projects", hash, "MEMORY.md"));
+
+  var instructionsTokens = countTokens(globalClaudeMd + globalRulesContent + projectClaudeMd + projectLocalClaudeMd);
+  var memoryTokens = countTokens(memoryContent + memoryIndex);
+
+  // Parse session
+  var content = readFileSync(sessionFile, "utf-8");
+  var lines = content.trim().split("\n");
+
+  // Extract tool info
+  var toolCounts = extractToolsFromSession(lines);
+  var builtinToolTokens = estimateBuiltinToolTokens(toolCounts.builtinTools);
+
+  // Parse conversation messages
+  var userText = "";
+  var assistantText = "";
+  var toolResultText = "";
+  var contextWindow = 0;
+  var lastModel = "";
+
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    if (!line) continue;
+    try {
+      var parsed = JSON.parse(line);
+      if (parsed.type === "user" && parsed.message) {
+        var userContent = parsed.message.content;
+        if (typeof userContent === "string") {
+          userText += userContent + "\n";
+        } else if (Array.isArray(userContent)) {
+          for (var j = 0; j < userContent.length; j++) {
+            var block = userContent[j];
+            if (block.type === "text" && block.text) {
+              userText += block.text + "\n";
+            } else if (block.type === "tool_result") {
+              if (typeof block.content === "string") {
+                toolResultText += block.content + "\n";
+              } else if (Array.isArray(block.content)) {
+                for (var ri = 0; ri < block.content.length; ri++) {
+                  if (block.content[ri].type === "text" && block.content[ri].text) {
+                    toolResultText += block.content[ri].text + "\n";
+                  }
+                }
+              }
+            }
+          }
+        }
+      } else if (parsed.type === "assistant" && parsed.message) {
+        var aContent = parsed.message.content;
+        if (typeof aContent === "string") {
+          assistantText += aContent + "\n";
+        } else if (Array.isArray(aContent)) {
+          for (var k = 0; k < aContent.length; k++) {
+            var ab = aContent[k];
+            if (ab.type === "text" && ab.text) {
+              assistantText += ab.text + "\n";
+            } else if (ab.type === "tool_use" && ab.input) {
+              assistantText += JSON.stringify(ab.input) + "\n";
+            } else if (ab.type === "thinking" && ab.thinking) {
+              assistantText += ab.thinking + "\n";
+            }
+          }
+        }
+        if (parsed.message.model) {
+          lastModel = parsed.message.model;
+        }
+      }
+    } catch {}
+  }
+
+  var userTokens = countTokens(userText);
+  var assistantTokens = countTokens(assistantText);
+  var toolResultTokens = countTokens(toolResultText);
+  contextWindow = guessContextWindow(lastModel);
+
+  var autocompactAt = Math.round(contextWindow * 0.9);
+  var systemPromptEstimate = 4500;
+
+  var segments: ContextBreakdownSegment[] = [
+    { label: "System prompt", tokens: systemPromptEstimate, id: "system", estimated: true },
+    { label: "Built-in tools (" + Object.keys(BUILTIN_TOOLS).length + ")", tokens: builtinToolTokens, id: "builtin_tools", estimated: true },
+  ];
+
+  // Add per-MCP-server segments
+  toolCounts.mcpTools.forEach(function (tools, serverName) {
+    var mcpTokens = tools.length * MCP_TOOL_AVG_TOKENS;
+    segments.push({
+      label: serverName + " (" + tools.length + " tools)",
+      tokens: mcpTokens,
+      id: "mcp_" + serverName,
+      estimated: true,
+    });
+  });
+
+  segments.push(
+    { label: "Instructions", tokens: instructionsTokens, id: "instructions", estimated: false },
+    { label: "Memory", tokens: memoryTokens, id: "memory", estimated: false },
+    { label: "Your messages", tokens: userTokens, id: "user", estimated: false },
+    { label: "Claude responses", tokens: assistantTokens, id: "assistant", estimated: false },
+    { label: "Tool results", tokens: toolResultTokens, id: "tool_results", estimated: false },
+  );
+
+  return { segments, contextWindow, autocompactAt };
+}

package/server/src/project/file-browser.ts

@@ -0,0 +1,106 @@
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve, relative } from "node:path";
+import type { FileEntry } from "@lattice/shared";
+
+var MAX_FILE_SIZE = 512 * 1024;
+
+export function validatePath(projectPath: string, relativePath: string): string | null {
+  var resolved = resolve(projectPath, relativePath);
+  var normalizedRoot = resolve(projectPath);
+  if (!resolved.startsWith(normalizedRoot + "/") && resolved !== normalizedRoot) {
+    return null;
+  }
+  return resolved;
+}
+
+export function listDirectory(projectPath: string, relativePath: string): FileEntry[] {
+  var fullPath = validatePath(projectPath, relativePath);
+  if (!fullPath) {
+    return [];
+  }
+
+  var entries: FileEntry[] = [];
+  var names: string[];
+  try {
+    names = readdirSync(fullPath);
+  } catch {
+    return [];
+  }
+
+  for (var i = 0; i < names.length; i++) {
+    var name = names[i];
+    if (name.startsWith(".")) {
+      continue;
+    }
+    var entryFull = join(fullPath, name);
+    try {
+      var stat = statSync(entryFull);
+      var entryRelative = relative(projectPath, entryFull);
+      entries.push({
+        name: name,
+        path: entryRelative,
+        isDirectory: stat.isDirectory(),
+        size: stat.isDirectory() ? 0 : stat.size,
+        modifiedAt: stat.mtimeMs,
+      });
+    } catch {
+      // skip entries we can't stat
+    }
+  }
+
+  entries.sort(function (a, b) {
+    if (a.isDirectory && !b.isDirectory) return -1;
+    if (!a.isDirectory && b.isDirectory) return 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  return entries;
+}
+
+export function readFile(projectPath: string, relativePath: string): string | null {
+  var fullPath = validatePath(projectPath, relativePath);
+  if (!fullPath) {
+    return null;
+  }
+
+  var stat: ReturnType<typeof statSync>;
+  try {
+    stat = statSync(fullPath);
+  } catch {
+    return null;
+  }
+
+  if (stat.size > MAX_FILE_SIZE) {
+    return null;
+  }
+
+  var buf: Buffer;
+  try {
+    buf = readFileSync(fullPath);
+  } catch {
+    return null;
+  }
+
+  for (var i = 0; i < Math.min(buf.length, 8192); i++) {
+    var byte = buf[i];
+    if (byte === 0) {
+      return null;
+    }
+  }
+
+  return buf.toString("utf-8");
+}
+
+export function writeFile(projectPath: string, relativePath: string, content: string): boolean {
+  var fullPath = validatePath(projectPath, relativePath);
+  if (!fullPath) {
+    return false;
+  }
+
+  try {
+    writeFileSync(fullPath, content, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}

package/server/src/project/project-files.ts

@@ -0,0 +1,267 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+
+export function readProjectClaudeMd(projectPath: string): string {
+  var filePath = join(projectPath, "CLAUDE.md");
+  if (!existsSync(filePath)) return "";
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+export function writeProjectClaudeMd(projectPath: string, content: string): void {
+  writeFileSync(join(projectPath, "CLAUDE.md"), content, "utf-8");
+}
+
+export function readProjectClaudeSettings(projectPath: string): Record<string, unknown> {
+  var filePath = join(projectPath, ".claude", "settings.json");
+  if (!existsSync(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export function mergeProjectClaudeSettings(projectPath: string, updates: Record<string, unknown>): void {
+  var existing = readProjectClaudeSettings(projectPath);
+  Object.assign(existing, updates);
+  var dir = join(projectPath, ".claude");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "settings.json"), JSON.stringify(existing, null, 2) + "\n", "utf-8");
+}
+
+export function readProjectRules(projectPath: string): Array<{ filename: string; content: string }> {
+  var dir = join(projectPath, ".claude", "rules");
+  if (!existsSync(dir)) return [];
+  var results: Array<{ filename: string; content: string }> = [];
+  try {
+    var files = readdirSync(dir);
+    for (var file of files) {
+      if (!file.endsWith(".md")) continue;
+      try {
+        var content = readFileSync(join(dir, file), "utf-8");
+        results.push({ filename: file, content });
+      } catch {
+        // skip unreadable files
+      }
+    }
+  } catch {
+    return [];
+  }
+  return results;
+}
+
+export function writeProjectRules(projectPath: string, rules: Array<{ filename: string; content: string }>): void {
+  var dir = join(projectPath, ".claude", "rules");
+  mkdirSync(dir, { recursive: true });
+
+  var incoming = new Set<string>();
+  for (var rule of rules) {
+    incoming.add(rule.filename);
+  }
+
+  try {
+    var existing = readdirSync(dir);
+    for (var file of existing) {
+      if (file.endsWith(".md") && !incoming.has(file)) {
+        unlinkSync(join(dir, file));
+      }
+    }
+  } catch {
+    // dir just created, nothing to delete
+  }
+
+  for (var rule of rules) {
+    writeFileSync(join(dir, rule.filename), rule.content, "utf-8");
+  }
+}
+
+export function readProjectMcpServers(projectPath: string): Record<string, unknown> {
+  var filePath = join(projectPath, ".mcp.json");
+  if (!existsSync(filePath)) return {};
+  try {
+    var parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    return parsed?.mcpServers ?? {};
+  } catch {
+    return {};
+  }
+}
+
+export function writeProjectMcpServers(projectPath: string, servers: Record<string, unknown>): void {
+  var filePath = join(projectPath, ".mcp.json");
+  writeFileSync(filePath, JSON.stringify({ mcpServers: servers }, null, 2) + "\n", "utf-8");
+}
+
+export function readProjectSkills(projectPath: string): Array<{ name: string; description: string; path: string }> {
+  return scanSkillsDir(join(projectPath, ".claude", "skills"));
+}
+
+export function readGlobalRules(): Array<{ filename: string; content: string }> {
+  var dir = join(homedir(), ".claude", "rules");
+  if (!existsSync(dir)) return [];
+  var results: Array<{ filename: string; content: string }> = [];
+  try {
+    var files = readdirSync(dir);
+    for (var file of files) {
+      if (!file.endsWith(".md")) continue;
+      try {
+        var content = readFileSync(join(dir, file), "utf-8");
+        results.push({ filename: file, content });
+      } catch {
+        // skip unreadable files
+      }
+    }
+  } catch {
+    return [];
+  }
+  return results;
+}
+
+export function readGlobalPermissions(): { allow: string[]; deny: string[] } {
+  var settings = readJsonFile(join(homedir(), ".claude", "settings.json"));
+  var local = readJsonFile(join(homedir(), ".claude", "settings.local.json"));
+
+  var allow = new Set<string>();
+  var deny = new Set<string>();
+
+  collectPermissions(settings, allow, deny);
+  collectPermissions(local, allow, deny);
+
+  return { allow: Array.from(allow), deny: Array.from(deny) };
+}
+
+export function readGlobalMcpServers(): Record<string, unknown> {
+  var filePath = join(homedir(), ".claude.json");
+  if (!existsSync(filePath)) return {};
+  try {
+    var parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    return parsed?.mcpServers ?? {};
+  } catch {
+    return {};
+  }
+}
+
+export function writeGlobalMcpServers(servers: Record<string, unknown>): void {
+  var filePath = join(homedir(), ".claude.json");
+  var existing: Record<string, unknown> = {};
+  if (existsSync(filePath)) {
+    try {
+      existing = JSON.parse(readFileSync(filePath, "utf-8"));
+    } catch {}
+  }
+  existing.mcpServers = servers;
+  writeFileSync(filePath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+}
+
+export function readGlobalSkills(): Array<{ name: string; description: string; path: string }> {
+  var results: Array<{ name: string; description: string; path: string }> = [];
+  var dirs = [
+    join(homedir(), ".claude", "skills"),
+    join(homedir(), ".agents", "skills"),
+  ];
+  for (var dir of dirs) {
+    var skills = scanSkillsDir(dir);
+    for (var skill of skills) {
+      results.push(skill);
+    }
+  }
+  return results;
+}
+
+function readJsonFile(filePath: string): Record<string, unknown> {
+  if (!existsSync(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function collectPermissions(obj: Record<string, unknown>, allow: Set<string>, deny: Set<string>): void {
+  var perms = obj.permissions as Record<string, unknown> | undefined;
+  if (!perms) return;
+  var allowArr = perms.allow;
+  var denyArr = perms.deny;
+  if (Array.isArray(allowArr)) {
+    for (var item of allowArr) {
+      if (typeof item === "string") allow.add(item);
+    }
+  }
+  if (Array.isArray(denyArr)) {
+    for (var item of denyArr) {
+      if (typeof item === "string") deny.add(item);
+    }
+  }
+}
+
+function parseFrontmatter(content: string): { name: string; description: string } {
+  var match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return { name: "", description: "" };
+  var yaml = match[1];
+  var name = "";
+  var desc = "";
+  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) desc = descMatch[1].trim().replace(/^["']|["']$/g, "");
+  }
+  return { name, description: desc };
+}
+
+function scanSkillsDir(dir: string): Array<{ name: string; description: string; path: string }> {
+  if (!existsSync(dir)) return [];
+  var results: Array<{ name: string; description: string; path: string }> = [];
+  try {
+    var entries = readdirSync(dir, { withFileTypes: true });
+    for (var entry of entries) {
+      var entryPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        try {
+          var subFiles = readdirSync(entryPath);
+          for (var subFile of subFiles) {
+            if (subFile.toUpperCase().startsWith("SKILL")) {
+              var skillPath = join(entryPath, subFile);
+              var content = readFileSync(skillPath, "utf-8");
+              var meta = parseFrontmatter(content);
+              var skillName = meta.name || entry.name;
+              var description = meta.description || firstNonEmptyLine(content.replace(/^---[\s\S]*?---\s*/, ""));
+              results.push({ name: skillName, description, path: skillPath });
+              break;
+            }
+          }
+        } catch {
+          // skip unreadable subdirectories
+        }
+      } else if (entry.name.toUpperCase().startsWith("SKILL")) {
+        try {
+          var content = readFileSync(entryPath, "utf-8");
+          var meta = parseFrontmatter(content);
+          var name = meta.name || entry.name.replace(/\.[^.]+$/, "");
+          var description = meta.description || firstNonEmptyLine(content.replace(/^---[\s\S]*?---\s*/, ""));
+          results.push({ name, description, path: entryPath });
+        } catch {
+          // skip unreadable files
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  return results;
+}
+
+function firstNonEmptyLine(text: string): string {
+  var lines = text.split("\n");
+  for (var line of lines) {
+    var trimmed = line.trim();
+    if (trimmed.length > 0) return trimmed;
+  }
+  return "";
+}