sparkecoder 0.1.9 → 0.1.11

package/dist/server/index.js

@@ -10,16 +10,16 @@ import { Hono as Hono5 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
-import { resolve as resolve6, dirname as dirname4, join as join3 } from "path";
-import { spawn } from "child_process";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3 } from "fs";
+import { resolve as resolve8, dirname as dirname6, join as join3 } from "path";
+import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/server/routes/sessions.ts
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/db/index.ts
 import Database from "better-sqlite3";
@@ -650,11 +650,11 @@ var fileBackupQueries = {
 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/config/index.ts
@@ -978,12 +978,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) {
@@ -1005,11 +1005,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, "'\\''")}'`;
@@ -1222,8 +1230,8 @@ async function listSessionTerminals(sessionId, workingDirectory) {
   const terminalsDir = join2(workingDirectory, LOG_BASE_DIR, sessionId, "terminals");
   const terminals3 = [];
   try {
-    const { readdir: readdir2 } = await import("fs/promises");
-    const entries = await readdir2(terminalsDir, { withFileTypes: true });
+    const { readdir: readdir3 } = await import("fs/promises");
+    const entries = await readdir3(terminalsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const meta = await getMeta(entry.name, workingDirectory, sessionId);
@@ -1373,7 +1381,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;
@@ -1612,9 +1620,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";
@@ -1803,6 +1811,501 @@ function clearCheckpointManager(sessionId) {
   activeManagers.delete(sessionId);
 }
 
+// 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: exec5 } = await import("child_process");
+    const { promisify: promisify5 } = await import("util");
+    const execAsync5 = promisify5(exec5);
+    const isWindows = process.platform === "win32";
+    const checkCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
+    await execAsync5(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((resolve9) => {
+        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();
+          resolve9(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."),
@@ -1832,7 +2335,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 {
@@ -1848,12 +2351,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,
@@ -1861,7 +2369,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) {
@@ -1870,14 +2379,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");
@@ -1901,6 +2410,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,
@@ -1908,7 +2422,8 @@ Working directory: ${options.workingDirectory}`,
             mode: "str_replace",
             linesRemoved: oldLines,
             linesAdded: newLines,
-            lineDelta: newLines - oldLines
+            lineDelta: newLines - oldLines,
+            ...diagnosticsOutput && { diagnostics: diagnosticsOutput }
           };
         }
         return {
@@ -2055,9 +2570,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) {
@@ -2085,18 +2600,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({
@@ -2138,7 +2653,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,
@@ -2236,6 +2751,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 {
@@ -2250,7 +2958,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
@@ -2258,6 +2967,9 @@ function createTools(options) {
     load_skill: createLoadSkillTool({
       sessionId: options.sessionId,
       skillsDirectories: options.skillsDirectories
+    }),
+    linter: createLinterTool({
+      workingDirectory: options.workingDirectory
     })
   };
 }
@@ -2305,6 +3017,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
 
@@ -2361,7 +3074,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
 
@@ -2381,7 +3094,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}
@@ -2731,9 +3454,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({
@@ -2747,8 +3470,8 @@ var Agent = class _Agent {
           this.pendingApprovals.set(toolCallId, execution);
           options.onApprovalRequired?.(execution);
           sessionQueries.updateStatus(this.session.id, "waiting");
-          const approved = await new Promise((resolve7) => {
-            approvalResolvers.set(toolCallId, { resolve: resolve7, sessionId: this.session.id });
+          const approved = await new Promise((resolve9) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve9, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
@@ -2843,18 +3566,18 @@ var Agent = class _Agent {
 
 // src/server/routes/sessions.ts
 var sessions2 = new Hono();
-var createSessionSchema = z8.object({
-  name: z8.string().optional(),
-  workingDirectory: z8.string().optional(),
-  model: z8.string().optional(),
-  toolApprovals: z8.record(z8.string(), z8.boolean()).optional()
+var createSessionSchema = z9.object({
+  name: z9.string().optional(),
+  workingDirectory: z9.string().optional(),
+  model: z9.string().optional(),
+  toolApprovals: z9.record(z9.string(), z9.boolean()).optional()
 });
-var paginationQuerySchema = z8.object({
-  limit: z8.string().optional(),
-  offset: z8.string().optional()
+var paginationQuerySchema = z9.object({
+  limit: z9.string().optional(),
+  offset: z9.string().optional()
 });
-var messagesQuerySchema = z8.object({
-  limit: z8.string().optional()
+var messagesQuerySchema = z9.object({
+  limit: z9.string().optional()
 });
 sessions2.get(
   "/",
@@ -2993,10 +3716,10 @@ sessions2.get("/:id/tools", async (c) => {
     count: executions.length
   });
 });
-var updateSessionSchema = z8.object({
-  model: z8.string().optional(),
-  name: z8.string().optional(),
-  toolApprovals: z8.record(z8.string(), z8.boolean()).optional()
+var updateSessionSchema = z9.object({
+  model: z9.string().optional(),
+  name: z9.string().optional(),
+  toolApprovals: z9.record(z9.string(), z9.boolean()).optional()
 });
 sessions2.patch(
   "/:id",
@@ -3197,7 +3920,7 @@ sessions2.get("/:id/diff/:filePath", async (c) => {
 // src/server/routes/agents.ts
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/server/resumable-stream.ts
 import { createResumableStreamContext } from "resumable-stream/generic";
@@ -3274,18 +3997,18 @@ var streamContext = createResumableStreamContext({
 // src/server/routes/agents.ts
 import { nanoid as nanoid4 } from "nanoid";
 var agents = new Hono2();
-var runPromptSchema = z9.object({
-  prompt: z9.string().min(1)
+var runPromptSchema = z10.object({
+  prompt: z10.string().min(1)
 });
-var quickStartSchema = z9.object({
-  prompt: z9.string().min(1),
-  name: z9.string().optional(),
-  workingDirectory: z9.string().optional(),
-  model: z9.string().optional(),
-  toolApprovals: z9.record(z9.string(), z9.boolean()).optional()
+var quickStartSchema = z10.object({
+  prompt: z10.string().min(1),
+  name: z10.string().optional(),
+  workingDirectory: z10.string().optional(),
+  model: z10.string().optional(),
+  toolApprovals: z10.record(z10.string(), z10.boolean()).optional()
 });
-var rejectSchema = z9.object({
-  reason: z9.string().optional()
+var rejectSchema = z10.object({
+  reason: z10.string().optional()
 }).optional();
 var streamAbortControllers = /* @__PURE__ */ new Map();
 function createAgentStreamProducer(sessionId, prompt, streamId) {
@@ -3846,7 +4569,7 @@ agents.post(
 // src/server/routes/health.ts
 import { Hono as Hono3 } from "hono";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var health = new Hono3();
 health.get("/", async (c) => {
   const config = getConfig();
@@ -3892,9 +4615,9 @@ health.get("/api-keys", async (c) => {
     supportedProviders: SUPPORTED_PROVIDERS
   });
 });
-var setApiKeySchema = z10.object({
-  provider: z10.string(),
-  apiKey: z10.string().min(1)
+var setApiKeySchema = z11.object({
+  provider: z11.string(),
+  apiKey: z11.string().min(1)
 });
 health.post(
   "/api-keys",
@@ -3933,12 +4656,12 @@ health.delete("/api-keys/:provider", async (c) => {
 // src/server/routes/terminals.ts
 import { Hono as Hono4 } from "hono";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var terminals2 = new Hono4();
-var spawnSchema = z11.object({
-  command: z11.string(),
-  cwd: z11.string().optional(),
-  name: z11.string().optional()
+var spawnSchema = z12.object({
+  command: z12.string(),
+  cwd: z12.string().optional(),
+  name: z12.string().optional()
 });
 terminals2.post(
   "/:sessionId/terminals",
@@ -4019,8 +4742,8 @@ terminals2.get("/:sessionId/terminals/:terminalId", async (c) => {
     // We don't track exit codes in tmux mode
   });
 });
-var logsQuerySchema = z11.object({
-  tail: z11.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
+var logsQuerySchema = z12.object({
+  tail: z12.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
 });
 terminals2.get(
   "/:sessionId/terminals/:terminalId/logs",
@@ -4044,8 +4767,8 @@ terminals2.get(
     });
   }
 );
-var killSchema = z11.object({
-  signal: z11.enum(["SIGTERM", "SIGKILL"]).optional()
+var killSchema = z12.object({
+  signal: z12.enum(["SIGTERM", "SIGKILL"]).optional()
 });
 terminals2.post(
   "/:sessionId/terminals/:terminalId/kill",
@@ -4059,8 +4782,8 @@ terminals2.post(
     return c.json({ success: true, message: "Terminal killed" });
   }
 );
-var writeSchema = z11.object({
-  input: z11.string()
+var writeSchema = z12.object({
+  input: z12.string()
 });
 terminals2.post(
   "/:sessionId/terminals/:terminalId/write",
@@ -4325,13 +5048,13 @@ var DEFAULT_WEB_PORT = 6969;
 var WEB_PORT_SEQUENCE = [6969, 6970, 6971, 6972, 6973, 6974, 6975, 6976, 6977, 6978];
 function getWebDirectory() {
   try {
-    const currentDir = dirname4(fileURLToPath(import.meta.url));
-    const webDir = resolve6(currentDir, "..", "web");
-    if (existsSync7(webDir) && existsSync7(join3(webDir, "package.json"))) {
+    const currentDir = dirname6(fileURLToPath2(import.meta.url));
+    const webDir = resolve8(currentDir, "..", "web");
+    if (existsSync10(webDir) && existsSync10(join3(webDir, "package.json"))) {
       return webDir;
     }
-    const altWebDir = resolve6(currentDir, "..", "..", "web");
-    if (existsSync7(altWebDir) && existsSync7(join3(altWebDir, "package.json"))) {
+    const altWebDir = resolve8(currentDir, "..", "..", "web");
+    if (existsSync10(altWebDir) && existsSync10(join3(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -4354,18 +5077,18 @@ async function isSparkcoderWebRunning(port) {
   }
 }
 function isPortInUse(port) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const server = createNetServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve7(true);
+        resolve9(true);
       } else {
-        resolve7(false);
+        resolve9(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve7(false);
+      resolve9(false);
     });
     server.listen(port, "0.0.0.0");
   });
@@ -4390,11 +5113,11 @@ async function findWebPort(preferredPort) {
 }
 function hasProductionBuild(webDir) {
   const buildIdPath = join3(webDir, ".next", "BUILD_ID");
-  return existsSync7(buildIdPath);
+  return existsSync10(buildIdPath);
 }
 function runCommand(command, args, cwd, env) {
-  return new Promise((resolve7) => {
-    const child = spawn(command, args, {
+  return new Promise((resolve9) => {
+    const child = spawn2(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env,
@@ -4408,10 +5131,10 @@ function runCommand(command, args, cwd, env) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve7({ success: code === 0, output });
+      resolve9({ success: code === 0, output });
     });
     child.on("error", (err) => {
-      resolve7({ success: false, output: err.message });
+      resolve9({ success: false, output: err.message });
     });
   });
 }
@@ -4426,13 +5149,15 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false) {
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const usePnpm = existsSync7(join3(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync7(join3(webDir, "package-lock.json"));
+  const usePnpm = existsSync10(join3(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync10(join3(webDir, "package-lock.json"));
   const pkgManager = usePnpm ? "pnpm" : useNpm ? "npm" : "npx";
   const { NODE_OPTIONS, TSX_TSCONFIG_PATH, ...cleanEnv } = process.env;
   const webEnv = {
     ...cleanEnv,
-    NEXT_PUBLIC_API_URL: `http://127.0.0.1:${apiPort}`
+    NEXT_PUBLIC_API_URL: `http://127.0.0.1:${apiPort}`,
+    PORT: String(actualPort)
+    // Next.js respects PORT env var
   };
   const isProduction = process.env.NODE_ENV === "production";
   let command;
@@ -4454,7 +5179,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false) {
     command = pkgManager;
     args = pkgManager === "npx" ? ["next", "dev", "-p", String(actualPort)] : ["run", "dev", "-p", String(actualPort)];
   }
-  const child = spawn(command, args, {
+  const child = spawn2(command, args, {
     cwd: webDir,
     stdio: ["ignore", "pipe", "pipe"],
     env: webEnv,
@@ -4465,10 +5190,10 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false) {
   let started = false;
   let exited = false;
   let exitCode = null;
-  const startedPromise = new Promise((resolve7) => {
+  const startedPromise = new Promise((resolve9) => {
     const timeout = setTimeout(() => {
       if (!started && !exited) {
-        resolve7(false);
+        resolve9(false);
       }
     }, startupTimeout);
     child.stdout?.on("data", (data) => {
@@ -4476,7 +5201,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false) {
       if (!started && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
         started = true;
         clearTimeout(timeout);
-        resolve7(true);
+        resolve9(true);
       }
     });
     child.stderr?.on("data", (data) => {
@@ -4488,14 +5213,14 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false) {
     child.on("error", (err) => {
       if (!quiet) console.error(`  \u274C Web UI spawn error: ${err.message}`);
       clearTimeout(timeout);
-      resolve7(false);
+      resolve9(false);
     });
     child.on("exit", (code) => {
       exited = true;
       exitCode = code;
       if (!started) {
         clearTimeout(timeout);
-        resolve7(false);
+        resolve9(false);
       }
       webUIProcess = null;
     });
@@ -4580,8 +5305,8 @@ async function startServer(options = {}) {
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync7(config.resolvedWorkingDirectory)) {
-    mkdirSync2(config.resolvedWorkingDirectory, { recursive: true });
+  if (!existsSync10(config.resolvedWorkingDirectory)) {
+    mkdirSync3(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
   initDatabase(config.resolvedDatabasePath);