micro-models-agent 0.45.0 → 0.46.1

package/dist/main.js

@@ -2263,7 +2263,9 @@ var init_defaults = __esm(() => {
     retry: {
       maxRetries: 3,
       baseDelay: 1000,
-      maxDelay: 30000
+      maxDelay: 30000,
+      maxStreamRetries: 2,
+      noDataTimeoutMs: 60000
     },
     maxToolIterations: 1000,
     stuckThreshold: 6,
@@ -2396,6 +2398,8 @@ Use read_file on {path} to see the current content before editing — the target
     "error.llm_retries": "LLM request failed after retries",
     "error.llm_429": "Rate limit exceeded (HTTP 429) for {model} on {baseUrl}. The provider is throttling requests — free models are especially strict. Get an API key or switch to a paid/faster model: {baseUrl}",
     "error.no_response_body": "No response body stream",
+    "error.llm_stream_idle": "LLM stream stalled — no data for {timeout}ms",
+    "error.llm_timeout": "LLM request timed out ({timeout}ms)",
     "session.started": "Session started: {id}",
     "session.ended": "Session ended: {id}",
     "session.not_found": "Session not found: {id}",
@@ -2779,6 +2783,19 @@ Available commands:`,
     "repl.lsp_timeout": "timeout",
     "repl.lsp_failed": "did not start",
     "repl.lsp_unknown": "unknown",
+    "repl.lsp": "LSP server management (status, restart, check)",
+    "repl.lsp_usage": "Usage: /lsp [status|restart|check <path>]",
+    "repl.lsp_not_available": "LSP module not available",
+    "repl.lsp_status_header": "LSP Status:",
+    "repl.lsp_enabled": "Enabled:",
+    "repl.lsp_disabled_servers": "Disabled servers:",
+    "repl.lsp_failure_counts": "Failure counts:",
+    "repl.lsp_all_ok": "All servers operational",
+    "repl.lsp_restarting": "Resetting LSP server state...",
+    "repl.lsp_restarted": "LSP servers reset. Failed servers will be retried on next use.",
+    "repl.lsp_check_usage": "Usage: /lsp check <file-or-directory>",
+    "repl.lsp_checking": "Running LSP check on {path}...",
+    "repl.lsp_check_error": "LSP check failed: {error}",
     "repl.work_dir": "Dir:",
     "repl.agents_label": "Instructions:",
     "repl.not_found": "not found",
@@ -3059,6 +3076,8 @@ var init_ru = __esm(() => {
     "error.llm_retries": "Запрос LLM не удался после повторов",
     "error.llm_429": "Превышен лимит запросов (HTTP 429) для {model} на {baseUrl}. Провайдер ограничивает трафик — особенно строгие free-модели. Получите API-ключ или переключитесь на платную/быструю модель: {baseUrl}",
     "error.no_response_body": "Нет потока тела ответа",
+    "error.llm_stream_idle": "Поток LLM завис — нет данных {timeout}мс",
+    "error.llm_timeout": "Время запроса LLM истекло ({timeout}мс)",
     "session.started": "Сессия начата: {id}",
     "session.ended": "Сессия завершена: {id}",
     "session.not_found": "Сессия не найдена: {id}",
@@ -3437,6 +3456,19 @@ var init_ru = __esm(() => {
     "repl.lsp_timeout": "таймаут",
     "repl.lsp_failed": "не стартовал",
     "repl.lsp_unknown": "неизвестно",
+    "repl.lsp": "Управление LSP-серверами (status, restart, check)",
+    "repl.lsp_usage": "Использование: /lsp [status|restart|check <путь>]",
+    "repl.lsp_not_available": "Модуль LSP недоступен",
+    "repl.lsp_status_header": "Статус LSP:",
+    "repl.lsp_enabled": "Включён:",
+    "repl.lsp_disabled_servers": "Отключённые серверы:",
+    "repl.lsp_failure_counts": "Количество ошибок:",
+    "repl.lsp_all_ok": "Все серверы работают",
+    "repl.lsp_restarting": "Сброс состояния LSP-серверов...",
+    "repl.lsp_restarted": "LSP-серверы сброшены. Упавшие серверы будут повторно запущены при следующем использовании.",
+    "repl.lsp_check_usage": "Использование: /lsp check <файл-или-каталог>",
+    "repl.lsp_checking": "Запуск LSP-проверки {path}...",
+    "repl.lsp_check_error": "LSP-проверка не удалась: {error}",
     "repl.work_dir": "Директория:",
     "repl.agents_label": "Инструкции:",
     "repl.not_found": "не найден",
@@ -5172,7 +5204,9 @@ class OpenAICompatProvider {
     this.retryConfig = config.retry ?? {
       maxRetries: 3,
       baseDelay: 1000,
-      maxDelay: 30000
+      maxDelay: 30000,
+      maxStreamRetries: 2,
+      noDataTimeoutMs: 60000
     };
     this.rateLimiter = createRateLimiter(config.rateLimits);
   }
@@ -5203,6 +5237,32 @@ class OpenAICompatProvider {
     }
   }
   async* doStream(messages, tools, signal, options) {
+    const { baseDelay, maxDelay, maxStreamRetries, noDataTimeoutMs } = this.retryConfig;
+    const streamRetries = maxStreamRetries ?? 2;
+    const idleTimeoutMs = noDataTimeoutMs ?? 60000;
+    for (let attempt = 0;; attempt++) {
+      let emitted = false;
+      const onEmit = () => {
+        emitted = true;
+      };
+      try {
+        const sawDone = yield* this.streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs);
+        if (sawDone || emitted)
+          return;
+        if (attempt >= streamRetries)
+          return;
+      } catch (err) {
+        if (err?.name === "AbortError" || err?.llmTerminal || signal?.aborted)
+          throw err;
+        if (emitted || attempt >= streamRetries)
+          throw err;
+      }
+      const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+      const jitter = Math.random() * baseDelay * 0.1;
+      await this.sleep(delay + jitter, signal);
+    }
+  }
+  async* streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs) {
     const body = buildRequestBody({
       model: this.model,
       messages,
@@ -5218,8 +5278,11 @@ class OpenAICompatProvider {
       headers["Authorization"] = `Bearer ${this.config.apiKey}`;
     }
     const controller = new AbortController;
-    const totalTimeoutMs = 120000;
-    const timeoutId = setTimeout(() => controller.abort(), totalTimeoutMs);
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, REQUEST_TIMEOUT_MS);
     const abortSignal = (() => {
       if (!signal)
         return controller.signal;
@@ -5232,20 +5295,31 @@ class OpenAICompatProvider {
         return controller.signal;
       }
     })();
-    const response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-      signal: abortSignal
-    });
+    let response;
+    try {
+      response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: abortSignal
+      });
+    } catch (err) {
+      if (err?.name === "AbortError")
+        throw err;
+      const wrapped = err instanceof Error ? err : new Error(String(err));
+      wrapped.llmTerminal = true;
+      throw wrapped;
+    }
     if (!response.ok) {
       clearTimeout(timeoutId);
       const errorText = await response.text();
-      throw new Error(t("error.llm_api", {
+      const err = new Error(t("error.llm_api", {
         status: response.status,
         statusText: response.statusText,
         errorText
       }));
+      err.llmTerminal = true;
+      throw err;
     }
     const reader = response.body?.getReader();
     if (!reader) {
@@ -5256,9 +5330,29 @@ class OpenAICompatProvider {
     let buffer = "";
     const toolCallAccs = new Map;
     let usage;
+    let sawDone = false;
+    const readIdle = () => new Promise((resolve, reject) => {
+      const idleTimer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, idleTimeoutMs);
+      reader.read().then((result) => {
+        clearTimeout(idleTimer);
+        if (timedOut)
+          reject(new Error(t("error.llm_stream_idle", { timeout: idleTimeoutMs })));
+        else
+          resolve(result);
+      }, (err) => {
+        clearTimeout(idleTimer);
+        if (timedOut)
+          reject(new Error(t("error.llm_stream_idle", { timeout: idleTimeoutMs })));
+        else
+          reject(err);
+      });
+    });
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        const { done, value } = await readIdle();
         if (done)
           break;
         buffer += decoder.decode(value, { stream: true });
@@ -5270,8 +5364,10 @@ class OpenAICompatProvider {
           if (!trimmed || !trimmed.startsWith("data: "))
             continue;
           const data = trimmed.slice(6);
-          if (data === "[DONE]")
+          if (data === "[DONE]") {
+            sawDone = true;
             continue;
+          }
           try {
             const parsed = JSON.parse(data);
             const choice = parsed.choices?.[0];
@@ -5288,6 +5384,7 @@ class OpenAICompatProvider {
             const delta = choice.delta || {};
             const finishReason = choice.finish_reason;
             if (delta.reasoning_content) {
+              onEmit();
               yield { type: "reasoning", content: delta.reasoning_content };
             }
             if (delta.tool_calls) {
@@ -5307,11 +5404,13 @@ class OpenAICompatProvider {
               }
             }
             if (delta.content) {
+              onEmit();
               yield { type: "text", content: delta.content };
             }
             if (finishReason === "tool_calls" && toolCallAccs.size > 0) {
               for (const [, acc] of toolCallAccs) {
                 if (acc.name) {
+                  onEmit();
                   yield {
                     type: "tool_call",
                     toolCall: {
@@ -5328,12 +5427,14 @@ class OpenAICompatProvider {
         }
       }
       if (usage) {
+        onEmit();
         yield { type: "done", usage };
       }
     } finally {
       clearTimeout(timeoutId);
       reader.releaseLock();
     }
+    return sawDone;
   }
   async doNonStreaming(messages, tools, signal, options) {
     const body = buildRequestBody({
@@ -5350,12 +5451,30 @@ class OpenAICompatProvider {
     if (this.config.apiKey && this.config.apiKey !== "not-needed") {
       headers["Authorization"] = `Bearer ${this.config.apiKey}`;
     }
+    const controller = new AbortController;
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, REQUEST_TIMEOUT_MS);
+    const abortSignal = (() => {
+      if (!signal)
+        return controller.signal;
+      try {
+        return AbortSignal.any([controller.signal, signal]);
+      } catch {
+        signal.addEventListener("abort", () => controller.abort(), {
+          once: true
+        });
+        return controller.signal;
+      }
+    })();
     try {
       const response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
         method: "POST",
         headers,
         body: JSON.stringify(body),
-        signal
+        signal: abortSignal
       });
       if (!response.ok) {
         const errorText = await response.text();
@@ -5402,7 +5521,12 @@ class OpenAICompatProvider {
       }
       return chunks;
     } catch (err) {
+      if (timedOut && err?.name === "AbortError") {
+        throw new Error(t("error.llm_timeout", { timeout: REQUEST_TIMEOUT_MS }));
+      }
       throw err instanceof Error ? err : new Error(String(err));
+    } finally {
+      clearTimeout(timeoutId);
     }
   }
   countTokens(text) {
@@ -5486,6 +5610,7 @@ class OpenAICompatProvider {
     });
   }
 }
+var REQUEST_TIMEOUT_MS = 120000;
 var init_openai_compat = __esm(() => {
   init_token_counter();
   init_i18n();
@@ -11587,6 +11712,7 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
     onPhase?.(phase);
   }
   async run(input, onChunk, onMeta, onTool, onPhase) {
+    this.shutdownRequested = false;
     this.setScope();
     const {
       config,
@@ -12259,7 +12385,6 @@ ${warnLine}
     if (killed > 0) {
       logger.info(`Killed ${killed} background process(es) on shutdown`);
     }
-    logger.closeSessionLog();
     pluginManager.runOnSessionEnd({
       logger,
       sessionManager: sessionManager?.getActiveMeta(),
@@ -19915,6 +20040,10 @@ import { resolve as resolve20 } from "path";
 import { platform as platform8 } from "os";
 
 class LspClient {
+  logger = null;
+  setLogger(logger) {
+    this.logger = logger;
+  }
   process = null;
   requestId = 0;
   pending = new Map;
@@ -19974,11 +20103,25 @@ class LspClient {
     try {
       await this.sendRequest("initialize", initParams, timeout);
     } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.logger?.warn(`LSP initialize failed (attempt 1): ${msg}`, {
+        command: config.command,
+        projectRoot
+      });
       if (!(e instanceof Error) || !e.message.includes("initialize"))
         throw e;
       await this.shutdown();
       await this.startServer(config, projectRoot);
-      await this.sendRequest("initialize", initParams, timeout);
+      try {
+        await this.sendRequest("initialize", initParams, timeout);
+      } catch (retryErr) {
+        const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+        this.logger?.error(`LSP initialize failed (attempt 2, giving up): ${retryMsg}`, {
+          command: config.command,
+          projectRoot
+        });
+        throw retryErr;
+      }
     }
     this.initialized = true;
   }
@@ -20016,8 +20159,11 @@ class LspClient {
       });
       this.process = proc;
       setTimeout(() => {
-        if (!this.initialized && this.process)
-          reject(new Error("LSP server start timeout"));
+        if (!this.initialized && this.process) {
+          const msg = "LSP server start timeout";
+          this.logger?.error(msg, { command: config.command, projectRoot, timeout: config.timeout ?? 1e4 });
+          reject(new Error(msg));
+        }
       }, config.timeout ?? 1e4);
     });
   }
@@ -20056,7 +20202,9 @@ class LspClient {
       try {
         const msg = JSON.parse(body);
         this.handleMessage(msg);
-      } catch {}
+      } catch (e) {
+        this.logger?.debug(`LSP JSON parse error: ${e instanceof Error ? e.message : String(e)}`);
+      }
     }
   }
   handleMessage(msg) {
@@ -20094,7 +20242,9 @@ class LspClient {
       setTimeout(() => {
         if (this.pending.has(id)) {
           this.pending.delete(id);
-          reject(new Error(`LSP request timeout: ${method}`));
+          const msg = `LSP request timeout: ${method}`;
+          this.logger?.warn(msg, { method, timeout });
+          reject(new Error(msg));
         }
       }, timeout);
     });
@@ -20104,27 +20254,37 @@ class LspClient {
     this.write(message);
   }
   write(message) {
-    if (!this.process?.stdin?.writable)
+    if (!this.process?.stdin?.writable) {
+      this.logger?.debug("LSP write failed: process stdin not writable");
       return;
+    }
     const header = `Content-Length: ${Buffer.byteLength(message)}\r
 \r
 `;
     try {
       this.process.stdin.write(header + message);
-    } catch {}
+    } catch (e) {
+      this.logger?.debug(`LSP write error: ${e instanceof Error ? e.message : String(e)}`);
+    }
   }
   async shutdown() {
     try {
       if (this.process && this.initialized && this.process.stdin?.writable) {
-        this.sendRequest("shutdown", null, 3000).catch(() => {});
+        this.sendRequest("shutdown", null, 3000).catch((e) => {
+          this.logger?.debug(`LSP shutdown request failed: ${e instanceof Error ? e.message : String(e)}`);
+        });
         this.sendNotification("exit", null);
         await new Promise((r) => setTimeout(r, 200));
       }
-    } catch {} finally {
+    } catch (e) {
+      this.logger?.debug(`LSP shutdown error: ${e instanceof Error ? e.message : String(e)}`);
+    } finally {
       if (this.process) {
         try {
           killTree(this.process);
-        } catch {}
+        } catch (e) {
+          this.logger?.debug(`LSP killTree error: ${e instanceof Error ? e.message : String(e)}`);
+        }
         this.process = null;
       }
       this.initialized = false;
@@ -20232,9 +20392,26 @@ class LspModule {
   client;
   failuresByServer = new Map;
   disabledServers = new Set;
-  constructor(config, client) {
+  logger = null;
+  constructor(config, client, logger) {
     this.config = { ...DEFAULT_LSP_CONFIG, ...config };
     this.client = client ?? new LspClient;
+    this.logger = logger ?? null;
+    this.client.setLogger(this.logger);
+  }
+  setLogger(logger) {
+    this.logger = logger;
+    this.client.setLogger(logger);
+  }
+  resetDisabledServers() {
+    this.failuresByServer.clear();
+    this.disabledServers.clear();
+  }
+  getDisabledServers() {
+    return Array.from(this.disabledServers);
+  }
+  getFailureCounts() {
+    return new Map(this.failuresByServer);
   }
   isLspDisabled() {
     return this.disabledServers.size > 0;
@@ -20505,7 +20682,9 @@ async function runCheck(config, baseDir, deps) {
           lines.push(formatStartupError(file, baseDir, d));
         }
       }
-    } catch {}
+    } catch (e) {
+      deps.logger?.debug(`Startup LSP check failed for ${file}: ${e instanceof Error ? e.message : String(e)}`);
+    }
   }
   if (checked === 0 || lines.length === 0)
     return null;
@@ -21596,7 +21775,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
       pluginManager.register(browserPlugin);
     }
   }
-  const lspModule = new LspModule(config.lsp);
+  const lspModule = new LspModule(config.lsp, undefined, logger);
   moduleRegistry.register(lspModule);
   const lspPlugin = lspModule.getPlugin();
   if (lspPlugin) {
@@ -30620,6 +30799,70 @@ Excluded blocks: ${info.excluded.length}`));
       }
     }
   });
