@shareai-lab/kode 1.1.12 → 1.1.13

package/dist/utils/file.js

@@ -0,0 +1,282 @@
+import {
+  readFileSync,
+  writeFileSync,
+  openSync,
+  readSync,
+  closeSync,
+  existsSync,
+  readdirSync
+} from "fs";
+import { logError } from "./log.js";
+import {
+  isAbsolute,
+  normalize,
+  resolve,
+  resolve as resolvePath,
+  relative,
+  sep,
+  basename,
+  dirname,
+  extname,
+  join
+} from "path";
+import { glob as globLib } from "glob";
+import { cwd } from "process";
+import { listAllContentFiles } from "./ripgrep.js";
+import { LRUCache } from "lru-cache";
+import { getCwd } from "./state.js";
+async function glob(filePattern, cwd2, { limit, offset }, abortSignal) {
+  const paths = await globLib([filePattern], {
+    cwd: cwd2,
+    nocase: true,
+    nodir: true,
+    signal: abortSignal,
+    stat: true,
+    withFileTypes: true
+  });
+  const sortedPaths = paths.sort((a, b) => (a.mtimeMs ?? 0) - (b.mtimeMs ?? 0));
+  const truncated = sortedPaths.length > offset + limit;
+  return {
+    files: sortedPaths.slice(offset, offset + limit).map((path) => path.fullpath()),
+    truncated
+  };
+}
+function readFileSafe(filepath) {
+  try {
+    return readFileSync(filepath, "utf-8");
+  } catch (error) {
+    logError(error);
+    return null;
+  }
+}
+function isInDirectory(relativePath, relativeCwd) {
+  if (relativePath === ".") {
+    return true;
+  }
+  if (relativePath.startsWith("~")) {
+    return false;
+  }
+  if (relativePath.includes("\0") || relativeCwd.includes("\0")) {
+    return false;
+  }
+  let normalizedPath = normalize(relativePath);
+  let normalizedCwd = normalize(relativeCwd);
+  normalizedPath = normalizedPath.endsWith(sep) ? normalizedPath : normalizedPath + sep;
+  normalizedCwd = normalizedCwd.endsWith(sep) ? normalizedCwd : normalizedCwd + sep;
+  const fullPath = resolvePath(cwd(), normalizedCwd, normalizedPath);
+  const fullCwd = resolvePath(cwd(), normalizedCwd);
+  const rel = relative(fullCwd, fullPath);
+  if (!rel || rel === "") return true;
+  if (rel.startsWith("..")) return false;
+  if (isAbsolute(rel)) return false;
+  return true;
+}
+function readTextContent(filePath, offset = 0, maxLines) {
+  const enc = detectFileEncoding(filePath);
+  const content = readFileSync(filePath, enc);
+  const lines = content.split(/\r?\n/);
+  const toReturn = maxLines !== void 0 && lines.length - offset > maxLines ? lines.slice(offset, offset + maxLines) : lines.slice(offset);
+  return {
+    content: toReturn.join("\n"),
+    // TODO: This probably won't work for Windows
+    lineCount: toReturn.length,
+    totalLines: lines.length
+  };
+}
+function writeTextContent(filePath, content, encoding, endings) {
+  let toWrite = content;
+  if (endings === "CRLF") {
+    toWrite = content.split("\n").join("\r\n");
+  }
+  writeFileSync(filePath, toWrite, { encoding, flush: true });
+}
+const repoEndingCache = new LRUCache({
+  fetchMethod: (path) => detectRepoLineEndingsDirect(path),
+  ttl: 5 * 60 * 1e3,
+  ttlAutopurge: false,
+  max: 1e3
+});
+async function detectRepoLineEndings(filePath) {
+  return repoEndingCache.fetch(resolve(filePath));
+}
+async function detectRepoLineEndingsDirect(cwd2) {
+  const abortController = new AbortController();
+  setTimeout(() => {
+    abortController.abort();
+  }, 1e3);
+  const allFiles = await listAllContentFiles(cwd2, abortController.signal, 15);
+  let crlfCount = 0;
+  for (const file of allFiles) {
+    const lineEnding = detectLineEndings(file);
+    if (lineEnding === "CRLF") {
+      crlfCount++;
+    }
+  }
+  return crlfCount > 3 ? "CRLF" : "LF";
+}
+function fetch(cache, key, value) {
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+  const v = value();
+  cache.set(key, v);
+  return v;
+}
+const fileEncodingCache = new LRUCache({
+  fetchMethod: (path) => detectFileEncodingDirect(path),
+  ttl: 5 * 60 * 1e3,
+  ttlAutopurge: false,
+  max: 1e3
+});
+function detectFileEncoding(filePath) {
+  const k = resolve(filePath);
+  return fetch(fileEncodingCache, k, () => detectFileEncodingDirect(k));
+}
+function detectFileEncodingDirect(filePath) {
+  const BUFFER_SIZE = 4096;
+  const buffer = Buffer.alloc(BUFFER_SIZE);
+  let fd = void 0;
+  try {
+    fd = openSync(filePath, "r");
+    const bytesRead = readSync(fd, buffer, 0, BUFFER_SIZE, 0);
+    if (bytesRead >= 2) {
+      if (buffer[0] === 255 && buffer[1] === 254) return "utf16le";
+    }
+    if (bytesRead >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
+      return "utf8";
+    }
+    const isUtf8 = buffer.slice(0, bytesRead).toString("utf8").length > 0;
+    return isUtf8 ? "utf8" : "ascii";
+  } catch (error) {
+    logError(`Error detecting encoding for file ${filePath}: ${error}`);
+    return "utf8";
+  } finally {
+    if (fd) closeSync(fd);
+  }
+}
+const lineEndingCache = new LRUCache({
+  fetchMethod: (path) => detectLineEndingsDirect(path),
+  ttl: 5 * 60 * 1e3,
+  ttlAutopurge: false,
+  max: 1e3
+});
+function detectLineEndings(filePath) {
+  const k = resolve(filePath);
+  return fetch(lineEndingCache, k, () => detectLineEndingsDirect(k));
+}
+function detectLineEndingsDirect(filePath, encoding = "utf8") {
+  try {
+    const buffer = Buffer.alloc(4096);
+    const fd = openSync(filePath, "r");
+    const bytesRead = readSync(fd, buffer, 0, 4096, 0);
+    closeSync(fd);
+    const content = buffer.toString(encoding, 0, bytesRead);
+    let crlfCount = 0;
+    let lfCount = 0;
+    for (let i = 0; i < content.length; i++) {
+      if (content[i] === "\n") {
+        if (i > 0 && content[i - 1] === "\r") {
+          crlfCount++;
+        } else {
+          lfCount++;
+        }
+      }
+    }
+    return crlfCount > lfCount ? "CRLF" : "LF";
+  } catch (error) {
+    logError(`Error detecting line endings for file ${filePath}: ${error}`);
+    return "LF";
+  }
+}
+function normalizeFilePath(filePath) {
+  const absoluteFilePath = isAbsolute(filePath) ? filePath : resolve(getCwd(), filePath);
+  if (absoluteFilePath.endsWith(" AM.png")) {
+    return absoluteFilePath.replace(
+      " AM.png",
+      `${String.fromCharCode(8239)}AM.png`
+    );
+  }
+  if (absoluteFilePath.endsWith(" PM.png")) {
+    return absoluteFilePath.replace(
+      " PM.png",
+      `${String.fromCharCode(8239)}PM.png`
+    );
+  }
+  return absoluteFilePath;
+}
+function getAbsolutePath(path) {
+  return path ? isAbsolute(path) ? path : resolve(getCwd(), path) : void 0;
+}
+function getAbsoluteAndRelativePaths(path) {
+  const absolutePath = getAbsolutePath(path);
+  const relativePath = absolutePath ? relative(getCwd(), absolutePath) : void 0;
+  return { absolutePath, relativePath };
+}
+function findSimilarFile(filePath) {
+  try {
+    const dir = dirname(filePath);
+    const fileBaseName = basename(filePath, extname(filePath));
+    if (!existsSync(dir)) {
+      return void 0;
+    }
+    const files = readdirSync(dir);
+    const similarFiles = files.filter(
+      (file) => basename(file, extname(file)) === fileBaseName && join(dir, file) !== filePath
+    );
+    const firstMatch = similarFiles[0];
+    if (firstMatch) {
+      return firstMatch;
+    }
+    return void 0;
+  } catch (error) {
+    logError(`Error finding similar file for ${filePath}: ${error}`);
+    return void 0;
+  }
+}
+function addLineNumbers({
+  content,
+  // 1-indexed
+  startLine
+}) {
+  if (!content) {
+    return "";
+  }
+  return content.split(/\r?\n/).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");
+}
+function isDirEmpty(dirPath) {
+  try {
+    const entries = readdirSync(dirPath);
+    return entries.length === 0;
+  } catch (error) {
+    logError(`Error checking directory: ${error}`);
+    return false;
+  }
+}
+export {
+  addLineNumbers,
+  detectFileEncoding,
+  detectFileEncodingDirect,
+  detectLineEndings,
+  detectLineEndingsDirect,
+  detectRepoLineEndings,
+  detectRepoLineEndingsDirect,
+  findSimilarFile,
+  getAbsoluteAndRelativePaths,
+  getAbsolutePath,
+  glob,
+  isDirEmpty,
+  isInDirectory,
+  normalizeFilePath,
+  readFileSafe,
+  readTextContent,
+  writeTextContent
+};
+//# sourceMappingURL=file.js.map

