replicas-engine 0.1.166 → 0.1.168

package/dist/src/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 import { execSync as execSync2 } from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
 
@@ -20,6 +20,96 @@ import { readFileSync } from "fs";
 
 // ../shared/src/event.ts
 var CODEX_QUOTA_STATUS_EVENT_TYPE = "codex-quota-status";
+var CONTEXT_USAGE_EVENT_TYPE = "context-usage";
+
+// ../shared/src/languages.ts
+var EXT_TO_LANGUAGE = {
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".js": "javascript",
+  ".jsx": "jsx",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".pyw": "python",
+  ".pyi": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".scala": "scala",
+  ".swift": "swift",
+  ".m": "objectivec",
+  ".mm": "objectivec",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".hh": "cpp",
+  ".hxx": "cpp",
+  ".cs": "csharp",
+  ".vb": "vbnet",
+  ".fs": "fsharp",
+  ".php": "php",
+  ".phtml": "php",
+  ".css": "css",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".less": "less",
+  ".html": "html",
+  ".htm": "html",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".xml": "xml",
+  ".svg": "xml",
+  ".json": "json",
+  ".json5": "json5",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".ini": "ini",
+  ".md": "markdown",
+  ".markdown": "markdown",
+  ".sql": "sql",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  ".fish": "bash",
+  ".dockerfile": "dockerfile",
+  ".graphql": "graphql",
+  ".proto": "protobuf",
+  ".r": "r",
+  ".lua": "lua",
+  ".dart": "dart",
+  ".zig": "zig",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".hs": "haskell",
+  ".ml": "ocaml",
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".pl": "perl",
+  ".perl": "perl",
+  ".elm": "elm",
+  ".lisp": "lisp"
+};
+function detectLanguageByPath(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  if (dot === -1) {
+    const basename2 = filePath.split("/").pop() ?? "";
+    if (basename2 === "Dockerfile") return "dockerfile";
+    if (basename2 === "Makefile") return "makefile";
+    return null;
+  }
+  const ext = filePath.slice(dot).toLowerCase();
+  return EXT_TO_LANGUAGE[ext] ?? null;
+}
 
 // ../shared/src/pricing.ts
 var PLANS = {
@@ -285,7 +375,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "13-05-2026-royal-york-v12";
+var DAYTONA_SNAPSHOT_ID = "14-05-2026-royal-york-v13";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -453,7 +543,7 @@ var BaseRefreshManager = class {
           this.health.lastErrorMessage = message;
           if (attempt < 3) {
             console.warn(`[${this.managerName}] Initial refresh attempt ${attempt} failed, retrying in 2s...`);
-            await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+            await new Promise((resolve3) => setTimeout(resolve3, 2e3));
           } else {
             console.error(`[${this.managerName}] Initial refresh failed after 3 attempts:`, error);
           }
@@ -694,7 +784,7 @@ var codexTokenManager = new CodexTokenManager();
 // src/git/service.ts
 import { readdir, stat } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync2, spawnSync } from "child_process";
 import { join as join4 } from "path";
 
 // src/utils/state.ts
@@ -1052,6 +1142,7 @@ var GitService = class {
       if (removedMatch) {
         removed = parseInt(removedMatch[1], 10);
       }
+      added += this.countUntrackedAddedLines(repoPath);
       return {
         added,
         removed
@@ -1061,18 +1152,60 @@ var GitService = class {
       return null;
     }
   }
+  getUntrackedDiff(repoPath, extraFlags = []) {
+    const listing = execFileSync2("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
+      cwd: repoPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const paths = listing.split("\0").filter(Boolean);
+    if (paths.length === 0) return "";
+    try {
+      execFileSync2("git", ["add", "--intent-to-add", "--", ...paths], { cwd: repoPath, stdio: ["pipe", "pipe", "pipe"] });
+      const result = spawnSync("git", ["diff", ...extraFlags, "--", ...paths], {
+        cwd: repoPath,
+        encoding: "utf-8",
+        maxBuffer: 50 * 1024 * 1024
+      });
+      return result.status === 0 || result.status === 1 ? result.stdout : "";
+    } finally {
+      try {
+        execFileSync2("git", ["reset", "--", ...paths], { cwd: repoPath, stdio: ["pipe", "pipe", "pipe"] });
+      } catch {
+      }
+    }
+  }
+  countUntrackedAddedLines(repoPath) {
+    try {
+      const output = this.getUntrackedDiff(repoPath, ["--shortstat"]);
+      const match = output.match(/(\d+) insertion/);
+      return match ? parseInt(match[1], 10) : 0;
+    } catch (error) {
+      console.error("Error counting untracked added lines:", error);
+      return 0;
+    }
+  }
   getFullGitDiff(repoPath, defaultBranch) {
     try {
       const diffBase = this.getDiffBase(repoPath, defaultBranch);
-      return execFileSync2("git", ["diff", diffBase, "-M", "-C"], {
+      const trackedDiff = execFileSync2("git", ["diff", diffBase, "-M", "-C"], {
         cwd: repoPath,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
+      return trackedDiff + this.getUntrackedAsDiff(repoPath);
     } catch {
       return "";
     }
   }
+  getUntrackedAsDiff(repoPath) {
+    try {
+      return this.getUntrackedDiff(repoPath);
+    } catch (error) {
+      console.error("Error building untracked diff:", error);
+      return "";
+    }
+  }
   getDiffBase(repoPath, defaultBranch) {
     const baseBranch = `origin/${defaultBranch}`;
     try {
@@ -2616,6 +2749,15 @@ var CodingAgentManager = class {
     await this.initialized;
     return this.messageQueue.enqueue(request);
   }
+  emitContextUsage(payload) {
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: CONTEXT_USAGE_EVENT_TYPE,
+      payload: { ...payload }
+    };
+    this.onEvent(event);
+    return event;
+  }
   buildCombinedInstructions(customInstructions) {
     const startHooksInstruction = this.getStartHooksInstruction();
     const repositorySystemPromptInstruction = this.getRepositorySystemPromptInstruction();
@@ -2761,8 +2903,8 @@ var PromptStream = class {
         if (this.closed) {
           return Promise.resolve({ value: void 0, done: true });
         }
-        return new Promise((resolve2) => {
-          this.waiters.push(resolve2);
+        return new Promise((resolve3) => {
+          this.waiters.push(resolve3);
         });
       }
     };
@@ -2926,6 +3068,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
           }
         }
         if (msg.type === "result") {
+          await this.recordContextUsage(response);
           this.activePromptStream?.close();
           break;
         }
@@ -2947,6 +3090,45 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       }
     }
   }
+  getContextUsageProvider() {
+    return this.systemPromptOverride ? "relay" : "claude";
+  }
+  buildContextUsagePayload(usage) {
+    const maxTokens = Number.isFinite(usage.maxTokens) ? usage.maxTokens : null;
+    const percentage = Number.isFinite(usage.percentage) ? usage.percentage : maxTokens && maxTokens > 0 ? usage.totalTokens / maxTokens * 100 : 0;
+    return {
+      provider: this.getContextUsageProvider(),
+      source: "claude_context",
+      model: usage.model,
+      totalTokens: usage.totalTokens,
+      maxTokens,
+      rawMaxTokens: Number.isFinite(usage.rawMaxTokens) ? usage.rawMaxTokens : maxTokens,
+      percentage,
+      categories: usage.categories.map((category) => ({
+        name: category.name,
+        tokens: category.tokens,
+        percentage: maxTokens && maxTokens > 0 ? category.tokens / maxTokens * 100 : 0,
+        color: category.color,
+        ...category.isDeferred !== void 0 ? { isDeferred: category.isDeferred } : {}
+      })),
+      apiUsage: usage.apiUsage ? {
+        inputTokens: usage.apiUsage.input_tokens,
+        outputTokens: usage.apiUsage.output_tokens,
+        cacheCreationInputTokens: usage.apiUsage.cache_creation_input_tokens,
+        cacheReadInputTokens: usage.apiUsage.cache_read_input_tokens
+      } : null,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async recordContextUsage(response) {
+    try {
+      const usage = await response.getContextUsage();
+      const event = this.emitContextUsage(this.buildContextUsagePayload(usage));
+      await appendFile4(this.historyFile, JSON.stringify(event) + "\n", "utf-8");
+    } catch (error) {
+      console.warn("[ClaudeManager] Failed to record context usage:", error instanceof Error ? error.message : error);
+    }
+  }
   /**
    * Determines if an error is an OAuth authentication failure from the Claude SDK.
    * Known patterns:
@@ -3037,7 +3219,7 @@ function isJsonlEvent2(value) {
   return typeof value.timestamp === "string" && typeof value.type === "string" && isRecord3(value.payload);
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function extractRateLimitsSnapshot(parsed) {
   if (!isRecord3(parsed)) return null;
@@ -4567,19 +4749,290 @@ var ChatService = class {
   }
 };
 
+// src/services/repo-file-service.ts
+import { execFile as execFile2 } from "child_process";
+import { readFile as readFile9, realpath, stat as stat3 } from "fs/promises";
+import { join as join13, resolve, extname } from "path";
+var CACHE_TTL_MS = 3e4;
+var SEARCH_TIMEOUT_MS = 15e3;
+var MAX_CONTENT_BYTES = 256 * 1024;
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 5e3;
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".next", "dist", "build", "out", "vendor", ".turbo", "__pycache__"]);
+function isBinaryExtension(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  const binaryExts = /* @__PURE__ */ new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".ico",
+    ".webp",
+    ".svg",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".otf",
+    ".eot",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".bz2",
+    ".7z",
+    ".rar",
+    ".pdf",
+    ".doc",
+    ".docx",
+    ".xls",
+    ".xlsx",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".o",
+    ".a",
+    ".mp3",
+    ".mp4",
+    ".avi",
+    ".mov",
+    ".wav",
+    ".ogg",
+    ".sqlite",
+    ".db",
+    ".lock"
+  ]);
+  return binaryExts.has(ext);
+}
+function isExcludedPath(filePath) {
+  const segments = filePath.split("/");
+  return segments.some((seg) => EXCLUDED_DIRS.has(seg));
+}
+function scoreMatch(query2, filePath) {
+  const lowerQuery = query2.toLowerCase();
+  const lowerPath = filePath.toLowerCase();
+  const segments = lowerPath.split("/");
+  const basename2 = segments[segments.length - 1] ?? "";
+  if (basename2 === lowerQuery) return 100;
+  if (basename2.startsWith(lowerQuery)) return 90;
+  if (segments.some((seg) => seg === lowerQuery)) return 80;
+  if (basename2.includes(lowerQuery)) return 70;
+  if (segments.some((seg) => seg.includes(lowerQuery))) return 60;
+  if (lowerPath.includes(lowerQuery)) return 50;
+  return 0;
+}
+function execGitAsync(args, cwd, timeoutMs) {
+  return new Promise((resolve3, reject) => {
+    const child = execFile2("git", args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      maxBuffer: 10 * 1024 * 1024
+    }, (error, stdout) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve3(stdout);
+      }
+    });
+    child.stdin?.end();
+  });
+}
+var RepoFileService = class {
+  cache = /* @__PURE__ */ new Map();
+  gitService;
+  indexInflight = null;
+  constructor(gitService2) {
+    this.gitService = gitService2;
+  }
+  async search(params) {
+    const { q = "", prefix = "", refresh = false } = params;
+    const limit = Math.min(Math.max(params.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);
+    const parsedOffset = params.cursor ? parseInt(Buffer.from(params.cursor, "base64").toString(), 10) : 0;
+    const offset = Number.isNaN(parsedOffset) ? 0 : parsedOffset;
+    let stale = false;
+    let indexedAt = "";
+    try {
+      if (!this.indexInflight || refresh) {
+        const inflight = this.indexAll(refresh);
+        const wrapped = inflight.finally(() => {
+          if (this.indexInflight === wrapped) this.indexInflight = null;
+        });
+        this.indexInflight = wrapped;
+      }
+      await this.indexInflight;
+    } catch {
+      stale = true;
+    }
+    const repos = await this.gitService.listRepositories();
+    const multiRepo = repos.length > 1;
+    const allResults = [];
+    for (const repo of repos) {
+      const cached = this.cache.get(repo.name);
+      if (!cached) continue;
+      if (!indexedAt || cached.timestamp > new Date(indexedAt).getTime()) {
+        indexedAt = new Date(cached.timestamp).toISOString();
+      }
+      const isStale = Date.now() - cached.timestamp > CACHE_TTL_MS;
+      if (isStale) stale = true;
+      for (const filePath of cached.files) {
+        if (prefix && !filePath.startsWith(prefix)) continue;
+        let score = 0;
+        if (q) {
+          score = scoreMatch(q, filePath);
+          if (score === 0) continue;
+        }
+        allResults.push({
+          repoName: repo.name,
+          path: filePath,
+          displayPath: multiRepo ? `${repo.name}/${filePath}` : filePath,
+          status: cached.changedFiles.has(filePath) ? "changed" : "untouched",
+          score,
+          indexedAt: new Date(cached.timestamp).toISOString(),
+          stale: isStale
+        });
+      }
+    }
+    allResults.sort((a, b) => q ? b.score - a.score || a.displayPath.localeCompare(b.displayPath) : a.displayPath.localeCompare(b.displayPath));
+    const paged = allResults.slice(offset, offset + limit);
+    const nextOffset = offset + limit;
+    const nextCursor = nextOffset < allResults.length ? Buffer.from(String(nextOffset)).toString("base64") : null;
+    return {
+      files: paged,
+      nextCursor,
+      indexedAt: indexedAt || (/* @__PURE__ */ new Date()).toISOString(),
+      stale
+    };
+  }
+  async readFile(repoName, filePath) {
+    if (filePath.includes("..") || filePath.startsWith("/")) {
+      return null;
+    }
+    const repos = await this.gitService.listRepositories();
+    const repo = repos.find((r) => r.name === repoName);
+    if (!repo) return null;
+    try {
+      const fullPath = await realpath(resolve(join13(repo.path, filePath)));
+      const repoRoot = await realpath(repo.path);
+      const repoPrefix = repoRoot.endsWith("/") ? repoRoot : repoRoot + "/";
+      if (!fullPath.startsWith(repoPrefix) && fullPath !== repoRoot) return null;
+      const fileStat = await stat3(fullPath);
+      if (!fileStat.isFile()) return null;
+      const sizeBytes = fileStat.size;
+      if (isBinaryExtension(filePath)) {
+        return {
+          repoName,
+          path: filePath,
+          content: null,
+          language: null,
+          sizeBytes,
+          binary: true,
+          tooLarge: false
+        };
+      }
+      if (sizeBytes > MAX_CONTENT_BYTES) {
+        return {
+          repoName,
+          path: filePath,
+          content: null,
+          language: detectLanguageByPath(filePath),
+          sizeBytes,
+          binary: false,
+          tooLarge: true
+        };
+      }
+      const content = await readFile9(fullPath, "utf-8");
+      return {
+        repoName,
+        path: filePath,
+        content,
+        language: detectLanguageByPath(filePath),
+        sizeBytes,
+        binary: false,
+        tooLarge: false
+      };
+    } catch {
+      return null;
+    }
+  }
+  async indexAll(refresh) {
+    const repos = await this.gitService.listRepositories();
+    for (const repo of repos) {
+      const cached = this.cache.get(repo.name);
+      const isFresh = cached && Date.now() - cached.timestamp < CACHE_TTL_MS;
+      if (isFresh && !refresh) continue;
+      try {
+        const [files, changedFiles] = await Promise.all([
+          this.listRepoFiles(repo.path),
+          this.listChangedFiles(repo.path, repo.defaultBranch)
+        ]);
+        this.cache.set(repo.name, {
+          files,
+          changedFiles,
+          timestamp: Date.now()
+        });
+      } catch {
+      }
+    }
+  }
+  async listRepoFiles(repoPath) {
+    const output = await execGitAsync(
+      ["ls-files", "-z", "--cached", "--others", "--exclude-standard"],
+      repoPath,
+      SEARCH_TIMEOUT_MS
+    );
+    return output.split("\0").filter((f) => f.length > 0 && !isExcludedPath(f));
+  }
+  async listChangedFiles(repoPath, defaultBranch) {
+    const changedFiles = /* @__PURE__ */ new Set();
+    try {
+      const mergeBase = await execGitAsync(
+        ["merge-base", `origin/${defaultBranch}`, "HEAD"],
+        repoPath,
+        SEARCH_TIMEOUT_MS
+      );
+      const diffOutput = await execGitAsync(
+        ["diff", "--name-only", "-M", mergeBase.trim()],
+        repoPath,
+        SEARCH_TIMEOUT_MS
+      );
+      for (const file of diffOutput.split("\n")) {
+        if (file.length > 0) {
+          changedFiles.add(file);
+        }
+      }
+    } catch {
+    }
+    try {
+      const untrackedOutput = await execGitAsync(
+        ["ls-files", "--others", "--exclude-standard"],
+        repoPath,
+        SEARCH_TIMEOUT_MS
+      );
+      for (const file of untrackedOutput.split("\n")) {
+        if (file.length > 0) {
+          changedFiles.add(file);
+        }
+      }
+    } catch {
+    }
+    return changedFiles;
+  }
+};
+
 // src/v1-routes.ts
 import { Hono } from "hono";
 import { z as z2 } from "zod";
-import { readdir as readdir6, stat as stat3, readFile as readFile12 } from "fs/promises";
-import { join as join16, resolve } from "path";
+import { readdir as readdir6, stat as stat4, readFile as readFile13 } from "fs/promises";
+import { join as join17, resolve as resolve2 } from "path";
 
 // src/services/plan-service.ts
-import { readdir as readdir4, readFile as readFile9 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile10 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { basename, join as join13 } from "path";
+import { basename, join as join14 } from "path";
 var PLAN_DIRECTORIES = [
-  join13(homedir10(), ".claude", "plans"),
-  join13(homedir10(), ".replicas", "plans")
+  join14(homedir10(), ".claude", "plans"),
+  join14(homedir10(), ".replicas", "plans")
 ];
 function isMarkdownFile(filename) {
   return filename.toLowerCase().endsWith(".md");
@@ -4613,9 +5066,9 @@ var PlanService = class {
       return null;
     }
     for (const directory of PLAN_DIRECTORIES) {
-      const filePath = join13(directory, safeFilename);
+      const filePath = join14(directory, safeFilename);
       try {
-        const content = await readFile9(filePath, "utf-8");
+        const content = await readFile10(filePath, "utf-8");
         return { filename: safeFilename, content };
       } catch {
       }
@@ -4627,15 +5080,15 @@ var planService = new PlanService();
 
 // src/services/warm-hooks-service.ts
 import { spawn } from "child_process";
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/services/warm-hook-logs-service.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile9, readdir as readdir5 } from "fs/promises";
-import { join as join14 } from "path";
-var LOGS_DIR2 = join14(SANDBOX_PATHS.REPLICAS_DIR, "warm-hook-logs");
+import { mkdir as mkdir11, readFile as readFile11, writeFile as writeFile9, readdir as readdir5 } from "fs/promises";
+import { join as join15 } from "path";
+var LOGS_DIR2 = join15(SANDBOX_PATHS.REPLICAS_DIR, "warm-hook-logs");
 function sanitizeFilename2(name) {
   const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
   const hash = createHash2("sha256").update(name).digest("hex").slice(0, 8);
@@ -4665,7 +5118,7 @@ var WarmHookLogsService = class {
       hookName: "organization",
       ...entry
     };
-    await writeFile9(join14(LOGS_DIR2, globalFilename()), `${JSON.stringify(log, null, 2)}
+    await writeFile9(join15(LOGS_DIR2, globalFilename()), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveEnvironmentHookLog(entry) {
@@ -4675,7 +5128,7 @@ var WarmHookLogsService = class {
       hookName: "environment",
       ...entry
     };
-    await writeFile9(join14(LOGS_DIR2, environmentFilename()), `${JSON.stringify(log, null, 2)}
+    await writeFile9(join15(LOGS_DIR2, environmentFilename()), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveRepoHookLog(repoName, entry) {
@@ -4685,7 +5138,7 @@ var WarmHookLogsService = class {
       hookName: repoName,
       ...entry
     };
-    await writeFile9(join14(LOGS_DIR2, repoFilename2(repoName)), `${JSON.stringify(log, null, 2)}
+    await writeFile9(join15(LOGS_DIR2, repoFilename2(repoName)), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async getAllLogs() {
@@ -4704,7 +5157,7 @@ var WarmHookLogsService = class {
         continue;
       }
       try {
-        const raw = await readFile10(join14(LOGS_DIR2, file), "utf-8");
+        const raw = await readFile11(join15(LOGS_DIR2, file), "utf-8");
         const stored = JSON.parse(raw);
         logs.push(withPreview2(stored));
       } catch {
@@ -4722,7 +5175,7 @@ var WarmHookLogsService = class {
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "global" ? globalFilename() : hookType === "environment" ? environmentFilename() : repoFilename2(hookName);
     try {
-      const raw = await readFile10(join14(LOGS_DIR2, filename), "utf-8");
+      const raw = await readFile11(join15(LOGS_DIR2, filename), "utf-8");
       const stored = JSON.parse(raw);
       if (stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
@@ -4741,12 +5194,12 @@ var warmHookLogsService = new WarmHookLogsService();
 // src/services/warm-hooks-service.ts
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join15(repoPath, filename);
+    const configPath = join16(repoPath, filename);
     if (!existsSync8(configPath)) {
       continue;
     }
     try {
-      const raw = await readFile11(configPath, "utf-8");
+      const raw = await readFile12(configPath, "utf-8");
       const config = parseReplicasConfigString(raw, filename);
       if (!config.warmHook) {
         return null;
@@ -4792,7 +5245,7 @@ async function executeHookScriptStreaming(params) {
   let bufferExceeded = false;
   params.onChunk(`$ ${params.label}
 `);
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const proc = spawn("bash", ["-lc", params.content], {
       cwd: params.cwd,
       env: process.env,
@@ -4825,7 +5278,7 @@ async function executeHookScriptStreaming(params) {
     proc.on("close", (code) => {
       clearTimeout(timer);
       const output = [`$ ${params.label}`, ...outputParts].join("");
-      resolve2({
+      resolve3({
         exitCode: bufferExceeded ? 1 : code ?? 1,
         output,
         timedOut: killed && !bufferExceeded
@@ -4835,7 +5288,7 @@ async function executeHookScriptStreaming(params) {
       clearTimeout(timer);
       const output = [`$ ${params.label}
 `, ...outputParts, err.message].join("");
-      resolve2({
+      resolve3({
         exitCode: 1,
         output,
         timedOut: false
@@ -5236,6 +5689,28 @@ function createV1Routes(deps) {
     };
     return c.json(response);
   });
+  app2.get("/repo-files/search", async (c) => {
+    const q = c.req.query("q") ?? "";
+    const prefix = c.req.query("prefix") ?? "";
+    const rawLimit = c.req.query("limit") ? parseInt(c.req.query("limit"), 10) : void 0;
+    const limit = rawLimit !== void 0 && !Number.isNaN(rawLimit) ? rawLimit : void 0;
+    const cursor = c.req.query("cursor") ?? void 0;
+    const refresh = c.req.query("refresh") === "true";
+    const result = await deps.repoFileService.search({ q, prefix, limit, cursor, refresh });
+    return c.json(result);
+  });
+  app2.get("/repo-files/content", async (c) => {
+    const repoName = c.req.query("repoName");
+    const path4 = c.req.query("path");
+    if (!repoName || !path4) {
+      return c.json(jsonError("repoName and path are required"), 400);
+    }
+    const result = await deps.repoFileService.readFile(repoName, path4);
+    if (!result) {
+      return c.json(jsonError("File not found"), 404);
+    }
+    return c.json(result);
+  });
   app2.get("/plans", async (c) => {
     try {
       const plans = await planService.listPlans();
@@ -5500,8 +5975,8 @@ function createV1Routes(deps) {
       const logFiles = files.filter((f) => f.endsWith(".log"));
       const sessions = await Promise.all(
         logFiles.map(async (filename) => {
-          const filePath = join16(LOG_DIR, filename);
-          const fileStat = await stat3(filePath);
+          const filePath = join17(LOG_DIR, filename);
+          const fileStat = await stat4(filePath);
           const sessionId = filename.replace(/\.log$/, "");
           return {
             sessionId,
@@ -5529,15 +6004,15 @@ function createV1Routes(deps) {
       if (!sessionId || /[/\\]/.test(sessionId) || sessionId.includes("..")) {
         return c.json(jsonError("Invalid session ID"), 400);
       }
-      const filePath = resolve(LOG_DIR, `${sessionId}.log`);
-      if (!filePath.startsWith(resolve(LOG_DIR))) {
+      const filePath = resolve2(LOG_DIR, `${sessionId}.log`);
+      if (!filePath.startsWith(resolve2(LOG_DIR))) {
         return c.json(jsonError("Invalid session ID"), 400);
       }
       const offset = parseInt(c.req.query("offset") || "0", 10);
       const limit = Math.min(parseInt(c.req.query("limit") || "500", 10), 5e3);
       let content;
       try {
-        content = await readFile12(filePath, "utf-8");
+        content = await readFile13(filePath, "utf-8");
       } catch {
         return c.json(jsonError("Log session not found"), 404);
       }
@@ -5611,7 +6086,7 @@ app.get("/health", async (c) => {
     return c.json({ status: "initializing", timestamp: (/* @__PURE__ */ new Date()).toISOString() }, 503);
   }
   try {
-    const logContent = await readFile13("/var/log/cloud-init-output.log", "utf-8");
+    const logContent = await readFile14("/var/log/cloud-init-output.log", "utf-8");
     let status;
     if (logContent.includes(COMPLETION_MESSAGE)) {
       status = "active";
@@ -5653,7 +6128,8 @@ app.get("/token-refresh/health", async (c) => {
     codex: codexTokenManager.getHealthStatus()
   });
 });
-app.route("/", createV1Routes({ chatService }));
+var repoFileService = new RepoFileService(gitService);
+app.route("/", createV1Routes({ chatService, repoFileService }));
 var port = ENGINE_ENV.REPLICAS_ENGINE_PORT;
 function startStatusBroadcaster() {
   let previousRepoStatus = "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.166",
+  "version": "0.1.168",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",