+  ctx.registerCommand({
+    name: "lsp",
+    description: t("repl.lsp"),
+    usage: t("repl.lsp_usage"),
+    action: async (args) => {
+      const subcommand = args[0] || "status";
+      const lspModule = ctx.agent.deps?.moduleRegistry?.getModules?.()?.find((m) => m.name === "lsp");
+      if (!lspModule) {
+        console.log(pc2.yellow(t("repl.lsp_not_available")));
+        return;
+      }
+      switch (subcommand) {
+        case "status": {
+          const disabled = lspModule.getDisabledServers();
+          const failures = lspModule.getFailureCounts();
+          const config = ctx.config.lsp;
+          console.log(pc2.bold(t("repl.lsp_status_header")));
+          console.log(`${t("repl.lsp_enabled")} ${config?.enabled ? pc2.green("yes") : pc2.red("no")}`);
+          if (disabled.length > 0) {
+            console.log(pc2.yellow(`${t("repl.lsp_disabled_servers")} ${disabled.join(", ")}`));
+          }
+          if (failures.size > 0) {
+            console.log(pc2.dim(t("repl.lsp_failure_counts")));
+            for (const [server, count] of failures) {
+              console.log(pc2.dim(`  ${server}: ${count}`));
+            }
+          }
+          if (disabled.length === 0 && failures.size === 0) {
+            console.log(pc2.green(t("repl.lsp_all_ok")));
+          }
+          break;
+        }
+        case "restart": {
+          console.log(pc2.yellow(t("repl.lsp_restarting")));
+          lspModule.resetDisabledServers();
+          console.log(pc2.green(t("repl.lsp_restarted")));
+          break;
+        }
+        case "check": {
+          const path = args[1];
+          if (!path) {
+            console.log(pc2.yellow(t("repl.lsp_check_usage")));
+            return;
+          }
+          console.log(pc2.dim(t("repl.lsp_checking", { path })));
+          try {
+            const result = await ctx.agent.deps?.toolExecutor?.execute("lsp_check", { path }, ctx.agent.deps?.toolCtx);
+            if (result?.output) {
+              console.log(result.output);
+            }
+          } catch (e) {
+            console.log(pc2.red(t("repl.lsp_check_error", {
+              error: e instanceof Error ? e.message : String(e)
+            })));
+          }
+          break;
+        }
+        default: {
+          console.log(pc2.dim(t("repl.lsp_usage")));
+          break;
+        }
+      }
+    }
+  });
 }
 function registerSessionCommands(ctx) {
   if (!ctx.sessionManager)
@@ -30874,6 +31117,7 @@ var init_repl_commands = __esm(() => {
     reload: "agent",
     wizard: "agent",
     sysprompt: "agent",
+    lsp: "agent",
     sessions: "session",
     new: "session",
     resume: "session",
@@ -33113,16 +33357,24 @@ async function probeLspServers(config, baseDir, deps = {}) {
       await probeClient.probe(server, projectRoot, serverTimeout);
       ok.push({ language, ok: true, durationMs: Date.now() - started });
     } catch (e) {
+      const errorMsg = e instanceof Error ? e.message : String(e);
+      deps.logger?.warn(`LSP probe failed for ${language}: ${errorMsg}`, {
+        command: server.command,
+        timeout: serverTimeout,
+        durationMs: Date.now() - started
+      });
       failed.push({
         language,
         ok: false,
-        error: e instanceof Error ? e.message : String(e),
+        error: errorMsg,
         durationMs: Date.now() - started
       });
     }
   };
   for (let i = 0;i < servers.length; i += maxParallel) {
     if (Date.now() >= deadline) {
+      const remaining = servers.slice(i).map((s) => s.language);
+      deps.logger?.warn(`LSP probe deadline reached, skipping: ${remaining.join(", ")}`);
       for (const { language } of servers.slice(i)) {
         failed.push({ language, ok: false, error: "timeout", durationMs: 0 });
       }
@@ -33421,6 +33673,7 @@ class Repl {
       this.running = false;
       this.saveHistory();
       this.agent.shutdown();
+      this.logger?.closeSessionLog();
       if (this.exitOnClose)
         process.exit(0);
     });
@@ -33429,6 +33682,7 @@ class Repl {
         this.running = false;
         this.saveHistory();
         this.agent.shutdown();
+        this.logger?.closeSessionLog();
         process.exit(0);
       });
     }
@@ -33775,6 +34029,7 @@ ${t("image.clipboard_empty")}`));
     this.running = false;
     this.saveHistory();
     this.agent.shutdown();
+    this.logger?.closeSessionLog();
     this.rl.close();
   }
 }

package/dist/migration/backup.js

@@ -0,0 +1,45 @@
+import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { t } from "../i18n/index";
+export class BackupManager {
+    configDir;
+    constructor(configDir) {
+        this.configDir = configDir;
+    }
+    backupConfig() {
+        const configPath = join(this.configDir, "config.json");
+        if (!existsSync(configPath))
+            return;
+        const bakPath = join(this.configDir, "config.json.bak");
+        copyFileSync(configPath, bakPath);
+    }
+    backupAll() {
+        const bakDir = this.configDir + ".bak";
+        if (existsSync(bakDir))
+            return;
+        if (existsSync(this.configDir)) {
+            cpSync(this.configDir, bakDir, { recursive: true });
+        }
+    }
+    writeFreshConfig(config) {
+        if (!existsSync(this.configDir)) {
+            mkdirSync(this.configDir, { recursive: true });
+        }
+        writeFileSync(join(this.configDir, "config.json"), JSON.stringify(config, null, 2), "utf-8");
+    }
+    getBackupSummary() {
+        const lines = [];
+        const bakConfig = join(this.configDir, "config.json.bak");
+        const bakDir = this.configDir + ".bak";
+        if (existsSync(bakConfig)) {
+            lines.push(t("migration.config_bak"));
+        }
+        if (existsSync(bakDir)) {
+            const files = readdirSync(bakDir);
+            lines.push(t("migration.dir_bak", { count: files.length }));
+        }
+        return lines.length > 0
+            ? `${t("migration.migrated")}\n${lines.join("\n")}`
+            : t("migration.not_needed");
+    }
+}

package/dist/migration/detect.js

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+const V1_ONLY_FIELDS = ["apiBase", "apiKey", "chatEndpoint", "temperature", "maxTokens"];
+export class MigrationDetector {
+    configDir;
+    constructor(configDir) {
+        this.configDir = configDir;
+    }
+    needsMigration() {
+        const configPath = join(this.configDir, "config.json");
+        if (!existsSync(configPath))
+            return false;
+        try {
+            const content = readFileSync(configPath, "utf-8");
+            const config = JSON.parse(content);
+            if (config.version && config.version.startsWith("2."))
+                return false;
+            for (const field of V1_ONLY_FIELDS) {
+                if (field in config)
+                    return true;
+            }
+            const v2Required = ["provider", "contextWindow", "contextBudget"];
+            const hasAllV2Fields = v2Required.every((f) => f in config);
+            if (!hasAllV2Fields)
+                return true;
+            return false;
+        }
+        catch {
+            return true;
+        }
+    }
+    hasOldSessions() {
+        const sessionsDir = join(this.configDir, "sessions");
+        if (!existsSync(sessionsDir))
+            return false;
+        return readdirSync(sessionsDir).length > 0;
+    }
+    hasOldProfile() {
+        const profilePath = join(this.configDir, "profile.json");
+        if (!existsSync(profilePath))
+            return false;
+        try {
+            const profile = JSON.parse(readFileSync(profilePath, "utf-8"));
+            return !profile.platform && !profile.os;
+        }
+        catch {
+            return false;
+        }
+    }
+}