replicas-engine 0.1.362 → 0.1.364

package/README.md

@@ -28,6 +28,7 @@ Chats:
 - `GET /chats/:chatId`
 - `DELETE /chats/:chatId`
 - `GET /chats/:chatId/history`
+- `GET /chats/:chatId/slash-commands`
 - `POST /chats/:chatId/messages`
 - `POST /chats/:chatId/interrupt`
 

package/dist/src/index.js

@@ -121,9 +121,9 @@ var EXT_TO_LANGUAGE = {
 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";
+    const basename3 = filePath.split("/").pop() ?? "";
+    if (basename3 === "Dockerfile") return "dockerfile";
+    if (basename3 === "Makefile") return "makefile";
     return null;
   }
   const ext = filePath.slice(dot).toLowerCase();
@@ -295,7 +295,7 @@ var WORKSPACE_SIZES = ["small", "large"];
 var INVALID_WORKSPACE_SIZE_ERROR = `Invalid size: must be one of ${WORKSPACE_SIZES.join(", ")}`;
 
 // ../shared/src/e2b.ts
-var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-27-v4";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-28-v2";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -427,6 +427,56 @@ function normalizeRepositoryUrl(url, options = {}) {
 }
 
 // ../shared/src/slash-commands.ts
+function normalizeSlashCommandName(name) {
+  const command = name.trim().replace(/^\/+/, "");
+  if (!command || /\s/.test(command)) return null;
+  return `/${command}`;
+}
+function createProviderSlashCommand(provider, name, description, argumentHint) {
+  const command = normalizeSlashCommandName(name);
+  if (!command) return null;
+  const trimmedDescription = description?.trim();
+  const trimmedArgumentHint = argumentHint?.trim();
+  return {
+    command,
+    description: trimmedDescription || `Run ${command}.`,
+    ...trimmedArgumentHint ? { argumentHint: trimmedArgumentHint } : {},
+    providers: [provider]
+  };
+}
+var SLASH_COMMANDS = [
+  {
+    command: "/plan",
+    description: "Switch to plan mode and optionally send a prompt.",
+    argumentHint: "[prompt]",
+    providers: ["claude", "codex", "cursor", "opencode", "relay"]
+  },
+  {
+    command: "/fast",
+    description: "Use the fast service tier for future turns.",
+    providers: ["claude", "codex"]
+  },
+  {
+    command: "/goal",
+    description: "Set or clear a task goal.",
+    argumentHint: "<objective | clear>",
+    providers: ["codex"]
+  }
+];
+function mergeSlashCommands(...commandGroups) {
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const command of commandGroups.flat()) {
+    const key = command.command.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    commands.push(command);
+  }
+  return commands;
+}
+function getSlashCommandsForProvider(provider, commands = SLASH_COMMANDS) {
+  return commands.filter((command) => command.providers.includes(provider));
+}
 var MAX_CODEX_GOAL_OBJECTIVE_CHARS = 4e3;
 function parseGoalCommand(message) {
   const match = message.trim().match(/^\/goal(?:\s+([\s\S]*))?$/i);
@@ -5257,7 +5307,7 @@ async function registerDesktopPreview() {
 
 // src/services/chat/chat-service.ts
 import { existsSync as existsSync7 } from "fs";
-import { appendFile as appendFile3, copyFile, mkdir as mkdir13, readFile as readFile13, rename as rename2, rm } from "fs/promises";
+import { appendFile as appendFile3, copyFile, mkdir as mkdir13, readFile as readFile14, rename as rename2, rm } from "fs/promises";
 import { homedir as homedir14 } from "os";
 import { join as join19 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
@@ -6579,6 +6629,16 @@ var MAX_MIDTURN_CONTINUE_RETRIES = 2;
 var TRANSIENT_RETRY_DELAYS_MS = [1e3, 2500];
 var CLAUDE_TRANSIENT_HTTP_STATUSES = [408, 500, 502, 503, 504, 529];
 var CLAUDE_MIDTURN_CONTINUE_PROMPT = "Your previous turn was interrupted by a transient network error before it could finish. Continue from exactly where you left off. Do not repeat any tool calls, commits, messages, or other actions you have already completed \u2014 first check what is already done, then do only the remaining work.";
+function toSlashCommands(command) {
+  const names = [command.name, ...command.aliases ?? []];
+  return names.flatMap((name) => {
+    const result = createProviderSlashCommand("claude", name, command.description, command.argumentHint);
+    return result ? [result] : [];
+  });
+}
+function normalizeClaudeSlashCommands(commands) {
+  return mergeSlashCommands(...commands.map(toSlashCommands));
+}
 var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   historyFilePath;
   historyFile;
@@ -6602,6 +6662,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   disallowedToolsOverride;
   /** Active tool-input requests keyed by requestId; resolved when the user selects an option. */
   pendingToolInputs = /* @__PURE__ */ new Map();
+  supportedSlashCommands = [];
   authRetrying = false;
   constructor(options) {
     super(options);
@@ -6640,6 +6701,21 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   isAuthRetrying() {
     return this.authRetrying;
   }
+  async listSlashCommands() {
+    await this.initialized;
+    if (!this.activeQuery || this.isProcessing()) {
+      return this.supportedSlashCommands;
+    }
+    try {
+      const commands = await this.activeQuery?.supportedCommands();
+      if (commands) {
+        this.supportedSlashCommands = normalizeClaudeSlashCommands(commands);
+      }
+    } catch (error) {
+      console.warn("[ClaudeManager] Failed to load slash commands:", error);
+    }
+    return this.supportedSlashCommands;
+  }
   setAuthRetrying(value) {
     if (this.authRetrying === value) return;
     this.authRetrying = value;
@@ -7390,6 +7466,9 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       this.handlePartialAssistantMessage(message);
       return;
     }
+    if (message.type === "system" && message.subtype === "commands_changed") {
+      this.supportedSlashCommands = normalizeClaudeSlashCommands(message.commands);
+    }
     this.trackNativeCompaction(message);
     await this.recordEvent(message);
   }
@@ -7612,7 +7691,7 @@ var AspClient = class {
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.362";
+var ENGINE_PACKAGE_VERSION = "0.1.364";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -7867,6 +7946,7 @@ var TURN_START_METHOD = "turn/start";
 var TURN_INTERRUPT_METHOD = "turn/interrupt";
 var ACCOUNT_RATE_LIMITS_READ_METHOD = "account/rateLimits/read";
 var MODEL_LIST_METHOD = "model/list";
+var SKILLS_LIST_METHOD = "skills/list";
 var MAX_CODEX_ASP_TRANSCRIPT_OUTPUT_CHARS = DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS;
 function codexApprovalPolicyOverrides() {
   if (!ENGINE_ENV.REPLICAS_DISABLE_GH_PR_MERGE) {
@@ -8420,6 +8500,20 @@ var TranscriptUpdateCoalescer = class {
 };
 
 // src/managers/codex-asp/codex-asp-manager.ts
+var CODEX_SLASH_COMMANDS_CACHE_MS = 3e4;
+function skillToSlashCommand(skill) {
+  if (!skill.enabled) return null;
+  const description = skill.interface?.shortDescription ?? skill.shortDescription ?? skill.description;
+  return createProviderSlashCommand("codex", skill.name, description);
+}
+function skillsListToSlashCommands(response) {
+  return mergeSlashCommands(
+    ...response.data.map((entry) => entry.skills.flatMap((skill) => {
+      const command = skillToSlashCommand(skill);
+      return command ? [command] : [];
+    }))
+  );
+}
 var CodexAspManager = class extends CodingAgentManager {
   currentThreadId = null;
   activeTurnId = null;
@@ -8437,6 +8531,8 @@ var CodexAspManager = class extends CodingAgentManager {
   skillRegistriesApplied = false;
   modelServiceTierCache = null;
   activeServiceTier;
+  slashCommandsCache = null;
+  slashCommandsRequest = null;
   constructor(options) {
     super(options);
     this.historyFile = options.historyFilePath ? new CodexHistoryFile(options.historyFilePath) : null;
@@ -8515,6 +8611,34 @@ var CodexAspManager = class extends CodingAgentManager {
   getGoal() {
     return this.currentGoal;
   }
+  async listSlashCommands() {
+    await this.initialized;
+    const now = Date.now();
+    if (this.slashCommandsCache && this.slashCommandsCache.expiresAt > now) {
+      return this.slashCommandsCache.commands;
+    }
+    if (!this.slashCommandsRequest) {
+      this.slashCommandsRequest = (async () => {
+        try {
+          const host = await getCodexAspHost();
+          await this.applySkillRegistries(host);
+          const response = await host.client.request(
+            SKILLS_LIST_METHOD,
+            { cwds: [this.workingDirectory] }
+          );
+          const commands = skillsListToSlashCommands(response);
+          this.slashCommandsCache = { commands, expiresAt: Date.now() + CODEX_SLASH_COMMANDS_CACHE_MS };
+          return commands;
+        } catch (error) {
+          console.warn("[CodexAspManager] Failed to load slash commands:", error);
+          return this.slashCommandsCache?.commands ?? [];
+        } finally {
+          this.slashCommandsRequest = null;
+        }
+      })();
+    }
+    return this.slashCommandsRequest;
+  }
   async clearGoal() {
     await this.initialized;
     if (!this.currentThreadId) {
@@ -9381,9 +9505,11 @@ var CodexAspManager = class extends CodingAgentManager {
 };
 
 // src/managers/cursor-manager.ts
-import { mkdir as mkdir11 } from "fs/promises";
-import { dirname as dirname5, join as join15 } from "path";
+import { mkdir as mkdir11, readFile as readFile10, readdir as readdir4 } from "fs/promises";
+import { basename, dirname as dirname5, extname, join as join15 } from "path";
+import { parse as parseYaml2 } from "yaml";
 import { Agent as CursorAgent } from "@cursor/sdk";
+var CURSOR_SLASH_COMMANDS_CACHE_MS = 3e4;
 var CURSOR_COMPOSER_CONTEXT_WINDOW = 2e5;
 var CURSOR_CATEGORY_COLORS = {
   input: "#3eeba3",
@@ -9394,12 +9520,45 @@ var CURSOR_CATEGORY_COLORS = {
 function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
+function extractCursorCommandDescription(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return void 0;
+  try {
+    const parsed = parseYaml2(match[1]);
+    if (isRecord4(parsed) && typeof parsed.description === "string") return parsed.description;
+  } catch {
+  }
+  return void 0;
+}
+async function listCursorCommandsInDirectory(directory) {
+  let entries;
+  try {
+    entries = await readdir4(directory, { withFileTypes: true });
+  } catch (error) {
+    if (isRecord4(error) && error.code === "ENOENT") return [];
+    console.warn("[CursorManager] Failed to read slash command directory:", error);
+    return [];
+  }
+  const commands = await Promise.all(entries.filter((entry) => entry.isFile() && extname(entry.name) === ".md").map(async (entry) => {
+    const name = basename(entry.name, ".md");
+    let description;
+    try {
+      description = extractCursorCommandDescription(await readFile10(join15(directory, entry.name), "utf8"));
+    } catch (error) {
+      console.warn("[CursorManager] Failed to read slash command file:", error);
+    }
+    return createProviderSlashCommand("cursor", name, description);
+  }));
+  return commands.filter((command) => Boolean(command));
+}
 var CursorManager = class extends CodingAgentManager {
   agent = null;
   activeRun = null;
   activeModel = null;
   historyFilePath;
   historyFile;
+  slashCommandsCache = null;
+  slashCommandsRequest = null;
   constructor(options) {
     super(options);
     this.historyFilePath = options.historyFilePath ?? join15(ENGINE_ENV.HOME_DIR, ".replicas", "cursor", "history.jsonl");
@@ -9421,6 +9580,26 @@ var CursorManager = class extends CodingAgentManager {
       goal: null
     };
   }
+  async listSlashCommands() {
+    await this.initialized;
+    const now = Date.now();
+    if (this.slashCommandsCache && this.slashCommandsCache.expiresAt > now) {
+      return this.slashCommandsCache.commands;
+    }
+    this.slashCommandsRequest ??= (async () => {
+      try {
+        const commands = mergeSlashCommands(
+          await listCursorCommandsInDirectory(join15(this.workingDirectory, ".cursor", "commands")),
+          await listCursorCommandsInDirectory(join15(ENGINE_ENV.HOME_DIR, ".cursor", "commands"))
+        );
+        this.slashCommandsCache = { commands, expiresAt: Date.now() + CURSOR_SLASH_COMMANDS_CACHE_MS };
+        return commands;
+      } finally {
+        this.slashCommandsRequest = null;
+      }
+    })();
+    return this.slashCommandsRequest;
+  }
   async ensureAgent(request) {
     if (this.agent) return this.agent;
     const apiKey = ENGINE_ENV.CURSOR_API_KEY;
@@ -9560,7 +9739,7 @@ var CursorManager = class extends CodingAgentManager {
 };
 
 // src/managers/opencode-manager.ts
-import { mkdir as mkdir12, readFile as readFile10 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile11 } from "fs/promises";
 import { delimiter, dirname as dirname6, join as join16 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 import { fileURLToPath } from "url";
@@ -9573,6 +9752,7 @@ var OPENCODE_SHIM_DIR = dirname6(fileURLToPath(new URL("../../scripts/opencode",
 var OPENCODE_CONFIG_PATH = join16(ENGINE_ENV.HOME_DIR, ".config", "opencode", "opencode.json");
 var OPENCODE_FETCH_DISPATCHER = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
 var OPENCODE_WORKSPACE_PERMISSION = "allow";
+var OPENCODE_SLASH_COMMANDS_CACHE_MS = 3e4;
 var OPENCODE_VARIANT_CANDIDATES_BY_THINKING_LEVEL = {
   low: ["low"],
   medium: ["medium"],
@@ -9604,6 +9784,25 @@ async function opencodeConfig(model) {
 function getConfiguredOpencodeModels(model) {
   return [.../* @__PURE__ */ new Set([model, ...AGENT_MODELS.opencode])];
 }
+function opencodeCommandToSlashCommand(command) {
+  return createProviderSlashCommand("opencode", command.name, command.description);
+}
+function opencodeSkillToSlashCommand(skill) {
+  if (!skill.slash) return null;
+  return createProviderSlashCommand("opencode", skill.name, skill.description);
+}
+function opencodeCommandListToSlashCommands(response) {
+  return mergeSlashCommands(response.data.flatMap((command) => {
+    const result = opencodeCommandToSlashCommand(command);
+    return result ? [result] : [];
+  }));
+}
+function opencodeSkillListToSlashCommands(response) {
+  return mergeSlashCommands(response.data.flatMap((skill) => {
+    const result = opencodeSkillToSlashCommand(skill);
+    return result ? [result] : [];
+  }));
+}
 function isOpencodePart(value) {
   return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
 }
@@ -9627,7 +9826,7 @@ function isOpencodeMcpEntry(value) {
 async function readProvisionedOpencodeMcpConfig() {
   let raw;
   try {
-    raw = await readFile10(OPENCODE_CONFIG_PATH, "utf8");
+    raw = await readFile11(OPENCODE_CONFIG_PATH, "utf8");
   } catch (error) {
     if (isRecord4(error) && error.code === "ENOENT") return void 0;
     console.error("[OpencodeManager] Failed to read Opencode config:", error);
@@ -9699,6 +9898,8 @@ var OpencodeManager = class extends CodingAgentManager {
   reasoningParts = /* @__PURE__ */ new Map();
   nonAssistantMessageIds = /* @__PURE__ */ new Set();
   modelVariants = /* @__PURE__ */ new Map();
+  slashCommandsCache = null;
+  slashCommandsRequest = null;
   constructor(options) {
     super(options);
     this.sessionId = options.initialSessionId;
@@ -9731,6 +9932,35 @@ var OpencodeManager = class extends CodingAgentManager {
       goal: null
     };
   }
+  async listSlashCommands() {
+    await this.initialized;
+    const now = Date.now();
+    if (this.slashCommandsCache && this.slashCommandsCache.expiresAt > now) {
+      return this.slashCommandsCache.commands;
+    }
+    this.slashCommandsRequest ??= (async () => {
+      try {
+        const client = await this.ensureClient(DEFAULT_OPENCODE_MODEL);
+        const location = { directory: this.workingDirectory };
+        const [commandResponse, skillResponse] = await Promise.all([
+          client.v2.command.list({ location }, { throwOnError: true }),
+          client.v2.skill.list({ location }, { throwOnError: true })
+        ]);
+        const commands = mergeSlashCommands(
+          opencodeCommandListToSlashCommands(commandResponse.data),
+          opencodeSkillListToSlashCommands(skillResponse.data)
+        );
+        this.slashCommandsCache = { commands, expiresAt: Date.now() + OPENCODE_SLASH_COMMANDS_CACHE_MS };
+        return commands;
+      } catch (error) {
+        console.warn("[OpencodeManager] Failed to load slash commands:", error);
+        return this.slashCommandsCache?.commands ?? [];
+      } finally {
+        this.slashCommandsRequest = null;
+      }
+    })();
+    return this.slashCommandsRequest;
+  }
   async ensureClient(model) {
     if (this.client && this.configuredModels.has(model)) return this.client;
     if (!ENGINE_ENV.OPENROUTER_API_KEY) {
@@ -10545,6 +10775,9 @@ var RelayManager = class {
   async getHistory() {
     return this.inner.getHistory();
   }
+  async listSlashCommands() {
+    return this.inner.listSlashCommands?.() ?? [];
+  }
   isProcessing() {
     return this.inner.isProcessing();
   }
@@ -10604,7 +10837,7 @@ var KeepAliveService = class _KeepAliveService {
 var keepAliveService = new KeepAliveService();
 
 // src/services/canvas-service.ts
-import { readdir as readdir4, readFile as readFile11, stat as stat3 } from "fs/promises";
+import { readdir as readdir5, readFile as readFile12, stat as stat3 } from "fs/promises";
 import { homedir as homedir12 } from "os";
 import { join as join17 } from "path";
 var CANVAS_DIRECTORIES = [
@@ -10617,7 +10850,7 @@ var CanvasService = class {
     for (const directory of CANVAS_DIRECTORIES) {
       let entries;
       try {
-        entries = await readdir4(directory, { withFileTypes: true });
+        entries = await readdir5(directory, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -10664,7 +10897,7 @@ var CanvasService = class {
         };
       }
       try {
-        const bytes = await readFile11(filePath);
+        const bytes = await readFile12(filePath);
         return { filename: safe, kind, sizeBytes, mimeType, updatedAt, bytes };
       } catch {
         continue;
@@ -10779,8 +11012,8 @@ async function reconcileCanvasItems(filenames) {
 }
 
 // src/services/upload-chat-transcripts.ts
-import { readdir as readdir5, readFile as readFile12 } from "fs/promises";
-import { basename, join as join18 } from "path";
+import { readdir as readdir6, readFile as readFile13 } from "fs/promises";
+import { basename as basename2, join as join18 } from "path";
 import { homedir as homedir13 } from "os";
 var ENGINE_DIR2 = join18(homedir13(), ".replicas", "engine");
 var HISTORY_DIRS = [
@@ -10795,13 +11028,13 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map()) {
   for (const dir of HISTORY_DIRS) {
     let entries;
     try {
-      entries = await readdir5(dir);
+      entries = await readdir6(dir);
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.endsWith(".jsonl")) continue;
-      const chatId = basename(entry, ".jsonl");
+      const chatId = basename2(entry, ".jsonl");
       tasks.push(
         uploadChatTranscript(chatId, join18(dir, entry), chatsById.get(chatId)).then(() => {
           flushed++;
@@ -10816,7 +11049,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map()) {
   return { flushed, failed };
 }
 async function uploadChatTranscript(chatId, filePath, chat) {
-  const bytes = await readFile12(filePath);
+  const bytes = await readFile13(filePath);
   if (bytes.byteLength === 0) return;
   const form = new FormData();
   form.append("chat_id", chatId);
@@ -11046,6 +11279,21 @@ var ChatService = class {
     const chat = this.chats.get(chatId);
     return chat ? this.toSummary(chat) : null;
   }
+  async listSlashCommands(chatId) {
+    const chat = this.requireChat(chatId);
+    const provider = chat.persisted.provider;
+    const discovered = await chat.provider.listSlashCommands?.() ?? [];
+    const providerCommands = discovered.map((command) => ({
+      ...command,
+      providers: [provider]
+    }));
+    return {
+      commands: mergeSlashCommands(
+        getSlashCommandsForProvider(provider),
+        providerCommands
+      )
+    };
+  }
   async createChat(request) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const title = request.title?.trim() || `${request.provider} chat`;
@@ -11121,7 +11369,7 @@ var ChatService = class {
   }
   async readSenders(chatId) {
     try {
-      const content = await readFile13(this.senderFilePath(chatId), "utf-8");
+      const content = await readFile14(this.senderFilePath(chatId), "utf-8");
       const lines = content.split("\n").filter((line) => line.trim().length > 0);
       const senders = [];
       for (const line of lines) {
@@ -11531,7 +11779,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile13(CHATS_FILE, "utf-8");
+      const content = await readFile14(CHATS_FILE, "utf-8");
       return parsePersistedChatsContent(content);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
@@ -11546,7 +11794,7 @@ var ChatService = class {
         console.error("[ChatService] Failed to quarantine corrupt chats file:", renameError);
       }
       try {
-        const backupContent = await readFile13(CHATS_BACKUP_FILE, "utf-8");
+        const backupContent = await readFile14(CHATS_BACKUP_FILE, "utf-8");
         return parsePersistedChatsContent(backupContent);
       } catch (backupError) {
         if (backupError && typeof backupError === "object" && "code" in backupError && backupError.code === "ENOENT") {
@@ -11633,8 +11881,8 @@ var ChatService = class {
 
 // src/services/repo-file-service.ts
 import { execFile as execFile2 } from "child_process";
-import { readFile as readFile14, realpath, stat as stat4 } from "fs/promises";
-import { join as join20, resolve as resolve2, extname } from "path";
+import { readFile as readFile15, realpath, stat as stat4 } from "fs/promises";
+import { join as join20, resolve as resolve2, extname as extname2 } from "path";
 var CACHE_TTL_MS = 3e4;
 var SEARCH_TIMEOUT_MS = 15e3;
 var MAX_CONTENT_BYTES = 256 * 1024;
@@ -11642,7 +11890,7 @@ 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 ext = extname2(filePath).toLowerCase();
   const binaryExts = /* @__PURE__ */ new Set([
     ".png",
     ".jpg",
@@ -11694,11 +11942,11 @@ 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;
+  const basename3 = segments[segments.length - 1] ?? "";
+  if (basename3 === lowerQuery) return 100;
+  if (basename3.startsWith(lowerQuery)) return 90;
   if (segments.some((seg) => seg === lowerQuery)) return 80;
-  if (basename2.includes(lowerQuery)) return 70;
+  if (basename3.includes(lowerQuery)) return 70;
   if (segments.some((seg) => seg.includes(lowerQuery))) return 60;
   if (lowerPath.includes(lowerQuery)) return 50;
   return 0;
@@ -11823,7 +12071,7 @@ var RepoFileService = class {
           tooLarge: true
         };
       }
-      const content = await readFile14(fullPath, "utf-8");
+      const content = await readFile15(fullPath, "utf-8");
       return {
         repoName,
         path: filePath,
@@ -11901,17 +12149,17 @@ var RepoFileService = class {
 // src/v1-routes.ts
 import { Hono } from "hono";
 import { z as z2 } from "zod";
-import { readdir as readdir7, stat as stat5, readFile as readFile17 } from "fs/promises";
+import { readdir as readdir8, stat as stat5, readFile as readFile18 } from "fs/promises";
 import { join as join23, resolve as resolve3 } from "path";
 
 // src/services/warm-hooks-service.ts
 import { spawn as spawn4 } from "child_process";
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import { join as join22 } from "path";
 
 // src/services/warm-hook-logs-service.ts
-import { mkdir as mkdir14, readFile as readFile15, writeFile as writeFile6, readdir as readdir6, appendFile as appendFile4, unlink as unlink3 } from "fs/promises";
+import { mkdir as mkdir14, readFile as readFile16, writeFile as writeFile6, readdir as readdir7, appendFile as appendFile4, unlink as unlink3 } from "fs/promises";
 import { homedir as homedir15 } from "os";
 import { join as join21 } from "path";
 var LOGS_DIR2 = join21(homedir15(), ".replicas", "warm-hook-logs");
@@ -11958,7 +12206,7 @@ var WarmHookLogsService = class {
   async getAllLogs() {
     let files;
     try {
-      files = await readdir6(LOGS_DIR2);
+      files = await readdir7(LOGS_DIR2);
     } catch (err) {
       if (err.code === "ENOENT") {
         return [];
@@ -11971,7 +12219,7 @@ var WarmHookLogsService = class {
         continue;
       }
       try {
-        const raw = await readFile15(join21(LOGS_DIR2, file), "utf-8");
+        const raw = await readFile16(join21(LOGS_DIR2, file), "utf-8");
         const stored = JSON.parse(raw);
         logs.push(withPreview2(stored));
       } catch {
@@ -12000,7 +12248,7 @@ var WarmHookLogsService = class {
   }
   async getCurrentRunLog() {
     try {
-      return await readFile15(CURRENT_RUN_LOG, "utf-8");
+      return await readFile16(CURRENT_RUN_LOG, "utf-8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -12009,7 +12257,7 @@ var WarmHookLogsService = class {
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "global" ? GLOBAL_FILENAME : hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
     try {
-      const raw = await readFile15(join21(LOGS_DIR2, filename), "utf-8");
+      const raw = await readFile16(join21(LOGS_DIR2, filename), "utf-8");
       const stored = JSON.parse(raw);
       if (stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
@@ -12033,7 +12281,7 @@ async function readRepoWarmHook(repoPath) {
       continue;
     }
     try {
-      const raw = await readFile16(configPath, "utf-8");
+      const raw = await readFile17(configPath, "utf-8");
       const config = parseReplicasConfigString(raw, filename);
       if (!config.warmHook) {
         return null;
@@ -12468,6 +12716,17 @@ function createV1Routes(deps) {
       return c.json(jsonError("Failed to load chat history", error instanceof Error ? error.message : "Unknown error"), 404);
     }
   });
+  app2.get("/chats/:chatId/slash-commands", async (c) => {
+    try {
+      const response = await deps.chatService.listSlashCommands(c.req.param("chatId"));
+      return c.json(response);
+    } catch (error) {
+      if (error instanceof ChatNotFoundError) {
+        return c.json(jsonError("Failed to load slash commands", error.message), 404);
+      }
+      return c.json(jsonError("Failed to load slash commands", error instanceof Error ? error.message : "Unknown error"), 500);
+    }
+  });
   app2.post("/chats/:chatId/messages", async (c) => {
     try {
       const body = sendMessageSchema.parse(await c.req.json());
@@ -12979,7 +13238,7 @@ function createV1Routes(deps) {
   });
   app2.get("/logs", async (c) => {
     try {
-      const files = await readdir7(LOG_DIR).catch(() => []);
+      const files = await readdir8(LOG_DIR).catch(() => []);
       const logFiles = files.filter((f) => f.endsWith(".log"));
       const sessions = await Promise.all(
         logFiles.map(async (filename) => {
@@ -13020,7 +13279,7 @@ function createV1Routes(deps) {
       const limit = Math.min(parseInt(c.req.query("limit") || "500", 10), 5e3);
       let content;
       try {
-        content = await readFile17(filePath, "utf-8");
+        content = await readFile18(filePath, "utf-8");
       } catch {
         return c.json(jsonError("Log session not found"), 404);
       }

package/package.json

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