@codedir/mimir-code 0.1.0

package/dist/index.js

@@ -0,0 +1,1656 @@
+// src/types/index.ts
+var createOk = (value) => ({ ok: true, value });
+var createErr = (error) => ({ ok: false, error });
+
+// src/core/Agent.ts
+var Agent = class {
+  // private provider: ILLMProvider; // TODO: Will be used when LLM integration is implemented
+  toolRegistry;
+  config;
+  conversationHistory = [];
+  currentIteration = 0;
+  constructor(_provider, toolRegistry, config) {
+    this.toolRegistry = toolRegistry;
+    this.config = config;
+  }
+  async run(task) {
+    this.conversationHistory = [
+      {
+        role: "system",
+        content: "You are a helpful coding assistant."
+      },
+      {
+        role: "user",
+        content: task
+      }
+    ];
+    while (this.currentIteration < this.config.maxIterations) {
+      const action = await this.reason();
+      if (action.type === "finish") {
+        return createOk(action.result);
+      }
+      const observation = await this.act(action);
+      await this.observe(observation);
+      this.currentIteration++;
+    }
+    return createErr(new Error("Max iterations reached"));
+  }
+  async reason() {
+    return {
+      type: "finish",
+      result: "Task completed"
+    };
+  }
+  async act(action) {
+    if (!action.toolName || !action.arguments) {
+      return {
+        type: "error",
+        error: "Invalid action: missing toolName or arguments"
+      };
+    }
+    const result = await this.toolRegistry.execute(action.toolName, action.arguments);
+    return {
+      type: "tool_result",
+      data: result
+    };
+  }
+  async observe(observation) {
+    this.conversationHistory.push({
+      role: "assistant",
+      content: JSON.stringify(observation)
+    });
+  }
+};
+
+// src/core/Tool.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  unregister(toolName) {
+    this.tools.delete(toolName);
+  }
+  get(toolName) {
+    return this.tools.get(toolName);
+  }
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  has(toolName) {
+    return this.tools.has(toolName);
+  }
+  async execute(toolName, args) {
+    const tool = this.get(toolName);
+    if (!tool) {
+      return {
+        success: false,
+        error: `Tool not found: ${toolName}`
+      };
+    }
+    try {
+      const validatedArgs = tool.schema.parse(args);
+      return await tool.execute(validatedArgs);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/core/RiskAssessor.ts
+var RiskAssessor = class {
+  // Critical patterns - system-destroying commands
+  criticalPatterns = [
+    { pattern: /rm\s+-rf\s+\/(?!tmp|var\/tmp)/, reason: "Deletes root filesystem" },
+    { pattern: /format\s+[a-z]:/i, reason: "Formats entire drive" },
+    { pattern: /del\s+\/[sf]/i, reason: "Deletes system files (Windows)" },
+    { pattern: /shutdown|reboot|poweroff/, reason: "System shutdown/reboot" },
+    { pattern: /dd\s+.*of=\/dev\/(sda|hda|nvme)/, reason: "Direct disk write (can destroy data)" },
+    { pattern: /mkfs/, reason: "Formats filesystem" },
+    {
+      pattern: /(>|vim|vi|nano|emacs|edit).*\/etc\/(passwd|shadow|sudoers)/,
+      reason: "Modifies critical system files"
+    },
+    { pattern: /curl.*\|\s*(bash|sh|python)/, reason: "Executes remote script without inspection" },
+    { pattern: /wget.*\|\s*(bash|sh|python)/, reason: "Executes remote script without inspection" }
+  ];
+  // High risk patterns - destructive but recoverable
+  highPatterns = [
+    { pattern: /rm\s+-rf\s+(?!\/($|\s))/, reason: "Recursive force delete" },
+    { pattern: /sudo\s+rm/, reason: "Elevated permissions file deletion" },
+    { pattern: /git\s+push\s+--force/, reason: "Force pushes can overwrite history" },
+    { pattern: /npm\s+publish/, reason: "Publishes package to registry" },
+    { pattern: /docker\s+rmi.*-f/, reason: "Force removes Docker images" },
+    { pattern: /docker\s+system\s+prune\s+-a/, reason: "Removes all unused Docker data" },
+    { pattern: /git\s+reset\s+--hard\s+HEAD~/, reason: "Permanently deletes commits" },
+    { pattern: /git\s+clean\s+-fd/, reason: "Deletes untracked files" },
+    { pattern: /chmod\s+777/, reason: "Makes files world-writable (security risk)" },
+    { pattern: /chown\s+-R/, reason: "Recursive ownership change" }
+  ];
+  // Medium risk patterns - potentially problematic
+  mediumPatterns = [
+    { pattern: /npm\s+install/, reason: "Installs dependencies (can include malicious packages)" },
+    { pattern: /yarn\s+add/, reason: "Installs dependencies (can include malicious packages)" },
+    { pattern: /pip\s+install/, reason: "Installs Python packages" },
+    { pattern: /git\s+push/, reason: "Pushes changes to remote" },
+    { pattern: /docker\s+run/, reason: "Runs Docker container" },
+    { pattern: /docker\s+exec/, reason: "Executes command in container" },
+    { pattern: /ssh\s+/, reason: "Remote connection" },
+    { pattern: /scp\s+/, reason: "Remote file transfer" },
+    { pattern: /rsync\s+/, reason: "File synchronization" },
+    { pattern: /npm\s+run\s+build/, reason: "Runs build scripts" }
+  ];
+  /**
+   * Assess risk level and provide detailed reasons
+   */
+  assess(command) {
+    const reasons = [];
+    let maxScore = 0;
+    for (const { pattern, reason } of this.criticalPatterns) {
+      if (pattern.test(command)) {
+        reasons.push(`\u{1F534} CRITICAL: ${reason}`);
+        maxScore = Math.max(maxScore, 100);
+      }
+    }
+    for (const { pattern, reason } of this.highPatterns) {
+      if (pattern.test(command)) {
+        reasons.push(`\u{1F7E0} HIGH: ${reason}`);
+        maxScore = Math.max(maxScore, 75);
+      }
+    }
+    for (const { pattern, reason } of this.mediumPatterns) {
+      if (pattern.test(command)) {
+        reasons.push(`\u{1F7E1} MEDIUM: ${reason}`);
+        maxScore = Math.max(maxScore, 50);
+      }
+    }
+    const additionalRisks = this.assessAdditionalRisks(command);
+    reasons.push(...additionalRisks.reasons);
+    maxScore = Math.max(maxScore, additionalRisks.score);
+    const level = this.scoreToLevel(maxScore);
+    if (reasons.length === 0) {
+      reasons.push("No specific risks detected");
+    }
+    return {
+      level,
+      reasons,
+      score: maxScore
+    };
+  }
+  /**
+   * Additional risk checks (file size, complexity, etc.)
+   */
+  assessAdditionalRisks(command) {
+    const reasons = [];
+    let score = 0;
+    if (command.length > 500) {
+      reasons.push("\u26A0\uFE0F  Command is unusually long (possible obfuscation)");
+      score = Math.max(score, 30);
+    }
+    const chainCount = (command.match(/[;&|]+/g) || []).length;
+    if (chainCount > 3) {
+      reasons.push(`\u26A0\uFE0F  Multiple chained commands (${chainCount} chains)`);
+      score = Math.max(score, 40);
+    }
+    if (/>\/dev\/null|2>&1/.test(command)) {
+      reasons.push("\u26A0\uFE0F  Output redirected (hiding results)");
+      score = Math.max(score, 20);
+    }
+    if (/sudo\s*$/.test(command)) {
+      reasons.push("\u{1F7E0} Elevated permissions without specific command");
+      score = Math.max(score, 60);
+    }
+    if (/export\s+|setenv\s+/.test(command) && /PATH/.test(command)) {
+      reasons.push("\u{1F7E1} Modifies PATH environment variable");
+      score = Math.max(score, 45);
+    }
+    if (/base64\s+--decode|echo\s+.*\|\s*base64/.test(command)) {
+      reasons.push("\u26A0\uFE0F  Uses Base64 encoding (possible obfuscation)");
+      score = Math.max(score, 35);
+    }
+    if (/eval\s+/.test(command)) {
+      reasons.push("\u{1F7E0} Uses eval (dynamic code execution)");
+      score = Math.max(score, 65);
+    }
+    return { reasons, score };
+  }
+  /**
+   * Convert numeric score to risk level
+   */
+  scoreToLevel(score) {
+    if (score >= 80) return "critical";
+    if (score >= 60) return "high";
+    if (score >= 30) return "medium";
+    return "low";
+  }
+  /**
+   * Check if command matches any allowed patterns
+   */
+  isAllowed(command, allowlist) {
+    return allowlist.some((pattern) => {
+      try {
+        const regex = new RegExp(pattern);
+        return regex.test(command);
+      } catch {
+        return command.includes(pattern);
+      }
+    });
+  }
+  /**
+   * Check if command matches any blocked patterns
+   */
+  isBlocked(command, blocklist) {
+    return blocklist.some((pattern) => {
+      try {
+        const regex = new RegExp(pattern);
+        return regex.test(command);
+      } catch {
+        return command.includes(pattern);
+      }
+    });
+  }
+  /**
+   * Get a human-readable summary of the risk assessment
+   */
+  getSummary(assessment) {
+    const levelEmoji = {
+      low: "\u{1F7E2}",
+      medium: "\u{1F7E1}",
+      high: "\u{1F7E0}",
+      critical: "\u{1F534}"
+    };
+    const lines = [
+      `${levelEmoji[assessment.level]} Risk Level: ${assessment.level.toUpperCase()} (score: ${assessment.score}/100)`,
+      "",
+      "Reasons:",
+      ...assessment.reasons.map((r) => `  \u2022 ${r}`)
+    ];
+    return lines.join("\n");
+  }
+};
+
+// src/core/PermissionManager.ts
+var PermissionManager = class {
+  riskAssessor;
+  allowlist = /* @__PURE__ */ new Set();
+  blocklist = /* @__PURE__ */ new Set();
+  auditLog = [];
+  constructor() {
+    this.riskAssessor = new RiskAssessor();
+  }
+  async checkPermission(command) {
+    const assessment = this.riskAssessor.assess(command);
+    if (this.riskAssessor.isBlocked(command, Array.from(this.blocklist))) {
+      this.logDecision(command, assessment.level, "deny");
+      return { allowed: false, assessment };
+    }
+    if (this.riskAssessor.isAllowed(command, Array.from(this.allowlist))) {
+      this.logDecision(command, assessment.level, "allow");
+      return { allowed: true, assessment };
+    }
+    if (assessment.level === "high" || assessment.level === "critical") {
+      this.logDecision(command, assessment.level, "deny");
+      return { allowed: false, assessment };
+    }
+    this.logDecision(command, assessment.level, "allow");
+    return { allowed: true, assessment };
+  }
+  addToAllowlist(pattern) {
+    this.allowlist.add(pattern);
+  }
+  addToBlocklist(pattern) {
+    this.blocklist.add(pattern);
+  }
+  logDecision(command, riskLevel, decision) {
+    this.auditLog.push({
+      command,
+      riskLevel,
+      decision,
+      timestamp: Date.now()
+    });
+  }
+  getAuditLog() {
+    return [...this.auditLog];
+  }
+};
+
+// src/utils/errors.ts
+var MimirError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MimirError";
+  }
+};
+var ConfigurationError = class extends MimirError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var ProviderError = class extends MimirError {
+  constructor(message, provider) {
+    super(message);
+    this.provider = provider;
+    this.name = "ProviderError";
+  }
+};
+var ToolExecutionError = class extends MimirError {
+  constructor(message, toolName) {
+    super(message);
+    this.toolName = toolName;
+    this.name = "ToolExecutionError";
+  }
+};
+var PermissionDeniedError = class extends MimirError {
+  constructor(message, command) {
+    super(message);
+    this.command = command;
+    this.name = "PermissionDeniedError";
+  }
+};
+var DockerError = class extends MimirError {
+  constructor(message) {
+    super(message);
+    this.name = "DockerError";
+  }
+};
+var NetworkError = class extends MimirError {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "NetworkError";
+  }
+};
+var RateLimitError = class extends MimirError {
+  constructor(message, retryAfter) {
+    super(message);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+};
+
+// src/providers/BaseLLMProvider.ts
+var BaseLLMProvider = class {
+  config;
+  retryConfig;
+  constructor(config, retryConfig) {
+    this.config = config;
+    this.retryConfig = retryConfig ?? {
+      maxRetries: 3,
+      retryDelay: 1e3,
+      backoffMultiplier: 2
+    };
+  }
+  getProviderName() {
+    return this.config.provider;
+  }
+  getModelName() {
+    return this.config.model;
+  }
+  /**
+   * Retry wrapper for API calls
+   * Only retries on NetworkError (5xx server errors)
+   * Does NOT retry on auth errors, rate limits, or client errors
+   */
+  async withRetry(fn) {
+    let lastError;
+    let delay = this.retryConfig.retryDelay;
+    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        const shouldRetry = error instanceof NetworkError && attempt < this.retryConfig.maxRetries;
+        if (shouldRetry) {
+          await this.sleep(delay);
+          delay *= this.retryConfig.backoffMultiplier;
+        } else {
+          throw lastError;
+        }
+      }
+    }
+    throw lastError;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/providers/DeepSeekProvider.ts
+import { encoding_for_model } from "tiktoken";
+
+// src/providers/utils/apiClient.ts
+import axios from "axios";
+var APIClient = class {
+  axiosInstance;
+  providerName;
+  constructor(config) {
+    this.axiosInstance = axios.create({
+      baseURL: config.baseURL,
+      headers: config.headers,
+      timeout: config.timeout || 6e4
+      // 60 seconds default
+    });
+    this.providerName = this.extractProviderName(config.baseURL);
+  }
+  /**
+   * POST request with JSON payload
+   */
+  async post(endpoint, data) {
+    try {
+      const response = await this.axiosInstance.post(endpoint, data);
+      return response.data;
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint) {
+    try {
+      const response = await this.axiosInstance.get(endpoint);
+      return response.data;
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * Stream request for Server-Sent Events (SSE)
+   * Returns async iterable of string chunks
+   */
+  async *stream(endpoint, data) {
+    try {
+      const response = await this.axiosInstance.post(endpoint, data, {
+        responseType: "stream",
+        headers: {
+          Accept: "text/event-stream"
+        }
+      });
+      const stream = response.data;
+      for await (const chunk of stream) {
+        const chunkStr = chunk.toString("utf-8");
+        yield chunkStr;
+      }
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * Map axios errors to custom error types
+   */
+  mapError(error) {
+    if (!axios.isAxiosError(error)) {
+      return error;
+    }
+    const axiosError = error;
+    const status = axiosError.response?.status;
+    const errorData = axiosError.response?.data;
+    const message = errorData?.error?.message || errorData?.message || axiosError.message;
+    if (status === 429) {
+      const retryAfter = parseInt(axiosError.response?.headers["retry-after"] || "60");
+      return new RateLimitError(`${this.providerName} rate limit exceeded: ${message}`, retryAfter);
+    }
+    if (status === 401 || status === 403) {
+      return new ProviderError(
+        `${this.providerName} authentication failed: ${message}`,
+        this.providerName
+      );
+    }
+    if (status && status >= 500) {
+      return new NetworkError(`${this.providerName} server error: ${message}`, status);
+    }
+    if (status && status >= 400) {
+      return new ProviderError(`${this.providerName} request error: ${message}`, this.providerName);
+    }
+    if (axiosError.code === "ECONNABORTED" || axiosError.code === "ETIMEDOUT") {
+      return new NetworkError(`${this.providerName} request timeout: ${message}`);
+    }
+    return new ProviderError(`${this.providerName} error: ${message}`, this.providerName);
+  }
+  /**
+   * Extract provider name from base URL
+   */
+  extractProviderName(baseURL) {
+    try {
+      const url = new URL(baseURL);
+      const hostname = url.hostname;
+      if (hostname.includes("deepseek")) return "DeepSeek";
+      if (hostname.includes("anthropic")) return "Anthropic";
+      if (hostname.includes("openai")) return "OpenAI";
+      if (hostname.includes("google")) return "Google";
+      return hostname;
+    } catch {
+      return "Unknown Provider";
+    }
+  }
+};
+
+// src/providers/pricing/pricingData.ts
+var STATIC_PRICING_TABLE = {
+  deepseek: {
+    "deepseek-chat": {
+      inputPerMillionTokens: 0.14,
+      outputPerMillionTokens: 0.28
+    },
+    "deepseek-reasoner": {
+      inputPerMillionTokens: 0.55,
+      outputPerMillionTokens: 2.19
+    }
+  },
+  anthropic: {
+    "claude-opus-4-5-20251101": {
+      inputPerMillionTokens: 15,
+      outputPerMillionTokens: 75
+    },
+    "claude-opus-4-5": {
+      inputPerMillionTokens: 15,
+      outputPerMillionTokens: 75
+    },
+    "claude-sonnet-4-5-20250929": {
+      inputPerMillionTokens: 3,
+      outputPerMillionTokens: 15
+    },
+    "claude-sonnet-4-5": {
+      inputPerMillionTokens: 3,
+      outputPerMillionTokens: 15
+    },
+    "claude-haiku-4-5": {
+      inputPerMillionTokens: 1,
+      outputPerMillionTokens: 5
+    },
+    "claude-3-7-sonnet-latest": {
+      inputPerMillionTokens: 3,
+      outputPerMillionTokens: 15
+    },
+    "claude-3-5-haiku-latest": {
+      inputPerMillionTokens: 1,
+      outputPerMillionTokens: 5
+    }
+  }
+};
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function getStaticPricing(provider, model) {
+  const providerPricing = STATIC_PRICING_TABLE[provider.toLowerCase()];
+  if (!providerPricing) {
+    return null;
+  }
+  return providerPricing[model] || null;
+}
+
+// src/providers/utils/toolFormatters.ts
+function toOpenAITools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.schema
+      // Already JSON Schema
+    }
+  }));
+}
+function toAnthropicTools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: {
+      type: "object",
+      ...tool.schema
+      // Merge with existing schema
+    }
+  }));
+}
+function parseOpenAIToolCalls(response) {
+  const toolCalls = response.choices?.[0]?.message?.tool_calls || [];
+  return toolCalls.map((tc) => {
+    let parsedArgs;
+    try {
+      parsedArgs = JSON.parse(tc.function.arguments);
+    } catch {
+      parsedArgs = {};
+    }
+    return {
+      id: tc.id,
+      name: tc.function.name,
+      arguments: parsedArgs
+    };
+  });
+}
+function parseAnthropicToolCalls(response) {
+  const content = response.content || [];
+  return content.filter(
+    (block) => block.type === "tool_use"
+  ).map((block) => ({
+    id: block.id,
+    name: block.name,
+    arguments: block.input
+  }));
+}
+function mapOpenAIFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "tool_calls":
+      return "tool_calls";
+    case "length":
+      return "length";
+    case "content_filter":
+    case "insufficient_system_resource":
+      return "error";
+    default:
+      return "error";
+  }
+}
+function mapAnthropicFinishReason(reason) {
+  switch (reason) {
+    case "end_turn":
+      return "stop";
+    case "tool_use":
+      return "tool_calls";
+    case "max_tokens":
+      return "length";
+    case "stop_sequence":
+      return "stop";
+    default:
+      return "error";
+  }
+}
+
+// src/providers/utils/streamParsers.ts
+async function* parseOpenAIStream(stream) {
+  let buffer = "";
+  for await (const chunk of stream) {
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (trimmed === "data: [DONE]") {
+        yield { content: "", done: true };
+        return;
+      }
+      if (trimmed.startsWith("data: ")) {
+        const jsonStr = trimmed.substring(6);
+        try {
+          const data = JSON.parse(jsonStr);
+          const delta = data.choices?.[0]?.delta;
+          const content = delta?.content || "";
+          const finishReason = data.choices?.[0]?.finish_reason;
+          if (content) {
+            yield { content, done: false };
+          }
+          if (finishReason) {
+            yield { content: "", done: true };
+            return;
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+  }
+  if (buffer.trim()) {
+    yield { content: "", done: true };
+  }
+}
+async function* parseAnthropicStream(stream) {
+  let buffer = "";
+  let currentEvent = "";
+  for await (const chunk of stream) {
+    buffer += chunk;
+    const events = buffer.split("\n\n");
+    buffer = events.pop() || "";
+    for (const event of events) {
+      const lines = event.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("event: ")) {
+          currentEvent = trimmed.substring(7);
+        } else if (trimmed.startsWith("data: ")) {
+          const jsonStr = trimmed.substring(6);
+          try {
+            const data = JSON.parse(jsonStr);
+            if (currentEvent === "content_block_delta") {
+              const content = data.delta?.text || "";
+              if (content) {
+                yield { content, done: false };
+              }
+            }
+            if (currentEvent === "content_block_start") {
+              const content = data.content_block?.text || "";
+              if (content) {
+                yield { content, done: false };
+              }
+            }
+            if (currentEvent === "message_delta") {
+              continue;
+            }
+            if (currentEvent === "message_stop") {
+              yield { content: "", done: true };
+              return;
+            }
+            if (currentEvent === "error") {
+              throw new Error(data.error?.message || "Anthropic streaming error");
+            }
+          } catch (error) {
+            if (currentEvent === "error") {
+              throw error;
+            }
+            continue;
+          }
+        }
+      }
+    }
+  }
+  if (buffer.trim()) {
+    yield { content: "", done: true };
+  }
+}
+
+// src/providers/DeepSeekProvider.ts
+var DeepSeekProvider = class extends BaseLLMProvider {
+  apiClient;
+  encoder;
+  constructor(config) {
+    super(config);
+    const apiKey = config.apiKey || process.env.DEEPSEEK_API_KEY;
+    if (!apiKey) {
+      throw new ConfigurationError(
+        "DEEPSEEK_API_KEY not found in config or environment variables. Please set DEEPSEEK_API_KEY in your .env file or pass it via config."
+      );
+    }
+    const baseURL = config.baseURL || "https://api.deepseek.com";
+    this.apiClient = new APIClient({
+      baseURL,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      timeout: 6e4
+    });
+    this.encoder = encoding_for_model("gpt-4");
+  }
+  async chat(messages, tools) {
+    return this.withRetry(async () => {
+      const requestBody = {
+        model: this.config.model,
+        messages: this.formatMessages(messages),
+        tools: tools ? toOpenAITools(tools) : void 0,
+        temperature: this.config.temperature,
+        max_tokens: this.config.maxTokens
+      };
+      const response = await this.apiClient.post(
+        "/chat/completions",
+        requestBody
+      );
+      return this.parseResponse(response);
+    });
+  }
+  async *streamChat(messages, tools) {
+    const requestBody = {
+      model: this.config.model,
+      messages: this.formatMessages(messages),
+      tools: tools ? toOpenAITools(tools) : void 0,
+      temperature: this.config.temperature,
+      max_tokens: this.config.maxTokens,
+      stream: true
+    };
+    const stream = this.apiClient.stream("/chat/completions", requestBody);
+    for await (const chunk of parseOpenAIStream(stream)) {
+      yield chunk;
+    }
+  }
+  countTokens(text) {
+    return this.encoder.encode(text).length;
+  }
+  calculateCost(inputTokens, outputTokens) {
+    const pricing = getStaticPricing("deepseek", this.config.model);
+    if (!pricing) {
+      return 0;
+    }
+    return inputTokens / 1e6 * pricing.inputPerMillionTokens + outputTokens / 1e6 * pricing.outputPerMillionTokens;
+  }
+  /**
+   * Format messages for OpenAI-compatible API
+   */
+  formatMessages(messages) {
+    return messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content,
+      name: msg.name
+    }));
+  }
+  /**
+   * Parse DeepSeek API response
+   */
+  parseResponse(response) {
+    const choice = response.choices[0];
+    const message = choice?.message;
+    const usage = response.usage;
+    if (!choice || !message) {
+      throw new Error("Invalid response from DeepSeek API: missing choice or message");
+    }
+    return {
+      content: message.content || "",
+      toolCalls: parseOpenAIToolCalls(response),
+      finishReason: mapOpenAIFinishReason(choice.finish_reason),
+      usage: {
+        inputTokens: usage.prompt_tokens,
+        outputTokens: usage.completion_tokens,
+        totalTokens: usage.total_tokens
+      }
+    };
+  }
+};
+
+// src/providers/AnthropicProvider.ts
+import { encoding_for_model as encoding_for_model2 } from "tiktoken";
+var AnthropicProvider = class extends BaseLLMProvider {
+  apiClient;
+  encoder;
+  constructor(config) {
+    super(config);
+    const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new ConfigurationError(
+        "ANTHROPIC_API_KEY not found in config or environment variables. Please set ANTHROPIC_API_KEY in your .env file or pass it via config."
+      );
+    }
+    const baseURL = config.baseURL || "https://api.anthropic.com";
+    this.apiClient = new APIClient({
+      baseURL,
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json"
+      },
+      timeout: 6e4
+    });
+    this.encoder = encoding_for_model2("gpt-4");
+  }
+  async chat(messages, tools) {
+    return this.withRetry(async () => {
+      const { system, messages: userMessages } = this.formatAnthropicMessages(messages);
+      const requestBody = {
+        model: this.config.model,
+        messages: userMessages,
+        max_tokens: this.config.maxTokens,
+        temperature: this.config.temperature
+      };
+      if (system) {
+        requestBody.system = system;
+      }
+      if (tools && tools.length > 0) {
+        requestBody.tools = toAnthropicTools(tools);
+      }
+      const response = await this.apiClient.post(
+        "/v1/messages",
+        requestBody
+      );
+      return this.parseResponse(response);
+    });
+  }
+  async *streamChat(messages, tools) {
+    const { system, messages: userMessages } = this.formatAnthropicMessages(messages);
+    const requestBody = {
+      model: this.config.model,
+      messages: userMessages,
+      max_tokens: this.config.maxTokens,
+      temperature: this.config.temperature,
+      stream: true
+    };
+    if (system) {
+      requestBody.system = system;
+    }
+    if (tools && tools.length > 0) {
+      requestBody.tools = toAnthropicTools(tools);
+    }
+    const stream = this.apiClient.stream("/v1/messages", requestBody);
+    for await (const chunk of parseAnthropicStream(stream)) {
+      yield chunk;
+    }
+  }
+  countTokens(text) {
+    return this.encoder.encode(text).length;
+  }
+  calculateCost(inputTokens, outputTokens) {
+    const pricing = getStaticPricing("anthropic", this.config.model);
+    if (!pricing) {
+      return 0;
+    }
+    return inputTokens / 1e6 * pricing.inputPerMillionTokens + outputTokens / 1e6 * pricing.outputPerMillionTokens;
+  }
+  /**
+   * Format messages for Anthropic API
+   * Extracts system messages into separate parameter
+   */
+  formatAnthropicMessages(messages) {
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const userMessages = messages.filter((m) => m.role !== "system");
+    const system = systemMessages.length > 0 ? systemMessages.map((m) => m.content).join("\n\n") : void 0;
+    return {
+      system,
+      messages: userMessages.map((msg) => ({
+        role: msg.role === "assistant" ? "assistant" : "user",
+        content: msg.content
+      }))
+    };
+  }
+  /**
+   * Parse Anthropic API response
+   */
+  parseResponse(response) {
+    const content = response.content || [];
+    const usage = response.usage;
+    const textContent = content.filter((block) => block.type === "text").map((block) => block.text).join("");
+    return {
+      content: textContent,
+      toolCalls: parseAnthropicToolCalls(response),
+      finishReason: mapAnthropicFinishReason(response.stop_reason),
+      usage: {
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        totalTokens: usage.input_tokens + usage.output_tokens
+      }
+    };
+  }
+};
+
+// src/providers/ProviderFactory.ts
+var ProviderFactory = class {
+  static create(config) {
+    switch (config.provider.toLowerCase()) {
+      case "deepseek":
+        return new DeepSeekProvider(config);
+      case "anthropic":
+        return new AnthropicProvider(config);
+      case "openai":
+        throw new Error(
+          "OpenAI provider coming soon - see roadmap Phase 3. In the meantime, you can use DeepSeek which is OpenAI-compatible."
+        );
+      case "google":
+      case "gemini":
+        throw new Error("Google/Gemini provider coming soon - see roadmap Phase 3.");
+      case "qwen":
+        throw new Error(
+          "Qwen provider coming soon - see roadmap Phase 3. In the meantime, you can use DeepSeek which is similar."
+        );
+      case "ollama":
+        throw new Error("Ollama provider coming soon - see roadmap Phase 3.");
+      default:
+        throw new Error(`Unsupported provider: ${config.provider}`);
+    }
+  }
+};
+
+// src/config/schemas.ts
+import { z } from "zod";
+var ThemeSchema = z.enum([
+  "mimir",
+  "dark",
+  "light",
+  "dark-colorblind",
+  "light-colorblind",
+  "dark-ansi",
+  "light-ansi"
+]);
+var UIConfigSchema = z.object({
+  theme: ThemeSchema.default("mimir"),
+  syntaxHighlighting: z.boolean().default(true),
+  showLineNumbers: z.boolean().default(true),
+  compactMode: z.boolean().default(false),
+  // Autocomplete behavior
+  autocompleteAutoShow: z.boolean().default(true),
+  // Automatically show autocomplete when suggestions available
+  autocompleteExecuteOnSelect: z.boolean().default(true)
+  // Execute command immediately if no more parameters needed
+});
+var LLMConfigSchema = z.object({
+  provider: z.enum(["deepseek", "anthropic", "openai", "google", "gemini", "qwen", "ollama"]),
+  model: z.string(),
+  apiKey: z.string().optional(),
+  baseURL: z.string().optional(),
+  temperature: z.number().min(0).max(2).default(0.7),
+  maxTokens: z.number().default(4096)
+});
+var PermissionsConfigSchema = z.object({
+  autoAccept: z.boolean().default(false),
+  acceptRiskLevel: z.enum(["low", "medium", "high", "critical"]).default("medium"),
+  alwaysAcceptCommands: z.array(z.string()).nullable().default([]).transform((val) => val ?? [])
+});
+var shortcutSchema = z.union([z.string(), z.array(z.string()).min(1)]).transform((val) => Array.isArray(val) ? val : [val]);
+var KeyBindingsConfigSchema = z.object({
+  // Core actions - Ctrl+C and Escape share the same 'interrupt' logic
+  interrupt: shortcutSchema.default(["Ctrl+C", "Escape"]),
+  accept: shortcutSchema.default(["Enter"]),
+  // Mode and navigation
+  modeSwitch: shortcutSchema.default(["Shift+Tab"]),
+  editCommand: shortcutSchema.default(["Ctrl+E"]),
+  // Autocomplete/tooltips
+  showTooltip: shortcutSchema.default(["Ctrl+Space", "Tab"]),
+  navigateUp: shortcutSchema.default(["ArrowUp"]),
+  navigateDown: shortcutSchema.default(["ArrowDown"]),
+  // Utility
+  help: shortcutSchema.default(["?"]),
+  clearScreen: shortcutSchema.default(["Ctrl+L"]),
+  undo: shortcutSchema.default(["Ctrl+Z"]),
+  redo: shortcutSchema.default(["Ctrl+Y"]),
+  // Auto-converted to Cmd+Shift+Z on Mac
+  // Legacy/deprecated - kept for backwards compatibility
+  reject: shortcutSchema.default([]).optional()
+});
+var DockerConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  baseImage: z.string().default("alpine:latest"),
+  cpuLimit: z.number().optional(),
+  memoryLimit: z.string().optional()
+});
+var MonitoringConfigSchema = z.object({
+  metricsRetentionDays: z.number().min(1).max(365).default(90),
+  enableHealthChecks: z.boolean().default(true),
+  healthCheckIntervalSeconds: z.number().min(10).max(3600).default(300),
+  slowOperationThresholdMs: z.number().min(100).default(5e3),
+  batchWriteIntervalSeconds: z.number().min(1).max(60).default(10)
+});
+var BudgetConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  dailyLimit: z.number().min(0).optional(),
+  // USD
+  weeklyLimit: z.number().min(0).optional(),
+  monthlyLimit: z.number().min(0).optional(),
+  warningThreshold: z.number().min(0).max(1).default(0.8)
+  // 80%
+});
+var RateLimitConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  commandsPerMinute: z.number().min(1).default(60),
+  toolExecutionsPerMinute: z.number().min(1).default(30),
+  llmCallsPerMinute: z.number().min(1).default(20),
+  maxFileSizeMB: z.number().min(1).default(100)
+});
+var ConfigSchema = z.object({
+  llm: LLMConfigSchema,
+  permissions: PermissionsConfigSchema,
+  keyBindings: KeyBindingsConfigSchema,
+  docker: DockerConfigSchema,
+  ui: UIConfigSchema,
+  monitoring: MonitoringConfigSchema,
+  budget: BudgetConfigSchema,
+  rateLimit: RateLimitConfigSchema
+});
+
+// src/utils/logger.ts
+import winston from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+import fs from "fs";
+import path from "path";
+var Logger = class {
+  logger;
+  fileLoggingEnabled = false;
+  consoleTransport;
+  constructor(logDir = ".mimir/logs") {
+    const absoluteLogDir = path.resolve(process.cwd(), logDir);
+    try {
+      if (!fs.existsSync(absoluteLogDir)) {
+        fs.mkdirSync(absoluteLogDir, { recursive: true });
+      }
+      this.fileLoggingEnabled = true;
+    } catch (error) {
+      console.warn(
+        `[Logger] Warning: Failed to create log directory at ${absoluteLogDir}. File logging disabled. Error: ${error}`
+      );
+      this.fileLoggingEnabled = false;
+    }
+    this.consoleTransport = new winston.transports.Console({
+      format: winston.format.combine(winston.format.colorize(), winston.format.simple())
+    });
+    const transports = [this.consoleTransport];
+    if (this.fileLoggingEnabled) {
+      transports.push(
+        // Error logs with daily rotation
+        new DailyRotateFile({
+          dirname: absoluteLogDir,
+          filename: "%DATE%-error.log",
+          datePattern: "YYYYMMDD",
+          level: "error",
+          maxSize: "10m",
+          // Rotate when file reaches 10MB
+          maxFiles: "30d",
+          // Keep logs for 30 days
+          zippedArchive: true
+          // Compress old logs
+        }),
+        // Combined logs with daily rotation
+        new DailyRotateFile({
+          dirname: absoluteLogDir,
+          filename: "%DATE%.log",
+          datePattern: "YYYYMMDD",
+          maxSize: "10m",
+          // Rotate when file reaches 10MB
+          maxFiles: "30d",
+          // Keep logs for 30 days
+          zippedArchive: true
+          // Compress old logs
+        })
+      );
+    }
+    this.logger = winston.createLogger({
+      level: process.env.LOG_LEVEL || "info",
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.errors({ stack: true }),
+        winston.format.json()
+      ),
+      transports
+    });
+  }
+  error(message, meta) {
+    this.logger.error(message, meta);
+  }
+  warn(message, meta) {
+    this.logger.warn(message, meta);
+  }
+  info(message, meta) {
+    this.logger.info(message, meta);
+  }
+  debug(message, meta) {
+    this.logger.debug(message, meta);
+  }
+  /**
+   * Disable console logging (useful when Ink UI is active)
+   */
+  disableConsole() {
+    this.logger.remove(this.consoleTransport);
+  }
+  /**
+   * Enable console logging
+   */
+  enableConsole() {
+    if (!this.logger.transports.includes(this.consoleTransport)) {
+      this.logger.add(this.consoleTransport);
+    }
+  }
+};
+var logger = new Logger();
+
+// src/config/AllowlistLoader.ts
+import yaml from "yaml";
+import path2 from "path";
+import { z as z2 } from "zod";
+var AllowlistSchema = z2.object({
+  // Command patterns that are always allowed
+  commands: z2.array(z2.string()).default([]),
+  // File patterns that can be modified without confirmation
+  files: z2.array(z2.string()).default([]),
+  // Network destinations that are allowed
+  urls: z2.array(z2.string()).default([]),
+  // Environment variables that can be accessed
+  envVars: z2.array(z2.string()).default([]),
+  // Specific bash commands that are safe
+  bashCommands: z2.array(z2.string()).default([])
+});
+var AllowlistLoader = class {
+  constructor(fs3) {
+    this.fs = fs3;
+  }
+  /**
+   * Load allowlist from project .mimir/allowlist.yml
+   */
+  async loadProjectAllowlist(projectRoot) {
+    const allowlistPath = path2.join(projectRoot, ".mimir", "allowlist.yml");
+    return await this.loadAllowlistFile(allowlistPath, "project");
+  }
+  /**
+   * Load allowlist from global ~/.mimir/allowlist.yml
+   */
+  async loadGlobalAllowlist() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
+    const allowlistPath = path2.join(homeDir, ".mimir", "allowlist.yml");
+    return await this.loadAllowlistFile(allowlistPath, "global");
+  }
+  /**
+   * Load and parse allowlist file
+   */
+  async loadAllowlistFile(filePath, scope) {
+    try {
+      if (!await this.fs.exists(filePath)) {
+        logger.debug(`No ${scope} allowlist found`, { path: filePath });
+        return null;
+      }
+      const content = await this.fs.readFile(filePath);
+      const parsed = yaml.parse(content);
+      const allowlist = AllowlistSchema.parse(parsed);
+      logger.info(`Loaded ${scope} allowlist`, {
+        path: filePath,
+        commands: allowlist.commands.length,
+        files: allowlist.files.length,
+        urls: allowlist.urls.length
+      });
+      return allowlist;
+    } catch (error) {
+      logger.error(`Failed to load ${scope} allowlist`, {
+        path: filePath,
+        error
+      });
+      return null;
+    }
+  }
+  /**
+   * Merge multiple allowlists (global + project)
+   * Project allowlist takes precedence
+   */
+  merge(global, project) {
+    const merged = {
+      commands: [],
+      files: [],
+      urls: [],
+      envVars: [],
+      bashCommands: []
+    };
+    if (global) {
+      merged.commands.push(...global.commands);
+      merged.files.push(...global.files);
+      merged.urls.push(...global.urls);
+      merged.envVars.push(...global.envVars);
+      merged.bashCommands.push(...global.bashCommands);
+    }
+    if (project) {
+      merged.commands = [.../* @__PURE__ */ new Set([...merged.commands, ...project.commands])];
+      merged.files = [.../* @__PURE__ */ new Set([...merged.files, ...project.files])];
+      merged.urls = [.../* @__PURE__ */ new Set([...merged.urls, ...project.urls])];
+      merged.envVars = [.../* @__PURE__ */ new Set([...merged.envVars, ...project.envVars])];
+      merged.bashCommands = [.../* @__PURE__ */ new Set([...merged.bashCommands, ...project.bashCommands])];
+    }
+    return merged;
+  }
+  /**
+   * Create example allowlist file
+   */
+  async createExample(filePath, scope) {
+    const exampleContent = scope === "global" ? this.getGlobalExample() : this.getProjectExample();
+    try {
+      const dir = path2.dirname(filePath);
+      if (!await this.fs.exists(dir)) {
+        await this.fs.mkdir(dir, { recursive: true });
+      }
+      await this.fs.writeFile(filePath, exampleContent);
+      logger.info(`Created example ${scope} allowlist`, { path: filePath });
+    } catch (error) {
+      logger.error(`Failed to create example allowlist`, {
+        path: filePath,
+        error
+      });
+      throw error;
+    }
+  }
+  /**
+   * Get example global allowlist
+   */
+  getGlobalExample() {
+    return `# Global Allowlist
+# Commands, files, and operations that are safe across all projects
+
+# Commands that don't require permission prompt
+commands:
+  - '/status'      # Git status
+  - '/diff'        # Git diff
+  - '/help'        # Show help
+  - '/version'     # Show version
+  - '/doctor'      # System diagnostics
+
+# Safe bash commands
+bashCommands:
+  - 'git status'
+  - 'git diff'
+  - 'git log'
+  - 'ls'
+  - 'pwd'
+  - 'echo *'
+  - 'cat *.md'
+
+# Files that can be modified without confirmation (use globs)
+files:
+  - '**/*.md'      # Documentation files
+  - '**/*.txt'     # Text files
+  - '**/README.*'  # README files
+
+# URLs that can be accessed without confirmation
+urls:
+  - 'https://api.github.com/**'
+  - 'https://registry.npmjs.org/**'
+
+# Environment variables that can be read
+envVars:
+  - 'NODE_ENV'
+  - 'PATH'
+  - 'USER'
+  - 'HOME'
+`;
+  }
+  /**
+   * Get example project allowlist
+   */
+  getProjectExample() {
+    return `# Project Allowlist
+# Team-shared permissions for this project
+# Commit this file to version control for consistent team experience
+
+# Custom slash commands that are safe to run
+commands:
+  - '/test'           # Run test suite
+  - '/lint'           # Run linter
+  - '/build'          # Build project
+  - '/test-coverage'  # Run tests with coverage
+
+# Safe bash commands specific to this project
+bashCommands:
+  - 'yarn test'
+  - 'yarn lint'
+  - 'yarn build'
+  - 'npm run test'
+  - 'npm run lint'
+
+# Files that can be auto-formatted or modified
+files:
+  - 'src/**/*.ts'     # TypeScript source files
+  - 'src/**/*.tsx'    # React TypeScript files
+  - 'tests/**/*.ts'   # Test files
+  - '*.json'          # JSON config files
+  - '.prettierrc.*'   # Prettier config
+  - '.eslintrc.*'     # ESLint config
+
+# API endpoints used by this project
+urls:
+  - 'https://api.example.com/**'
+  - 'https://staging.example.com/**'
+
+# Environment variables specific to this project
+envVars:
+  - 'API_KEY'
+  - 'DATABASE_URL'
+  - 'REDIS_URL'
+`;
+  }
+};
+
+// src/config/ConfigLoader.ts
+import yaml2 from "yaml";
+import path3 from "path";
+import os from "os";
+import dotenv from "dotenv";
+var ConfigLoader = class {
+  constructor(fs3) {
+    this.fs = fs3;
+    this.allowlistLoader = new AllowlistLoader(fs3);
+  }
+  allowlistLoader;
+  /**
+   * Load configuration with full hierarchy:
+   * 1. Default config
+   * 2. Global (~/.mimir/config.yml)
+   * 3. Project (.mimir/config.yml)
+   * 4. Environment variables (.env)
+   * 5. CLI flags
+   *
+   * Also loads allowlist from:
+   * 1. Global (~/.mimir/allowlist.yml)
+   * 2. Project (.mimir/allowlist.yml)
+   */
+  async load(options = {}) {
+    let config = this.getDefaults();
+    const globalConfig = await this.loadGlobalConfig();
+    if (globalConfig) {
+      config = this.merge(config, globalConfig);
+    }
+    if (options.projectRoot) {
+      const projectConfig = await this.loadProjectConfig(options.projectRoot);
+      if (projectConfig) {
+        config = this.merge(config, projectConfig);
+      }
+    }
+    const envConfig = this.loadEnvConfig(options.projectRoot);
+    if (envConfig) {
+      config = this.merge(config, envConfig);
+    }
+    if (options.cliFlags) {
+      config = this.merge(config, options.cliFlags);
+    }
+    const validatedConfig = ConfigSchema.parse(config);
+    const globalAllowlist = await this.allowlistLoader.loadGlobalAllowlist();
+    const projectAllowlist = options.projectRoot ? await this.allowlistLoader.loadProjectAllowlist(options.projectRoot) : null;
+    const mergedAllowlist = this.allowlistLoader.merge(globalAllowlist, projectAllowlist);
+    if (mergedAllowlist.commands.length > 0) {
+      validatedConfig.permissions.alwaysAcceptCommands = [
+        .../* @__PURE__ */ new Set([
+          ...validatedConfig.permissions.alwaysAcceptCommands,
+          ...mergedAllowlist.commands
+        ])
+      ];
+    }
+    return {
+      config: validatedConfig,
+      allowlist: mergedAllowlist
+    };
+  }
+  getDefaults() {
+    const isWindows = process.platform === "win32";
+    return {
+      llm: {
+        provider: "deepseek",
+        model: "deepseek-chat",
+        temperature: 0.7,
+        maxTokens: 4096
+      },
+      permissions: {
+        autoAccept: false,
+        acceptRiskLevel: "medium",
+        alwaysAcceptCommands: []
+      },
+      keyBindings: {
+        interrupt: ["Ctrl+C", "Escape"],
+        accept: ["Enter"],
+        modeSwitch: ["Shift+Tab"],
+        editCommand: ["Ctrl+E"],
+        // Windows: Ctrl+Space is intercepted by terminal - use Tab only
+        // macOS/Linux: Both work
+        showTooltip: isWindows ? ["Tab"] : ["Ctrl+Space", "Tab"],
+        navigateUp: ["ArrowUp"],
+        navigateDown: ["ArrowDown"],
+        help: ["?"],
+        clearScreen: ["Ctrl+L"],
+        undo: ["Ctrl+Z"],
+        redo: ["Ctrl+Y"]
+      },
+      docker: {
+        enabled: true,
+        baseImage: "alpine:latest"
+      },
+      ui: {
+        theme: "mimir",
+        syntaxHighlighting: true,
+        showLineNumbers: true,
+        compactMode: false,
+        autocompleteAutoShow: true,
+        autocompleteExecuteOnSelect: true
+      },
+      monitoring: {
+        metricsRetentionDays: 90,
+        enableHealthChecks: true,
+        healthCheckIntervalSeconds: 300,
+        slowOperationThresholdMs: 5e3,
+        batchWriteIntervalSeconds: 10
+      },
+      budget: {
+        enabled: false,
+        warningThreshold: 0.8
+      },
+      rateLimit: {
+        enabled: true,
+        commandsPerMinute: 60,
+        toolExecutionsPerMinute: 30,
+        llmCallsPerMinute: 20,
+        maxFileSizeMB: 100
+      }
+    };
+  }
+  async loadGlobalConfig() {
+    try {
+      const configPath = path3.join(os.homedir(), ".mimir", "config.yml");
+      if (!await this.fs.exists(configPath)) {
+        return null;
+      }
+      const content = await this.fs.readFile(configPath);
+      return yaml2.parse(content);
+    } catch (error) {
+      logger.warn("Failed to load global config", { error });
+      return null;
+    }
+  }
+  async loadProjectConfig(projectRoot) {
+    try {
+      const configPath = path3.join(projectRoot, ".mimir", "config.yml");
+      if (!await this.fs.exists(configPath)) {
+        return null;
+      }
+      const content = await this.fs.readFile(configPath);
+      return yaml2.parse(content);
+    } catch (error) {
+      logger.warn("Failed to load project config", { error });
+      return null;
+    }
+  }
+  loadEnvConfig(projectRoot) {
+    try {
+      const envPath = projectRoot ? path3.join(projectRoot, ".env") : ".env";
+      dotenv.config({ path: envPath });
+      const envConfig = {};
+      if (process.env.DEEPSEEK_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY) {
+        const provider = process.env.LLM_PROVIDER?.toUpperCase();
+        const apiKey = provider ? process.env[`${provider}_API_KEY`] : void 0;
+        const baseURL = provider ? process.env[`${provider}_BASE_URL`] : void 0;
+        if (apiKey || baseURL) {
+          envConfig.llm = {
+            ...apiKey && { apiKey },
+            ...baseURL && { baseURL }
+          };
+        }
+      }
+      if (process.env.DOCKER_ENABLED) {
+        envConfig.docker = {
+          enabled: process.env.DOCKER_ENABLED === "true"
+        };
+      }
+      if (process.env.MIMIR_THEME) {
+        envConfig.ui = {
+          theme: process.env.MIMIR_THEME
+        };
+      }
+      return Object.keys(envConfig).length > 0 ? envConfig : null;
+    } catch (error) {
+      logger.warn("Failed to load .env config", { error });
+      return null;
+    }
+  }
+  merge(base, override) {
+    return {
+      llm: { ...base.llm, ...override.llm },
+      permissions: { ...base.permissions, ...override.permissions },
+      keyBindings: { ...base.keyBindings, ...override.keyBindings },
+      docker: { ...base.docker, ...override.docker },
+      ui: { ...base.ui, ...override.ui },
+      monitoring: { ...base.monitoring, ...override.monitoring },
+      budget: { ...base.budget, ...override.budget },
+      rateLimit: { ...base.rateLimit, ...override.rateLimit }
+    };
+  }
+  async save(config, scope, projectRoot) {
+    const configPath = scope === "global" ? path3.join(os.homedir(), ".mimir", "config.yml") : path3.join(projectRoot || process.cwd(), ".mimir", "config.yml");
+    const configDir = path3.dirname(configPath);
+    if (!await this.fs.exists(configDir)) {
+      await this.fs.mkdir(configDir, { recursive: true });
+    }
+    const yamlContent = yaml2.stringify(config);
+    await this.fs.writeFile(configPath, yamlContent);
+    logger.info(`Config saved to ${configPath}`);
+  }
+  validate(config) {
+    return ConfigSchema.parse(config);
+  }
+};
+
+// src/platform/FileSystemAdapter.ts
+import fs2 from "fs/promises";
+import { globby } from "globby";
+var FileSystemAdapter = class {
+  async readFile(path4, encoding = "utf-8") {
+    return fs2.readFile(path4, encoding);
+  }
+  async writeFile(path4, content, encoding = "utf-8") {
+    await fs2.writeFile(path4, content, encoding);
+  }
+  async exists(path4) {
+    try {
+      await fs2.access(path4);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async mkdir(path4, options) {
+    await fs2.mkdir(path4, options);
+  }
+  async readdir(path4) {
+    return fs2.readdir(path4);
+  }
+  async stat(path4) {
+    const stats = await fs2.stat(path4);
+    return {
+      isFile: () => stats.isFile(),
+      isDirectory: () => stats.isDirectory(),
+      size: stats.size,
+      mtime: stats.mtime
+    };
+  }
+  async unlink(path4) {
+    await fs2.unlink(path4);
+  }
+  async rmdir(path4, options) {
+    await fs2.rmdir(path4, options);
+  }
+  async copyFile(src, dest) {
+    await fs2.copyFile(src, dest);
+  }
+  async glob(pattern, options) {
+    return globby(pattern, {
+      cwd: options?.cwd,
+      ignore: options?.ignore
+    });
+  }
+};
+export {
+  Agent,
+  BaseLLMProvider,
+  ConfigLoader,
+  ConfigurationError,
+  DockerError,
+  FileSystemAdapter,
+  Logger,
+  MimirError,
+  NetworkError,
+  PermissionDeniedError,
+  PermissionManager,
+  ProviderError,
+  ProviderFactory,
+  RateLimitError,
+  ToolExecutionError,
+  ToolRegistry,
+  createErr,
+  createOk,
+  logger
+};
+//# sourceMappingURL=index.js.map