@within-7/minto 0.4.2 → 0.4.3

package/dist/utils/async.js

@@ -1,167 +0,0 @@
-const DEFAULT_RETRY_CONFIG = {
-  baseDelayMs: 1e3,
-  maxDelayMs: 32e3,
-  maxServerDelayMs: 6e4,
-  jitterFactor: 0.1
-};
-function abortableDelay(delayMs, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new Error("Request was aborted"));
-      return;
-    }
-    const timeoutId = setTimeout(() => {
-      resolve();
-    }, delayMs);
-    if (signal) {
-      const abortHandler = () => {
-        clearTimeout(timeoutId);
-        reject(new Error("Request was aborted"));
-      };
-      signal.addEventListener("abort", abortHandler, { once: true });
-    }
-  });
-}
-function getRetryDelay(attempt, retryAfterHeader, config = DEFAULT_RETRY_CONFIG) {
-  if (retryAfterHeader) {
-    const retryAfterMs = parseInt(retryAfterHeader, 10) * 1e3;
-    if (!isNaN(retryAfterMs) && retryAfterMs > 0) {
-      return Math.min(retryAfterMs, config.maxServerDelayMs);
-    }
-  }
-  const delay = config.baseDelayMs * Math.pow(2, attempt - 1);
-  const jitter = Math.random() * config.jitterFactor * delay;
-  return Math.min(delay + jitter, config.maxDelayMs);
-}
-function withTimeout(promise, timeoutMs, message = "Operation timed out") {
-  return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      reject(new Error(message));
-    }, timeoutMs);
-    promise.then((result) => {
-      clearTimeout(timeoutId);
-      resolve(result);
-    }).catch((error) => {
-      clearTimeout(timeoutId);
-      reject(error);
-    });
-  });
-}
-function createTimeoutController(timeoutMs) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  return {
-    controller,
-    cleanup: () => clearTimeout(timeoutId)
-  };
-}
-async function retryWithBackoff(fn, options = {}) {
-  const {
-    maxRetries = 3,
-    signal,
-    config = DEFAULT_RETRY_CONFIG,
-    onRetry,
-    shouldRetry
-  } = options;
-  const fullConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
-  let lastError;
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    if (signal?.aborted) {
-      throw new Error("Request was aborted");
-    }
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (shouldRetry && !shouldRetry(lastError)) {
-        throw lastError;
-      }
-      if (attempt < maxRetries) {
-        onRetry?.(attempt, lastError);
-        const delay = getRetryDelay(attempt, void 0, fullConfig);
-        await abortableDelay(delay, signal);
-      }
-    }
-  }
-  throw lastError ?? new Error("Retry failed with unknown error");
-}
-function memoizeWithLimit(fn, options = {}) {
-  const { max = 100, ttl = 6e4, resolver } = options;
-  const cache = /* @__PURE__ */ new Map();
-  const evictOldest = () => {
-    if (cache.size >= max) {
-      const oldest = cache.keys().next().value;
-      if (oldest) cache.delete(oldest);
-    }
-  };
-  const isExpired = (entry) => {
-    return Date.now() - entry.timestamp > ttl;
-  };
-  return ((...args) => {
-    const key = resolver ? resolver(...args) : JSON.stringify(args);
-    const existing = cache.get(key);
-    if (existing && !isExpired(existing)) {
-      cache.delete(key);
-      cache.set(key, existing);
-      return existing.value;
-    }
-    if (existing) {
-      cache.delete(key);
-    }
-    const value = fn(...args);
-    evictOldest();
-    cache.set(key, { value, timestamp: Date.now() });
-    return value;
-  });
-}
-function memoizeAsyncWithLimit(fn, options = {}) {
-  const { max = 100, ttl = 6e4, resolver } = options;
-  const cache = /* @__PURE__ */ new Map();
-  const pending = /* @__PURE__ */ new Map();
-  const evictOldest = () => {
-    if (cache.size >= max) {
-      const oldest = cache.keys().next().value;
-      if (oldest) cache.delete(oldest);
-    }
-  };
-  const isExpired = (entry) => {
-    return Date.now() - entry.timestamp > ttl;
-  };
-  return (async (...args) => {
-    const key = resolver ? resolver(...args) : JSON.stringify(args);
-    const existing = cache.get(key);
-    if (existing && !isExpired(existing)) {
-      cache.delete(key);
-      cache.set(key, existing);
-      return existing.value;
-    }
-    const pendingPromise = pending.get(key);
-    if (pendingPromise) {
-      return pendingPromise;
-    }
-    if (existing) {
-      cache.delete(key);
-    }
-    const promise = fn(...args);
-    pending.set(key, promise);
-    try {
-      const value = await promise;
-      evictOldest();
-      cache.set(key, { value, timestamp: Date.now() });
-      return value;
-    } finally {
-      pending.delete(key);
-    }
-  });
-}
-export {
-  DEFAULT_RETRY_CONFIG,
-  abortableDelay,
-  createTimeoutController,
-  getRetryDelay,
-  memoizeAsyncWithLimit,
-  memoizeWithLimit,
-  retryWithBackoff,
-  withTimeout
-};
-//# sourceMappingURL=async.js.map

