replicas-engine 0.1.24 → 0.1.26

package/dist/src/index.js

@@ -54,6 +54,35 @@ async function readJSONL(filePath) {
     return [];
   }
 }
+async function readJSONLPaginated(filePath, limit, offset = 0) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n").filter((line) => line.trim());
+    const allEvents = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch (e) {
+        return null;
+      }
+    }).filter((event) => event !== null);
+    const total = allEvents.length;
+    const startIndex = Math.max(0, total - offset - (limit ?? total));
+    const endIndex = Math.max(0, total - offset);
+    const events = allEvents.slice(startIndex, endIndex);
+    const hasMore = startIndex > 0;
+    return {
+      events,
+      total,
+      hasMore
+    };
+  } catch (error) {
+    return {
+      events: [],
+      total: 0,
+      hasMore: false
+    };
+  }
+}
 
 // src/services/codex-manager.ts
 import { readdir, stat, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
@@ -91,6 +120,15 @@ var MonolithService = class {
 var monolithService = new MonolithService();
 
 // src/services/linear-event-converter.ts
+function linearThoughtToResponse(thought) {
+  return {
+    linearSessionId: thought.linearSessionId,
+    content: {
+      type: "response",
+      body: thought.content.body
+    }
+  };
+}
 function summarizeInput(input) {
   if (!input) return "";
   if (typeof input === "string") return input;
@@ -101,6 +139,14 @@ function summarizeInput(input) {
     if (obj.pattern) return `pattern: ${String(obj.pattern)}`;
     if (obj.query) return String(obj.query);
     if (obj.url) return String(obj.url);
+    if (obj.todos && Array.isArray(obj.todos)) {
+      const todos = obj.todos;
+      const completed = todos.filter((t) => t.status === "completed").length;
+      const total = todos.length;
+      const currentTask = todos.find((t) => t.status === "in_progress");
+      const summary = `${completed}/${total}`;
+      return currentTask?.content ? `${summary}: ${currentTask.content}` : summary;
+    }
     const keys = Object.keys(obj);
     if (keys.length > 0) {
       const firstKey = keys[0];
@@ -289,12 +335,18 @@ function convertCodexEvent(event, linearSessionId) {
       };
     }
     if (item.type === "todo_list") {
+      const items = "items" in item && Array.isArray(item.items) ? item.items : [];
+      const completed = items.filter((t) => t.completed).length;
+      const total = items.length;
+      const currentTask = items.find((t) => !t.completed);
+      const summary = `${completed}/${total}`;
+      const parameter = currentTask?.text ? `${summary}: ${currentTask.text}` : summary;
       return {
         linearSessionId,
         content: {
           type: "action",
           action: "Updating plan",
-          parameter: ""
+          parameter
         }
       };
     }
@@ -357,12 +409,18 @@ function convertCodexEvent(event, linearSessionId) {
       };
     }
     if (item.type === "todo_list") {
+      const items = "items" in item && Array.isArray(item.items) ? item.items : [];
+      const completed = items.filter((t) => t.completed).length;
+      const total = items.length;
+      const currentTask = items.find((t) => !t.completed);
+      const summary = `${completed}/${total}`;
+      const parameter = currentTask?.text ? `${summary}: ${currentTask.text}` : summary;
       return {
         linearSessionId,
         content: {
           type: "action",
           action: "Updating plan",
-          parameter: "",
+          parameter,
           result: "Done"
         }
       };
@@ -509,6 +567,9 @@ async function getPullRequestUrl(cwd) {
       return cachedPr.prUrl;
     }
     cachedPr = null;
+    if (persistedState.prUrl && persistedState.branch !== currentBranch) {
+      await saveEngineState({ prUrl: null });
+    }
     try {
       const remoteRef = execSync(`git ls-remote --heads origin ${currentBranch}`, {
         cwd,
@@ -1092,15 +1153,30 @@ var CodexManager = class {
         input = message;
       }
       const { events } = await this.currentThread.runStreamed(input);
+      let latestThoughtEvent = null;
       for await (const event of events) {
         if (linearSessionId) {
           const linearEvent = convertCodexEvent(event, linearSessionId);
           if (linearEvent) {
-            monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
-            });
+            if (latestThoughtEvent) {
+              monolithService.sendEvent({ type: "agent_update", payload: latestThoughtEvent }).catch(() => {
+              });
+            }
+            if (linearEvent.content.type === "thought") {
+              latestThoughtEvent = linearEvent;
+            } else {
+              latestThoughtEvent = null;
+              monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
+              });
+            }
           }
         }
       }
+      if (linearSessionId && latestThoughtEvent) {
+        const responseEvent = linearThoughtToResponse(latestThoughtEvent);
+        monolithService.sendEvent({ type: "agent_update", payload: responseEvent }).catch(() => {
+        });
+      }
     } finally {
       if (linearSessionId) {
         const status = await getGitStatus(this.workingDirectory);
@@ -1129,6 +1205,38 @@ var CodexManager = class {
       events
     };
   }
+  /**
+   * Get paginated history from the end (bottom-up pagination).
+   * @param limit - Maximum number of events to return
+   * @param offset - Number of events to skip from the end
+   * @returns Paginated history result
+   */
+  async getHistoryPaginated(limit, offset = 0) {
+    if (!this.currentThreadId) {
+      return {
+        thread_id: null,
+        events: [],
+        total: 0,
+        hasMore: false
+      };
+    }
+    const sessionFile = await this.findSessionFile(this.currentThreadId);
+    if (!sessionFile) {
+      return {
+        thread_id: this.currentThreadId,
+        events: [],
+        total: 0,
+        hasMore: false
+      };
+    }
+    const result = await readJSONLPaginated(sessionFile, limit, offset);
+    return {
+      thread_id: this.currentThreadId,
+      events: result.events,
+      total: result.total,
+      hasMore: result.hasMore
+    };
+  }
   async getStatus() {
     let sessionFile = null;
     if (this.currentThreadId) {
@@ -1249,6 +1357,29 @@ codex.post("/send", async (c) => {
 });
 codex.get("/history", async (c) => {
   try {
+    const limitStr = c.req.query("limit");
+    const offsetStr = c.req.query("offset");
+    if (limitStr !== void 0 || offsetStr !== void 0) {
+      const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+      const offset = offsetStr ? parseInt(offsetStr, 10) : 0;
+      if (limitStr && (isNaN(limit) || limit < 1)) {
+        return c.json({ error: "limit must be a positive integer" }, 400);
+      }
+      if (isNaN(offset) || offset < 0) {
+        return c.json({ error: "offset must be a non-negative integer" }, 400);
+      }
+      const history2 = await codexManager.getHistoryPaginated(limit, offset);
+      if (!history2.thread_id) {
+        return c.json({
+          message: "No active thread",
+          thread_id: null,
+          events: [],
+          total: 0,
+          hasMore: false
+        });
+      }
+      return c.json(history2);
+    }
     const history = await codexManager.getHistory();
     if (!history.thread_id) {
       return c.json({
@@ -1494,16 +1625,31 @@ var ClaudeManager = class {
           model: model || "opus"
         }
       });
+      let latestThoughtEvent = null;
       for await (const msg of response) {
         await this.handleMessage(msg);
         if (linearSessionId) {
           const linearEvent = convertClaudeEvent(msg, linearSessionId);
           if (linearEvent) {
-            monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
-            });
+            if (latestThoughtEvent) {
+              monolithService.sendEvent({ type: "agent_update", payload: latestThoughtEvent }).catch(() => {
+              });
+            }
+            if (linearEvent.content.type === "thought") {
+              latestThoughtEvent = linearEvent;
+            } else {
+              latestThoughtEvent = null;
+              monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
+              });
+            }
           }
         }
       }
+      if (linearSessionId && latestThoughtEvent) {
+        const responseEvent = linearThoughtToResponse(latestThoughtEvent);
+        monolithService.sendEvent({ type: "agent_update", payload: responseEvent }).catch(() => {
+        });
+      }
     } finally {
       if (linearSessionId) {
         const status = await getGitStatus(this.workingDirectory);
@@ -1520,6 +1666,22 @@ var ClaudeManager = class {
       events
     };
   }
+  /**
+   * Get paginated history from the end (bottom-up pagination).
+   * @param limit - Maximum number of events to return
+   * @param offset - Number of events to skip from the end
+   * @returns Paginated history result
+   */
+  async getHistoryPaginated(limit, offset = 0) {
+    await this.initialized;
+    const result = await readJSONLPaginated(this.historyFile, limit, offset);
+    return {
+      thread_id: this.sessionId,
+      events: result.events,
+      total: result.total,
+      hasMore: result.hasMore
+    };
+  }
   async getStatus() {
     await this.initialized;
     const status = {
@@ -1606,6 +1768,29 @@ claude.post("/send", async (c) => {
 });
 claude.get("/history", async (c) => {
   try {
+    const limitStr = c.req.query("limit");
+    const offsetStr = c.req.query("offset");
+    if (limitStr !== void 0 || offsetStr !== void 0) {
+      const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+      const offset = offsetStr ? parseInt(offsetStr, 10) : 0;
+      if (limitStr && (isNaN(limit) || limit < 1)) {
+        return c.json({ error: "limit must be a positive integer" }, 400);
+      }
+      if (isNaN(offset) || offset < 0) {
+        return c.json({ error: "offset must be a non-negative integer" }, 400);
+      }
+      const history2 = await claudeManager.getHistoryPaginated(limit, offset);
+      if (!history2.thread_id) {
+        return c.json({
+          message: "No active session",
+          thread_id: null,
+          events: [],
+          total: 0,
+          hasMore: false
+        });
+      }
+      return c.json(history2);
+    }
     const history = await claudeManager.getHistory();
     if (!history.thread_id) {
       return c.json({
@@ -2047,7 +2232,7 @@ async function initializeGitRepository() {
     console.log(`[GitInit] Creating workspace branch: ${branchName}`);
     runGitCommand(`git checkout -b ${branchName}`, repoPath);
     initializedBranch = branchName;
-    await saveEngineState({ branch: branchName });
+    await saveEngineState({ branch: branchName, prUrl: null });
     console.log(`[GitInit] Successfully initialized on branch: ${branchName}`);
     return {
       success: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",
@@ -31,7 +31,7 @@
     "@openai/codex-sdk": "^0.50.0",
     "dotenv": "^17.2.3",
     "hono": "^4.10.3",
-    "zod": "3.24.1"
+    "zod": "^3.25.0"
   },
   "devDependencies": {
     "@types/node": "^20.11.17",