@mobvibe/cli 0.1.6 → 0.1.7

package/dist/index.js

@@ -380,7 +380,7 @@ var getCliConfig = async () => {
 // src/daemon/daemon.ts
 import { spawn as spawn2 } from "child_process";
 import fs5 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 
 // src/acp/session-manager.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -1045,12 +1045,12 @@ var SessionManager = class {
   emitSessionsChanged(payload) {
     this.sessionsChangedEmitter.emit("changed", payload);
   }
-  emitSessionAttached(sessionId) {
+  emitSessionAttached(sessionId, force = false) {
     const record = this.sessions.get(sessionId);
     if (!record) {
       return;
     }
-    if (record.isAttached) {
+    if (record.isAttached && !force) {
       return;
     }
     const attachedAt = /* @__PURE__ */ new Date();
@@ -1497,7 +1497,7 @@ var SessionManager = class {
   async loadSession(sessionId, cwd, backendId) {
     const existing = this.sessions.get(sessionId);
     if (existing) {
-      this.emitSessionAttached(sessionId);
+      this.emitSessionAttached(sessionId, true);
       return this.buildSummary(existing);
     }
     const backend = this.resolveBackend(backendId);
@@ -1580,6 +1580,47 @@ var SessionManager = class {
       throw error;
     }
   }
+  /**
+   * Reload a historical session from the ACP agent.
+   * Replays session history even if the session is already loaded.
+   */
+  async reloadSession(sessionId, cwd, backendId) {
+    const existing = this.sessions.get(sessionId);
+    if (!existing) {
+      return this.loadSession(sessionId, cwd, backendId);
+    }
+    if (!existing.connection.supportsSessionLoad()) {
+      throw createCapabilityNotSupportedError(
+        "Agent does not support session loading"
+      );
+    }
+    const response = await existing.connection.loadSession(sessionId, cwd);
+    const { modelId, modelName, availableModels } = resolveModelState(
+      response.models
+    );
+    const { modeId, modeName, availableModes } = resolveModeState(
+      response.modes
+    );
+    const agentInfo = existing.connection.getAgentInfo();
+    existing.cwd = cwd;
+    existing.agentName = agentInfo?.title ?? agentInfo?.name ?? existing.agentName;
+    existing.modelId = modelId;
+    existing.modelName = modelName;
+    existing.availableModels = availableModels;
+    existing.modeId = modeId;
+    existing.modeName = modeName;
+    existing.availableModes = availableModes;
+    existing.updatedAt = /* @__PURE__ */ new Date();
+    const summary = this.buildSummary(existing);
+    this.emitSessionsChanged({
+      added: [],
+      updated: [summary],
+      removed: []
+    });
+    this.emitSessionAttached(sessionId, true);
+    logger.info({ sessionId, backendId }, "session_reloaded");
+    return summary;
+  }
   applySessionUpdateToRecord(record, notification) {
     const update = notification.update;
     if (update.sessionUpdate === "current_mode_update") {
@@ -1656,9 +1697,187 @@ var SessionManager = class {
 import { EventEmitter as EventEmitter3 } from "events";
 import fs4 from "fs/promises";
 import { homedir } from "os";
-import path4 from "path";
+import path5 from "path";
 import ignore from "ignore";
 import { io } from "socket.io-client";
+
+// src/lib/git-utils.ts
+import { exec } from "child_process";
+import path4 from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var MAX_BUFFER = 10 * 1024 * 1024;
+async function isGitRepo(cwd) {
+  try {
+    await execAsync("git rev-parse --is-inside-work-tree", {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitBranch(cwd) {
+  try {
+    const { stdout } = await execAsync("git branch --show-current", {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    const branch = stdout.trim();
+    if (branch) {
+      return branch;
+    }
+    const { stdout: hashOut } = await execAsync("git rev-parse --short HEAD", {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    return hashOut.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseGitStatus(output) {
+  const files = [];
+  const lines = output.split("\n").filter((line) => line.length > 0);
+  for (const line of lines) {
+    const indexStatus = line[0];
+    const workTreeStatus = line[1];
+    const filePath = line.slice(3).split(" -> ").pop()?.trim();
+    if (!filePath) {
+      continue;
+    }
+    let status;
+    if (indexStatus === "?" || workTreeStatus === "?") {
+      status = "?";
+    } else if (indexStatus === "!" || workTreeStatus === "!") {
+      status = "!";
+    } else if (indexStatus === "A" || workTreeStatus === "A") {
+      status = "A";
+    } else if (indexStatus === "D" || workTreeStatus === "D") {
+      status = "D";
+    } else if (indexStatus === "R" || workTreeStatus === "R") {
+      status = "R";
+    } else if (indexStatus === "C" || workTreeStatus === "C") {
+      status = "C";
+    } else if (indexStatus === "U" || workTreeStatus === "U") {
+      status = "U";
+    } else if (indexStatus === "M" || workTreeStatus === "M" || indexStatus !== " " || workTreeStatus !== " ") {
+      status = "M";
+    } else {
+      continue;
+    }
+    files.push({ path: filePath, status });
+  }
+  return files;
+}
+async function getGitStatus(cwd) {
+  try {
+    const { stdout } = await execAsync("git status --porcelain=v1", {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    return parseGitStatus(stdout);
+  } catch {
+    return [];
+  }
+}
+function aggregateDirStatus(files) {
+  const dirStatus = {};
+  const statusPriority = {
+    A: 7,
+    D: 6,
+    M: 5,
+    R: 4,
+    C: 3,
+    U: 2,
+    "?": 1,
+    "!": 0
+  };
+  for (const file of files) {
+    const parts = file.path.split("/");
+    let currentPath = "";
+    for (let i = 0; i < parts.length - 1; i++) {
+      currentPath = currentPath ? `${currentPath}/${parts[i]}` : parts[i];
+      const existing = dirStatus[currentPath];
+      if (!existing || statusPriority[file.status] > statusPriority[existing]) {
+        dirStatus[currentPath] = file.status;
+      }
+    }
+  }
+  return dirStatus;
+}
+function parseDiffOutput(diffOutput) {
+  const addedLines = [];
+  const modifiedLines = [];
+  const deletedLines = [];
+  const lines = diffOutput.split("\n");
+  let currentLine = 0;
+  let inHunk = false;
+  let pendingDeletionLine = 0;
+  for (const line of lines) {
+    const hunkMatch = line.match(/^@@\s+-\d+(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@/);
+    if (hunkMatch) {
+      currentLine = Number.parseInt(hunkMatch[1], 10);
+      inHunk = true;
+      pendingDeletionLine = 0;
+      continue;
+    }
+    if (!inHunk) {
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      addedLines.push(currentLine);
+      currentLine++;
+      pendingDeletionLine = 0;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      if (pendingDeletionLine === 0) {
+        pendingDeletionLine = currentLine;
+      }
+      const deletionPos = Math.max(1, currentLine);
+      if (!deletedLines.includes(deletionPos)) {
+        deletedLines.push(deletionPos);
+      }
+    } else if (!line.startsWith("\\")) {
+      currentLine++;
+      pendingDeletionLine = 0;
+    }
+  }
+  return { addedLines, modifiedLines, deletedLines };
+}
+async function getFileDiff(cwd, filePath) {
+  try {
+    const relativePath = path4.isAbsolute(filePath) ? path4.relative(cwd, filePath) : filePath;
+    const { stdout } = await execAsync(`git diff HEAD -- "${relativePath}"`, {
+      cwd,
+      maxBuffer: MAX_BUFFER
+    });
+    if (!stdout.trim()) {
+      const { stdout: statusOut } = await execAsync(
+        `git status --porcelain=v1 -- "${relativePath}"`,
+        { cwd, maxBuffer: MAX_BUFFER }
+      );
+      if (statusOut.startsWith("?") || statusOut.startsWith("A")) {
+        const { stdout: wcOut } = await execAsync(`wc -l < "${relativePath}"`, {
+          cwd,
+          maxBuffer: MAX_BUFFER
+        });
+        const lineCount = Number.parseInt(wcOut.trim(), 10) || 0;
+        return {
+          addedLines: Array.from({ length: lineCount }, (_, i) => i + 1),
+          modifiedLines: [],
+          deletedLines: []
+        };
+      }
+      return { addedLines: [], modifiedLines: [], deletedLines: [] };
+    }
+    return parseDiffOutput(stdout);
+  } catch {
+    return { addedLines: [], modifiedLines: [], deletedLines: [] };
+  }
+}
+
+// src/daemon/socket-client.ts
 var SESSION_ROOT_NAME = "Working Directory";
 var MAX_RESOURCE_FILES = 2e3;
 var DEFAULT_IGNORES = [
@@ -1678,7 +1897,7 @@ var DEFAULT_IGNORES = [
 var loadGitignore = async (rootPath) => {
   const ig = ignore().add(DEFAULT_IGNORES);
   try {
-    const gitignorePath = path4.join(rootPath, ".gitignore");
+    const gitignorePath = path5.join(rootPath, ".gitignore");
     const content = await fs4.readFile(gitignorePath, "utf8");
     ig.add(content);
   } catch {
@@ -1686,7 +1905,7 @@ var loadGitignore = async (rootPath) => {
   return ig;
 };
 var resolveImageMimeType = (filePath) => {
-  const extension = path4.extname(filePath).toLowerCase();
+  const extension = path5.extname(filePath).toLowerCase();
   switch (extension) {
     case ".apng":
       return "image/apng";
@@ -1712,7 +1931,7 @@ var readDirectoryEntries = async (dirPath) => {
   const entries = await fs4.readdir(dirPath, { withFileTypes: true });
   const resolvedEntries = await Promise.all(
     entries.map(async (entry) => {
-      const entryPath = path4.join(dirPath, entry.name);
+      const entryPath = path5.join(dirPath, entry.name);
       let isDirectory = entry.isDirectory();
       if (!isDirectory && entry.isSymbolicLink()) {
         try {
@@ -2112,7 +2331,7 @@ var SocketClient = class extends EventEmitter3 {
         if (!record || !record.cwd) {
           throw new Error("Session not found or no working directory");
         }
-        const resolved = requestPath ? path4.isAbsolute(requestPath) ? requestPath : path4.join(record.cwd, requestPath) : record.cwd;
+        const resolved = requestPath ? path5.isAbsolute(requestPath) ? requestPath : path5.join(record.cwd, requestPath) : record.cwd;
         const entries = await readDirectoryEntries(resolved);
         this.sendRpcResponse(request.requestId, { path: resolved, entries });
       } catch (error) {
@@ -2138,7 +2357,7 @@ var SocketClient = class extends EventEmitter3 {
         if (!record || !record.cwd) {
           throw new Error("Session not found or no working directory");
         }
-        const resolved = path4.isAbsolute(requestPath) ? requestPath : path4.join(record.cwd, requestPath);
+        const resolved = path5.isAbsolute(requestPath) ? requestPath : path5.join(record.cwd, requestPath);
         const mimeType = resolveImageMimeType(resolved);
         if (mimeType) {
           const buffer = await fs4.readFile(resolved);
@@ -2243,6 +2462,113 @@ var SocketClient = class extends EventEmitter3 {
         this.sendRpcError(request.requestId, error);
       }
     });
+    this.socket.on("rpc:session:reload", async (request) => {
+      try {
+        const { sessionId, cwd } = request.params;
+        logger.info(
+          { requestId: request.requestId, sessionId, cwd },
+          "rpc_session_reload"
+        );
+        const session = await sessionManager.reloadSession(sessionId, cwd);
+        this.sendRpcResponse(request.requestId, session);
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_session_reload_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:git:status", async (request) => {
+      try {
+        const { sessionId } = request.params;
+        logger.debug(
+          { requestId: request.requestId, sessionId },
+          "rpc_git_status"
+        );
+        const record = sessionManager.getSession(sessionId);
+        if (!record || !record.cwd) {
+          throw new Error("Session not found or no working directory");
+        }
+        const isRepo = await isGitRepo(record.cwd);
+        if (!isRepo) {
+          this.sendRpcResponse(request.requestId, {
+            isGitRepo: false,
+            files: [],
+            dirStatus: {}
+          });
+          return;
+        }
+        const [branch, files] = await Promise.all([
+          getGitBranch(record.cwd),
+          getGitStatus(record.cwd)
+        ]);
+        const dirStatus = aggregateDirStatus(files);
+        this.sendRpcResponse(request.requestId, {
+          isGitRepo: true,
+          branch,
+          files,
+          dirStatus
+        });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_git_status_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:git:fileDiff", async (request) => {
+      try {
+        const { sessionId, path: filePath } = request.params;
+        logger.debug(
+          { requestId: request.requestId, sessionId, path: filePath },
+          "rpc_git_file_diff"
+        );
+        const record = sessionManager.getSession(sessionId);
+        if (!record || !record.cwd) {
+          throw new Error("Session not found or no working directory");
+        }
+        const isRepo = await isGitRepo(record.cwd);
+        if (!isRepo) {
+          this.sendRpcResponse(request.requestId, {
+            isGitRepo: false,
+            path: filePath,
+            addedLines: [],
+            modifiedLines: []
+          });
+          return;
+        }
+        const { addedLines, modifiedLines } = await getFileDiff(
+          record.cwd,
+          filePath
+        );
+        this.sendRpcResponse(request.requestId, {
+          isGitRepo: true,
+          path: filePath,
+          addedLines,
+          modifiedLines
+        });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_git_file_diff_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
   }
   setupSessionManagerListeners() {
     const { sessionManager } = this.options;
@@ -2302,8 +2628,8 @@ var SocketClient = class extends EventEmitter3 {
     const ig = await loadGitignore(rootPath);
     const allFiles = await this.listAllFiles(rootPath, ig, rootPath, []);
     return allFiles.map((filePath) => ({
-      name: path4.basename(filePath),
-      relativePath: path4.relative(rootPath, filePath),
+      name: path5.basename(filePath),
+      relativePath: path5.relative(rootPath, filePath),
       path: filePath
     }));
   }
@@ -2316,8 +2642,8 @@ var SocketClient = class extends EventEmitter3 {
       if (collected.length >= MAX_RESOURCE_FILES) {
         break;
       }
-      const entryPath = path4.join(rootPath, entry.name);
-      const relativePath = path4.relative(baseDir, entryPath);
+      const entryPath = path5.join(rootPath, entry.name);
+      const relativePath = path5.relative(baseDir, entryPath);
       const checkPath = entry.isDirectory() ? `${relativePath}/` : relativePath;
       if (ig.ignores(checkPath)) {
         continue;
@@ -2504,7 +2830,7 @@ var DaemonManager = class {
     }
   }
   async spawnBackground() {
-    const logFile = path5.join(
+    const logFile = path6.join(
       this.config.logPath,
       `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-daemon.log`
     );
@@ -2605,7 +2931,7 @@ var DaemonManager = class {
       console.log("No log files found");
       return;
     }
-    const latestLog = path5.join(this.config.logPath, logFiles[0]);
+    const latestLog = path6.join(this.config.logPath, logFiles[0]);
     logger.info({ logFile: latestLog }, "daemon_logs_latest");
     console.log(`Log file: ${latestLog}
 `);