package/dist/utils/async.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/async.ts"],
-  "sourcesContent": ["/**\n * Shared async utilities for consistent async patterns across the codebase.\n * Extracted from claude.ts and openai.ts to eliminate code duplication.\n */\n\nexport interface RetryConfig {\n  baseDelayMs: number\n  maxDelayMs: number\n  maxServerDelayMs: number\n  jitterFactor: number\n}\n\nexport const DEFAULT_RETRY_CONFIG: RetryConfig = {\n  baseDelayMs: 1000,\n  maxDelayMs: 32000,\n  maxServerDelayMs: 60000,\n  jitterFactor: 0.1,\n}\n\nexport interface RetryOptions {\n  maxRetries?: number\n  signal?: AbortSignal\n  config?: Partial<RetryConfig>\n  onRetry?: (attempt: number, error: Error) => void\n  /** Optional predicate to determine if a given error is retryable. Defaults to retrying all errors. */\n  shouldRetry?: (error: Error) => boolean\n}\n\n/**\n * Creates a promise that resolves after the specified delay.\n * Can be aborted via an AbortSignal.\n */\nexport function abortableDelay(\n  delayMs: number,\n  signal?: AbortSignal,\n): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(new Error('Request was aborted'))\n      return\n    }\n\n    const timeoutId = setTimeout(() => {\n      resolve()\n    }, delayMs)\n\n    if (signal) {\n      const abortHandler = () => {\n        clearTimeout(timeoutId)\n        reject(new Error('Request was aborted'))\n      }\n      signal.addEventListener('abort', abortHandler, { once: true })\n    }\n  })\n}\n\n/**\n * Calculate retry delay with exponential backoff and optional jitter.\n * Respects server-provided Retry-After headers when available.\n */\nexport function getRetryDelay(\n  attempt: number,\n  retryAfterHeader?: string | null,\n  config: RetryConfig = DEFAULT_RETRY_CONFIG,\n): number {\n  if (retryAfterHeader) {\n    const retryAfterMs = parseInt(retryAfterHeader, 10) * 1000\n    if (!isNaN(retryAfterMs) && retryAfterMs > 0) {\n      return Math.min(retryAfterMs, config.maxServerDelayMs)\n    }\n  }\n\n  const delay = config.baseDelayMs * Math.pow(2, attempt - 1)\n  const jitter = Math.random() * config.jitterFactor * delay\n\n  return Math.min(delay + jitter, config.maxDelayMs)\n}\n\n/**\n * Wraps a promise with a timeout.\n * Rejects with a timeout error if the promise doesn't resolve in time.\n */\nexport function withTimeout<T>(\n  promise: Promise<T>,\n  timeoutMs: number,\n  message = 'Operation timed out',\n): Promise<T> {\n  return new Promise((resolve, reject) => {\n    const timeoutId = setTimeout(() => {\n      reject(new Error(message))\n    }, timeoutMs)\n\n    promise\n      .then(result => {\n        clearTimeout(timeoutId)\n        resolve(result)\n      })\n      .catch(error => {\n        clearTimeout(timeoutId)\n        reject(error)\n      })\n  })\n}\n\n/**\n * Creates an AbortController that automatically aborts after the specified timeout.\n * Returns both the controller and a cleanup function.\n */\nexport function createTimeoutController(timeoutMs: number): {\n  controller: AbortController\n  cleanup: () => void\n} {\n  const controller = new AbortController()\n  const timeoutId = setTimeout(() => controller.abort(), timeoutMs)\n\n  return {\n    controller,\n    cleanup: () => clearTimeout(timeoutId),\n  }\n}\n\n/**\n * Retries an async function with exponential backoff.\n * Supports abort signals and custom retry conditions.\n */\nexport async function retryWithBackoff<T>(\n  fn: () => Promise<T>,\n  options: RetryOptions = {},\n): Promise<T> {\n  const {\n    maxRetries = 3,\n    signal,\n    config = DEFAULT_RETRY_CONFIG,\n    onRetry,\n    shouldRetry,\n  } = options\n\n  const fullConfig = { ...DEFAULT_RETRY_CONFIG, ...config }\n  let lastError: Error | undefined\n\n  for (let attempt = 1; attempt <= maxRetries; attempt++) {\n    if (signal?.aborted) {\n      throw new Error('Request was aborted')\n    }\n\n    try {\n      return await fn()\n    } catch (error) {\n      lastError = error instanceof Error ? error : new Error(String(error))\n\n      // If shouldRetry predicate is provided and says no, throw immediately\n      if (shouldRetry && !shouldRetry(lastError)) {\n        throw lastError\n      }\n\n      if (attempt < maxRetries) {\n        onRetry?.(attempt, lastError)\n        const delay = getRetryDelay(attempt, undefined, fullConfig)\n        await abortableDelay(delay, signal)\n      }\n    }\n  }\n\n  throw lastError ?? new Error('Retry failed with unknown error')\n}\n\n/**\n * Options for memoizeWithLimit\n */\nexport interface MemoizeOptions<T extends (...args: unknown[]) => unknown> {\n  /** Maximum number of cached entries (default: 100) */\n  max?: number\n  /** Time-to-live in milliseconds (default: 60000) */\n  ttl?: number\n  /** Custom resolver function to generate cache key from arguments */\n  resolver?: (...args: Parameters<T>) => string\n}\n\n/**\n * Creates a memoized version of a function with LRU cache and TTL.\n * Unlike lodash memoize which has unlimited cache, this has bounded memory usage.\n *\n * @param fn - The function to memoize\n * @param options - Cache configuration options\n * @returns Memoized function\n */\nexport function memoizeWithLimit<T extends (...args: unknown[]) => unknown>(\n  fn: T,\n  options: MemoizeOptions<T> = {},\n): T {\n  const { max = 100, ttl = 60000, resolver } = options\n\n  interface CacheEntry {\n    value: ReturnType<T>\n    timestamp: number\n  }\n\n  const cache = new Map<string, CacheEntry>()\n\n  // LRU eviction helper\n  const evictOldest = () => {\n    if (cache.size >= max) {\n      const oldest = cache.keys().next().value\n      if (oldest) cache.delete(oldest)\n    }\n  }\n\n  // Check if entry is expired\n  const isExpired = (entry: CacheEntry): boolean => {\n    return Date.now() - entry.timestamp > ttl\n  }\n\n  return ((...args: Parameters<T>): ReturnType<T> => {\n    const key = resolver ? resolver(...args) : JSON.stringify(args)\n\n    // Check cache\n    const existing = cache.get(key)\n    if (existing && !isExpired(existing)) {\n      // Move to end for LRU\n      cache.delete(key)\n      cache.set(key, existing)\n      return existing.value\n    }\n\n    // Remove expired entry if exists\n    if (existing) {\n      cache.delete(key)\n    }\n\n    // Compute new value\n    const value = fn(...args) as ReturnType<T>\n\n    // Evict oldest if at capacity\n    evictOldest()\n\n    // Store in cache\n    cache.set(key, { value, timestamp: Date.now() })\n\n    return value\n  }) as T\n}\n\n/**\n * Async version of memoizeWithLimit for async functions\n */\nexport function memoizeAsyncWithLimit<\n  T extends (...args: unknown[]) => Promise<unknown>,\n>(fn: T, options: MemoizeOptions<T> = {}): T {\n  const { max = 100, ttl = 60000, resolver } = options\n\n  interface CacheEntry {\n    value: Awaited<ReturnType<T>>\n    timestamp: number\n  }\n\n  const cache = new Map<string, CacheEntry>()\n  const pending = new Map<string, Promise<Awaited<ReturnType<T>>>>()\n\n  const evictOldest = () => {\n    if (cache.size >= max) {\n      const oldest = cache.keys().next().value\n      if (oldest) cache.delete(oldest)\n    }\n  }\n\n  const isExpired = (entry: CacheEntry): boolean => {\n    return Date.now() - entry.timestamp > ttl\n  }\n\n  return (async (...args: Parameters<T>): Promise<Awaited<ReturnType<T>>> => {\n    const key = resolver ? resolver(...args) : JSON.stringify(args)\n\n    // Check cache\n    const existing = cache.get(key)\n    if (existing && !isExpired(existing)) {\n      cache.delete(key)\n      cache.set(key, existing)\n      return existing.value\n    }\n\n    // Check pending\n    const pendingPromise = pending.get(key)\n    if (pendingPromise) {\n      return pendingPromise\n    }\n\n    // Remove expired\n    if (existing) {\n      cache.delete(key)\n    }\n\n    // Compute new value\n    const promise = fn(...args) as Promise<Awaited<ReturnType<T>>>\n    pending.set(key, promise)\n\n    try {\n      const value = await promise\n      evictOldest()\n      cache.set(key, { value, timestamp: Date.now() })\n      return value\n    } finally {\n      pending.delete(key)\n    }\n  }) as T\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/utils/asyncFile.js

@@ -1,215 +0,0 @@
-import { promises as fs } from "fs";
-import { existsSync } from "fs";
-import { dirname, basename, extname, join } from "path";
-import { logError } from "./log.js";
-import { LRUCache } from "lru-cache";
-async function readFileAsync(filePath, encoding = "utf8") {
-  try {
-    return await fs.readFile(filePath, encoding);
-  } catch (error) {
-    logError(error);
-    return null;
-  }
-}
-async function writeFileAsync(filePath, content, encoding = "utf8") {
-  try {
-    await fs.writeFile(filePath, content, { encoding });
-    return true;
-  } catch (error) {
-    logError(error);
-    return false;
-  }
-}
-async function existsAsync(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readdirAsync(dirPath) {
-  try {
-    return await fs.readdir(dirPath);
-  } catch (error) {
-    logError(error);
-    return [];
-  }
-}
-async function statAsync(filePath) {
-  try {
-    const stats = await fs.stat(filePath);
-    return {
-      size: stats.size,
-      mtime: stats.mtime,
-      isFile: stats.isFile(),
-      isDirectory: stats.isDirectory()
-    };
-  } catch {
-    return null;
-  }
-}
-async function unlinkAsync(filePath) {
-  try {
-    await fs.unlink(filePath);
-    return true;
-  } catch (error) {
-    logError(error);
-    return false;
-  }
-}
-async function mkdirAsync(dirPath, recursive = true) {
-  try {
-    await fs.mkdir(dirPath, { recursive });
-    return true;
-  } catch (error) {
-    logError(error);
-    return false;
-  }
-}
-async function copyFileAsync(src, dest) {
-  try {
-    await fs.copyFile(src, dest);
-    return true;
-  } catch (error) {
-    logError(error);
-    return false;
-  }
-}
-async function renameAsync(oldPath, newPath) {
-  try {
-    await fs.rename(oldPath, newPath);
-    return true;
-  } catch (error) {
-    logError(error);
-    return false;
-  }
-}
-async function readJsonAsync(filePath) {
-  const content = await readFileAsync(filePath);
-  if (!content) return null;
-  try {
-    return JSON.parse(content);
-  } catch (error) {
-    logError(`Failed to parse JSON from ${filePath}: ${error}`);
-    return null;
-  }
-}
-async function writeJsonAsync(filePath, data, pretty = true) {
-  try {
-    const content = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
-    return await writeFileAsync(filePath, content);
-  } catch (error) {
-    logError(error);
-    return false;
-  }
-}
-async function readFileWithLineNumbersAsync(filePath, options = {}) {
-  const { startLine = 1, maxLines, encoding = "utf8" } = options;
-  const fileContent = await readFileAsync(filePath, encoding);
-  if (fileContent === null) return null;
-  const lines = fileContent.split(/\r?\n/);
-  const offset = startLine - 1;
-  const toReturn = maxLines !== void 0 && lines.length - offset > maxLines ? lines.slice(offset, offset + maxLines) : lines.slice(offset);
-  const numberedContent = toReturn.map((line, index) => {
-    const lineNum = index + startLine;
-    const numStr = String(lineNum);
-    if (numStr.length >= 6) {
-      return `${numStr}	${line}`;
-    }
-    const n = numStr.padStart(6, " ");
-    return `${n}	${line}`;
-  }).join("\n");
-  return {
-    content: numberedContent,
-    lineCount: toReturn.length,
-    totalLines: lines.length
-  };
-}
-async function findSimilarFileAsync(filePath) {
-  try {
-    const dir = dirname(filePath);
-    const fileBaseName = basename(filePath, extname(filePath));
-    if (!existsSync(dir)) {
-      return void 0;
-    }
-    const files = await readdirAsync(dir);
-    const similarFiles = files.filter(
-      (file) => basename(file, extname(file)) === fileBaseName && join(dir, file) !== filePath
-    );
-    return similarFiles[0];
-  } catch (error) {
-    logError(`Error finding similar file for ${filePath}: ${error}`);
-    return void 0;
-  }
-}
-async function isDirEmptyAsync(dirPath) {
-  const entries = await readdirAsync(dirPath);
-  return entries.length === 0;
-}
-const fileContentCache = new LRUCache({
-  max: 100,
-  ttl: 3e4
-  // 30 seconds
-});
-async function readFileCachedAsync(filePath, encoding = "utf8") {
-  const cacheKey = `${filePath}:${encoding}`;
-  const cached = fileContentCache.get(cacheKey);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const content = await readFileAsync(filePath, encoding);
-  if (content !== null) {
-    fileContentCache.set(cacheKey, content);
-  }
-  return content;
-}
-function invalidateFileCache(filePath) {
-  for (const key of fileContentCache.keys()) {
-    if (key.startsWith(filePath)) {
-      fileContentCache.delete(key);
-    }
-  }
-}
-function clearFileCache() {
-  fileContentCache.clear();
-}
-async function readFilesAsync(filePaths, encoding = "utf8") {
-  const results = await Promise.all(
-    filePaths.map(async (path) => ({
-      path,
-      content: await readFileAsync(path, encoding)
-    }))
-  );
-  return new Map(results.map((r) => [r.path, r.content]));
-}
-async function ensureWriteFileAsync(filePath, content, encoding = "utf8") {
-  const dir = dirname(filePath);
-  if (!await existsAsync(dir)) {
-    const created = await mkdirAsync(dir, true);
-    if (!created) return false;
-  }
-  return await writeFileAsync(filePath, content, encoding);
-}
-export {
-  clearFileCache,
-  copyFileAsync,
-  ensureWriteFileAsync,
-  existsAsync,
-  findSimilarFileAsync,
-  invalidateFileCache,
-  isDirEmptyAsync,
-  mkdirAsync,
-  readFileAsync,
-  readFileCachedAsync,
-  readFileWithLineNumbersAsync,
-  readFilesAsync,
-  readJsonAsync,
-  readdirAsync,
-  renameAsync,
-  statAsync,
-  unlinkAsync,
-  writeFileAsync,
-  writeJsonAsync
-};
-//# sourceMappingURL=asyncFile.js.map

package/dist/utils/asyncFile.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/asyncFile.ts"],
-  "sourcesContent": ["/**\n * Async File Operations Utility\n *\n * Provides non-blocking file operations for improved performance.\n * Use these instead of sync operations in hot paths.\n */\n\nimport { promises as fs } from 'fs'\nimport { existsSync } from 'fs'\nimport { resolve, dirname, basename, extname, join } from 'path'\nimport { getCwd } from './state'\nimport { logError } from './log'\nimport { LRUCache } from 'lru-cache'\n\n/**\n * Read file content asynchronously\n */\nexport async function readFileAsync(\n  filePath: string,\n  encoding: BufferEncoding = 'utf8',\n): Promise<string | null> {\n  try {\n    return await fs.readFile(filePath, encoding)\n  } catch (error) {\n    logError(error)\n    return null\n  }\n}\n\n/**\n * Write file content asynchronously\n */\nexport async function writeFileAsync(\n  filePath: string,\n  content: string,\n  encoding: BufferEncoding = 'utf8',\n): Promise<boolean> {\n  try {\n    await fs.writeFile(filePath, content, { encoding })\n    return true\n  } catch (error) {\n    logError(error)\n    return false\n  }\n}\n\n/**\n * Check if file exists asynchronously\n */\nexport async function existsAsync(filePath: string): Promise<boolean> {\n  try {\n    await fs.access(filePath)\n    return true\n  } catch {\n    return false\n  }\n}\n\n/**\n * Read directory contents asynchronously\n */\nexport async function readdirAsync(dirPath: string): Promise<string[]> {\n  try {\n    return await fs.readdir(dirPath)\n  } catch (error) {\n    logError(error)\n    return []\n  }\n}\n\n/**\n * Get file stats asynchronously\n */\nexport async function statAsync(filePath: string): Promise<{\n  size: number\n  mtime: Date\n  isFile: boolean\n  isDirectory: boolean\n} | null> {\n  try {\n    const stats = await fs.stat(filePath)\n    return {\n      size: stats.size,\n      mtime: stats.mtime,\n      isFile: stats.isFile(),\n      isDirectory: stats.isDirectory(),\n    }\n  } catch {\n    return null\n  }\n}\n\n/**\n * Delete file asynchronously\n */\nexport async function unlinkAsync(filePath: string): Promise<boolean> {\n  try {\n    await fs.unlink(filePath)\n    return true\n  } catch (error) {\n    logError(error)\n    return false\n  }\n}\n\n/**\n * Create directory asynchronously (recursive)\n */\nexport async function mkdirAsync(\n  dirPath: string,\n  recursive = true,\n): Promise<boolean> {\n  try {\n    await fs.mkdir(dirPath, { recursive })\n    return true\n  } catch (error) {\n    logError(error)\n    return false\n  }\n}\n\n/**\n * Copy file asynchronously\n */\nexport async function copyFileAsync(\n  src: string,\n  dest: string,\n): Promise<boolean> {\n  try {\n    await fs.copyFile(src, dest)\n    return true\n  } catch (error) {\n    logError(error)\n    return false\n  }\n}\n\n/**\n * Rename/move file asynchronously\n */\nexport async function renameAsync(\n  oldPath: string,\n  newPath: string,\n): Promise<boolean> {\n  try {\n    await fs.rename(oldPath, newPath)\n    return true\n  } catch (error) {\n    logError(error)\n    return false\n  }\n}\n\n/**\n * Read JSON file asynchronously with type safety\n */\nexport async function readJsonAsync<T>(filePath: string): Promise<T | null> {\n  const content = await readFileAsync(filePath)\n  if (!content) return null\n\n  try {\n    return JSON.parse(content) as T\n  } catch (error) {\n    logError(`Failed to parse JSON from ${filePath}: ${error}`)\n    return null\n  }\n}\n\n/**\n * Write JSON file asynchronously\n */\nexport async function writeJsonAsync<T>(\n  filePath: string,\n  data: T,\n  pretty = true,\n): Promise<boolean> {\n  try {\n    const content = pretty\n      ? JSON.stringify(data, null, 2)\n      : JSON.stringify(data)\n    return await writeFileAsync(filePath, content)\n  } catch (error) {\n    logError(error)\n    return false\n  }\n}\n\n/**\n * Read file with line numbers (async version of addLineNumbers)\n */\nexport async function readFileWithLineNumbersAsync(\n  filePath: string,\n  options: {\n    startLine?: number\n    maxLines?: number\n    encoding?: BufferEncoding\n  } = {},\n): Promise<{\n  content: string\n  lineCount: number\n  totalLines: number\n} | null> {\n  const { startLine = 1, maxLines, encoding = 'utf8' } = options\n\n  const fileContent = await readFileAsync(filePath, encoding)\n  if (fileContent === null) return null\n\n  const lines = fileContent.split(/\\r?\\n/)\n  const offset = startLine - 1\n\n  const toReturn =\n    maxLines !== undefined && lines.length - offset > maxLines\n      ? lines.slice(offset, offset + maxLines)\n      : lines.slice(offset)\n\n  // Add line numbers\n  const numberedContent = toReturn\n    .map((line, index) => {\n      const lineNum = index + startLine\n      const numStr = String(lineNum)\n      if (numStr.length >= 6) {\n        return `${numStr}\\t${line}`\n      }\n      const n = numStr.padStart(6, ' ')\n      return `${n}\\t${line}`\n    })\n    .join('\\n')\n\n  return {\n    content: numberedContent,\n    lineCount: toReturn.length,\n    totalLines: lines.length,\n  }\n}\n\n/**\n * Find similar files asynchronously\n */\nexport async function findSimilarFileAsync(\n  filePath: string,\n): Promise<string | undefined> {\n  try {\n    const dir = dirname(filePath)\n    const fileBaseName = basename(filePath, extname(filePath))\n\n    // Check if directory exists (use sync for this quick check)\n    if (!existsSync(dir)) {\n      return undefined\n    }\n\n    const files = await readdirAsync(dir)\n\n    const similarFiles = files.filter(\n      file =>\n        basename(file, extname(file)) === fileBaseName &&\n        join(dir, file) !== filePath,\n    )\n\n    return similarFiles[0]\n  } catch (error) {\n    logError(`Error finding similar file for ${filePath}: ${error}`)\n    return undefined\n  }\n}\n\n/**\n * Check if directory is empty asynchronously\n */\nexport async function isDirEmptyAsync(dirPath: string): Promise<boolean> {\n  const entries = await readdirAsync(dirPath)\n  return entries.length === 0\n}\n\n// File content cache for frequently accessed files\nconst fileContentCache = new LRUCache<string, string>({\n  max: 100,\n  ttl: 30_000, // 30 seconds\n})\n\n/**\n * Read file with caching for frequently accessed files\n */\nexport async function readFileCachedAsync(\n  filePath: string,\n  encoding: BufferEncoding = 'utf8',\n): Promise<string | null> {\n  const cacheKey = `${filePath}:${encoding}`\n\n  const cached = fileContentCache.get(cacheKey)\n  if (cached !== undefined) {\n    return cached\n  }\n\n  const content = await readFileAsync(filePath, encoding)\n  if (content !== null) {\n    fileContentCache.set(cacheKey, content)\n  }\n\n  return content\n}\n\n/**\n * Invalidate cache for a file\n */\nexport function invalidateFileCache(filePath: string): void {\n  // Remove all cache entries for this file (any encoding)\n  for (const key of fileContentCache.keys()) {\n    if (key.startsWith(filePath)) {\n      fileContentCache.delete(key)\n    }\n  }\n}\n\n/**\n * Clear entire file cache\n */\nexport function clearFileCache(): void {\n  fileContentCache.clear()\n}\n\n/**\n * Batch read multiple files concurrently\n */\nexport async function readFilesAsync(\n  filePaths: string[],\n  encoding: BufferEncoding = 'utf8',\n): Promise<Map<string, string | null>> {\n  const results = await Promise.all(\n    filePaths.map(async path => ({\n      path,\n      content: await readFileAsync(path, encoding),\n    })),\n  )\n\n  return new Map(results.map(r => [r.path, r.content]))\n}\n\n/**\n * Ensure parent directory exists before writing\n */\nexport async function ensureWriteFileAsync(\n  filePath: string,\n  content: string,\n  encoding: BufferEncoding = 'utf8',\n): Promise<boolean> {\n  const dir = dirname(filePath)\n\n  // Create parent directory if needed\n  if (!(await existsAsync(dir))) {\n    const created = await mkdirAsync(dir, true)\n    if (!created) return false\n  }\n\n  return await writeFileAsync(filePath, content, encoding)\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/utils/atomicWrite.js

@@ -1,23 +0,0 @@
-import { writeFileSync, renameSync, rmSync } from "fs";
-import { dirname, join } from "path";
-function atomicWriteFileSync(filePath, content, mode = 420) {
-  const dir = dirname(filePath);
-  const tempPath = join(
-    dir,
-    `.${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`
-  );
-  try {
-    writeFileSync(tempPath, content, { encoding: "utf-8", mode });
-    renameSync(tempPath, filePath);
-  } catch (error) {
-    try {
-      rmSync(tempPath, { force: true });
-    } catch {
-    }
-    throw error;
-  }
-}
-export {
-  atomicWriteFileSync
-};
-//# sourceMappingURL=atomicWrite.js.map

package/dist/utils/atomicWrite.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/atomicWrite.ts"],
-  "sourcesContent": ["import { writeFileSync, renameSync, rmSync } from 'fs'\nimport { dirname, join } from 'path'\n\n/**\n * Atomically write content to a file using temp file + rename pattern.\n * This prevents data corruption if writes are interrupted or multiple processes\n * attempt to write concurrently.\n *\n * @param filePath - The target file path to write to\n * @param content - The content to write\n * @throws {Error} If write or rename operation fails\n */\nexport function atomicWriteFileSync(\n  filePath: string,\n  content: string,\n  mode: number = 0o644,\n): void {\n  const dir = dirname(filePath)\n  const tempPath = join(\n    dir,\n    `.${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`,\n  )\n\n  try {\n    // Write to temporary file with specified permissions\n    writeFileSync(tempPath, content, { encoding: 'utf-8', mode })\n    // Atomically rename temp to target (atomic on most filesystems)\n    renameSync(tempPath, filePath)\n  } catch (error) {\n    // Clean up temporary file on failure\n    try {\n      rmSync(tempPath, { force: true })\n    } catch {\n      // Ignore cleanup errors\n    }\n    throw error\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,eAAe,YAAY,cAAc;AAClD,SAAS,SAAS,YAAY;AAWvB,SAAS,oBACd,UACA,SACA,OAAe,KACT;AACN,QAAM,MAAM,QAAQ,QAAQ;AAC5B,QAAM,WAAW;AAAA,IACf;AAAA,IACA,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC,CAAC;AAAA,EACvD;AAEA,MAAI;AAEF,kBAAc,UAAU,SAAS,EAAE,UAAU,SAAS,KAAK,CAAC;AAE5D,eAAW,UAAU,QAAQ;AAAA,EAC/B,SAAS,OAAO;AAEd,QAAI;AACF,aAAO,UAAU,EAAE,OAAO,KAAK,CAAC;AAAA,IAClC,QAAQ;AAAA,IAER;AACA,UAAM;AAAA,EACR;AACF;",
-  "names": []
-}

package/dist/utils/auth.js

@@ -1,11 +0,0 @@
-function isAnthropicAuthEnabled() {
-  return false;
-}
-function isLoggedInToAnthropic() {
-  return false;
-}
-export {
-  isAnthropicAuthEnabled,
-  isLoggedInToAnthropic
-};
-//# sourceMappingURL=auth.js.map

package/dist/utils/auth.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/auth.ts"],
-  "sourcesContent": ["import { USE_BEDROCK, USE_VERTEX } from './model'\nimport { getGlobalConfig } from './config'\n\nexport function isAnthropicAuthEnabled(): boolean {\n  return false\n  // return !(USE_BEDROCK || USE_VERTEX)\n}\n\nexport function isLoggedInToAnthropic(): boolean {\n  return false\n  // const config = getGlobalConfig()\n  // return !!config.primaryApiKey\n}\n"],
-  "mappings": "AAGO,SAAS,yBAAkC;AAChD,SAAO;AAET;AAEO,SAAS,wBAAiC;AAC/C,SAAO;AAGT;",
-  "names": []
-}