sparkecoder 0.1.9 → 0.1.11

package/dist/agent/index.js

@@ -2,11 +2,11 @@
 import {
   streamText,
   generateText as generateText2,
-  tool as tool6,
+  tool as tool7,
   stepCountIs
 } from "ai";
 import { gateway as gateway2 } from "@ai-sdk/gateway";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 import { nanoid as nanoid3 } from "nanoid";
 
 // src/db/index.ts
@@ -480,6 +480,17 @@ var SparkcoderConfigSchema = z.object({
 });
 
 // src/config/index.ts
+function getAppDataDirectory() {
+  const appName = "sparkecoder";
+  switch (platform()) {
+    case "darwin":
+      return join(homedir(), "Library", "Application Support", appName);
+    case "win32":
+      return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), appName);
+    default:
+      return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), appName);
+  }
+}
 var cachedConfig = null;
 function getConfig() {
   if (!cachedConfig) {
@@ -541,12 +552,12 @@ function calculateContextSize(messages2) {
 import { exec } from "child_process";
 import { promisify } from "util";
 import { mkdir, writeFile, readFile } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
 import { join as join2 } from "path";
 import { nanoid as nanoid2 } from "nanoid";
 var execAsync = promisify(exec);
 var SESSION_PREFIX = "spark_";
-var LOG_BASE_DIR = ".sparkecoder/sessions";
+var LOG_BASE_DIR = "sessions";
 var tmuxAvailableCache = null;
 async function isTmuxAvailable() {
   if (tmuxAvailableCache !== null) {
@@ -568,11 +579,19 @@ function generateTerminalId() {
 function getSessionName(terminalId) {
   return `${SESSION_PREFIX}${terminalId}`;
 }
-function getLogDir(terminalId, workingDirectory, sessionId) {
+function getTerminalDataDir() {
+  const appDataDir = getAppDataDirectory();
+  if (!existsSync2(appDataDir)) {
+    mkdirSync2(appDataDir, { recursive: true });
+  }
+  return appDataDir;
+}
+function getLogDir(terminalId, _workingDirectory, sessionId) {
+  const baseDir = getTerminalDataDir();
   if (sessionId) {
-    return join2(workingDirectory, LOG_BASE_DIR, sessionId, "terminals", terminalId);
+    return join2(baseDir, LOG_BASE_DIR, sessionId, "terminals", terminalId);
   }
-  return join2(workingDirectory, ".sparkecoder/terminals", terminalId);
+  return join2(baseDir, "terminals", terminalId);
 }
 function shellEscape(str) {
   return `'${str.replace(/'/g, "'\\''")}'`;
@@ -888,7 +907,7 @@ bash({ id: "abc123", input: "my text" })  // send text input
 - For npm: add --yes or -y to skip confirmation
 - If prompts are unavoidable, run in background mode and use input/key to respond
 
-Logs are saved to .sparkecoder/terminals/{id}/output.log`,
+Terminal output is stored in the global SparkECoder data directory. Use the \`tail\` option to read recent output.`,
     inputSchema: bashInputSchema,
     execute: async (inputArgs) => {
       const { command, background, id, kill, tail, input: textInput, key } = inputArgs;
@@ -1127,9 +1146,9 @@ Use this to understand existing code, check file contents, or gather context.`,
 // src/tools/write-file.ts
 import { tool as tool3 } from "ai";
 import { z as z4 } from "zod";
-import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { resolve as resolve4, relative as relative3, isAbsolute as isAbsolute2, dirname as dirname3 } from "path";
-import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { resolve as resolve5, relative as relative3, isAbsolute as isAbsolute2, dirname as dirname5 } from "path";
+import { existsSync as existsSync7 } from "fs";
 
 // src/checkpoints/index.ts
 import { readFile as readFile3, writeFile as writeFile2, unlink, mkdir as mkdir2 } from "fs/promises";
@@ -1182,6 +1201,501 @@ async function backupFile(sessionId, workingDirectory, filePath) {
   return backup;
 }
 
+// src/lsp/index.ts
+import { extname as extname2, dirname as dirname4 } from "path";
+
+// src/lsp/servers.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve4, dirname as dirname3 } from "path";
+function findNearestRoot(startDir, markers) {
+  let dir = startDir;
+  const root = "/";
+  while (dir !== root) {
+    for (const marker of markers) {
+      if (existsSync5(resolve4(dir, marker))) {
+        return dir;
+      }
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+async function commandExists(cmd) {
+  try {
+    const { exec: exec4 } = await import("child_process");
+    const { promisify: promisify4 } = await import("util");
+    const execAsync4 = promisify4(exec4);
+    const isWindows = process.platform === "win32";
+    const checkCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
+    await execAsync4(checkCmd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var TypeScriptServer = {
+  id: "typescript",
+  name: "TypeScript Language Server",
+  extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+  async spawn(root) {
+    const projectRoot = findNearestRoot(root, [
+      "package-lock.json",
+      "pnpm-lock.yaml",
+      "yarn.lock",
+      "bun.lockb",
+      "bun.lock"
+    ]) || root;
+    const hasNpx = await commandExists("npx");
+    const hasBunx = await commandExists("bunx");
+    const hasPnpx = await commandExists("pnpx");
+    let cmd;
+    if (hasPnpx) {
+      cmd = ["pnpx", "typescript-language-server", "--stdio"];
+    } else if (hasBunx) {
+      cmd = ["bunx", "typescript-language-server", "--stdio"];
+    } else if (hasNpx) {
+      cmd = ["npx", "typescript-language-server", "--stdio"];
+    } else {
+      console.warn("[lsp] No package runner (npx/bunx/pnpx) found for typescript-language-server");
+      return null;
+    }
+    try {
+      const proc = spawn(cmd[0], cmd.slice(1), {
+        cwd: projectRoot,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          // Suppress some noisy output
+          TSS_LOG: "-level none"
+        }
+      });
+      proc.stderr?.on("data", (data) => {
+        const msg = data.toString().trim();
+        if (msg && !msg.includes("deprecated")) {
+          console.debug("[lsp:typescript:stderr]", msg);
+        }
+      });
+      return {
+        process: proc,
+        initialization: {
+          // TypeScript-specific initialization options
+          preferences: {
+            includeInlayParameterNameHints: "none",
+            includeInlayPropertyDeclarationTypeHints: false,
+            includeInlayFunctionLikeReturnTypeHints: false
+          }
+        }
+      };
+    } catch (error) {
+      console.error("[lsp] Failed to spawn typescript-language-server:", error);
+      return null;
+    }
+  }
+};
+var servers = [
+  TypeScriptServer
+];
+function getServerForExtension(ext) {
+  for (const server of servers) {
+    if (server.extensions.includes(ext)) {
+      return server;
+    }
+  }
+  return null;
+}
+function getSupportedExtensions() {
+  const extensions = /* @__PURE__ */ new Set();
+  for (const server of servers) {
+    for (const ext of server.extensions) {
+      extensions.add(ext);
+    }
+  }
+  return Array.from(extensions);
+}
+
+// src/lsp/client.ts
+import {
+  createMessageConnection,
+  StreamMessageReader,
+  StreamMessageWriter
+} from "vscode-jsonrpc/node";
+import { pathToFileURL, fileURLToPath } from "url";
+import { readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { extname, normalize } from "path";
+function getLanguageId(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  const map = {
+    ".ts": "typescript",
+    ".tsx": "typescriptreact",
+    ".js": "javascript",
+    ".jsx": "javascriptreact",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    ".json": "json",
+    ".jsonc": "jsonc"
+  };
+  return map[ext] || "plaintext";
+}
+function normalizePath(filePath) {
+  return normalize(filePath);
+}
+async function createClient(serverId, handle, root) {
+  const { process: proc } = handle;
+  if (!proc.stdout || !proc.stdin) {
+    throw new Error("LSP server process has no stdout/stdin");
+  }
+  const connection = createMessageConnection(
+    new StreamMessageReader(proc.stdout),
+    new StreamMessageWriter(proc.stdin)
+  );
+  const diagnostics = /* @__PURE__ */ new Map();
+  const fileVersions = /* @__PURE__ */ new Map();
+  const diagnosticListeners = /* @__PURE__ */ new Map();
+  connection.onNotification("textDocument/publishDiagnostics", (params) => {
+    const filePath = normalizePath(fileURLToPath(params.uri));
+    diagnostics.set(filePath, params.diagnostics || []);
+    const listeners = diagnosticListeners.get(filePath);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener();
+      }
+    }
+  });
+  connection.onRequest("workspace/configuration", async (params) => {
+    return params.items.map(() => handle.initialization || {});
+  });
+  connection.onRequest("client/registerCapability", async () => {
+    return null;
+  });
+  connection.onRequest("window/workDoneProgress/create", async () => {
+    return null;
+  });
+  connection.onNotification("window/logMessage", (params) => {
+    if (params.type <= 2) {
+      console.debug(`[lsp:${serverId}]`, params.message);
+    }
+  });
+  connection.listen();
+  const initResult = await connection.sendRequest("initialize", {
+    processId: process.pid,
+    rootUri: pathToFileURL(root).href,
+    rootPath: root,
+    workspaceFolders: [
+      {
+        name: "workspace",
+        uri: pathToFileURL(root).href
+      }
+    ],
+    capabilities: {
+      textDocument: {
+        synchronization: {
+          dynamicRegistration: true,
+          willSave: false,
+          willSaveWaitUntil: false,
+          didSave: true
+        },
+        publishDiagnostics: {
+          relatedInformation: true,
+          versionSupport: true,
+          codeDescriptionSupport: true
+        },
+        completion: {
+          dynamicRegistration: true,
+          completionItem: {
+            snippetSupport: true,
+            documentationFormat: ["markdown", "plaintext"]
+          }
+        },
+        hover: {
+          dynamicRegistration: true,
+          contentFormat: ["markdown", "plaintext"]
+        },
+        definition: {
+          dynamicRegistration: true
+        },
+        references: {
+          dynamicRegistration: true
+        },
+        documentSymbol: {
+          dynamicRegistration: true
+        }
+      },
+      workspace: {
+        configuration: true,
+        didChangeConfiguration: {
+          dynamicRegistration: true
+        },
+        didChangeWatchedFiles: {
+          dynamicRegistration: true
+        },
+        workspaceFolders: true
+      }
+    },
+    initializationOptions: handle.initialization
+  });
+  await connection.sendNotification("initialized", {});
+  const client = {
+    serverId,
+    root,
+    diagnostics,
+    async notifyOpen(filePath) {
+      const normalized = normalizePath(filePath);
+      if (!existsSync6(normalized)) {
+        return;
+      }
+      try {
+        const content = await readFile4(normalized, "utf-8");
+        const version = (fileVersions.get(normalized) ?? -1) + 1;
+        fileVersions.set(normalized, version);
+        if (version === 0) {
+          await connection.sendNotification("textDocument/didOpen", {
+            textDocument: {
+              uri: pathToFileURL(normalized).href,
+              languageId: getLanguageId(normalized),
+              version,
+              text: content
+            }
+          });
+        } else {
+          await connection.sendNotification("textDocument/didChange", {
+            textDocument: {
+              uri: pathToFileURL(normalized).href,
+              version
+            },
+            contentChanges: [{ text: content }]
+          });
+        }
+      } catch (error) {
+        console.error("[lsp] Error notifying open:", error);
+      }
+    },
+    async notifyChange(filePath) {
+      const normalized = normalizePath(filePath);
+      if (!existsSync6(normalized)) {
+        return;
+      }
+      try {
+        const content = await readFile4(normalized, "utf-8");
+        const version = (fileVersions.get(normalized) ?? 0) + 1;
+        fileVersions.set(normalized, version);
+        await connection.sendNotification("textDocument/didChange", {
+          textDocument: {
+            uri: pathToFileURL(normalized).href,
+            version
+          },
+          contentChanges: [{ text: content }]
+        });
+      } catch (error) {
+        console.error("[lsp] Error notifying change:", error);
+      }
+    },
+    async notifyClose(filePath) {
+      const normalized = normalizePath(filePath);
+      fileVersions.delete(normalized);
+      diagnostics.delete(normalized);
+      try {
+        await connection.sendNotification("textDocument/didClose", {
+          textDocument: {
+            uri: pathToFileURL(normalized).href
+          }
+        });
+      } catch (error) {
+        console.error("[lsp] Error notifying close:", error);
+      }
+    },
+    async notifyWatchedFilesChanged(changes) {
+      try {
+        await connection.sendNotification("workspace/didChangeWatchedFiles", {
+          changes
+        });
+      } catch (error) {
+        console.error("[lsp] Error notifying watched files:", error);
+      }
+    },
+    async waitForDiagnostics(filePath, timeoutMs = 5e3) {
+      const normalized = normalizePath(filePath);
+      return new Promise((resolve8) => {
+        const startTime = Date.now();
+        let debounceTimer;
+        let resolved = false;
+        const cleanup = () => {
+          if (debounceTimer) clearTimeout(debounceTimer);
+          const listeners = diagnosticListeners.get(normalized);
+          if (listeners) {
+            const idx = listeners.indexOf(onDiagnostic);
+            if (idx >= 0) listeners.splice(idx, 1);
+            if (listeners.length === 0) {
+              diagnosticListeners.delete(normalized);
+            }
+          }
+        };
+        const finish = () => {
+          if (resolved) return;
+          resolved = true;
+          cleanup();
+          resolve8(diagnostics.get(normalized) || []);
+        };
+        const onDiagnostic = () => {
+          if (debounceTimer) clearTimeout(debounceTimer);
+          debounceTimer = setTimeout(finish, 150);
+        };
+        if (!diagnosticListeners.has(normalized)) {
+          diagnosticListeners.set(normalized, []);
+        }
+        diagnosticListeners.get(normalized).push(onDiagnostic);
+        setTimeout(() => {
+          if (!resolved) {
+            finish();
+          }
+        }, timeoutMs);
+        if (diagnostics.has(normalized)) {
+          onDiagnostic();
+        }
+      });
+    },
+    getDiagnostics(filePath) {
+      return diagnostics.get(normalizePath(filePath)) || [];
+    },
+    getAllDiagnostics() {
+      return new Map(diagnostics);
+    },
+    async shutdown() {
+      try {
+        await connection.sendRequest("shutdown");
+        await connection.sendNotification("exit");
+        connection.end();
+        connection.dispose();
+        proc.kill();
+      } catch (error) {
+        proc.kill("SIGKILL");
+      }
+    }
+  };
+  return client;
+}
+
+// src/lsp/types.ts
+function formatDiagnostic(diagnostic) {
+  const severity = {
+    [1 /* Error */]: "ERROR",
+    [2 /* Warning */]: "WARN",
+    [3 /* Information */]: "INFO",
+    [4 /* Hint */]: "HINT"
+  }[diagnostic.severity ?? 1 /* Error */];
+  const line = diagnostic.range.start.line + 1;
+  const col = diagnostic.range.start.character + 1;
+  const source = diagnostic.source ? ` [${diagnostic.source}]` : "";
+  return `${severity} [${line}:${col}]${source} ${diagnostic.message}`;
+}
+function formatDiagnosticsForAgent(filePath, diagnostics, options = {}) {
+  const { maxDiagnostics = 20, errorsOnly = true } = options;
+  const filtered = errorsOnly ? diagnostics.filter((d) => d.severity === 1 /* Error */) : diagnostics;
+  if (filtered.length === 0) return "";
+  const limited = filtered.slice(0, maxDiagnostics);
+  const suffix = filtered.length > maxDiagnostics ? `
+... and ${filtered.length - maxDiagnostics} more` : "";
+  const formatted = limited.map(formatDiagnostic).join("\n");
+  return `
+
+LSP errors detected in this file, please fix:
+<diagnostics file="${filePath}">
+${formatted}${suffix}
+</diagnostics>`;
+}
+
+// src/lsp/index.ts
+var state = {
+  clients: /* @__PURE__ */ new Map(),
+  broken: /* @__PURE__ */ new Set(),
+  initialized: false
+};
+async function getClientForFile(filePath) {
+  const normalized = normalizePath(filePath);
+  const ext = extname2(normalized);
+  const serverDef = getServerForExtension(ext);
+  if (!serverDef) {
+    return null;
+  }
+  const root = dirname4(normalized);
+  const key = `${serverDef.id}:${root}`;
+  const existing = state.clients.get(key);
+  if (existing) {
+    return existing;
+  }
+  if (state.broken.has(key)) {
+    return null;
+  }
+  try {
+    const handle = await serverDef.spawn(root);
+    if (!handle) {
+      state.broken.add(key);
+      return null;
+    }
+    console.log(`[lsp] Started ${serverDef.name} for ${root}`);
+    const client = await createClient(serverDef.id, handle, root);
+    state.clients.set(key, client);
+    handle.process.on("exit", (code) => {
+      console.log(`[lsp] ${serverDef.name} exited with code ${code}`);
+      state.clients.delete(key);
+    });
+    return client;
+  } catch (error) {
+    console.error(`[lsp] Failed to start ${serverDef.name}:`, error);
+    state.broken.add(key);
+    return null;
+  }
+}
+async function getClientsForFile(filePath) {
+  const client = await getClientForFile(filePath);
+  return client ? [client] : [];
+}
+async function touchFile(filePath, waitForDiagnostics = false) {
+  const clients = await getClientsForFile(filePath);
+  if (clients.length === 0) {
+    return;
+  }
+  await Promise.all(clients.map((client) => client.notifyOpen(filePath)));
+  if (waitForDiagnostics) {
+    await Promise.all(clients.map((client) => client.waitForDiagnostics(filePath)));
+  }
+}
+async function getDiagnostics(filePath) {
+  const normalized = normalizePath(filePath);
+  const clients = await getClientsForFile(normalized);
+  const allDiagnostics = [];
+  for (const client of clients) {
+    const diags = client.getDiagnostics(normalized);
+    allDiagnostics.push(...diags);
+  }
+  return allDiagnostics;
+}
+async function getAllDiagnostics() {
+  const results = {};
+  for (const client of state.clients.values()) {
+    const clientDiags = client.getAllDiagnostics();
+    for (const [path, diagnostics] of clientDiags.entries()) {
+      const existing = results[path] || [];
+      existing.push(...diagnostics);
+      results[path] = existing;
+    }
+  }
+  return results;
+}
+async function formatDiagnosticsOutput(filePath, options = {}) {
+  const diagnostics = await getDiagnostics(filePath);
+  return formatDiagnosticsForAgent(filePath, diagnostics, options);
+}
+function isSupported(filePath) {
+  const ext = extname2(filePath);
+  return getServerForExtension(ext) !== null;
+}
+
 // src/tools/write-file.ts
 var writeFileInputSchema = z4.object({
   path: z4.string().describe("The path to the file. Can be relative to working directory or absolute."),
@@ -1211,7 +1725,7 @@ Working directory: ${options.workingDirectory}`,
     inputSchema: writeFileInputSchema,
     execute: async ({ path, mode, content, old_string, new_string }) => {
       try {
-        const absolutePath = isAbsolute2(path) ? path : resolve4(options.workingDirectory, path);
+        const absolutePath = isAbsolute2(path) ? path : resolve5(options.workingDirectory, path);
         const relativePath = relative3(options.workingDirectory, absolutePath);
         if (relativePath.startsWith("..") && !isAbsolute2(path)) {
           return {
@@ -1227,12 +1741,17 @@ Working directory: ${options.workingDirectory}`,
             };
           }
           await backupFile(options.sessionId, options.workingDirectory, absolutePath);
-          const dir = dirname3(absolutePath);
-          if (!existsSync5(dir)) {
+          const dir = dirname5(absolutePath);
+          if (!existsSync7(dir)) {
             await mkdir3(dir, { recursive: true });
           }
-          const existed = existsSync5(absolutePath);
+          const existed = existsSync7(absolutePath);
           await writeFile3(absolutePath, content, "utf-8");
+          let diagnosticsOutput = "";
+          if (options.enableLSP !== false && isSupported(absolutePath)) {
+            await touchFile(absolutePath, true);
+            diagnosticsOutput = await formatDiagnosticsOutput(absolutePath);
+          }
           return {
             success: true,
             path: absolutePath,
@@ -1240,7 +1759,8 @@ Working directory: ${options.workingDirectory}`,
             mode: "full",
             action: existed ? "replaced" : "created",
             bytesWritten: Buffer.byteLength(content, "utf-8"),
-            lineCount: content.split("\n").length
+            lineCount: content.split("\n").length,
+            ...diagnosticsOutput && { diagnostics: diagnosticsOutput }
           };
         } else if (mode === "str_replace") {
           if (old_string === void 0 || new_string === void 0) {
@@ -1249,14 +1769,14 @@ Working directory: ${options.workingDirectory}`,
               error: 'Both old_string and new_string are required for "str_replace" mode'
             };
           }
-          if (!existsSync5(absolutePath)) {
+          if (!existsSync7(absolutePath)) {
             return {
               success: false,
               error: `File not found: ${path}. Use "full" mode to create new files.`
             };
           }
           await backupFile(options.sessionId, options.workingDirectory, absolutePath);
-          const currentContent = await readFile4(absolutePath, "utf-8");
+          const currentContent = await readFile5(absolutePath, "utf-8");
           if (!currentContent.includes(old_string)) {
             const lines = currentContent.split("\n");
             const preview = lines.slice(0, 20).join("\n");
@@ -1280,6 +1800,11 @@ Working directory: ${options.workingDirectory}`,
           await writeFile3(absolutePath, newContent, "utf-8");
           const oldLines = old_string.split("\n").length;
           const newLines = new_string.split("\n").length;
+          let diagnosticsOutput = "";
+          if (options.enableLSP !== false && isSupported(absolutePath)) {
+            await touchFile(absolutePath, true);
+            diagnosticsOutput = await formatDiagnosticsOutput(absolutePath);
+          }
           return {
             success: true,
             path: absolutePath,
@@ -1287,7 +1812,8 @@ Working directory: ${options.workingDirectory}`,
             mode: "str_replace",
             linesRemoved: oldLines,
             linesAdded: newLines,
-            lineDelta: newLines - oldLines
+            lineDelta: newLines - oldLines,
+            ...diagnosticsOutput && { diagnostics: diagnosticsOutput }
           };
         }
         return {
@@ -1434,9 +1960,9 @@ import { tool as tool5 } from "ai";
 import { z as z6 } from "zod";
 
 // src/skills/index.ts
-import { readFile as readFile5, readdir } from "fs/promises";
-import { resolve as resolve5, basename, extname } from "path";
-import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile6, readdir } from "fs/promises";
+import { resolve as resolve6, basename, extname as extname3 } from "path";
+import { existsSync as existsSync8 } from "fs";
 function parseSkillFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!frontmatterMatch) {
@@ -1464,18 +1990,18 @@ function parseSkillFrontmatter(content) {
   }
 }
 function getSkillNameFromPath(filePath) {
-  return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  return basename(filePath, extname3(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 async function loadSkillsFromDirectory(directory) {
-  if (!existsSync6(directory)) {
+  if (!existsSync8(directory)) {
     return [];
   }
   const skills = [];
   const files = await readdir(directory);
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = resolve5(directory, file);
-    const content = await readFile5(filePath, "utf-8");
+    const filePath = resolve6(directory, file);
+    const content = await readFile6(filePath, "utf-8");
     const parsed = parseSkillFrontmatter(content);
     if (parsed) {
       skills.push({
@@ -1517,7 +2043,7 @@ async function loadSkillContent(skillName, directories) {
   if (!skill) {
     return null;
   }
-  const content = await readFile5(skill.filePath, "utf-8");
+  const content = await readFile6(skill.filePath, "utf-8");
   const parsed = parseSkillFrontmatter(content);
   return {
     ...skill,
@@ -1615,6 +2141,199 @@ Once loaded, a skill's content will be available in the conversation context.`,
   });
 }
 
+// src/tools/linter.ts
+import { tool as tool6 } from "ai";
+import { z as z7 } from "zod";
+import { resolve as resolve7, relative as relative4, isAbsolute as isAbsolute3, extname as extname4 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { readdir as readdir2, stat as stat2 } from "fs/promises";
+var linterInputSchema = z7.object({
+  paths: z7.array(z7.string()).optional().describe("File or directory paths to check for lint errors. If not provided, returns diagnostics for all recently touched files."),
+  fix: z7.boolean().optional().default(false).describe("Reserved for future use: auto-fix lint errors (not yet implemented)")
+});
+async function findSupportedFiles(dir, workingDirectory, maxFiles = 50) {
+  const files = [];
+  const supportedExtensions = getSupportedExtensions();
+  async function walk(currentDir) {
+    if (files.length >= maxFiles) return;
+    try {
+      const entries = await readdir2(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (files.length >= maxFiles) break;
+        const fullPath = resolve7(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          if (["node_modules", ".git", "dist", "build", ".next", "coverage"].includes(entry.name)) {
+            continue;
+          }
+          await walk(fullPath);
+        } else if (entry.isFile()) {
+          const ext = extname4(entry.name);
+          if (supportedExtensions.includes(ext)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  await walk(dir);
+  return files;
+}
+function createLinterTool(options) {
+  return tool6({
+    description: `Check files for linting and type errors using the Language Server Protocol (LSP).
+
+Supports TypeScript, JavaScript, TSX, JSX files.
+
+Usage:
+- \`linter({})\` - Get diagnostics for all recently edited files
+- \`linter({ paths: ["src/app.ts"] })\` - Check specific files
+- \`linter({ paths: ["src/"] })\` - Check all supported files in a directory
+
+Returns detailed error information including line numbers, error messages, and severity.
+Use this after making changes to verify your code is correct, or proactively to find issues.
+
+Working directory: ${options.workingDirectory}`,
+    inputSchema: linterInputSchema,
+    execute: async ({ paths }) => {
+      try {
+        if (!paths || paths.length === 0) {
+          const allDiagnostics = await getAllDiagnostics();
+          if (Object.keys(allDiagnostics).length === 0) {
+            return {
+              success: true,
+              message: "No lint errors found. No files have been analyzed yet - specify paths to check specific files.",
+              files: [],
+              totalErrors: 0,
+              totalWarnings: 0
+            };
+          }
+          return formatDiagnosticsResult(allDiagnostics, options.workingDirectory);
+        }
+        const filesToCheck = [];
+        for (const path of paths) {
+          const absolutePath = isAbsolute3(path) ? path : resolve7(options.workingDirectory, path);
+          if (!existsSync9(absolutePath)) {
+            continue;
+          }
+          const stats = await stat2(absolutePath);
+          if (stats.isDirectory()) {
+            const dirFiles = await findSupportedFiles(absolutePath, options.workingDirectory);
+            filesToCheck.push(...dirFiles);
+          } else if (stats.isFile()) {
+            if (isSupported(absolutePath)) {
+              filesToCheck.push(absolutePath);
+            }
+          }
+        }
+        if (filesToCheck.length === 0) {
+          return {
+            success: true,
+            message: "No supported files found to check. Supported extensions: " + getSupportedExtensions().join(", "),
+            files: [],
+            totalErrors: 0,
+            totalWarnings: 0
+          };
+        }
+        await Promise.all(
+          filesToCheck.map((file) => touchFile(file, true))
+        );
+        const diagnosticsMap = {};
+        for (const file of filesToCheck) {
+          const diagnostics = await getDiagnostics(file);
+          if (diagnostics.length > 0) {
+            diagnosticsMap[file] = diagnostics;
+          }
+        }
+        return formatDiagnosticsResult(diagnosticsMap, options.workingDirectory);
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+function formatDiagnosticsResult(diagnosticsMap, workingDirectory) {
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let totalInfo = 0;
+  const files = [];
+  for (const [filePath, diagnostics] of Object.entries(diagnosticsMap)) {
+    const relativePath = relative4(workingDirectory, filePath);
+    let fileErrors = 0;
+    let fileWarnings = 0;
+    const formattedDiagnostics = diagnostics.map((d) => {
+      const severity = getSeverityString(d.severity);
+      if (d.severity === 1 /* Error */) {
+        fileErrors++;
+        totalErrors++;
+      } else if (d.severity === 2 /* Warning */) {
+        fileWarnings++;
+        totalWarnings++;
+      } else {
+        totalInfo++;
+      }
+      return {
+        severity,
+        line: d.range.start.line + 1,
+        column: d.range.start.character + 1,
+        message: d.message,
+        source: d.source,
+        code: d.code
+      };
+    });
+    files.push({
+      path: filePath,
+      relativePath,
+      errors: fileErrors,
+      warnings: fileWarnings,
+      diagnostics: formattedDiagnostics
+    });
+  }
+  files.sort((a, b) => b.errors - a.errors);
+  const hasIssues = totalErrors > 0 || totalWarnings > 0;
+  return {
+    success: true,
+    message: hasIssues ? `Found ${totalErrors} error(s) and ${totalWarnings} warning(s) in ${files.length} file(s).` : `No lint errors found in ${Object.keys(diagnosticsMap).length || "any"} file(s).`,
+    files,
+    totalErrors,
+    totalWarnings,
+    totalInfo,
+    summary: hasIssues ? formatSummary(files) : void 0
+  };
+}
+function getSeverityString(severity) {
+  switch (severity) {
+    case 1 /* Error */:
+      return "error";
+    case 2 /* Warning */:
+      return "warning";
+    case 3 /* Information */:
+      return "info";
+    case 4 /* Hint */:
+      return "hint";
+    default:
+      return "error";
+  }
+}
+function formatSummary(files) {
+  const lines = [];
+  for (const file of files) {
+    lines.push(`
+${file.relativePath}:`);
+    for (const d of file.diagnostics.slice(0, 10)) {
+      const prefix = d.severity === "error" ? "\u274C" : d.severity === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+      lines.push(`  ${prefix} [${d.line}:${d.column}] ${d.message}`);
+    }
+    if (file.diagnostics.length > 10) {
+      lines.push(`  ... and ${file.diagnostics.length - 10} more`);
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/tools/index.ts
 function createTools(options) {
   return {
@@ -1629,7 +2348,8 @@ function createTools(options) {
     }),
     write_file: createWriteFileTool({
       workingDirectory: options.workingDirectory,
-      sessionId: options.sessionId
+      sessionId: options.sessionId,
+      enableLSP: options.enableLSP ?? true
     }),
     todo: createTodoTool({
       sessionId: options.sessionId
@@ -1637,6 +2357,9 @@ function createTools(options) {
     load_skill: createLoadSkillTool({
       sessionId: options.sessionId,
       skillsDirectories: options.skillsDirectories
+    }),
+    linter: createLinterTool({
+      workingDirectory: options.workingDirectory
     })
   };
 }
@@ -1684,6 +2407,7 @@ You have access to powerful tools for:
 - **bash**: Execute commands in the terminal (see below for details)
 - **read_file**: Read file contents to understand code and context
 - **write_file**: Create new files or edit existing ones (supports targeted string replacement)
+- **linter**: Check files for type errors and lint issues (TypeScript, JavaScript, TSX, JSX)
 - **todo**: Manage your task list to track progress on complex operations
 - **load_skill**: Load specialized knowledge documents for specific tasks
 
@@ -1740,7 +2464,7 @@ bash({ id: "abc123", input: "my text" })  // send text input
 - Use \`key: "y"\` or \`key: "n"\` for yes/no prompts
 - Use \`input: "text"\` for text input prompts
 
-Logs are saved to \`.sparkecoder/terminals/{id}/output.log\` and can be read with \`read_file\` if needed.
+Terminal output is stored in the global SparkECoder data directory. Use the \`tail\` option to read recent output.
 
 ## Guidelines
 
@@ -1760,7 +2484,17 @@ Logs are saved to \`.sparkecoder/terminals/{id}/output.log\` and can be read wit
 - Use \`read_file\` to understand code before modifying
 - Use \`write_file\` with mode "str_replace" for targeted edits to existing files
 - Use \`write_file\` with mode "full" only for new files or complete rewrites
-- Always verify changes by reading files after modifications
+- After making changes, use the \`linter\` tool to check for type errors and lint issues
+- The \`write_file\` tool automatically shows lint errors in its output for TypeScript/JavaScript files
+
+### Linter Tool
+The linter tool uses Language Server Protocol (LSP) to detect type errors and lint issues:
+\`\`\`
+linter({})                           // Check all recently edited files
+linter({ paths: ["src/app.ts"] })    // Check specific files
+linter({ paths: ["src/"] })          // Check all files in a directory
+\`\`\`
+Use this proactively after making code changes to catch errors early.
 
 ### Searching and Exploration
 ${searchInstructions}
@@ -2110,9 +2844,9 @@ var Agent = class _Agent {
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool6({
+      wrappedTools[name] = tool7({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z7.object({}),
+        inputSchema: originalTool.inputSchema || z8.object({}),
         execute: async (input, toolOptions) => {
           const toolCallId = toolOptions.toolCallId || nanoid3();
           const execution = toolExecutionQueries.create({
@@ -2126,8 +2860,8 @@ var Agent = class _Agent {
           this.pendingApprovals.set(toolCallId, execution);
           options.onApprovalRequired?.(execution);
           sessionQueries.updateStatus(this.session.id, "waiting");
-          const approved = await new Promise((resolve6) => {
-            approvalResolvers.set(toolCallId, { resolve: resolve6, sessionId: this.session.id });
+          const approved = await new Promise((resolve8) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve8, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);