package/dist/utils/file.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/file.ts"],
+  "sourcesContent": ["import {\n  readFileSync,\n  writeFileSync,\n  openSync,\n  readSync,\n  closeSync,\n  existsSync,\n  readdirSync,\n} from 'fs'\nimport { logError } from './log'\nimport {\n  isAbsolute,\n  normalize,\n  resolve,\n  resolve as resolvePath,\n  relative,\n  sep,\n  basename,\n  dirname,\n  extname,\n  join,\n} from 'path'\nimport { glob as globLib } from 'glob'\nimport { cwd } from 'process'\nimport { listAllContentFiles } from './ripgrep'\nimport { LRUCache } from 'lru-cache'\nimport { getCwd } from './state'\n\nexport type File = {\n  filename: string\n  content: string\n}\n\nexport type LineEndingType = 'CRLF' | 'LF'\n\nexport async function glob(\n  filePattern: string,\n  cwd: string,\n  { limit, offset }: { limit: number; offset: number },\n  abortSignal: AbortSignal,\n): Promise<{ files: string[]; truncated: boolean }> {\n  // TODO: Use worker threads\n  const paths = await globLib([filePattern], {\n    cwd,\n    nocase: true,\n    nodir: true,\n    signal: abortSignal,\n    stat: true,\n    withFileTypes: true,\n  })\n  const sortedPaths = paths.sort((a, b) => (a.mtimeMs ?? 0) - (b.mtimeMs ?? 0))\n  const truncated = sortedPaths.length > offset + limit\n  return {\n    files: sortedPaths\n      .slice(offset, offset + limit)\n      .map(path => path.fullpath()),\n    truncated,\n  }\n}\n\nexport function readFileSafe(filepath: string): string | null {\n  try {\n    return readFileSync(filepath, 'utf-8')\n  } catch (error) {\n    logError(error)\n    return null\n  }\n}\n\nexport function isInDirectory(\n  relativePath: string,\n  relativeCwd: string,\n): boolean {\n  if (relativePath === '.') {\n    return true\n  }\n\n  // Reject paths starting with ~ (home directory)\n  if (relativePath.startsWith('~')) {\n    return false\n  }\n\n  // Reject paths containing null bytes or other sneaky characters\n  if (relativePath.includes('\\0') || relativeCwd.includes('\\0')) {\n    return false\n  }\n\n  // Normalize paths to resolve any '..' or '.' segments\n  // and add trailing slashes\n  let normalizedPath = normalize(relativePath)\n  let normalizedCwd = normalize(relativeCwd)\n\n  normalizedPath = normalizedPath.endsWith(sep)\n    ? normalizedPath\n    : normalizedPath + sep\n  normalizedCwd = normalizedCwd.endsWith(sep)\n    ? normalizedCwd\n    : normalizedCwd + sep\n\n  // Join with a base directory to make them absolute-like for comparison\n  const fullPath = resolvePath(cwd(), normalizedCwd, normalizedPath)\n  const fullCwd = resolvePath(cwd(), normalizedCwd)\n\n  // Robust subpath check using path.relative (case-insensitive on Windows)\n  const rel = relative(fullCwd, fullPath)\n  if (!rel || rel === '') return true\n  if (rel.startsWith('..')) return false\n  if (isAbsolute(rel)) return false\n  return true\n}\n\nexport function readTextContent(\n  filePath: string,\n  offset = 0,\n  maxLines?: number,\n): { content: string; lineCount: number; totalLines: number } {\n  const enc = detectFileEncoding(filePath)\n  const content = readFileSync(filePath, enc)\n  const lines = content.split(/\\r?\\n/)\n\n  // Truncate number of lines if needed\n  const toReturn =\n    maxLines !== undefined && lines.length - offset > maxLines\n      ? lines.slice(offset, offset + maxLines)\n      : lines.slice(offset)\n\n  return {\n    content: toReturn.join('\\n'), // TODO: This probably won't work for Windows\n    lineCount: toReturn.length,\n    totalLines: lines.length,\n  }\n}\n\nexport function writeTextContent(\n  filePath: string,\n  content: string,\n  encoding: BufferEncoding,\n  endings: LineEndingType,\n): void {\n  let toWrite = content\n  if (endings === 'CRLF') {\n    toWrite = content.split('\\n').join('\\r\\n')\n  }\n\n  writeFileSync(filePath, toWrite, { encoding, flush: true })\n}\n\nconst repoEndingCache = new LRUCache<string, LineEndingType>({\n  fetchMethod: path => detectRepoLineEndingsDirect(path),\n  ttl: 5 * 60 * 1000,\n  ttlAutopurge: false,\n  max: 1000,\n})\n\nexport async function detectRepoLineEndings(\n  filePath: string,\n): Promise<LineEndingType | undefined> {\n  return repoEndingCache.fetch(resolve(filePath))\n}\n\nexport async function detectRepoLineEndingsDirect(\n  cwd: string,\n): Promise<LineEndingType> {\n  const abortController = new AbortController()\n  setTimeout(() => {\n    abortController.abort()\n  }, 1_000)\n  const allFiles = await listAllContentFiles(cwd, abortController.signal, 15)\n\n  let crlfCount = 0\n  for (const file of allFiles) {\n    const lineEnding = detectLineEndings(file)\n    if (lineEnding === 'CRLF') {\n      crlfCount++\n    }\n  }\n\n  return crlfCount > 3 ? 'CRLF' : 'LF'\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nfunction fetch<K extends {}, V extends {}>(\n  cache: LRUCache<K, V>,\n  key: K,\n  value: () => V,\n): V {\n  if (cache.has(key)) {\n    return cache.get(key)!\n  }\n\n  const v = value()\n  cache.set(key, v)\n  return v\n}\n\nconst fileEncodingCache = new LRUCache<string, BufferEncoding>({\n  fetchMethod: path => detectFileEncodingDirect(path),\n  ttl: 5 * 60 * 1000,\n  ttlAutopurge: false,\n  max: 1000,\n})\n\nexport function detectFileEncoding(filePath: string): BufferEncoding {\n  const k = resolve(filePath)\n  return fetch(fileEncodingCache, k, () => detectFileEncodingDirect(k))\n}\n\nexport function detectFileEncodingDirect(filePath: string): BufferEncoding {\n  const BUFFER_SIZE = 4096\n  const buffer = Buffer.alloc(BUFFER_SIZE)\n\n  let fd: number | undefined = undefined\n  try {\n    fd = openSync(filePath, 'r')\n    const bytesRead = readSync(fd, buffer, 0, BUFFER_SIZE, 0)\n\n    if (bytesRead >= 2) {\n      if (buffer[0] === 0xff && buffer[1] === 0xfe) return 'utf16le'\n    }\n\n    if (\n      bytesRead >= 3 &&\n      buffer[0] === 0xef &&\n      buffer[1] === 0xbb &&\n      buffer[2] === 0xbf\n    ) {\n      return 'utf8'\n    }\n\n    const isUtf8 = buffer.slice(0, bytesRead).toString('utf8').length > 0\n    return isUtf8 ? 'utf8' : 'ascii'\n  } catch (error) {\n    logError(`Error detecting encoding for file ${filePath}: ${error}`)\n    return 'utf8'\n  } finally {\n    if (fd) closeSync(fd)\n  }\n}\n\nconst lineEndingCache = new LRUCache<string, LineEndingType>({\n  fetchMethod: path => detectLineEndingsDirect(path),\n  ttl: 5 * 60 * 1000,\n  ttlAutopurge: false,\n  max: 1000,\n})\n\nexport function detectLineEndings(filePath: string): LineEndingType {\n  const k = resolve(filePath)\n  return fetch(lineEndingCache, k, () => detectLineEndingsDirect(k))\n}\n\nexport function detectLineEndingsDirect(\n  filePath: string,\n  encoding: BufferEncoding = 'utf8',\n): LineEndingType {\n  try {\n    const buffer = Buffer.alloc(4096)\n    const fd = openSync(filePath, 'r')\n    const bytesRead = readSync(fd, buffer, 0, 4096, 0)\n    closeSync(fd)\n\n    const content = buffer.toString(encoding, 0, bytesRead)\n    let crlfCount = 0\n    let lfCount = 0\n\n    for (let i = 0; i < content.length; i++) {\n      if (content[i] === '\\n') {\n        if (i > 0 && content[i - 1] === '\\r') {\n          crlfCount++\n        } else {\n          lfCount++\n        }\n      }\n    }\n\n    return crlfCount > lfCount ? 'CRLF' : 'LF'\n  } catch (error) {\n    logError(`Error detecting line endings for file ${filePath}: ${error}`)\n    return 'LF'\n  }\n}\n\nexport function normalizeFilePath(filePath: string): string {\n  const absoluteFilePath = isAbsolute(filePath)\n    ? filePath\n    : resolve(getCwd(), filePath)\n\n  // One weird trick for half-width space characters in MacOS screenshot filenames\n  if (absoluteFilePath.endsWith(' AM.png')) {\n    return absoluteFilePath.replace(\n      ' AM.png',\n      `${String.fromCharCode(8239)}AM.png`,\n    )\n  }\n\n  // One weird trick for half-width space characters in MacOS screenshot filenames\n  if (absoluteFilePath.endsWith(' PM.png')) {\n    return absoluteFilePath.replace(\n      ' PM.png',\n      `${String.fromCharCode(8239)}PM.png`,\n    )\n  }\n\n  return absoluteFilePath\n}\n\nexport function getAbsolutePath(path: string | undefined): string | undefined {\n  return path ? (isAbsolute(path) ? path : resolve(getCwd(), path)) : undefined\n}\n\nexport function getAbsoluteAndRelativePaths(path: string | undefined): {\n  absolutePath: string | undefined\n  relativePath: string | undefined\n} {\n  const absolutePath = getAbsolutePath(path)\n  const relativePath = absolutePath\n    ? relative(getCwd(), absolutePath)\n    : undefined\n  return { absolutePath, relativePath }\n}\n\n/**\n * Find files with the same name but different extensions in the same directory\n * @param filePath The path to the file that doesn't exist\n * @returns The found file with a different extension, or undefined if none found\n */\n\nexport function findSimilarFile(filePath: string): string | undefined {\n  try {\n    const dir = dirname(filePath)\n    const fileBaseName = basename(filePath, extname(filePath))\n\n    // Check if directory exists\n    if (!existsSync(dir)) {\n      return undefined\n    }\n\n    // Get all files in the directory\n    const files = readdirSync(dir)\n\n    // Find files with the same base name but different extension\n    const similarFiles = files.filter(\n      file =>\n        basename(file, extname(file)) === fileBaseName &&\n        join(dir, file) !== filePath,\n    )\n\n    // Return just the filename of the first match if found\n    const firstMatch = similarFiles[0]\n    if (firstMatch) {\n      return firstMatch\n    }\n    return undefined\n  } catch (error) {\n    // In case of any errors, return undefined\n    logError(`Error finding similar file for ${filePath}: ${error}`)\n    return undefined\n  }\n}\n\n/**\n * Adds cat -n style line numbers to the content\n */\nexport function addLineNumbers({\n  content,\n  // 1-indexed\n  startLine,\n}: {\n  content: string\n  startLine: number\n}): string {\n  if (!content) {\n    return ''\n  }\n\n  return content\n    .split(/\\r?\\n/)\n    .map((line, index) => {\n      const lineNum = index + startLine\n      const numStr = String(lineNum)\n      // Handle large numbers differently\n      if (numStr.length >= 6) {\n        return `${numStr}\\t${line}`\n      }\n      // Regular numbers get padding to 6 characters\n      const n = numStr.padStart(6, ' ')\n      return `${n}\\t${line}`\n    })\n    .join('\\n') // TODO: This probably won't work for Windows\n}\n\n/**\n * Checks if a directory is empty by efficiently reading just the first entry\n * @param dirPath The path to the directory to check\n * @returns true if the directory is empty, false otherwise\n */\nexport function isDirEmpty(dirPath: string): boolean {\n  try {\n    const entries = readdirSync(dirPath)\n    return entries.length === 0\n  } catch (error) {\n    logError(`Error checking directory: ${error}`)\n    return false\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["cwd"]
+}

