@cryptiklemur/lattice 5.10.0 → 5.11.0

package/dist/server/handlers/chat.js

@@ -13,12 +13,12 @@ function formatSdkRule(rule) {
     if (!rule.ruleContent)
         return rule.toolName;
     if (rule.toolName === "Bash") {
-        var firstWord = rule.ruleContent.split(/\s+/)[0].replace(/:.*$/, "");
+        const firstWord = rule.ruleContent.split(/\s+/)[0].replace(/:.*$/, "");
         if (firstWord === "curl" || firstWord === "wget") {
-            var urlMatch = rule.ruleContent.match(/https?:\/\/[^\s"']+/);
+            const urlMatch = rule.ruleContent.match(/https?:\/\/[^\s"']+/);
             if (urlMatch) {
                 try {
-                    var parsed = new URL(urlMatch[0]);
+                    const parsed = new URL(urlMatch[0]);
                     return rule.toolName + "(" + firstWord + ":" + parsed.hostname + ")";
                 }
                 catch { }
@@ -29,9 +29,9 @@ function formatSdkRule(rule) {
     return rule.toolName + "(" + rule.ruleContent + ")";
 }
 function addProjectAllowRules(projectPath, suggestions, fallbackToolName, fallbackInput) {
-    var claudeDir = join(projectPath, ".claude");
-    var settingsPath = join(claudeDir, "settings.json");
-    var settings = {};
+    const claudeDir = join(projectPath, ".claude");
+    const settingsPath = join(claudeDir, "settings.json");
+    let settings = {};
     if (existsSync(settingsPath)) {
         try {
             settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
@@ -43,26 +43,26 @@ function addProjectAllowRules(projectPath, suggestions, fallbackToolName, fallba
     if (!settings.permissions) {
         settings.permissions = {};
     }
-    var permissions = settings.permissions;
+    const permissions = settings.permissions;
     if (!Array.isArray(permissions.allow)) {
         permissions.allow = [];
     }
     if (!Array.isArray(permissions.additionalDirectories)) {
         permissions.additionalDirectories = [];
     }
-    var allowList = permissions.allow;
-    var additionalDirs = permissions.additionalDirectories;
+    const allowList = permissions.allow;
+    const additionalDirs = permissions.additionalDirectories;
     if (suggestions && suggestions.length > 0) {
-        for (var si = 0; si < suggestions.length; si++) {
-            var suggestion = suggestions[si];
+        for (let si = 0; si < suggestions.length; si++) {
+            const suggestion = suggestions[si];
             if (suggestion.type === "addRules" && suggestion.behavior === "allow" && suggestion.rules) {
-                for (var ri = 0; ri < suggestion.rules.length; ri++) {
-                    var rule = formatSdkRule(suggestion.rules[ri]);
+                for (let ri = 0; ri < suggestion.rules.length; ri++) {
+                    const rule = formatSdkRule(suggestion.rules[ri]);
                     if (!allowList.includes(rule)) {
                         allowList.push(rule);
                     }
                     if (suggestion.rules[ri].ruleContent) {
-                        var ruleDir = suggestion.rules[ri].ruleContent.replace(/\/\*\*$/, "").replace(/^\//, "");
+                        const ruleDir = suggestion.rules[ri].ruleContent.replace(/\/\*\*$/, "").replace(/^\//, "");
                         if (ruleDir.startsWith("/") && !additionalDirs.includes(ruleDir)) {
                             additionalDirs.push(ruleDir);
                         }
@@ -70,7 +70,7 @@ function addProjectAllowRules(projectPath, suggestions, fallbackToolName, fallba
                 }
             }
             if (suggestion.type === "addDirectories" && suggestion.directories) {
-                for (var di = 0; di < suggestion.directories.length; di++) {
+                for (let di = 0; di < suggestion.directories.length; di++) {
                     if (!additionalDirs.includes(suggestion.directories[di])) {
                         additionalDirs.push(suggestion.directories[di]);
                     }
@@ -79,7 +79,7 @@ function addProjectAllowRules(projectPath, suggestions, fallbackToolName, fallba
         }
     }
     else {
-        var fallbackRule = buildPermissionRule(fallbackToolName, fallbackInput);
+        const fallbackRule = buildPermissionRule(fallbackToolName, fallbackInput);
         if (!allowList.includes(fallbackRule)) {
             allowList.push(fallbackRule);
         }
@@ -89,13 +89,13 @@ function addProjectAllowRules(projectPath, suggestions, fallbackToolName, fallba
     }
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
 }
-var activeSessionByClient = new Map();
-var pendingBudgetOverride = new Map();
+const activeSessionByClient = new Map();
+const pendingBudgetOverride = new Map();
 export function sendBudgetStatus(clientId) {
-    var config = loadConfig();
+    const config = loadConfig();
     if (!config.costBudget)
         return;
-    var dailySpend = getDailySpend();
+    const dailySpend = getDailySpend();
     sendTo(clientId, {
         type: "budget:status",
         dailySpend: dailySpend,
@@ -114,11 +114,11 @@ export function getActiveSession(clientId) {
 }
 registerHandler("budget", function (clientId, message) {
     if (message.type === "budget:override") {
-        var pending = pendingBudgetOverride.get(clientId);
+        const pending = pendingBudgetOverride.get(clientId);
         if (!pending)
             return;
         pendingBudgetOverride.delete(clientId);
-        var overrideAttachments = pending.sendMsg.attachmentIds
+        const overrideAttachments = pending.sendMsg.attachmentIds
             ? getAttachments(clientId, pending.sendMsg.attachmentIds)
             : [];
         startChatStream({
@@ -137,21 +137,21 @@ registerHandler("budget", function (clientId, message) {
 });
 registerHandler("chat", function (clientId, message) {
     if (message.type === "chat:send") {
-        var sendMsg = message;
-        var active = activeSessionByClient.get(clientId);
+        const sendMsg = message;
+        const active = activeSessionByClient.get(clientId);
         if (!active) {
             sendTo(clientId, { type: "chat:error", message: "No active session. Activate a session first." });
             return;
         }
-        var project = getProjectBySlug(active.projectSlug);
+        const project = getProjectBySlug(active.projectSlug);
         if (!project) {
             sendTo(clientId, { type: "chat:error", message: `Project not found: ${active.projectSlug}` });
             return;
         }
-        var config = loadConfig();
-        var env = Object.assign({}, config.globalEnv, project.env);
+        const config = loadConfig();
+        const env = Object.assign({}, config.globalEnv, project.env);
         if (config.costBudget && config.costBudget.dailyLimit > 0) {
-            var dailySpend = getDailySpend();
+            const dailySpend = getDailySpend();
             if (dailySpend >= config.costBudget.dailyLimit) {
                 if (config.costBudget.enforcement === "hard-block") {
                     sendTo(clientId, { type: "chat:error", message: "Daily cost budget exceeded ($" + dailySpend.toFixed(2) + " / $" + config.costBudget.dailyLimit.toFixed(2) + "). Sending is blocked until tomorrow." });
@@ -174,10 +174,10 @@ registerHandler("chat", function (clientId, message) {
                 }
             }
         }
-        var attachments = sendMsg.attachmentIds
+        const attachments = sendMsg.attachmentIds
             ? getAttachments(clientId, sendMsg.attachmentIds)
             : [];
-        var linkedSpec = findSpecBySession(active.sessionId);
+        const linkedSpec = findSpecBySession(active.sessionId);
         startChatStream({
             projectSlug: active.projectSlug,
             sessionId: active.sessionId,
@@ -194,12 +194,12 @@ registerHandler("chat", function (clientId, message) {
         return;
     }
     if (message.type === "chat:cancel") {
-        var active = activeSessionByClient.get(clientId);
+        const active = activeSessionByClient.get(clientId);
         if (!active) {
             sendTo(clientId, { type: "chat:error", message: "No active session." });
             return;
         }
-        var stream = getActiveStream(active.sessionId);
+        const stream = getActiveStream(active.sessionId);
         if (!stream) {
             sendTo(clientId, { type: "chat:error", message: "No active stream to cancel." });
             return;
@@ -208,18 +208,18 @@ registerHandler("chat", function (clientId, message) {
         return;
     }
     if (message.type === "chat:permission_response") {
-        var permMsg = message;
-        var pending = getPendingPermission(permMsg.requestId);
+        const permMsg = message;
+        const pending = getPendingPermission(permMsg.requestId);
         if (!pending) {
             return;
         }
-        var active = activeSessionByClient.get(clientId);
+        const active = activeSessionByClient.get(clientId);
         if (permMsg.allow) {
             if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "session" && active) {
                 addAutoApprovedTool(active.sessionId, pending.toolName);
             }
             if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "project" && active) {
-                var project = getProjectBySlug(active.projectSlug);
+                const project = getProjectBySlug(active.projectSlug);
                 if (project) {
                     addProjectAllowRules(project.path, pending.suggestions, pending.toolName, pending.input);
                 }
@@ -228,7 +228,7 @@ registerHandler("chat", function (clientId, message) {
             else {
                 pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
             }
-            var resolvedStatus = permMsg.alwaysAllow ? "always_allowed" : "allowed";
+            const resolvedStatus = permMsg.alwaysAllow ? "always_allowed" : "allowed";
             sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: resolvedStatus });
         }
         else {
@@ -239,12 +239,12 @@ registerHandler("chat", function (clientId, message) {
         return;
     }
     if (message.type === "chat:prompt_response") {
-        var promptRespMsg = message;
-        var pendingPrompt = getPendingPermission(promptRespMsg.requestId);
+        const promptRespMsg = message;
+        const pendingPrompt = getPendingPermission(promptRespMsg.requestId);
         if (!pendingPrompt || pendingPrompt.promptType !== "question") {
             return;
         }
-        var updatedInput = Object.assign({}, pendingPrompt.input, {
+        const updatedInput = Object.assign({}, pendingPrompt.input, {
             answers: promptRespMsg.answers,
         });
         if (promptRespMsg.annotations) {
@@ -260,8 +260,8 @@ registerHandler("chat", function (clientId, message) {
         return;
     }
     if (message.type === "chat:elicitation_response") {
-        var elicitMsg = message;
-        var pendingElicit = getPendingElicitation(elicitMsg.requestId);
+        const elicitMsg = message;
+        const pendingElicit = getPendingElicitation(elicitMsg.requestId);
         if (!pendingElicit)
             return;
         resolveElicitation(elicitMsg.requestId, {
@@ -271,11 +271,11 @@ registerHandler("chat", function (clientId, message) {
         return;
     }
     if (message.type === "chat:rewind_preview") {
-        var rewindMsg = message;
-        var activeForRewind = activeSessionByClient.get(clientId);
+        const rewindMsg = message;
+        const activeForRewind = activeSessionByClient.get(clientId);
         if (!activeForRewind)
             return;
-        var sessionStreamForRewind = getSessionStream(activeForRewind.sessionId);
+        const sessionStreamForRewind = getSessionStream(activeForRewind.sessionId);
         if (!sessionStreamForRewind) {
             sendTo(clientId, { type: "chat:rewind_preview_result", messageUuid: rewindMsg.messageUuid, canRewind: false, error: "No active stream for rewind" });
             return;
@@ -296,11 +296,11 @@ registerHandler("chat", function (clientId, message) {
         return;
     }
     if (message.type === "chat:rewind_execute") {
-        var execRewindMsg = message;
-        var activeForExec = activeSessionByClient.get(clientId);
+        const execRewindMsg = message;
+        const activeForExec = activeSessionByClient.get(clientId);
         if (!activeForExec)
             return;
-        var sessionStreamForExec = getSessionStream(activeForExec.sessionId);
+        const sessionStreamForExec = getSessionStream(activeForExec.sessionId);
         if (!sessionStreamForExec) {
             sendTo(clientId, { type: "chat:rewind_execute_result", messageUuid: execRewindMsg.messageUuid, success: false, error: "No active stream" });
             return;
@@ -323,11 +323,11 @@ registerHandler("chat", function (clientId, message) {
         return;
     }
     if (message.type === "chat:set_model") {
-        var modelMsg = message;
-        var activeSession = activeSessionByClient.get(clientId);
+        const modelMsg = message;
+        const activeSession = activeSessionByClient.get(clientId);
         if (!activeSession)
             return;
-        var sessionStream = getSessionStream(activeSession.sessionId);
+        const sessionStream = getSessionStream(activeSession.sessionId);
         if (sessionStream) {
             void sessionStream.queryInstance.setModel(modelMsg.model === "default" ? undefined : modelMsg.model).catch(function (err) {
                 log.chat("Failed to switch model: %O", err);
@@ -337,12 +337,12 @@ registerHandler("chat", function (clientId, message) {
         return;
     }
     if (message.type === "chat:set_permission_mode") {
-        var modeMsg = message;
-        var activeSession = activeSessionByClient.get(clientId);
+        const modeMsg = message;
+        const activeSession = activeSessionByClient.get(clientId);
         if (!activeSession) {
             return;
         }
-        var stream = getActiveStream(activeSession.sessionId);
+        const stream = getActiveStream(activeSession.sessionId);
         if (stream) {
             void stream.setPermissionMode(modeMsg.mode);
         }

package/dist/server/handlers/editor.js

@@ -7,7 +7,7 @@ import { loadConfig } from "../config.js";
 import { loadOrCreateIdentity } from "../identity.js";
 import { broadcast } from "../ws/broadcast.js";
 import { detectIdeProjectName } from "./settings.js";
-var binaryNames = {
+const binaryNames = {
     "vscode": ["code"],
     "vscode-insiders": ["code-insiders"],
     "cursor": ["cursor"],
@@ -19,12 +19,12 @@ var binaryNames = {
     "sublime": ["subl", "sublime_text"],
 };
 function detectEditorPath(editorType) {
-    var names = binaryNames[editorType];
+    const names = binaryNames[editorType];
     if (!names)
         return null;
-    for (var i = 0; i < names.length; i++) {
+    for (let i = 0; i < names.length; i++) {
         try {
-            var result = execSync("which " + names[i], { encoding: "utf-8", timeout: 3000 }).trim();
+            const result = execSync("which " + names[i], { encoding: "utf-8", timeout: 3000 }).trim();
             if (result)
                 return result;
         }
@@ -35,11 +35,11 @@ function detectEditorPath(editorType) {
     return null;
 }
 function ensureIdeaProject(projectPath, projectTitle) {
-    var ideaDir = join(projectPath, ".idea");
+    const ideaDir = join(projectPath, ".idea");
     if (!existsSync(ideaDir)) {
         mkdirSync(ideaDir, { recursive: true });
     }
-    var nameFile = join(ideaDir, ".name");
+    const nameFile = join(ideaDir, ".name");
     if (!existsSync(nameFile)) {
         writeFileSync(nameFile, projectTitle, "utf-8");
     }
@@ -47,19 +47,19 @@ function ensureIdeaProject(projectPath, projectTitle) {
 }
 registerHandler("editor", function (clientId, message) {
     if (message.type === "editor:detect") {
-        var detectMsg = message;
-        var detectedPath = detectEditorPath(detectMsg.editorType);
+        const detectMsg = message;
+        const detectedPath = detectEditorPath(detectMsg.editorType);
         sendTo(clientId, { type: "editor:detect_result", editorType: detectMsg.editorType, path: detectedPath });
         return;
     }
     if (message.type === "editor:ensure-project") {
-        var ensureMsg = message;
-        var config = loadConfig();
-        var project = config.projects.find(function (p) { return p.slug === ensureMsg.projectSlug; });
+        const ensureMsg = message;
+        const config = loadConfig();
+        const project = config.projects.find(function (p) { return p.slug === ensureMsg.projectSlug; });
         if (project) {
-            var name = ensureIdeaProject(project.path, project.title);
+            const name = ensureIdeaProject(project.path, project.title);
             sendTo(clientId, { type: "editor:ensure-project_result", projectSlug: ensureMsg.projectSlug, ideProjectName: name });
-            var identity = loadOrCreateIdentity();
+            const identity = loadOrCreateIdentity();
             broadcast({
                 type: "projects:list",
                 projects: config.projects.map(function (p) {

package/dist/server/handlers/fs.js

@@ -7,7 +7,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { loadConfig } from "../config.js";
-var activeProjectByClient = new Map();
+const activeProjectByClient = new Map();
 export function setActiveProject(clientId, projectSlug) {
     activeProjectByClient.set(clientId, projectSlug);
     subscribeClientToProject(clientId, projectSlug);
@@ -20,8 +20,8 @@ export function getActiveProjectForClient(clientId) {
 }
 registerHandler("fs", async function (clientId, message) {
     if (message.type === "fs:list") {
-        var listMsg = message;
-        var projectSlug = activeProjectByClient.get(clientId) || listMsg.projectSlug;
+        const listMsg = message;
+        let projectSlug = activeProjectByClient.get(clientId) || listMsg.projectSlug;
         if (listMsg.projectSlug) {
             setActiveProject(clientId, listMsg.projectSlug);
             projectSlug = listMsg.projectSlug;
@@ -30,18 +30,18 @@ registerHandler("fs", async function (clientId, message) {
             sendTo(clientId, { type: "chat:error", message: "No active project for fs:list" });
             return;
         }
-        var project = getProjectBySlug(projectSlug);
+        const project = getProjectBySlug(projectSlug);
         if (!project) {
             sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlug });
             return;
         }
-        var entries = await listDirectory(project.path, listMsg.path);
+        const entries = await 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;
+        const readMsg = message;
+        let projectSlugRead = activeProjectByClient.get(clientId) || readMsg.projectSlug;
         if (readMsg.projectSlug) {
             setActiveProject(clientId, readMsg.projectSlug);
             projectSlugRead = readMsg.projectSlug;
@@ -50,12 +50,12 @@ registerHandler("fs", async function (clientId, message) {
             sendTo(clientId, { type: "chat:error", message: "No active project for fs:read" });
             return;
         }
-        var projectRead = getProjectBySlug(projectSlugRead);
+        const projectRead = getProjectBySlug(projectSlugRead);
         if (!projectRead) {
             sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlugRead });
             return;
         }
-        var content = await readFile(projectRead.path, readMsg.path);
+        const content = await readFile(projectRead.path, readMsg.path);
         if (content === null) {
             sendTo(clientId, { type: "chat:error", message: "Cannot read file: " + readMsg.path });
             return;
@@ -64,18 +64,18 @@ registerHandler("fs", async function (clientId, message) {
         return;
     }
     if (message.type === "fs:write") {
-        var writeMsg = message;
-        var projectSlugWrite = activeProjectByClient.get(clientId);
+        const writeMsg = message;
+        const projectSlugWrite = activeProjectByClient.get(clientId);
         if (!projectSlugWrite) {
             sendTo(clientId, { type: "chat:error", message: "No active project for fs:write" });
             return;
         }
-        var projectWrite = getProjectBySlug(projectSlugWrite);
+        const projectWrite = getProjectBySlug(projectSlugWrite);
         if (!projectWrite) {
             sendTo(clientId, { type: "chat:error", message: "Project not found: " + projectSlugWrite });
             return;
         }
-        var ok = await writeFile(projectWrite.path, writeMsg.path, writeMsg.content);
+        const ok = await writeFile(projectWrite.path, writeMsg.path, writeMsg.content);
         if (!ok) {
             sendTo(clientId, { type: "chat:error", message: "Cannot write file: " + writeMsg.path });
             return;
@@ -93,48 +93,48 @@ function resolvePath(path) {
 }
 async function detectProjectName(dirPath) {
     try {
-        var pkgPath = join(dirPath, "package.json");
-        var pkg = JSON.parse(await fsReadFile(pkgPath, "utf-8"));
+        const pkgPath = join(dirPath, "package.json");
+        const pkg = JSON.parse(await fsReadFile(pkgPath, "utf-8"));
         if (pkg.name)
             return pkg.name;
     }
     catch { }
     try {
-        var cargoPath = join(dirPath, "Cargo.toml");
-        var cargo = await fsReadFile(cargoPath, "utf-8");
-        var cargoMatch = cargo.match(/\[package\][\s\S]*?name\s*=\s*"([^"]+)"/);
+        const cargoPath = join(dirPath, "Cargo.toml");
+        const cargo = await fsReadFile(cargoPath, "utf-8");
+        const cargoMatch = cargo.match(/\[package\][\s\S]*?name\s*=\s*"([^"]+)"/);
         if (cargoMatch)
             return cargoMatch[1];
     }
     catch { }
     try {
-        var composerPath = join(dirPath, "composer.json");
-        var composer = JSON.parse(await fsReadFile(composerPath, "utf-8"));
+        const composerPath = join(dirPath, "composer.json");
+        const composer = JSON.parse(await fsReadFile(composerPath, "utf-8"));
         if (composer.name)
             return composer.name;
     }
     catch { }
     try {
-        var pyprojectPath = join(dirPath, "pyproject.toml");
-        var pyproject = await fsReadFile(pyprojectPath, "utf-8");
-        var pyMatch = pyproject.match(/\[project\][\s\S]*?name\s*=\s*"([^"]+)"/);
+        const pyprojectPath = join(dirPath, "pyproject.toml");
+        const pyproject = await fsReadFile(pyprojectPath, "utf-8");
+        const pyMatch = pyproject.match(/\[project\][\s\S]*?name\s*=\s*"([^"]+)"/);
         if (pyMatch)
             return pyMatch[1];
     }
     catch { }
     try {
-        var goModPath = join(dirPath, "go.mod");
-        var goMod = await fsReadFile(goModPath, "utf-8");
-        var goMatch = goMod.match(/^module\s+(\S+)/m);
+        const goModPath = join(dirPath, "go.mod");
+        const goMod = await fsReadFile(goModPath, "utf-8");
+        const goMatch = goMod.match(/^module\s+(\S+)/m);
         if (goMatch) {
-            var parts = goMatch[1].split("/");
+            const parts = goMatch[1].split("/");
             return parts[parts.length - 1];
         }
     }
     catch { }
     try {
-        var entries = await readdir(dirPath);
-        for (var i = 0; i < entries.length; i++) {
+        const entries = await readdir(dirPath);
+        for (let i = 0; i < entries.length; i++) {
             if (entries[i].endsWith(".sln") || entries[i].endsWith(".csproj")) {
                 return entries[i].replace(/\.[^.]+$/, "");
             }
@@ -145,11 +145,11 @@ async function detectProjectName(dirPath) {
 }
 registerHandler("browse", async function (clientId, message) {
     if (message.type === "browse:list") {
-        var browseMsg = message;
-        var resolvedPath = resolvePath(browseMsg.path);
-        var home = homedir();
+        const browseMsg = message;
+        const resolvedPath = resolvePath(browseMsg.path);
+        const home = homedir();
         try {
-            var pathStat = await stat(resolvedPath);
+            const pathStat = await stat(resolvedPath);
             if (!pathStat.isDirectory()) {
                 sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
                 return;
@@ -160,15 +160,15 @@ registerHandler("browse", async function (clientId, message) {
             return;
         }
         try {
-            var dirEntries = await readdir(resolvedPath, { withFileTypes: true });
-            var results = [];
-            for (var i = 0; i < dirEntries.length; i++) {
-                var entry = dirEntries[i];
+            const dirEntries = await readdir(resolvedPath, { withFileTypes: true });
+            const results = [];
+            for (let i = 0; i < dirEntries.length; i++) {
+                const entry = dirEntries[i];
                 if (!entry.isDirectory())
                     continue;
-                var entryPath = join(resolvedPath, entry.name);
-                var hasClaudeMd = existsSync(join(entryPath, "CLAUDE.md"));
-                var projectName = await detectProjectName(entryPath);
+                const entryPath = join(resolvedPath, entry.name);
+                const hasClaudeMd = existsSync(join(entryPath, "CLAUDE.md"));
+                const projectName = await detectProjectName(entryPath);
                 results.push({
                     name: entry.name,
                     path: entryPath,
@@ -185,29 +185,29 @@ registerHandler("browse", async function (clientId, message) {
         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 = [];
+        const claudeProjectsDir = join(homedir(), ".claude", "projects");
+        const config = loadConfig();
+        const existingPaths = new Set(config.projects.map(function (p) { return p.path; }));
+        const suggestions = [];
         try {
-            var hashDirs = await readdir(claudeProjectsDir);
-            for (var i = 0; i < hashDirs.length; i++) {
-                var hashDir = hashDirs[i];
-                var candidatePath = "/" + hashDir.slice(1).replace(/-/g, "/");
+            const hashDirs = await readdir(claudeProjectsDir);
+            for (let i = 0; i < hashDirs.length; i++) {
+                const hashDir = hashDirs[i];
+                const candidatePath = "/" + hashDir.slice(1).replace(/-/g, "/");
                 if (!existsSync(candidatePath))
                     continue;
                 if (existingPaths.has(candidatePath))
                     continue;
                 try {
-                    var candidateStat = await stat(candidatePath);
+                    const candidateStat = await stat(candidatePath);
                     if (!candidateStat.isDirectory())
                         continue;
                 }
                 catch {
                     continue;
                 }
-                var hasClaudeMd = existsSync(join(candidatePath, "CLAUDE.md"));
-                var name = candidatePath.split("/").pop() || hashDir;
+                const hasClaudeMd = existsSync(join(candidatePath, "CLAUDE.md"));
+                const name = candidatePath.split("/").pop() || hashDir;
                 suggestions.push({
                     path: candidatePath,
                     name: name,