codelantern-agent-cli 0.0.0-stage → 1.0.0

package/dist/chunk-Y3PEOLTZ.js

@@ -0,0 +1,2513 @@
+#!/usr/bin/env node
+
+// src/provider/errors.ts
+import pc from "picocolors";
+var MissingApiKeyError = class extends Error {
+  constructor() {
+    super(
+      `GEMINI_API_KEY environment variable is not configured.
+
+To resolve this:
+  1. Get a Gemini API key from https://aistudio.google.com/app/apikey
+  2. Set the environment variable in your terminal or shell profile:
+     export GEMINI_API_KEY="your-api-key-here"
+  3. Or run Code Lantern with the key prefixed:
+     GEMINI_API_KEY="your-key" lantern
+`
+    );
+    this.name = "MissingApiKeyError";
+  }
+};
+var RateLimitError = class extends Error {
+  constructor(message = "Gemini API rate limit exceeded.") {
+    super(`${message}
+Please wait a moment before trying again or check your API quota at https://aistudio.google.com/`);
+    this.name = "RateLimitError";
+  }
+};
+var GeminiProviderError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "GeminiProviderError";
+    this.statusCode = statusCode;
+  }
+};
+function formatErrorMessage(err) {
+  if (err instanceof MissingApiKeyError) {
+    return pc.red(err.message);
+  }
+  if (err instanceof RateLimitError) {
+    return pc.yellow(`\u26A0\uFE0F ${err.message}`);
+  }
+  if (err instanceof Error) {
+    const msg = err.message || "";
+    if (msg.includes("API_KEY_INVALID") || msg.includes("API key not valid")) {
+      return pc.red("Invalid Gemini API Key. Please verify your GEMINI_API_KEY at https://aistudio.google.com/app/apikey");
+    }
+    if (msg.includes("RESOURCE_EXHAUSTED") || msg.includes("429")) {
+      return pc.yellow("Rate limit / quota exceeded. Please wait a few seconds or check your quota limits.");
+    }
+    if (msg.includes("NOT_FOUND") || msg.includes("models/")) {
+      return pc.red(`Model not found or unavailable. Please check the requested model ID: ${msg}`);
+    }
+    return pc.red(`Gemini Error: ${msg}`);
+  }
+  return pc.red(`An unexpected error occurred: ${String(err)}`);
+}
+
+// src/provider/gemini.ts
+import { GoogleGenAI, Type } from "@google/genai";
+var GeminiProvider = class {
+  client = null;
+  apiKey = null;
+  constructor(apiKey) {
+    const key = apiKey || process.env.GEMINI_API_KEY;
+    if (key && key.trim().length > 0) {
+      this.apiKey = key.trim();
+      this.client = new GoogleGenAI({ apiKey: this.apiKey });
+    }
+  }
+  isConfigured() {
+    return Boolean(this.apiKey && this.client);
+  }
+  getMaskedKey() {
+    if (!this.apiKey) return "Not configured";
+    if (this.apiKey.length <= 8) return "********";
+    return `${this.apiKey.slice(0, 4)}...${this.apiKey.slice(-4)}`;
+  }
+  ensureClient() {
+    if (!this.client || !this.apiKey) {
+      const envKey = process.env.GEMINI_API_KEY;
+      if (envKey && envKey.trim().length > 0) {
+        this.apiKey = envKey.trim();
+        this.client = new GoogleGenAI({ apiKey: this.apiKey });
+        return this.client;
+      }
+      throw new MissingApiKeyError();
+    }
+    return this.client;
+  }
+  async streamGenerate(modelId, systemInstruction, history, tools, callbacks, options) {
+    const client = this.ensureClient();
+    const contents = this.convertHistoryToContents(history);
+    const functionDeclarations = this.convertToolsToDeclarations(tools);
+    const config = {
+      systemInstruction,
+      temperature: options?.temperature ?? 0.2
+    };
+    if (options?.maxOutputTokens) {
+      config.maxOutputTokens = options.maxOutputTokens;
+    }
+    const toolList = [];
+    if (functionDeclarations.length > 0) {
+      toolList.push({ functionDeclarations });
+    }
+    if (options?.enableSearchGrounding) {
+      toolList.push({ googleSearch: {} });
+    }
+    if (toolList.length > 0) {
+      config.tools = toolList;
+    }
+    let attempts = 0;
+    const maxAttempts = 3;
+    let lastError = null;
+    while (attempts < maxAttempts) {
+      try {
+        attempts++;
+        const responseStream = await client.models.generateContentStream({
+          model: modelId,
+          contents,
+          config
+        });
+        let fullText = "";
+        const collectedToolCalls = [];
+        const usage = {
+          promptTokens: 0,
+          candidatesTokens: 0,
+          totalTokens: 0
+        };
+        for await (const chunk of responseStream) {
+          if (chunk.text) {
+            fullText += chunk.text;
+            if (callbacks.onChunk) {
+              callbacks.onChunk(chunk.text);
+            }
+          }
+          if (chunk.functionCalls && chunk.functionCalls.length > 0) {
+            for (const fc of chunk.functionCalls) {
+              collectedToolCalls.push({
+                id: fc.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+                name: fc.name || "",
+                args: fc.args || {}
+              });
+            }
+          }
+          if (chunk.usageMetadata) {
+            usage.promptTokens = chunk.usageMetadata.promptTokenCount ?? usage.promptTokens;
+            usage.candidatesTokens = chunk.usageMetadata.candidatesTokenCount ?? usage.candidatesTokens;
+            usage.totalTokens = chunk.usageMetadata.totalTokenCount ?? usage.totalTokens;
+            if (callbacks.onUsage) {
+              callbacks.onUsage(usage);
+            }
+          }
+        }
+        if (callbacks.onToolCalls && collectedToolCalls.length > 0) {
+          callbacks.onToolCalls(collectedToolCalls);
+        }
+        return {
+          text: fullText,
+          toolCalls: collectedToolCalls,
+          usage
+        };
+      } catch (err) {
+        lastError = err;
+        const msg = String(err?.message || err);
+        if (msg.includes("API_KEY_INVALID") || msg.includes("401") || msg.includes("403")) {
+          throw new GeminiProviderError(`Authentication failed: ${msg}`, 401);
+        }
+        const isRateLimit = msg.includes("429") || msg.includes("RESOURCE_EXHAUSTED");
+        const isTransient = msg.includes("503") || msg.includes("overloaded") || msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT");
+        if ((isRateLimit || isTransient) && attempts < maxAttempts) {
+          const delay = Math.pow(2, attempts) * 1e3 + Math.random() * 500;
+          await new Promise((r) => setTimeout(r, delay));
+          continue;
+        }
+        if (isRateLimit) {
+          throw new RateLimitError(msg);
+        }
+        throw new GeminiProviderError(`Gemini request failed: ${msg}`);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+  convertHistoryToContents(turns) {
+    const contents = [];
+    for (const turn of turns) {
+      const parts = [];
+      if (turn.role === "user") {
+        if (turn.text) {
+          parts.push({ text: turn.text });
+        }
+        if (turn.attachments && turn.attachments.length > 0) {
+          for (const att of turn.attachments) {
+            if (att.base64Data && att.mimeType) {
+              parts.push({
+                inlineData: {
+                  mimeType: att.mimeType,
+                  data: att.base64Data
+                }
+              });
+            } else if (att.textContent) {
+              parts.push({
+                text: `[Attached File: ${att.name}]
+\`\`\`
+${att.textContent}
+\`\`\``
+              });
+            }
+          }
+        }
+        if (parts.length > 0) {
+          contents.push({ role: "user", parts });
+        }
+      } else if (turn.role === "model") {
+        if (turn.text) {
+          parts.push({ text: turn.text });
+        }
+        if (turn.toolCalls && turn.toolCalls.length > 0) {
+          for (const tc of turn.toolCalls) {
+            parts.push({
+              functionCall: {
+                id: tc.id,
+                name: tc.name,
+                args: tc.args
+              }
+            });
+          }
+        }
+        if (parts.length > 0) {
+          contents.push({ role: "model", parts });
+        }
+      } else if (turn.role === "tool") {
+        if (turn.toolResults && turn.toolResults.length > 0) {
+          for (const res of turn.toolResults) {
+            parts.push({
+              functionResponse: {
+                id: res.callId,
+                name: res.name,
+                response: {
+                  result: res.error ? { error: res.error } : res.result
+                }
+              }
+            });
+          }
+        }
+        if (parts.length > 0) {
+          contents.push({ role: "tool", parts });
+        }
+      }
+    }
+    return contents;
+  }
+  convertToolsToDeclarations(tools) {
+    return tools.map((tool) => {
+      const properties = {};
+      for (const [propName, propDef] of Object.entries(tool.parameters.properties)) {
+        let typeVal = Type.STRING;
+        switch (propDef.type) {
+          case "number":
+          case "integer":
+            typeVal = Type.NUMBER;
+            break;
+          case "boolean":
+            typeVal = Type.BOOLEAN;
+            break;
+          case "array":
+            typeVal = Type.ARRAY;
+            break;
+          case "object":
+            typeVal = Type.OBJECT;
+            break;
+          default:
+            typeVal = Type.STRING;
+        }
+        properties[propName] = {
+          type: typeVal,
+          description: propDef.description,
+          ...propDef.enum ? { enum: propDef.enum } : {},
+          ...propDef.items ? { items: { type: Type.STRING } } : {}
+        };
+      }
+      return {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: Type.OBJECT,
+          properties,
+          required: tool.parameters.required || []
+        }
+      };
+    });
+  }
+};
+
+// src/security/secrets.ts
+import path from "path";
+var SECRET_FILE_PATTERNS = [
+  /^\.env(\..+)?$/i,
+  /\.pem$/i,
+  /\.key$/i,
+  /\.pfx$/i,
+  /\.p12$/i,
+  /^id_rsa/i,
+  /^id_dsa/i,
+  /^id_ecdsa/i,
+  /^id_ed25519/i,
+  /service[_-]?account.*\.json$/i,
+  /credentials.*\.json$/i,
+  /\.keystore$/i,
+  /\.token$/i,
+  /\.secret/i
+];
+function isSecretFile(filePath) {
+  const base = path.basename(filePath);
+  return SECRET_FILE_PATTERNS.some((pattern) => pattern.test(base));
+}
+function sanitizeSecrets(text) {
+  if (!text) return text;
+  let sanitized = text;
+  sanitized = sanitized.replace(/AIza[0-9A-Za-z\-_]{30,40}/g, "AIza***********************************");
+  sanitized = sanitized.replace(/ghp_[0-9a-zA-Z]{36}/g, "ghp_************************************");
+  sanitized = sanitized.replace(/github_pat_[0-9a-zA-Z_]{82}/g, "github_pat_**********************************************************************************");
+  const currentKey = process.env.GEMINI_API_KEY;
+  if (currentKey && currentKey.length > 5) {
+    sanitized = sanitized.split(currentKey).join("[REDACTED_GEMINI_API_KEY]");
+  }
+  return sanitized;
+}
+
+// src/security/sandbox.ts
+import path2 from "path";
+import fs from "fs";
+var isWindows = process.platform === "win32";
+function normalizeForComparison(p) {
+  const resolved = path2.resolve(p);
+  return isWindows ? resolved.toLowerCase() : resolved;
+}
+function isContainedWithin(parent, target) {
+  const normParent = normalizeForComparison(parent);
+  const normTarget = normalizeForComparison(target);
+  const rel = path2.relative(normParent, normTarget);
+  return !rel.startsWith("..") && !path2.isAbsolute(rel);
+}
+function validateWorkspacePath(targetPath, workspaceDir, allowedExternalPaths = []) {
+  if (!targetPath || typeof targetPath !== "string") {
+    return {
+      allowed: false,
+      resolvedPath: "",
+      relativePath: "",
+      reason: "Empty or invalid file path provided."
+    };
+  }
+  let normalizedWorkspace = path2.resolve(workspaceDir);
+  try {
+    if (fs.existsSync(normalizedWorkspace)) {
+      normalizedWorkspace = fs.realpathSync(normalizedWorkspace);
+    }
+  } catch {
+  }
+  const resolvedTarget = path2.isAbsolute(targetPath) ? path2.resolve(targetPath) : path2.resolve(normalizedWorkspace, targetPath);
+  const isExplicitlyAllowed = allowedExternalPaths.some((p) => {
+    const normAllowed = normalizeForComparison(p);
+    const normTarget = normalizeForComparison(resolvedTarget);
+    return normAllowed === normTarget;
+  });
+  if (isExplicitlyAllowed) {
+    return {
+      allowed: true,
+      resolvedPath: resolvedTarget,
+      relativePath: path2.relative(normalizedWorkspace, resolvedTarget) || path2.basename(resolvedTarget)
+    };
+  }
+  if (!isContainedWithin(normalizedWorkspace, resolvedTarget)) {
+    return {
+      allowed: false,
+      resolvedPath: resolvedTarget,
+      relativePath: path2.relative(normalizedWorkspace, resolvedTarget),
+      reason: `Path '${targetPath}' is outside the authorized workspace: ${normalizedWorkspace}`
+    };
+  }
+  try {
+    if (fs.existsSync(resolvedTarget)) {
+      const realTarget = fs.realpathSync(resolvedTarget);
+      if (!isContainedWithin(normalizedWorkspace, realTarget)) {
+        return {
+          allowed: false,
+          resolvedPath: realTarget,
+          relativePath: path2.relative(normalizedWorkspace, realTarget),
+          reason: `Symlink target points outside the workspace: ${realTarget}`
+        };
+      }
+    }
+  } catch {
+  }
+  if (isSecretFile(resolvedTarget)) {
+    return {
+      allowed: false,
+      resolvedPath: resolvedTarget,
+      relativePath: path2.relative(normalizedWorkspace, resolvedTarget),
+      reason: `Access to secret or credential file '${path2.basename(resolvedTarget)}' is blocked for security.`
+    };
+  }
+  return {
+    allowed: true,
+    resolvedPath: resolvedTarget,
+    relativePath: path2.relative(normalizedWorkspace, resolvedTarget) || "."
+  };
+}
+
+// src/approval/diffViewer.ts
+import * as Diff from "diff";
+import pc2 from "picocolors";
+function formatTerminalDiff(filePath, oldContent, newContent, contextLines = 3) {
+  const normalizedOld = oldContent.replace(/\r\n/g, "\n");
+  const normalizedNew = newContent.replace(/\r\n/g, "\n");
+  const patch = Diff.createPatch(filePath, normalizedOld, normalizedNew, "Original", "Modified", {
+    context: contextLines
+  });
+  const lines = patch.split("\n");
+  const formatted = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("---") || line.startsWith("+++")) {
+      formatted.push(pc2.bold(pc2.cyan(line)));
+    } else if (line.startsWith("@@")) {
+      formatted.push(pc2.magenta(line));
+    } else if (line.startsWith("+")) {
+      formatted.push(pc2.green(line));
+    } else if (line.startsWith("-")) {
+      formatted.push(pc2.red(line));
+    } else {
+      formatted.push(pc2.dim(line));
+    }
+  }
+  return formatted.join("\n");
+}
+function formatNewFilePreview(filePath, content, maxPreviewLines = 30) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
+  const preview = lines.slice(0, maxPreviewLines).map((line, idx) => {
+    const lineNum = String(idx + 1).padStart(4, " ");
+    return `${pc2.dim(lineNum)} ${pc2.green("+")} ${pc2.green(line)}`;
+  });
+  if (lines.length > maxPreviewLines) {
+    preview.push(pc2.dim(`    ... and ${lines.length - maxPreviewLines} more lines`));
+  }
+  return [
+    pc2.bold(pc2.cyan(`+++ Create new file: ${filePath} (${lines.length} lines)`)),
+    ...preview
+  ].join("\n");
+}
+
+// src/security/commandGuard.ts
+var DESTRUCTIVE_PATTERNS = [
+  // Unix root/home deletion
+  { regex: /\brm\s+-[rf]{1,2}\s+([/~]|\$HOME|\.\.\/|\.\.\\)/i, reason: "Attempt to delete root, home, or parent directories." },
+  { regex: /\brm\s+-[rf]{1,2}\s+\*\s*$/i, reason: "Attempt to recursively delete everything in directory." },
+  // Unix filesystem destruction
+  { regex: /\bmkfs(\.\w+)?\b/i, reason: "Filesystem format commands are forbidden." },
+  { regex: /\bdd\s+.*of=\/dev\/(r?[shv]d[a-z]|disk|nvme)/i, reason: "Direct disk write commands are forbidden." },
+  { regex: /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/, reason: "Fork bombs are strictly blocked." },
+  { regex: /\b(shutdown|reboot|poweroff|init\s+0)\b/i, reason: "System shutdown/reboot commands are forbidden." },
+  { regex: /\bchmod\s+-[rR]\s+777\s+([/~]|\$HOME)/i, reason: "Dangerous permissions modification at root/home." },
+  // Windows destructive commands
+  { regex: /\bformat\s+[a-z]:/i, reason: "Disk format command is forbidden." },
+  { regex: /\b(del|erase)\s+.*\/s.*\/q.*[a-z]:\\/i, reason: "Recursive deletion of root Windows drive is forbidden." },
+  { regex: /\b(rd|rmdir)\s+.*\/s.*\/q.*[a-z]:\\/i, reason: "Recursive removal of root Windows drive is forbidden." },
+  { regex: /\bRemove-Item\s+.*-Recurse\s+.*[a-z]:\\/i, reason: "Recursive PowerShell deletion of drive root is forbidden." }
+];
+function validateCommand(command) {
+  if (!command || command.trim().length === 0) {
+    return { allowed: false, reason: "Empty command string." };
+  }
+  const trimmed = command.trim();
+  for (const check of DESTRUCTIVE_PATTERNS) {
+    if (check.regex.test(trimmed)) {
+      return {
+        allowed: false,
+        reason: `Blocked dangerous command pattern: ${check.reason}`
+      };
+    }
+  }
+  const isPublishOrPush = /\b(npm\s+publish|git\s+push|docker\s+push)\b/i.test(trimmed);
+  return {
+    allowed: true,
+    isHighRisk: isPublishOrPush
+  };
+}
+
+// src/tools/fsTools.ts
+import fs2 from "fs";
+import path3 from "path";
+var readFileTool = {
+  definition: {
+    name: "read_file",
+    description: "Read the contents of a text file inside the workspace. Optionally specify a line range.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path of the file to read within the workspace."
+        },
+        start_line: {
+          type: "integer",
+          description: "Optional 1-indexed start line number to read from."
+        },
+        end_line: {
+          type: "integer",
+          description: "Optional 1-indexed end line number to read until (inclusive)."
+        }
+      },
+      required: ["path"]
+    }
+  },
+  async execute(args, context) {
+    const rawPath = String(args.path || "").trim();
+    const validation = validateWorkspacePath(rawPath, context.workspace);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        output: `Error: Access denied. ${validation.reason}`,
+        error: validation.reason
+      };
+    }
+    if (!fs2.existsSync(validation.resolvedPath)) {
+      return {
+        success: false,
+        output: `Error: File not found at '${validation.relativePath}'`,
+        error: "File not found"
+      };
+    }
+    const stat = fs2.statSync(validation.resolvedPath);
+    if (!stat.isFile()) {
+      return {
+        success: false,
+        output: `Error: Path is a directory, not a file: '${validation.relativePath}'`,
+        error: "Path is a directory"
+      };
+    }
+    if (stat.size > 1024 * 1024) {
+      return {
+        success: false,
+        output: `Error: File is too large to read entirely (${(stat.size / 1024).toFixed(0)}KB). Please specify start_line and end_line.`,
+        error: "File too large"
+      };
+    }
+    try {
+      const content = fs2.readFileSync(validation.resolvedPath, "utf8");
+      const lines = content.split("\n");
+      const totalLines = lines.length;
+      let start = 1;
+      let end = totalLines;
+      if (typeof args.start_line === "number" && args.start_line > 0) {
+        start = Math.max(1, Math.min(args.start_line, totalLines));
+      }
+      if (typeof args.end_line === "number" && args.end_line >= start) {
+        end = Math.min(args.end_line, totalLines);
+      }
+      const selectedLines = lines.slice(start - 1, end);
+      const numberedLines = selectedLines.map((line, idx) => {
+        const lineNum = String(start + idx).padStart(4, " ");
+        return `${lineNum} | ${line}`;
+      });
+      const output = [
+        `File: ${validation.relativePath} (${start}-${end} of ${totalLines} lines)`,
+        "```",
+        ...numberedLines,
+        "```"
+      ].join("\n");
+      return {
+        success: true,
+        output,
+        metadata: {
+          path: validation.relativePath,
+          startLine: start,
+          endLine: end,
+          totalLines
+        }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error reading file: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var writeFileTool = {
+  definition: {
+    name: "write_file",
+    description: "Create a new file or completely overwrite an existing file with the provided content.",
+    readOnly: false,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path of the file to create or overwrite."
+        },
+        content: {
+          type: "string",
+          description: "The complete text content to write to the file."
+        }
+      },
+      required: ["path", "content"]
+    }
+  },
+  async execute(args, context) {
+    const rawPath = String(args.path || "").trim();
+    const content = String(args.content ?? "");
+    const validation = validateWorkspacePath(rawPath, context.workspace);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        output: `Error: Access denied. ${validation.reason}`,
+        error: validation.reason
+      };
+    }
+    const fileExists = fs2.existsSync(validation.resolvedPath);
+    let oldContent = "";
+    if (fileExists) {
+      try {
+        oldContent = fs2.readFileSync(validation.resolvedPath, "utf8");
+      } catch {
+        oldContent = "";
+      }
+    }
+    const approved = await context.requestApproval({
+      type: "file_write",
+      summary: fileExists ? `Overwrite existing file: ${validation.relativePath}` : `Create new file: ${validation.relativePath}`,
+      details: {
+        path: validation.relativePath,
+        before: oldContent,
+        after: content,
+        diff: fileExists ? formatTerminalDiff(validation.relativePath, oldContent, content) : formatNewFilePreview(validation.relativePath, content)
+      }
+    });
+    if (!approved) {
+      return {
+        success: false,
+        output: `Write rejected: User declined approval to write '${validation.relativePath}'.`,
+        error: "Approval rejected"
+      };
+    }
+    try {
+      const parentDir = path3.dirname(validation.resolvedPath);
+      if (!fs2.existsSync(parentDir)) {
+        fs2.mkdirSync(parentDir, { recursive: true });
+      }
+      fs2.writeFileSync(validation.resolvedPath, content, "utf8");
+      const lines = content.split("\n").length;
+      return {
+        success: true,
+        output: `Successfully wrote ${lines} lines to ${validation.relativePath}`,
+        metadata: { path: validation.relativePath, lines }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Failed to write file: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var editFileTool = {
+  definition: {
+    name: "edit_file",
+    description: "Propose and apply a focused edit by replacing exact existing text with new replacement text.",
+    readOnly: false,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path of the file to edit."
+        },
+        target: {
+          type: "string",
+          description: "The exact string in the file to be replaced. Must match character-for-character including indentation."
+        },
+        replacement: {
+          type: "string",
+          description: "The replacement string to insert in place of target."
+        }
+      },
+      required: ["path", "target", "replacement"]
+    }
+  },
+  async execute(args, context) {
+    const rawPath = String(args.path || "").trim();
+    const target = String(args.target ?? "");
+    const replacement = String(args.replacement ?? "");
+    const validation = validateWorkspacePath(rawPath, context.workspace);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        output: `Error: Access denied. ${validation.reason}`,
+        error: validation.reason
+      };
+    }
+    if (!fs2.existsSync(validation.resolvedPath)) {
+      return {
+        success: false,
+        output: `Error: File not found at '${validation.relativePath}'`,
+        error: "File not found"
+      };
+    }
+    try {
+      const original = fs2.readFileSync(validation.resolvedPath, "utf8");
+      const hasCrlf = original.includes("\r\n");
+      let matchedTarget = target;
+      if (!original.includes(target)) {
+        if (hasCrlf && !target.includes("\r\n")) {
+          const crlfTarget = target.replace(/\n/g, "\r\n");
+          if (original.includes(crlfTarget)) {
+            matchedTarget = crlfTarget;
+          }
+        } else if (!hasCrlf && target.includes("\r\n")) {
+          const lfTarget = target.replace(/\r\n/g, "\n");
+          if (original.includes(lfTarget)) {
+            matchedTarget = lfTarget;
+          }
+        }
+      }
+      if (!original.includes(matchedTarget)) {
+        return {
+          success: false,
+          output: `Error: Target string not found in ${validation.relativePath}. Please verify whitespace, indentation, or read the file again to confirm line contents.`,
+          error: "Target string not found"
+        };
+      }
+      const occurrences = original.split(matchedTarget).length - 1;
+      if (occurrences > 1) {
+        return {
+          success: false,
+          output: `Warning: Target string appears ${occurrences} times in ${validation.relativePath}. Please provide more surrounding context in 'target' to make the match unique.`,
+          error: "Target string ambiguous"
+        };
+      }
+      const matchedReplacement = hasCrlf && !replacement.includes("\r\n") ? replacement.replace(/\n/g, "\r\n") : replacement;
+      const updated = original.replace(matchedTarget, matchedReplacement);
+      const approved = await context.requestApproval({
+        type: "file_edit",
+        summary: `Edit file: ${validation.relativePath}`,
+        details: {
+          path: validation.relativePath,
+          before: original,
+          after: updated,
+          diff: formatTerminalDiff(validation.relativePath, original, updated)
+        }
+      });
+      if (!approved) {
+        return {
+          success: false,
+          output: `Edit rejected: User declined approval to edit '${validation.relativePath}'.`,
+          error: "Approval rejected"
+        };
+      }
+      fs2.writeFileSync(validation.resolvedPath, updated, "utf8");
+      return {
+        success: true,
+        output: `Successfully applied edit to ${validation.relativePath}`,
+        metadata: { path: validation.relativePath }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Failed to edit file: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/tools/searchTools.ts
+import fs3 from "fs";
+import path4 from "path";
+import fg from "fast-glob";
+import ignore from "ignore";
+var DEFAULT_IGNORED_DIRS = [
+  "node_modules",
+  ".git",
+  ".codelantern",
+  ".lantern",
+  ".orbit",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".next",
+  ".cache",
+  ".gemini",
+  ".vscode",
+  ".idea"
+];
+function getWorkspaceIgnore(workspaceDir) {
+  const ig = ignore();
+  ig.add(DEFAULT_IGNORED_DIRS);
+  const gitignorePath = path4.join(workspaceDir, ".gitignore");
+  if (fs3.existsSync(gitignorePath)) {
+    try {
+      const gitignoreContent = fs3.readFileSync(gitignorePath, "utf8");
+      ig.add(gitignoreContent);
+    } catch {
+    }
+  }
+  return ig;
+}
+var listDirectoryTool = {
+  definition: {
+    name: "list_directory",
+    description: "List the contents of a directory in the workspace, respecting ignore rules.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path of directory to inspect. Omit or pass empty for workspace root."
+        },
+        depth: {
+          type: "integer",
+          description: "Maximum depth of recursion (default 1, max 4)."
+        }
+      }
+    }
+  },
+  async execute(args, context) {
+    const rawPath = String(args.path || "").trim();
+    let realWorkspace = path4.resolve(context.workspace);
+    try {
+      if (fs3.existsSync(realWorkspace)) realWorkspace = fs3.realpathSync(realWorkspace);
+    } catch {
+    }
+    const validation = validateWorkspacePath(rawPath || ".", realWorkspace);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        output: `Error: Access denied. ${validation.reason}`,
+        error: validation.reason
+      };
+    }
+    if (!fs3.existsSync(validation.resolvedPath)) {
+      return {
+        success: false,
+        output: `Directory not found: ${validation.relativePath || "."}`,
+        error: "Not found"
+      };
+    }
+    const maxDepth = Math.min(Math.max(1, Number(args.depth) || 1), 4);
+    const ig = getWorkspaceIgnore(realWorkspace);
+    try {
+      let walk2 = function(currentDir, currentDepth) {
+        if (currentDepth > maxDepth) return;
+        const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path4.join(currentDir, entry.name);
+          const relToWorkspace = path4.relative(realWorkspace, fullPath).replace(/\\/g, "/");
+          if (ig.ignores(relToWorkspace) || DEFAULT_IGNORED_DIRS.includes(entry.name)) {
+            continue;
+          }
+          const prefix = "  ".repeat(currentDepth - 1);
+          if (entry.isDirectory()) {
+            results.push(`${prefix}\u{1F4C1} ${entry.name}/`);
+            walk2(fullPath, currentDepth + 1);
+          } else {
+            results.push(`${prefix}\u{1F4C4} ${entry.name}`);
+          }
+        }
+      };
+      var walk = walk2;
+      const results = [];
+      walk2(validation.resolvedPath, 1);
+      return {
+        success: true,
+        output: results.length > 0 ? results.join("\n") : "(empty directory)",
+        metadata: { count: results.length }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error listing directory: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var fileSearchTool = {
+  definition: {
+    name: "file_search",
+    description: "Find files matching a glob pattern or partial filename across the project workspace.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: 'Glob pattern (e.g. "**/*.ts", "src/**/*.json", "*config*").'
+        },
+        directory: {
+          type: "string",
+          description: "Subdirectory to search inside. Defaults to workspace root."
+        }
+      },
+      required: ["pattern"]
+    }
+  },
+  async execute(args, context) {
+    const rawPattern = String(args.pattern || "").trim();
+    if (!rawPattern) {
+      return { success: false, output: "Pattern parameter is required.", error: "Missing pattern" };
+    }
+    let realWorkspace = path4.resolve(context.workspace);
+    try {
+      if (fs3.existsSync(realWorkspace)) realWorkspace = fs3.realpathSync(realWorkspace);
+    } catch {
+    }
+    const subDir = String(args.directory || "").trim();
+    const searchRoot = subDir ? path4.resolve(realWorkspace, subDir) : realWorkspace;
+    const validation = validateWorkspacePath(path4.relative(realWorkspace, searchRoot) || ".", realWorkspace);
+    if (!validation.allowed) {
+      return { success: false, output: `Access denied: ${validation.reason}`, error: validation.reason };
+    }
+    try {
+      const normalizedSearchRoot = searchRoot.replace(/\\/g, "/");
+      const normalizedPattern = rawPattern.replace(/\\/g, "/");
+      const globPattern = normalizedPattern.includes("/") ? normalizedPattern : `**/*${normalizedPattern}*`;
+      const matches = await fg(globPattern, {
+        cwd: normalizedSearchRoot,
+        dot: false,
+        ignore: DEFAULT_IGNORED_DIRS.map((d) => `**/${d}/**`),
+        onlyFiles: true
+      });
+      const ig = getWorkspaceIgnore(realWorkspace);
+      const filtered = matches.filter((m) => {
+        const full = path4.join(searchRoot, m);
+        const rel = path4.relative(realWorkspace, full).replace(/\\/g, "/");
+        return !ig.ignores(rel);
+      });
+      if (filtered.length === 0) {
+        return {
+          success: true,
+          output: `No files found matching '${rawPattern}' in ${subDir || "workspace"}.`
+        };
+      }
+      return {
+        success: true,
+        output: filtered.slice(0, 100).join("\n") + (filtered.length > 100 ? `
+... and ${filtered.length - 100} more matches` : ""),
+        metadata: { total: filtered.length }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error during file search: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var grepSearchTool = {
+  definition: {
+    name: "grep_search",
+    description: "Search for text or regex patterns within project files.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search string or regular expression to search for."
+        },
+        path_pattern: {
+          type: "string",
+          description: 'Optional glob pattern to restrict files searched (e.g. "*.ts", "src/**/*.js").'
+        }
+      },
+      required: ["query"]
+    }
+  },
+  async execute(args, context) {
+    const query = String(args.query || "").trim();
+    if (!query) {
+      return { success: false, output: "Query parameter is required.", error: "Missing query" };
+    }
+    let realWorkspace = path4.resolve(context.workspace);
+    try {
+      if (fs3.existsSync(realWorkspace)) realWorkspace = fs3.realpathSync(realWorkspace);
+    } catch {
+    }
+    const pathPattern = args.path_pattern ? String(args.path_pattern).replace(/\\/g, "/") : "**/*";
+    try {
+      const normalizedCwd = realWorkspace.replace(/\\/g, "/");
+      const files = await fg(pathPattern, {
+        cwd: normalizedCwd,
+        dot: false,
+        ignore: DEFAULT_IGNORED_DIRS.map((d) => `**/${d}/**`),
+        onlyFiles: true
+      });
+      const ig = getWorkspaceIgnore(realWorkspace);
+      const matchingLines = [];
+      const regex = new RegExp(query, "i");
+      for (const relFile of files) {
+        const normalizedRel = relFile.replace(/\\/g, "/");
+        if (ig.ignores(normalizedRel)) continue;
+        if (relFile.endsWith(".map") || relFile.endsWith(".min.js") || relFile.endsWith(".lock")) continue;
+        const fullPath = path4.join(realWorkspace, relFile);
+        try {
+          const stat = fs3.statSync(fullPath);
+          if (stat.size > 500 * 1024) continue;
+          const rawContent = fs3.readFileSync(fullPath, "utf8");
+          const lines = rawContent.replace(/\r\n/g, "\n").split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              matchingLines.push(`${normalizedRel}:${i + 1}: ${lines[i].trim()}`);
+              if (matchingLines.length >= 100) break;
+            }
+          }
+        } catch {
+        }
+        if (matchingLines.length >= 100) break;
+      }
+      if (matchingLines.length === 0) {
+        return {
+          success: true,
+          output: `No occurrences found for "${query}".`
+        };
+      }
+      return {
+        success: true,
+        output: matchingLines.join("\n") + (matchingLines.length >= 100 ? "\n(Search truncated to first 100 matches)" : ""),
+        metadata: { matchCount: matchingLines.length }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error executing grep search: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var projectTreeTool = {
+  definition: {
+    name: "project_tree",
+    description: "Display an ASCII tree visualization of the project structure.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: "Optional subfolder to show tree for. Defaults to workspace root."
+        },
+        max_depth: {
+          type: "integer",
+          description: "Maximum depth (default 3, max 5)."
+        }
+      }
+    }
+  },
+  async execute(args, context) {
+    const rawDir = String(args.directory || "").trim();
+    let realWorkspace = path4.resolve(context.workspace);
+    try {
+      if (fs3.existsSync(realWorkspace)) realWorkspace = fs3.realpathSync(realWorkspace);
+    } catch {
+    }
+    const validation = validateWorkspacePath(rawDir || ".", realWorkspace);
+    if (!validation.allowed) {
+      return { success: false, output: `Access denied: ${validation.reason}`, error: validation.reason };
+    }
+    const maxDepth = Math.min(Math.max(1, Number(args.max_depth) || 3), 5);
+    const ig = getWorkspaceIgnore(realWorkspace);
+    try {
+      let buildTree2 = function(currentDir, prefix, depth) {
+        if (depth > maxDepth) return;
+        let entries = [];
+        try {
+          entries = fs3.readdirSync(currentDir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        const validEntries = entries.filter((e) => {
+          if (DEFAULT_IGNORED_DIRS.includes(e.name)) return false;
+          const full = path4.join(currentDir, e.name);
+          const rel = path4.relative(realWorkspace, full).replace(/\\/g, "/");
+          return !ig.ignores(rel);
+        });
+        validEntries.sort((a, b) => {
+          if (a.isDirectory() && !b.isDirectory()) return -1;
+          if (!a.isDirectory() && b.isDirectory()) return 1;
+          return a.name.localeCompare(b.name);
+        });
+        validEntries.forEach((entry, idx) => {
+          const isLast = idx === validEntries.length - 1;
+          const pointer = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+          const fullPath = path4.join(currentDir, entry.name);
+          lines.push(`${prefix}${pointer}${entry.name}${entry.isDirectory() ? "/" : ""}`);
+          if (entry.isDirectory()) {
+            buildTree2(fullPath, prefix + (isLast ? "    " : "\u2502   "), depth + 1);
+          }
+        });
+      };
+      var buildTree = buildTree2;
+      const lines = [path4.basename(validation.resolvedPath) || "."];
+      buildTree2(validation.resolvedPath, "", 1);
+      return {
+        success: true,
+        output: lines.join("\n")
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error building tree: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/tools/bashTool.ts
+import { exec } from "child_process";
+var runCommandTool = {
+  definition: {
+    name: "run_command",
+    description: "Execute a terminal shell command inside the project workspace directory.",
+    readOnly: false,
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: 'The shell command to execute (e.g. "npm test", "git status", "dir").'
+        },
+        timeout_ms: {
+          type: "integer",
+          description: "Optional execution timeout in milliseconds (default 30000)."
+        }
+      },
+      required: ["command"]
+    }
+  },
+  async execute(args, context) {
+    const command = String(args.command || "").trim();
+    if (!command) {
+      return { success: false, output: "Command argument is required.", error: "Missing command" };
+    }
+    const guard = validateCommand(command);
+    if (!guard.allowed) {
+      return {
+        success: false,
+        output: `Command blocked by security guard: ${guard.reason}`,
+        error: guard.reason
+      };
+    }
+    const approved = await context.requestApproval({
+      type: "command",
+      summary: `Execute command: ${command}`,
+      details: {
+        command
+      }
+    });
+    if (!approved) {
+      return {
+        success: false,
+        output: `Command execution cancelled: User declined approval for '${command}'.`,
+        error: "Approval rejected"
+      };
+    }
+    const timeout = Math.min(Math.max(1e3, Number(args.timeout_ms) || 3e4), 12e4);
+    const startTime = Date.now();
+    return new Promise((resolve) => {
+      exec(
+        command,
+        {
+          cwd: context.workspace,
+          timeout,
+          maxBuffer: 5 * 1024 * 1024,
+          windowsHide: true,
+          env: {
+            ...process.env,
+            CI: "true"
+          }
+        },
+        (error, stdout, stderr) => {
+          const duration = Date.now() - startTime;
+          const exitCode = error && typeof error.code === "number" ? error.code : error ? 1 : 0;
+          let rawOutput = "";
+          if (stdout) rawOutput += stdout;
+          if (stderr) {
+            if (rawOutput) rawOutput += "\n--- stderr ---\n";
+            rawOutput += stderr;
+          }
+          if (!rawOutput) {
+            rawOutput = "(no output)";
+          }
+          const normalized = rawOutput.replace(/\r\n/g, "\n");
+          const cleanOutput = sanitizeSecrets(normalized.trim());
+          const formattedOutput = [
+            `Command: ${command}`,
+            `Exit code: ${exitCode}`,
+            `Duration: ${duration}ms`,
+            "Output:",
+            cleanOutput
+          ].join("\n");
+          resolve({
+            success: exitCode === 0,
+            output: formattedOutput,
+            error: error ? error.message : void 0,
+            metadata: { exitCode, duration }
+          });
+        }
+      );
+    });
+  }
+};
+
+// src/tools/gitTools.ts
+import { exec as exec2 } from "child_process";
+var gitStatusTool = {
+  definition: {
+    name: "git_status",
+    description: "Get current Git working tree status (branch, modified, untracked files).",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {}
+    }
+  },
+  async execute(_args, context) {
+    return new Promise((resolve) => {
+      exec2("git status --short --branch", { cwd: context.workspace, timeout: 1e4 }, (error, stdout, stderr) => {
+        if (error) {
+          return resolve({
+            success: false,
+            output: stderr.includes("not a git repository") ? "Workspace is not a Git repository." : `Git status error: ${error.message}`,
+            error: error.message
+          });
+        }
+        const out = stdout.trim() || "Working tree clean. Nothing to commit.";
+        resolve({
+          success: true,
+          output: out
+        });
+      });
+    });
+  }
+};
+var gitDiffTool = {
+  definition: {
+    name: "git_diff",
+    description: "Inspect git diff of unstaged or staged changes in the workspace repository.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        staged: {
+          type: "boolean",
+          description: "If true, shows diff of staged changes (--staged). Defaults to false."
+        }
+      }
+    }
+  },
+  async execute(args, context) {
+    const cmd = args.staged ? "git diff --staged" : "git diff";
+    return new Promise((resolve) => {
+      exec2(cmd, { cwd: context.workspace, timeout: 15e3, maxBuffer: 5 * 1024 * 1024 }, (error, stdout, stderr) => {
+        if (error) {
+          return resolve({
+            success: false,
+            output: `Git diff error: ${error.message}`,
+            error: error.message
+          });
+        }
+        const out = stdout.trim();
+        if (!out) {
+          return resolve({
+            success: true,
+            output: args.staged ? "No staged changes." : "No unstaged working tree changes."
+          });
+        }
+        const truncated = out.length > 5e4 ? out.slice(0, 5e4) + "\n\n[Diff truncated: exceeded 50KB]" : out;
+        resolve({
+          success: true,
+          output: truncated
+        });
+      });
+    });
+  }
+};
+
+// src/tools/webSearchTool.ts
+var webSearchTool = {
+  definition: {
+    name: "web_search",
+    description: "Search the web for up-to-date documentation, libraries, or error troubleshooting solutions.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search terms or question to look up."
+        }
+      },
+      required: ["query"]
+    }
+  },
+  async execute(args) {
+    const query = String(args.query || "").trim();
+    if (!query) {
+      return { success: false, output: "Missing query argument.", error: "Missing query" };
+    }
+    try {
+      const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 8e3);
+      const res = await fetch(url, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko)"
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!res.ok) {
+        return {
+          success: true,
+          output: `Search for "${query}" completed with status ${res.status}. No immediate text parsed.`
+        };
+      }
+      const html = await res.text();
+      const snippets = [];
+      const regex = /<a class="result__snippet[^>]*>([\s\S]*?)<\/a>/gi;
+      let match;
+      while ((match = regex.exec(html)) !== null && snippets.length < 5) {
+        const text = match[1].replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+        if (text) {
+          snippets.push(`- ${text}`);
+        }
+      }
+      if (snippets.length === 0) {
+        return {
+          success: true,
+          output: `Web search executed for "${query}". Found related topics, but snippets were condensed.`
+        };
+      }
+      return {
+        success: true,
+        output: `Search results for "${query}":
+
+${snippets.join("\n\n")}`,
+        metadata: { resultCount: snippets.length }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Web search could not reach external network: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor() {
+    this.registerBuiltins();
+  }
+  registerBuiltins() {
+    const builtins = [
+      readFileTool,
+      writeFileTool,
+      editFileTool,
+      listDirectoryTool,
+      fileSearchTool,
+      grepSearchTool,
+      projectTreeTool,
+      runCommandTool,
+      gitStatusTool,
+      gitDiffTool,
+      webSearchTool
+    ];
+    for (const tool of builtins) {
+      this.tools.set(tool.definition.name, tool);
+    }
+  }
+  registerTool(tool) {
+    this.tools.set(tool.definition.name, tool);
+  }
+  registerTools(tools) {
+    for (const tool of tools) {
+      this.tools.set(tool.definition.name, tool);
+    }
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  getDefinitions(planMode = false) {
+    const defs = [];
+    for (const tool of this.tools.values()) {
+      if (planMode && !tool.definition.readOnly) {
+        continue;
+      }
+      defs.push(tool.definition);
+    }
+    return defs;
+  }
+  async executeTool(name, args, context) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        success: false,
+        output: `Error: Unknown tool "${name}". Available tools: ${Array.from(this.tools.keys()).join(", ")}`,
+        error: "Tool not found"
+      };
+    }
+    if (context.planMode && !tool.definition.readOnly) {
+      return {
+        success: false,
+        output: `Plan mode is active (read-only). Action "${name}" was blocked.`,
+        error: "Plan mode read-only restriction"
+      };
+    }
+    try {
+      return await tool.execute(args, context);
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error executing tool "${name}": ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/config/schema.ts
+var DEFAULT_CONFIG = {
+  defaultModel: "gemini-3.8-flash",
+  maxSteps: 25,
+  temperature: 0.2,
+  maxOutputTokens: 8192,
+  yolo: false,
+  theme: "default",
+  autoCompactThreshold: 30,
+  // turns before auto-compacting
+  timeoutMs: 6e4,
+  mcpServers: {}
+};
+var ALLOWED_CONFIG_KEYS = [
+  "defaultModel",
+  "maxSteps",
+  "temperature",
+  "maxOutputTokens",
+  "yolo",
+  "theme",
+  "autoCompactThreshold",
+  "timeoutMs"
+];
+function validateConfigValue(key, value) {
+  switch (key) {
+    case "defaultModel":
+      if (typeof value !== "string" || value.trim().length === 0) {
+        return { valid: false, error: "defaultModel must be a non-empty string" };
+      }
+      return { valid: true, parsedValue: value.trim() };
+    case "maxSteps": {
+      const num = Number(value);
+      if (isNaN(num) || num < 1 || num > 100) {
+        return { valid: false, error: "maxSteps must be a number between 1 and 100" };
+      }
+      return { valid: true, parsedValue: Math.round(num) };
+    }
+    case "temperature": {
+      const num = Number(value);
+      if (isNaN(num) || num < 0 || num > 2) {
+        return { valid: false, error: "temperature must be a number between 0.0 and 2.0" };
+      }
+      return { valid: true, parsedValue: num };
+    }
+    case "maxOutputTokens": {
+      const num = Number(value);
+      if (isNaN(num) || num < 256 || num > 65536) {
+        return { valid: false, error: "maxOutputTokens must be between 256 and 65536" };
+      }
+      return { valid: true, parsedValue: Math.round(num) };
+    }
+    case "yolo": {
+      if (typeof value === "boolean") return { valid: true, parsedValue: value };
+      if (value === "true" || value === "1") return { valid: true, parsedValue: true };
+      if (value === "false" || value === "0") return { valid: true, parsedValue: false };
+      return { valid: false, error: "yolo must be a boolean (true/false)" };
+    }
+    case "theme": {
+      if (value === "default" || value === "ocean" || value === "minimal") {
+        return { valid: true, parsedValue: value };
+      }
+      return { valid: false, error: "theme must be 'default', 'ocean', or 'minimal'" };
+    }
+    case "autoCompactThreshold": {
+      const num = Number(value);
+      if (isNaN(num) || num < 5 || num > 200) {
+        return { valid: false, error: "autoCompactThreshold must be a number between 5 and 200" };
+      }
+      return { valid: true, parsedValue: Math.round(num) };
+    }
+    case "timeoutMs": {
+      const num = Number(value);
+      if (isNaN(num) || num < 5e3) {
+        return { valid: false, error: "timeoutMs must be at least 5000 (ms)" };
+      }
+      return { valid: true, parsedValue: Math.round(num) };
+    }
+    default:
+      return { valid: false, error: `Unknown configuration key: ${key}` };
+  }
+}
+
+// src/config/config.ts
+import fs4 from "fs";
+import path5 from "path";
+import os from "os";
+function getLanternHomeDir() {
+  const customHome = process.env.CODELANTERN_HOME || process.env.LANTERN_HOME;
+  if (customHome) {
+    if (!fs4.existsSync(customHome)) {
+      try {
+        fs4.mkdirSync(customHome, { recursive: true });
+      } catch {
+      }
+    }
+    return customHome;
+  }
+  const defaultDir = path5.join(os.homedir(), ".codelantern");
+  if (!fs4.existsSync(defaultDir)) {
+    try {
+      fs4.mkdirSync(defaultDir, { recursive: true });
+    } catch {
+    }
+  }
+  return defaultDir;
+}
+function getConfigFilePath() {
+  return path5.join(getLanternHomeDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigFilePath();
+  if (!fs4.existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = fs4.readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const merged = {
+      ...DEFAULT_CONFIG,
+      ...parsed
+    };
+    if (!merged.mcpServers || typeof merged.mcpServers !== "object") {
+      merged.mcpServers = {};
+    }
+    return merged;
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  const configPath = getConfigFilePath();
+  const safeConfig = {
+    defaultModel: config.defaultModel || DEFAULT_CONFIG.defaultModel,
+    maxSteps: config.maxSteps || DEFAULT_CONFIG.maxSteps,
+    temperature: config.temperature ?? DEFAULT_CONFIG.temperature,
+    maxOutputTokens: config.maxOutputTokens || DEFAULT_CONFIG.maxOutputTokens,
+    yolo: Boolean(config.yolo),
+    theme: config.theme || DEFAULT_CONFIG.theme,
+    autoCompactThreshold: config.autoCompactThreshold || DEFAULT_CONFIG.autoCompactThreshold,
+    timeoutMs: config.timeoutMs || DEFAULT_CONFIG.timeoutMs,
+    mcpServers: config.mcpServers || {}
+  };
+  try {
+    fs4.writeFileSync(configPath, JSON.stringify(safeConfig, null, 2), {
+      encoding: "utf8"
+    });
+  } catch (err) {
+    console.error(`Warning: Failed to save config to ${configPath}: ${err.message}`);
+  }
+}
+function setConfigValue(key, value) {
+  const validation = validateConfigValue(key, value);
+  if (!validation.valid) {
+    return { success: false, error: validation.error };
+  }
+  const current = loadConfig();
+  current[key] = validation.parsedValue;
+  saveConfig(current);
+  return { success: true, updatedConfig: current };
+}
+function getConfigValue(key) {
+  const current = loadConfig();
+  return current[key];
+}
+
+// src/mcp/mcpConfig.ts
+import fs5 from "fs";
+import path6 from "path";
+function getMcpConfigPath() {
+  return path6.join(getLanternHomeDir(), "mcp.json");
+}
+function loadMcpConfig() {
+  const filePath = getMcpConfigPath();
+  if (!fs5.existsSync(filePath)) {
+    return {};
+  }
+  try {
+    const raw = fs5.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      return parsed.mcpServers || parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function saveMcpConfig(servers) {
+  const filePath = getMcpConfigPath();
+  const data = { mcpServers: servers };
+  try {
+    fs5.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: "utf8" });
+  } catch (err) {
+    console.error(`Warning: Failed to save MCP config: ${err.message}`);
+  }
+}
+function addMcpServer(name, config) {
+  const current = loadMcpConfig();
+  current[name] = config;
+  saveMcpConfig(current);
+}
+function removeMcpServer(name) {
+  const current = loadMcpConfig();
+  if (current[name]) {
+    delete current[name];
+    saveMcpConfig(current);
+    return true;
+  }
+  return false;
+}
+function toggleMcpServer(name, disabled) {
+  const current = loadMcpConfig();
+  if (current[name]) {
+    current[name].disabled = disabled;
+    saveMcpConfig(current);
+    return true;
+  }
+  return false;
+}
+
+// src/mcp/mcpManager.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+var McpManager = class {
+  connections = /* @__PURE__ */ new Map();
+  async initialize() {
+    const servers = loadMcpConfig();
+    const allTools = [];
+    for (const [serverName, config] of Object.entries(servers)) {
+      if (config.disabled) {
+        continue;
+      }
+      try {
+        const tools = await this.connectServer(serverName, config);
+        allTools.push(...tools);
+      } catch (err) {
+        console.error(`Warning: Failed to connect MCP server '${serverName}': ${err.message}`);
+      }
+    }
+    return allTools;
+  }
+  async connectServer(serverName, config) {
+    if (this.connections.has(serverName)) {
+      await this.disconnectServer(serverName);
+    }
+    const safeEnv = {};
+    for (const [k, v] of Object.entries(process.env)) {
+      if (typeof v === "string") safeEnv[k] = v;
+    }
+    if (config.env) {
+      Object.assign(safeEnv, config.env);
+    }
+    const transport = new StdioClientTransport({
+      command: config.command,
+      args: config.args || [],
+      env: safeEnv
+    });
+    const client = new Client(
+      {
+        name: `orbit-client-${serverName}`,
+        version: "1.0.0"
+      },
+      {
+        capabilities: {}
+      }
+    );
+    await client.connect(transport);
+    const toolsResponse = await client.listTools();
+    const serverTools = [];
+    for (const mcpTool of toolsResponse.tools) {
+      const toolName = `mcp__${serverName}__${mcpTool.name}`.replace(/[^a-zA-Z0-9_]/g, "_");
+      const properties = {};
+      const required = [];
+      if (mcpTool.inputSchema && typeof mcpTool.inputSchema === "object") {
+        const schema = mcpTool.inputSchema;
+        if (schema.properties && typeof schema.properties === "object") {
+          for (const [k, v] of Object.entries(schema.properties)) {
+            properties[k] = {
+              type: v.type || "string",
+              description: v.description || ""
+            };
+          }
+        }
+        if (Array.isArray(schema.required)) {
+          required.push(...schema.required);
+        }
+      }
+      const definition = {
+        name: toolName,
+        description: `[MCP Server: ${serverName}] ${mcpTool.description || mcpTool.name}`,
+        readOnly: false,
+        parameters: {
+          type: "object",
+          properties,
+          required
+        }
+      };
+      const orbitTool = {
+        definition,
+        async execute(args, context) {
+          const approved = await context.requestApproval({
+            type: "command",
+            summary: `Run MCP tool ${serverName}:${mcpTool.name}`,
+            details: {
+              command: `mcp ${serverName} ${mcpTool.name} ${JSON.stringify(args)}`
+            }
+          });
+          if (!approved) {
+            return {
+              success: false,
+              output: `Execution denied by user for MCP tool ${serverName}:${mcpTool.name}`,
+              error: "Approval rejected"
+            };
+          }
+          try {
+            const result = await client.callTool({
+              name: mcpTool.name,
+              arguments: args
+            });
+            let textOutput = "";
+            if (Array.isArray(result.content)) {
+              for (const item of result.content) {
+                if (item.type === "text") {
+                  textOutput += item.text + "\n";
+                } else {
+                  textOutput += JSON.stringify(item) + "\n";
+                }
+              }
+            } else {
+              textOutput = JSON.stringify(result.content);
+            }
+            return {
+              success: !result.isError,
+              output: textOutput.trim(),
+              error: result.isError ? textOutput : void 0
+            };
+          } catch (err) {
+            return {
+              success: false,
+              output: `MCP execution error: ${err.message}`,
+              error: err.message
+            };
+          }
+        }
+      };
+      serverTools.push(orbitTool);
+    }
+    this.connections.set(serverName, {
+      name: serverName,
+      client,
+      transport,
+      tools: serverTools
+    });
+    return serverTools;
+  }
+  async disconnectServer(serverName) {
+    const conn = this.connections.get(serverName);
+    if (conn) {
+      try {
+        await conn.client.close();
+      } catch {
+      }
+      this.connections.delete(serverName);
+    }
+  }
+  async closeAll() {
+    for (const [serverName] of this.connections) {
+      await this.disconnectServer(serverName);
+    }
+  }
+};
+
+// src/approval/approver.ts
+import readline from "readline";
+import pc3 from "picocolors";
+var ApprovalEngine = class {
+  yolo;
+  planMode;
+  constructor(options) {
+    this.yolo = Boolean(options.yolo);
+    this.planMode = Boolean(options.planMode);
+  }
+  isYolo() {
+    return this.yolo;
+  }
+  setYolo(val) {
+    this.yolo = val;
+  }
+  isPlanMode() {
+    return this.planMode;
+  }
+  async requestApproval(req) {
+    if (this.planMode) {
+      console.log(pc3.yellow(`
+[Plan Mode] Tool action skipped (read-only): ${req.summary}`));
+      return false;
+    }
+    if (this.yolo) {
+      console.log(pc3.dim(`\u26A1 [YOLO] Auto-approved: ${req.summary}`));
+      return true;
+    }
+    console.log("\n" + pc3.bold(pc3.yellow("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501 Action Approval Required \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501")));
+    console.log(pc3.bold("Action: ") + req.summary);
+    if (req.type === "file_edit" && req.details?.before !== void 0 && req.details?.after !== void 0) {
+      const diffOutput = req.details.diff || formatTerminalDiff(
+        req.details.path || "file",
+        req.details.before,
+        req.details.after
+      );
+      console.log("\n" + diffOutput + "\n");
+    } else if (req.type === "file_write" && req.details?.after !== void 0) {
+      const preview = formatNewFilePreview(req.details.path || "file", req.details.after);
+      console.log("\n" + preview + "\n");
+    } else if (req.type === "command" && req.details?.command) {
+      console.log(pc3.cyan(`$ ${pc3.bold(req.details.command)}
+`));
+    }
+    const answer = await this.promptUser(
+      pc3.bold(pc3.yellow("Approve this action?")) + " [y/N / (a)ll-yolo]: "
+    );
+    const clean = answer.trim().toLowerCase();
+    if (clean === "a" || clean === "all" || clean === "yolo") {
+      this.yolo = true;
+      console.log(pc3.yellow("\u26A1 YOLO mode enabled for remainder of session.\n"));
+      return true;
+    }
+    if (clean === "y" || clean === "yes") {
+      console.log(pc3.green("\u2713 Approved.\n"));
+      return true;
+    }
+    console.log(pc3.red("\u2717 Denied by user.\n"));
+    return false;
+  }
+  promptUser(question) {
+    if (!process.stdin.isTTY) {
+      return Promise.resolve("no");
+    }
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+};
+
+// src/config/projectInstructions.ts
+import fs6 from "fs";
+import path7 from "path";
+var INSTRUCTION_FILES = [
+  "LANTERN.md",
+  "CODELANTERN.md",
+  ".codelantern/instructions.md",
+  ".lantern.md",
+  "GEMINI.md",
+  "ORBIT.md"
+];
+function loadProjectInstructions(workspaceDir) {
+  for (const filename of INSTRUCTION_FILES) {
+    const filePath = path7.join(workspaceDir, filename);
+    if (fs6.existsSync(filePath)) {
+      try {
+        const stat = fs6.statSync(filePath);
+        if (stat.isFile() && stat.size <= 200 * 1024) {
+          const content = fs6.readFileSync(filePath, "utf8").trim();
+          if (content.length > 0) {
+            return {
+              found: true,
+              filePath,
+              content
+            };
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return { found: false };
+}
+
+// src/session/sessionManager.ts
+import fs7 from "fs";
+import path8 from "path";
+import crypto from "crypto";
+function getSessionsDir() {
+  const dir = path8.join(getLanternHomeDir(), "sessions");
+  if (!fs7.existsSync(dir)) {
+    try {
+      fs7.mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+  }
+  return dir;
+}
+function generateSessionId() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 14);
+  const rand = crypto.randomBytes(3).toString("hex");
+  return `session_${timestamp}_${rand}`;
+}
+function createNewSession(workspace, model, initialTitle) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: generateSessionId(),
+    title: initialTitle || `Session in ${path8.basename(workspace) || "workspace"}`,
+    createdAt: now,
+    updatedAt: now,
+    workspace: path8.resolve(workspace),
+    model,
+    turns: [],
+    totalUsage: {
+      promptTokens: 0,
+      candidatesTokens: 0,
+      totalTokens: 0
+    }
+  };
+}
+function saveSession(session) {
+  const sessionsDir = getSessionsDir();
+  const filePath = path8.join(sessionsDir, `${session.id}.json`);
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const serialized = JSON.stringify(session, (_key, val) => {
+    if (typeof val === "string") {
+      return sanitizeSecrets(val);
+    }
+    return val;
+  }, 2);
+  try {
+    fs7.writeFileSync(filePath, serialized, { encoding: "utf8" });
+  } catch (err) {
+    console.error(`Warning: Failed to save session to ${filePath}: ${err.message}`);
+  }
+}
+function loadSession(sessionId) {
+  const sessionsDir = getSessionsDir();
+  const normalizedId = sessionId.endsWith(".json") ? sessionId : `${sessionId}.json`;
+  const filePath = path8.join(sessionsDir, normalizedId);
+  if (!fs7.existsSync(filePath)) {
+    if (!fs7.existsSync(sessionsDir)) return null;
+    const files = fs7.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+    const match = files.find((f) => f.startsWith(sessionId));
+    if (match) {
+      try {
+        const raw = fs7.readFileSync(path8.join(sessionsDir, match), "utf8");
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  try {
+    const raw = fs7.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function listSessions() {
+  const sessionsDir = getSessionsDir();
+  if (!fs7.existsSync(sessionsDir)) return [];
+  const files = fs7.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  const sessions = [];
+  for (const file of files) {
+    try {
+      const raw = fs7.readFileSync(path8.join(sessionsDir, file), "utf8");
+      const data = JSON.parse(raw);
+      sessions.push({
+        id: data.id,
+        title: data.title || "Untitled Session",
+        updatedAt: data.updatedAt || data.createdAt,
+        turnCount: data.turns?.length || 0,
+        workspace: data.workspace || "",
+        model: data.model || ""
+      });
+    } catch {
+    }
+  }
+  return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+}
+function deleteSession(sessionId) {
+  const sessionsDir = getSessionsDir();
+  const normalizedId = sessionId.endsWith(".json") ? sessionId : `${sessionId}.json`;
+  const filePath = path8.join(sessionsDir, normalizedId);
+  if (fs7.existsSync(filePath)) {
+    fs7.unlinkSync(filePath);
+    return true;
+  }
+  if (!fs7.existsSync(sessionsDir)) return false;
+  const files = fs7.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  const match = files.find((f) => f.startsWith(sessionId));
+  if (match) {
+    fs7.unlinkSync(path8.join(sessionsDir, match));
+    return true;
+  }
+  return false;
+}
+function exportSessionMarkdown(session) {
+  const lines = [
+    `# Code Lantern Session: ${session.title}`,
+    `**Session ID:** \`${session.id}\`  `,
+    `**Model:** \`${session.model}\`  `,
+    `**Workspace:** \`${session.workspace}\`  `,
+    `**Created:** ${session.createdAt}  `,
+    `**Updated:** ${session.updatedAt}  `,
+    `**Total Tokens:** ${session.totalUsage.totalTokens}  `,
+    "",
+    "---",
+    ""
+  ];
+  for (const turn of session.turns) {
+    const roleHeading = turn.role === "user" ? "### \u{1F464} User" : turn.role === "model" ? "### \u{1F3EE} Code Lantern" : "### \u{1F6E0}\uFE0F Tool";
+    lines.push(roleHeading);
+    lines.push(`*${turn.timestamp}*`);
+    lines.push("");
+    if (turn.text) {
+      lines.push(turn.text);
+      lines.push("");
+    }
+    if (turn.toolCalls && turn.toolCalls.length > 0) {
+      lines.push("**Tool Calls:**");
+      for (const call of turn.toolCalls) {
+        lines.push(`- \`${call.name}\`: \`${JSON.stringify(call.args)}\``);
+      }
+      lines.push("");
+    }
+    if (turn.toolResults && turn.toolResults.length > 0) {
+      lines.push("**Tool Results:**");
+      for (const res of turn.toolResults) {
+        const preview = typeof res.result === "string" ? res.result.slice(0, 200) : JSON.stringify(res.result).slice(0, 200);
+        lines.push(`- \`${res.name}\`: ${preview}...`);
+      }
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/session/compactor.ts
+function shouldCompact(turns, threshold = 30) {
+  return turns.length > threshold;
+}
+function compactTurns(turns, retainRecentCount = 10) {
+  if (turns.length <= retainRecentCount + 2) {
+    return turns;
+  }
+  const toCompact = turns.slice(0, turns.length - retainRecentCount);
+  const toKeep = turns.slice(turns.length - retainRecentCount);
+  const summaryPoints = [];
+  for (const turn of toCompact) {
+    if (turn.role === "user" && turn.text) {
+      summaryPoints.push(`- User asked: "${turn.text.slice(0, 150).replace(/\n/g, " ")}"`);
+    } else if (turn.role === "model") {
+      if (turn.toolCalls && turn.toolCalls.length > 0) {
+        const toolNames = turn.toolCalls.map((t) => t.name).join(", ");
+        summaryPoints.push(`- Orbit executed tools: ${toolNames}`);
+      }
+      if (turn.text) {
+        summaryPoints.push(`- Orbit responded: "${turn.text.slice(0, 120).replace(/\n/g, " ")}..."`);
+      }
+    }
+  }
+  const compactedTurn = {
+    role: "user",
+    text: `[SYSTEM: Earlier conversation context compacted (${toCompact.length} turns)]:
+${summaryPoints.join("\n")}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const ackTurn = {
+    role: "model",
+    text: "Understood. I retain full awareness of these previous tasks and will continue from here.",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return [compactedTurn, ackTurn, ...toKeep];
+}
+
+// src/agent/orbitAgent.ts
+import path9 from "path";
+import pc5 from "picocolors";
+
+// src/ui/spinner.ts
+import pc4 from "picocolors";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var TerminalSpinner = class {
+  timer = null;
+  frameIdx = 0;
+  message = "";
+  isTTY = Boolean(process.stdout.isTTY);
+  isRunning = false;
+  start(message) {
+    this.message = message;
+    this.isRunning = true;
+    if (!this.isTTY) {
+      console.log(`[Lantern] ${message}`);
+      return this;
+    }
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+    process.stdout.write("\x1B[?25l");
+    this.timer = setInterval(() => {
+      this.render();
+    }, 80);
+    this.render();
+    return this;
+  }
+  update(message) {
+    this.message = message;
+    if (!this.isTTY) {
+      console.log(`[Lantern] ${message}`);
+    } else if (this.isRunning) {
+      this.render();
+    }
+    return this;
+  }
+  render() {
+    if (!this.isTTY || !this.isRunning) return;
+    const frame = pc4.cyan(SPINNER_FRAMES[this.frameIdx % SPINNER_FRAMES.length]);
+    this.frameIdx++;
+    process.stdout.write(`\r\x1B[2K${frame} ${pc4.dim(this.message)}`);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.isRunning = false;
+    if (this.isTTY) {
+      process.stdout.write("\r\x1B[2K");
+      process.stdout.write("\x1B[?25h");
+    }
+    return this;
+  }
+  succeed(message) {
+    this.stop();
+    console.log(`${pc4.green("\u2713")} ${message}`);
+    return this;
+  }
+  fail(message) {
+    this.stop();
+    console.log(`${pc4.red("\u2717")} ${message}`);
+    return this;
+  }
+  info(message) {
+    this.stop();
+    console.log(`${pc4.cyan("\u2139")} ${message}`);
+    return this;
+  }
+};
+
+// src/agent/orbitAgent.ts
+var OrbitAgent = class {
+  provider;
+  tools;
+  mcpManager;
+  approvalEngine;
+  spinner;
+  constructor(apiKey) {
+    this.provider = new GeminiProvider(apiKey);
+    this.tools = new ToolRegistry();
+    this.mcpManager = new McpManager();
+    this.approvalEngine = new ApprovalEngine({});
+    this.spinner = new TerminalSpinner();
+  }
+  async initMcp() {
+    try {
+      const mcpTools = await this.mcpManager.initialize();
+      this.tools.registerTools(mcpTools);
+    } catch {
+    }
+  }
+  async shutdown() {
+    await this.mcpManager.closeAll();
+  }
+  buildSystemPrompt(workspace, planMode = false) {
+    const projectInstructions = loadProjectInstructions(workspace);
+    const basePrompt = [
+      "You are Code Lantern, an elite AI coding assistant operating directly in the terminal.",
+      `Current Workspace: ${path9.resolve(workspace)}`,
+      `Environment OS: ${process.platform}`,
+      "",
+      "CORE OPERATING PRINCIPLES:",
+      "1. Be direct, pragmatic, and helpful. Prioritize working, robust code over verbosity.",
+      "2. Inspect files before proposing edits to understand real project conventions and existing code.",
+      "3. Always use the provided tools to read, search, edit, create files, or run commands.",
+      "4. When editing files with edit_file, ensure the target string matches exactly, including indentation.",
+      "5. Safety boundaries: Never attempt to read secret files (.env, keys) or escape the workspace.",
+      "6. Never run destructive commands that wipe unrelated data, partitions, or system drives.",
+      "7. Never push code, make commits, or publish artifacts unless explicitly instructed by the user."
+    ];
+    if (planMode) {
+      basePrompt.push(
+        "",
+        "PLAN MODE IS ACTIVE (READ-ONLY):",
+        "- Your objective is to thoroughly inspect the codebase and produce a detailed, actionable implementation plan.",
+        "- You may inspect files and search code using read_file, file_search, grep_search, and project_tree.",
+        "- Do NOT attempt to write files, edit files, or run mutating commands.",
+        "- Structure your plan clearly: Overview, Architecture & Files Impacted, Step-by-Step Implementation, and Verification Strategy."
+      );
+    }
+    if (projectInstructions.found && projectInstructions.content) {
+      basePrompt.push(
+        "",
+        `PROJECT INSTRUCTIONS (${path9.basename(projectInstructions.filePath || "instructions")}):`,
+        "---",
+        projectInstructions.content,
+        "---"
+      );
+    }
+    return basePrompt.join("\n");
+  }
+  async runTurn(session, userPrompt, context, attachments = []) {
+    this.approvalEngine = new ApprovalEngine({
+      yolo: context.yolo,
+      planMode: context.planMode
+    });
+    const systemPrompt = this.buildSystemPrompt(context.workspace, context.planMode);
+    const activeTools = this.tools.getDefinitions(context.planMode);
+    const userTurn = {
+      role: "user",
+      text: userPrompt,
+      attachments: attachments.length > 0 ? attachments : void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    session.turns.push(userTurn);
+    let step = 0;
+    const maxSteps = context.maxSteps || 25;
+    let totalToolsExecuted = 0;
+    let finalAssistantText = "";
+    const sessionUsage = {
+      promptTokens: 0,
+      candidatesTokens: 0,
+      totalTokens: 0
+    };
+    while (step < maxSteps) {
+      step++;
+      this.spinner.start(`Thinking (step ${step}/${maxSteps})...`);
+      let currentStepText = "";
+      let currentToolCalls = [];
+      try {
+        const result = await this.provider.streamGenerate(
+          context.model,
+          systemPrompt,
+          session.turns,
+          activeTools,
+          {
+            onChunk: (chunk) => {
+              if (currentStepText === "") {
+                this.spinner.stop();
+              }
+              currentStepText += chunk;
+              if (!context.jsonOutput) {
+                process.stdout.write(chunk);
+              }
+            },
+            onToolCalls: (calls) => {
+              currentToolCalls = calls;
+            },
+            onUsage: (usage) => {
+              sessionUsage.promptTokens = usage.promptTokens;
+              sessionUsage.candidatesTokens = usage.candidatesTokens;
+              sessionUsage.totalTokens = usage.totalTokens;
+            }
+          }
+        );
+        this.spinner.stop();
+        if (currentStepText) {
+          if (!currentStepText.endsWith("\n")) {
+            console.log("");
+          }
+          finalAssistantText = currentStepText;
+        }
+        if (!result.toolCalls || result.toolCalls.length === 0) {
+          session.turns.push({
+            role: "model",
+            text: currentStepText,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          break;
+        }
+        session.turns.push({
+          role: "model",
+          text: currentStepText || void 0,
+          toolCalls: result.toolCalls,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const toolResults = [];
+        for (const call of result.toolCalls) {
+          totalToolsExecuted++;
+          const callSummary = `${call.name}(${Object.keys(call.args).map((k) => `${k}: ${JSON.stringify(call.args[k])}`).join(", ")})`;
+          if (!context.jsonOutput) {
+            console.log(pc5.cyan(`
+\u{1F6E0}\uFE0F  Tool: ${pc5.bold(call.name)}`) + pc5.dim(` ${callSummary.slice(0, 100)}`));
+          }
+          this.spinner.start(`Executing ${call.name}...`);
+          const toolContext = {
+            workspace: context.workspace,
+            yolo: this.approvalEngine.isYolo(),
+            planMode: context.planMode,
+            requestApproval: (req) => {
+              this.spinner.stop();
+              return this.approvalEngine.requestApproval(req);
+            }
+          };
+          const executionResult = await this.tools.executeTool(call.name, call.args, toolContext);
+          this.spinner.stop();
+          if (executionResult.success) {
+            if (!context.jsonOutput) {
+              const preview = executionResult.output.length > 200 ? executionResult.output.slice(0, 200) + "..." : executionResult.output;
+              console.log(pc5.green(`\u2713 Result:`) + pc5.dim(` ${preview.replace(/\n/g, " ")}`));
+            }
+            toolResults.push({
+              callId: call.id,
+              name: call.name,
+              result: executionResult.output
+            });
+          } else {
+            if (!context.jsonOutput) {
+              console.log(pc5.red(`\u2717 Error: ${executionResult.error || executionResult.output}`));
+            }
+            toolResults.push({
+              callId: call.id,
+              name: call.name,
+              result: { error: executionResult.error || executionResult.output },
+              error: executionResult.error
+            });
+          }
+        }
+        session.turns.push({
+          role: "tool",
+          toolResults,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (step >= maxSteps) {
+          const limitMsg = `
+[Reached maximum configured tool steps (${maxSteps}). Code Lantern paused to avoid infinite loops.]`;
+          console.log(pc5.yellow(limitMsg));
+          finalAssistantText += limitMsg;
+          break;
+        }
+      } catch (err) {
+        this.spinner.stop();
+        throw err;
+      }
+    }
+    if (shouldCompact(session.turns)) {
+      session.turns = compactTurns(session.turns);
+    }
+    session.totalUsage.promptTokens += sessionUsage.promptTokens;
+    session.totalUsage.candidatesTokens += sessionUsage.candidatesTokens;
+    session.totalUsage.totalTokens += sessionUsage.totalTokens;
+    saveSession(session);
+    return {
+      reply: finalAssistantText,
+      toolCount: totalToolsExecuted,
+      usage: sessionUsage
+    };
+  }
+};
+
+// src/provider/attachment.ts
+import fs8 from "fs";
+import path10 from "path";
+var MIME_MAP = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".ts": "text/plain",
+  ".js": "text/plain",
+  ".py": "text/plain",
+  ".sh": "text/plain",
+  ".html": "text/html",
+  ".css": "text/css"
+};
+var BINARY_IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".pdf"]);
+var MAX_ATTACHMENT_SIZE = 15 * 1024 * 1024;
+function loadAttachment(filePath) {
+  const resolved = path10.resolve(filePath);
+  if (!fs8.existsSync(resolved)) {
+    throw new Error(`Attached file does not exist: ${filePath}`);
+  }
+  const stat = fs8.statSync(resolved);
+  if (!stat.isFile()) {
+    throw new Error(`Attachment target is not a file: ${filePath}`);
+  }
+  if (stat.size > MAX_ATTACHMENT_SIZE) {
+    throw new Error(`Attachment file too large: ${filePath} (${(stat.size / (1024 * 1024)).toFixed(1)}MB, max 15MB)`);
+  }
+  const ext = path10.extname(resolved).toLowerCase();
+  const mimeType = MIME_MAP[ext] || "application/octet-stream";
+  const name = path10.basename(resolved);
+  if (BINARY_IMAGE_EXTS.has(ext)) {
+    const buffer = fs8.readFileSync(resolved);
+    return {
+      path: resolved,
+      name,
+      mimeType,
+      size: stat.size,
+      base64Data: buffer.toString("base64")
+    };
+  }
+  const textContent = fs8.readFileSync(resolved, "utf8");
+  return {
+    path: resolved,
+    name,
+    mimeType: mimeType.startsWith("text/") ? mimeType : "text/plain",
+    size: stat.size,
+    textContent
+  };
+}
+function loadAttachments(filePaths) {
+  if (!filePaths || filePaths.length === 0) return [];
+  return filePaths.map((p) => loadAttachment(p));
+}
+
+export {
+  MissingApiKeyError,
+  RateLimitError,
+  GeminiProviderError,
+  formatErrorMessage,
+  GeminiProvider,
+  isSecretFile,
+  sanitizeSecrets,
+  validateWorkspacePath,
+  formatTerminalDiff,
+  formatNewFilePreview,
+  validateCommand,
+  ToolRegistry,
+  DEFAULT_CONFIG,
+  ALLOWED_CONFIG_KEYS,
+  validateConfigValue,
+  getLanternHomeDir,
+  getConfigFilePath,
+  loadConfig,
+  saveConfig,
+  setConfigValue,
+  getConfigValue,
+  getMcpConfigPath,
+  loadMcpConfig,
+  saveMcpConfig,
+  addMcpServer,
+  removeMcpServer,
+  toggleMcpServer,
+  McpManager,
+  ApprovalEngine,
+  loadProjectInstructions,
+  getSessionsDir,
+  generateSessionId,
+  createNewSession,
+  saveSession,
+  loadSession,
+  listSessions,
+  deleteSession,
+  exportSessionMarkdown,
+  shouldCompact,
+  compactTurns,
+  OrbitAgent,
+  loadAttachment,
+  loadAttachments
+};
+//# sourceMappingURL=chunk-Y3PEOLTZ.js.map