package/dist/utils/fileRecoveryCore.js

@@ -0,0 +1,41 @@
+import { readTextContent } from "./file.js";
+import { fileFreshnessService } from "../services/fileFreshness.js";
+const MAX_FILES_TO_RECOVER = 5;
+const MAX_TOKENS_PER_FILE = 1e4;
+const MAX_TOTAL_FILE_TOKENS = 5e4;
+async function selectAndReadFiles() {
+  const importantFiles = fileFreshnessService.getImportantFiles(MAX_FILES_TO_RECOVER);
+  const results = [];
+  let totalTokens = 0;
+  for (const fileInfo of importantFiles) {
+    try {
+      const { content } = readTextContent(fileInfo.path);
+      const estimatedTokens = Math.ceil(content.length * 0.25);
+      let finalContent = content;
+      let truncated = false;
+      if (estimatedTokens > MAX_TOKENS_PER_FILE) {
+        const maxChars = Math.floor(MAX_TOKENS_PER_FILE / 0.25);
+        finalContent = content.substring(0, maxChars);
+        truncated = true;
+      }
+      const finalTokens = Math.min(estimatedTokens, MAX_TOKENS_PER_FILE);
+      if (totalTokens + finalTokens > MAX_TOTAL_FILE_TOKENS) {
+        break;
+      }
+      totalTokens += finalTokens;
+      results.push({
+        path: fileInfo.path,
+        content: finalContent,
+        tokens: finalTokens,
+        truncated
+      });
+    } catch (error) {
+      console.error(`Failed to read file for recovery: ${fileInfo.path}`, error);
+    }
+  }
+  return results;
+}
+export {
+  selectAndReadFiles
+};
+//# sourceMappingURL=fileRecoveryCore.js.map

