@cryptiklemur/lattice 4.0.2 → 5.0.1

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

@@ -1,307 +0,0 @@
-import { encodingForModel } from "js-tiktoken";
-import { existsSync, readFileSync, readdirSync, openSync, readSync, fstatSync, closeSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import type { ContextBreakdownSegment } from "#shared";
-import { guessContextWindow } from "./session";
-import { loadConfig } from "../config";
-import { getInstalledPluginCount, getPluginSkillRuleTokenEstimate } from "../handlers/plugins";
-
-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: typeof config.projects[number]) { 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 — read last 2MB for recent context (avoids reading 35MB+ files)
-  var fd = openSync(sessionFile, "r");
-  var fileStat = fstatSync(fd);
-  var readSize = Math.min(fileStat.size, 2 * 1024 * 1024);
-  var readBuf = Buffer.alloc(readSize);
-  readSync(fd, readBuf, 0, readSize, fileStat.size - readSize);
-  closeSync(fd);
-  var content = readBuf.toString("utf-8");
-  var lines = content.split("\n").filter(function (l) { return l.length > 0; });
-
-  // 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,
-    });
-  });
-
-  var pluginCount = getInstalledPluginCount();
-  if (pluginCount > 0) {
-    var pluginTokens = getPluginSkillRuleTokenEstimate();
-    segments.push({
-      label: "Plugins (" + pluginCount + ")",
-      tokens: pluginTokens,
-      id: "plugins",
-      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/src/server/project/file-browser.ts

@@ -1,106 +0,0 @@
-import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { join, resolve, relative } from "node:path";
-import type { FileEntry } from "#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/src/server/project/project-files.ts

@@ -1,267 +0,0 @@
-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 "";
-}