package/dist/utils/fileRecoveryCore.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/fileRecoveryCore.ts"],
+  "sourcesContent": ["import { readTextContent } from './file'\nimport { fileFreshnessService } from '../services/fileFreshness'\n\n/**\n * File recovery configuration for auto-compact feature\n * These limits ensure recovered files don't overwhelm the compressed context\n */\nconst MAX_FILES_TO_RECOVER = 5\nconst MAX_TOKENS_PER_FILE = 10_000\nconst MAX_TOTAL_FILE_TOKENS = 50_000\n\n/**\n * Selects and reads recently accessed files for context recovery\n *\n * During auto-compact, this function preserves development context by:\n * - Selecting files based on recent access patterns\n * - Enforcing token budgets to prevent context bloat\n * - Truncating large files while preserving essential content\n *\n * @returns Array of file data with content, token counts, and truncation flags\n */\nexport async function selectAndReadFiles(): Promise<\n  Array<{\n    path: string\n    content: string\n    tokens: number\n    truncated: boolean\n  }>\n> {\n  const importantFiles =\n    fileFreshnessService.getImportantFiles(MAX_FILES_TO_RECOVER)\n  const results = []\n  let totalTokens = 0\n\n  for (const fileInfo of importantFiles) {\n    try {\n      const { content } = readTextContent(fileInfo.path)\n      const estimatedTokens = Math.ceil(content.length * 0.25)\n\n      // Apply per-file token limit to prevent any single file from dominating context\n      let finalContent = content\n      let truncated = false\n\n      if (estimatedTokens > MAX_TOKENS_PER_FILE) {\n        const maxChars = Math.floor(MAX_TOKENS_PER_FILE / 0.25)\n        finalContent = content.substring(0, maxChars)\n        truncated = true\n      }\n\n      const finalTokens = Math.min(estimatedTokens, MAX_TOKENS_PER_FILE)\n\n      // Enforce total token budget to maintain auto-compact effectiveness\n      if (totalTokens + finalTokens > MAX_TOTAL_FILE_TOKENS) {\n        break\n      }\n\n      totalTokens += finalTokens\n      results.push({\n        path: fileInfo.path,\n        content: finalContent,\n        tokens: finalTokens,\n        truncated,\n      })\n    } catch (error) {\n      // Skip files that cannot be read, don't let one failure stop the process\n      console.error(`Failed to read file for recovery: ${fileInfo.path}`, error)\n    }\n  }\n\n  return results\n}\n"],
+  "mappings": "AAAA,SAAS,uBAAuB;AAChC,SAAS,4BAA4B;AAMrC,MAAM,uBAAuB;AAC7B,MAAM,sBAAsB;AAC5B,MAAM,wBAAwB;AAY9B,eAAsB,qBAOpB;AACA,QAAM,iBACJ,qBAAqB,kBAAkB,oBAAoB;AAC7D,QAAM,UAAU,CAAC;AACjB,MAAI,cAAc;AAElB,aAAW,YAAY,gBAAgB;AACrC,QAAI;AACF,YAAM,EAAE,QAAQ,IAAI,gBAAgB,SAAS,IAAI;AACjD,YAAM,kBAAkB,KAAK,KAAK,QAAQ,SAAS,IAAI;AAGvD,UAAI,eAAe;AACnB,UAAI,YAAY;AAEhB,UAAI,kBAAkB,qBAAqB;AACzC,cAAM,WAAW,KAAK,MAAM,sBAAsB,IAAI;AACtD,uBAAe,QAAQ,UAAU,GAAG,QAAQ;AAC5C,oBAAY;AAAA,MACd;AAEA,YAAM,cAAc,KAAK,IAAI,iBAAiB,mBAAmB;AAGjE,UAAI,cAAc,cAAc,uBAAuB;AACrD;AAAA,MACF;AAEA,qBAAe;AACf,cAAQ,KAAK;AAAA,QACX,MAAM,SAAS;AAAA,QACf,SAAS;AAAA,QACT,QAAQ;AAAA,QACR;AAAA,MACF,CAAC;AAAA,IACH,SAAS,OAAO;AAEd,cAAQ,MAAM,qCAAqC,SAAS,IAAI,IAAI,KAAK;AAAA,IAC3E;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/utils/format.js

@@ -0,0 +1,41 @@
+function wrapText(text, width) {
+  const lines = [];
+  let currentLine = "";
+  for (const char of text) {
+    if ([...currentLine].length < width) {
+      currentLine += char;
+    } else {
+      lines.push(currentLine);
+      currentLine = char;
+    }
+  }
+  if (currentLine) lines.push(currentLine);
+  return lines;
+}
+function formatDuration(ms) {
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const hours = Math.floor(ms / 36e5);
+  const minutes = Math.floor(ms % 36e5 / 6e4);
+  const seconds = (ms % 6e4 / 1e3).toFixed(1);
+  if (hours > 0) {
+    return `${hours}h ${minutes}m ${seconds}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+function formatNumber(number) {
+  return new Intl.NumberFormat("en", {
+    notation: "compact",
+    maximumFractionDigits: 1
+  }).format(number).toLowerCase();
+}
+export {
+  formatDuration,
+  formatNumber,
+  wrapText
+};
+//# sourceMappingURL=format.js.map

package/dist/utils/format.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/format.tsx"],
+  "sourcesContent": ["export function wrapText(text: string, width: number): string[] {\n  const lines: string[] = []\n  let currentLine = ''\n\n  for (const char of text) {\n    // Important: we need the spread to properly count multi-plane UTF-8 characters (eg. \uD805\uDE96)\n    if ([...currentLine].length < width) {\n      currentLine += char\n    } else {\n      lines.push(currentLine)\n      currentLine = char\n    }\n  }\n\n  if (currentLine) lines.push(currentLine)\n  return lines\n}\n\nexport function formatDuration(ms: number): string {\n  if (ms < 60000) {\n    return `${(ms / 1000).toFixed(1)}s`\n  }\n\n  const hours = Math.floor(ms / 3600000)\n  const minutes = Math.floor((ms % 3600000) / 60000)\n  const seconds = ((ms % 60000) / 1000).toFixed(1)\n\n  if (hours > 0) {\n    return `${hours}h ${minutes}m ${seconds}s`\n  }\n  if (minutes > 0) {\n    return `${minutes}m ${seconds}s`\n  }\n  return `${seconds}s`\n}\n\nexport function formatNumber(number: number): string {\n  return new Intl.NumberFormat('en', {\n    notation: 'compact',\n    maximumFractionDigits: 1,\n  })\n    .format(number) // eg. \"1321\" => \"1.3K\"\n    .toLowerCase() // eg. \"1.3K\" => \"1.3k\"\n}\n"],
+  "mappings": "AAAO,SAAS,SAAS,MAAc,OAAyB;AAC9D,QAAM,QAAkB,CAAC;AACzB,MAAI,cAAc;AAElB,aAAW,QAAQ,MAAM;AAEvB,QAAI,CAAC,GAAG,WAAW,EAAE,SAAS,OAAO;AACnC,qBAAe;AAAA,IACjB,OAAO;AACL,YAAM,KAAK,WAAW;AACtB,oBAAc;AAAA,IAChB;AAAA,EACF;AAEA,MAAI,YAAa,OAAM,KAAK,WAAW;AACvC,SAAO;AACT;AAEO,SAAS,eAAe,IAAoB;AACjD,MAAI,KAAK,KAAO;AACd,WAAO,IAAI,KAAK,KAAM,QAAQ,CAAC,CAAC;AAAA,EAClC;AAEA,QAAM,QAAQ,KAAK,MAAM,KAAK,IAAO;AACrC,QAAM,UAAU,KAAK,MAAO,KAAK,OAAW,GAAK;AACjD,QAAM,WAAY,KAAK,MAAS,KAAM,QAAQ,CAAC;AAE/C,MAAI,QAAQ,GAAG;AACb,WAAO,GAAG,KAAK,KAAK,OAAO,KAAK,OAAO;AAAA,EACzC;AACA,MAAI,UAAU,GAAG;AACf,WAAO,GAAG,OAAO,KAAK,OAAO;AAAA,EAC/B;AACA,SAAO,GAAG,OAAO;AACnB;AAEO,SAAS,aAAa,QAAwB;AACnD,SAAO,IAAI,KAAK,aAAa,MAAM;AAAA,IACjC,UAAU;AAAA,IACV,uBAAuB;AAAA,EACzB,CAAC,EACE,OAAO,MAAM,EACb,YAAY;AACjB;",
+  "names": []
+}

package/dist/utils/fuzzyMatcher.js

@@ -0,0 +1,252 @@
+const DEFAULT_CONFIG = {
+  weights: {
+    prefix: 0.35,
+    // Strong weight for prefix matching
+    substring: 0.2,
+    // Good for partial matches  
+    abbreviation: 0.3,
+    // Key for "nde"→"node" cases
+    editDistance: 0.1,
+    // Typo tolerance
+    popularity: 0.05
+    // Slight bias for common commands
+  },
+  minScore: 10,
+  // Lower threshold for better matching
+  maxEditDistance: 2,
+  popularCommands: [
+    "node",
+    "npm",
+    "git",
+    "ls",
+    "cd",
+    "cat",
+    "grep",
+    "find",
+    "cp",
+    "mv",
+    "python",
+    "java",
+    "docker",
+    "curl",
+    "wget",
+    "vim",
+    "nano"
+  ]
+};
+class FuzzyMatcher {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    const weightSum = Object.values(this.config.weights).reduce((a, b) => a + b, 0);
+    if (Math.abs(weightSum - 1) > 0.01) {
+      Object.keys(this.config.weights).forEach((key) => {
+        this.config.weights[key] /= weightSum;
+      });
+    }
+  }
+  /**
+   * Calculate fuzzy match score for a candidate against a query
+   */
+  match(candidate, query) {
+    const text = candidate.toLowerCase();
+    const pattern = query.toLowerCase();
+    if (text === pattern) {
+      return { score: 1e3, algorithm: "exact", confidence: 1 };
+    }
+    if (text.startsWith(pattern)) {
+      return {
+        score: 900 + (10 - pattern.length),
+        algorithm: "prefix-exact",
+        confidence: 0.95
+      };
+    }
+    const scores = {
+      prefix: this.prefixScore(text, pattern),
+      substring: this.substringScore(text, pattern),
+      abbreviation: this.abbreviationScore(text, pattern),
+      editDistance: this.editDistanceScore(text, pattern),
+      popularity: this.popularityScore(text)
+    };
+    const rawScore = Object.entries(scores).reduce((total, [algorithm, score]) => {
+      const weight = this.config.weights[algorithm];
+      return total + score * weight;
+    }, 0);
+    const lengthPenalty = Math.max(0, text.length - 6) * 1.5;
+    const finalScore = Math.max(0, rawScore - lengthPenalty);
+    const maxAlgorithm = Object.entries(scores).reduce(
+      (max, [alg, score]) => score > max.score ? { algorithm: alg, score } : max,
+      { algorithm: "none", score: 0 }
+    );
+    const confidence = Math.min(1, finalScore / 100);
+    return {
+      score: finalScore,
+      algorithm: maxAlgorithm.algorithm,
+      confidence
+    };
+  }
+  /**
+   * Algorithm 1: Prefix Matching (like pinyin prefix)
+   * Handles cases like "nod" → "node"
+   */
+  prefixScore(text, pattern) {
+    if (!text.startsWith(pattern)) return 0;
+    const coverage = pattern.length / text.length;
+    return 100 * coverage;
+  }
+  /**
+   * Algorithm 2: Substring Matching (like pinyin contains)  
+   * Handles cases like "ode" → "node", "py3" → "python3"
+   */
+  substringScore(text, pattern) {
+    const index = text.indexOf(pattern);
+    if (index !== -1) {
+      const positionFactor = Math.max(0, 10 - index) / 10;
+      const coverageFactor = pattern.length / text.length;
+      return 80 * positionFactor * coverageFactor;
+    }
+    const numMatch = pattern.match(/^(.+?)(\d+)$/);
+    if (numMatch) {
+      const [, prefix, num] = numMatch;
+      if (text.startsWith(prefix) && text.endsWith(num)) {
+        const coverageFactor = pattern.length / text.length;
+        return 70 * coverageFactor + 20;
+      }
+    }
+    return 0;
+  }
+  /**
+   * Algorithm 3: Abbreviation Matching (key innovation)
+   * Handles cases like "nde" → "node", "pyt3" → "python3", "gp5" → "gpt-5"
+   */
+  abbreviationScore(text, pattern) {
+    let score = 0;
+    let textPos = 0;
+    let perfectStart = false;
+    let consecutiveMatches = 0;
+    let wordBoundaryMatches = 0;
+    const textWords = text.split("-");
+    const textClean = text.replace(/-/g, "").toLowerCase();
+    for (let i = 0; i < pattern.length; i++) {
+      const char = pattern[i];
+      let charFound = false;
+      for (let j = textPos; j < textClean.length; j++) {
+        if (textClean[j] === char) {
+          charFound = true;
+          let originalPos = 0;
+          let cleanPos = 0;
+          for (let k = 0; k < text.length; k++) {
+            if (text[k] === "-") continue;
+            if (cleanPos === j) {
+              originalPos = k;
+              break;
+            }
+            cleanPos++;
+          }
+          if (j === textPos) {
+            consecutiveMatches++;
+          } else {
+            consecutiveMatches = 1;
+          }
+          if (i === 0 && j === 0) {
+            score += 50;
+            perfectStart = true;
+          } else if (originalPos === 0 || text[originalPos - 1] === "-") {
+            score += 35;
+            wordBoundaryMatches++;
+          } else if (j <= 2) {
+            score += 20;
+          } else if (j <= 6) {
+            score += 10;
+          } else {
+            score += 5;
+          }
+          if (consecutiveMatches > 1) {
+            score += consecutiveMatches * 5;
+          }
+          textPos = j + 1;
+          break;
+        }
+      }
+      if (!charFound) return 0;
+    }
+    if (perfectStart) score += 30;
+    if (wordBoundaryMatches >= 2) score += 25;
+    if (textPos <= textClean.length * 0.8) score += 15;
+    const lastPatternChar = pattern[pattern.length - 1];
+    const lastTextChar = text[text.length - 1];
+    if (/\d/.test(lastPatternChar) && lastPatternChar === lastTextChar) {
+      score += 25;
+    }
+    return score;
+  }
+  /**
+   * Algorithm 4: Edit Distance (typo tolerance)
+   * Handles cases like "noda" → "node"
+   */
+  editDistanceScore(text, pattern) {
+    if (pattern.length > text.length + this.config.maxEditDistance) return 0;
+    const dp = [];
+    const m = pattern.length;
+    const n = text.length;
+    for (let i = 0; i <= m; i++) {
+      dp[i] = [];
+      for (let j = 0; j <= n; j++) {
+        if (i === 0) dp[i][j] = j;
+        else if (j === 0) dp[i][j] = i;
+        else {
+          const cost = pattern[i - 1] === text[j - 1] ? 0 : 1;
+          dp[i][j] = Math.min(
+            dp[i - 1][j] + 1,
+            // deletion
+            dp[i][j - 1] + 1,
+            // insertion
+            dp[i - 1][j - 1] + cost
+            // substitution
+          );
+        }
+      }
+    }
+    const distance = dp[m][n];
+    if (distance > this.config.maxEditDistance) return 0;
+    return Math.max(0, 30 - distance * 10);
+  }
+  /**
+   * Algorithm 5: Command Popularity (like frequency in input method)
+   * Boost common commands that users frequently type
+   */
+  popularityScore(text) {
+    if (this.config.popularCommands.includes(text)) {
+      return 40;
+    }
+    if (text.length <= 5) return 10;
+    return 0;
+  }
+  /**
+   * Batch match multiple candidates and return sorted results
+   */
+  matchMany(candidates, query) {
+    return candidates.map((candidate) => ({
+      candidate,
+      result: this.match(candidate, query)
+    })).filter((item) => item.result.score >= this.config.minScore).sort((a, b) => b.result.score - a.result.score);
+  }
+}
+const defaultMatcher = new FuzzyMatcher();
+function matchCommand(command, query) {
+  return defaultMatcher.match(command, query);
+}
+import { matchManyAdvanced } from "./advancedFuzzyMatcher.js";
+function matchCommands(commands, query) {
+  return matchManyAdvanced(commands, query, 5).map((item) => ({
+    command: item.candidate,
+    score: item.score
+  }));
+}
+export {
+  FuzzyMatcher,
+  defaultMatcher,
+  matchCommand,
+  matchCommands
+};
+//# sourceMappingURL=fuzzyMatcher.js.map