codex-lens 0.1.28 → 0.1.30

package/build.js

@@ -20,6 +20,7 @@ async function buildAll() {
     'src/aggregator.js',
     'src/watcher.js',
     'src/pty-manager.js',
+    'src/git-manager.js',
     'src/lib/sse-parser.js',
     'src/lib/diff-builder.js',
     'src/lib/log-manager.js',

package/dist/aggregator.js

@@ -7,6 +7,7 @@ import { createProxyServer } from "./proxy.js";
 import { FileWatcher, scanDirectory } from "./watcher.js";
 import { createLogger } from "./lib/logger.js";
 import { spawnCodex, writeToPty, resizePty, killPty, onPtyData, onPtyExit, getPtyState, getOutputBuffer } from "./pty-manager.js";
+import { createGitManager } from "./git-manager.js";
 import path from "path";
 import { fileURLToPath } from "url";
 import { readFileSync, existsSync, writeFileSync } from "fs";
@@ -49,6 +50,7 @@ class Aggregator {
     this.proxyServer = null;
     this.fileWatcher = null;
     this.ptyProcess = null;
+    this.gitManager = null;
   }
   async start(proxyPort) {
     await fetchLatestVersion();
@@ -134,6 +136,16 @@ class Aggregator {
     await this.proxyServer.start();
     this.fileWatcher = new FileWatcher(this.projectRoot, (event) => this.broadcast(event));
     await this.fileWatcher.start();
+    this.gitManager = createGitManager(this.projectRoot, (event) => this.broadcast(event));
+    if (this.gitManager.isGitRepo()) {
+      await this.gitManager.broadcastUpdate();
+      logger.info("Git repository detected, git status broadcasting enabled");
+      this.fileWatcher.setGitStatusCallback((filePath) => {
+        if (this.gitManager?.isGitRepo()) {
+          this.gitManager.scheduleStatusUpdate();
+        }
+      });
+    }
     await this.startCodex(proxyPort);
     return { httpPort: HTTP_PORT, proxyPort };
   }
@@ -209,7 +221,7 @@ class Aggregator {
       }
     }
   }
-  handleClientMessage(data, ws) {
+  async handleClientMessage(data, ws) {
     if (data.type === "user_message") {
       writeToPty(data.data + "\r");
     } else if (data.type === "open_file") {
@@ -227,6 +239,33 @@ class Aggregator {
           }
         }));
       }
+    } else if (data.type === "git_status_request") {
+      if (this.gitManager?.isGitRepo()) {
+        this.gitManager.broadcastUpdate();
+      }
+    } else if (data.type === "git_stage") {
+      if (this.gitManager?.isGitRepo()) {
+        if (data.filePath) {
+          await this.gitManager.stageFile(data.filePath);
+        } else {
+          await this.gitManager.stageAll();
+        }
+        this.gitManager.broadcastUpdate();
+      }
+    } else if (data.type === "git_unstage") {
+      if (this.gitManager?.isGitRepo()) {
+        if (data.filePath) {
+          await this.gitManager.unstageFile(data.filePath);
+        } else {
+          await this.gitManager.unstageAll();
+        }
+        this.gitManager.broadcastUpdate();
+      }
+    } else if (data.type === "git_commit") {
+      if (this.gitManager?.isGitRepo()) {
+        await this.gitManager.commit(data.message);
+        this.gitManager.broadcastUpdate();
+      }
     }
   }
   broadcast(event) {

package/dist/git-manager.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { createLogger } from "./lib/logger.js";
+const logger = createLogger("GitManager");
+class GitManager {
+  constructor(projectRoot, wsEmitter) {
+    this.projectRoot = projectRoot;
+    this.wsEmitter = wsEmitter;
+    this.gitDir = join(projectRoot, ".git");
+    this.currentStatus = null;
+    this.currentBranch = null;
+    this._statusTimeout = null;
+  }
+  isGitRepo() {
+    return existsSync(this.gitDir);
+  }
+  runGitCommand(args) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn("git", args, {
+        cwd: this.projectRoot,
+        shell: true,
+        windowsHide: true
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        resolve({ code, stdout, stderr });
+      });
+      proc.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  parsePorcelainStatus(output) {
+    const lines = output.trim().split("\n");
+    const result = {
+      staged: [],
+      unstaged: [],
+      untracked: [],
+      conflicted: []
+    };
+    for (const line of lines) {
+      if (!line || line.length < 3) continue;
+      const indexStatus = line[0];
+      const workTreeStatus = line[1];
+      const path = line.slice(3).trim();
+      const fileInfo = { path, indexStatus, workTreeStatus };
+      if (indexStatus !== " " && indexStatus !== "?") {
+        result.staged.push(fileInfo);
+      }
+      if (workTreeStatus === "M" || workTreeStatus === "D") {
+        result.unstaged.push(fileInfo);
+      }
+      if (indexStatus === "?" && workTreeStatus === "?") {
+        result.untracked.push(fileInfo);
+      }
+      if (indexStatus === "U" || workTreeStatus === "U") {
+        result.conflicted.push(fileInfo);
+      }
+    }
+    return result;
+  }
+  async getStatus() {
+    if (!this.isGitRepo()) return null;
+    try {
+      const { stdout } = await this.runGitCommand(["status", "--porcelain"]);
+      this.currentStatus = this.parsePorcelainStatus(stdout);
+      return this.currentStatus;
+    } catch (error) {
+      logger.error(`Failed to get git status: ${error.message}`);
+      return null;
+    }
+  }
+  async getCurrentBranch() {
+    if (!this.isGitRepo()) return null;
+    try {
+      const { stdout } = await this.runGitCommand(["branch", "--show-current"]);
+      this.currentBranch = stdout.trim();
+      return this.currentBranch;
+    } catch (error) {
+      logger.error(`Failed to get branch: ${error.message}`);
+      return null;
+    }
+  }
+  async stageFile(filePath) {
+    await this.runGitCommand(["add", filePath]);
+    return this.getStatus();
+  }
+  async unstageFile(filePath) {
+    await this.runGitCommand(["reset", "HEAD", "--", filePath]);
+    return this.getStatus();
+  }
+  async stageAll() {
+    await this.runGitCommand(["add", "-A"]);
+    return this.getStatus();
+  }
+  async unstageAll() {
+    await this.runGitCommand(["reset", "HEAD"]);
+    return this.getStatus();
+  }
+  async commit(message) {
+    await this.runGitCommand(["commit", "-m", message]);
+    return this.getStatus();
+  }
+  async broadcastUpdate() {
+    const branch = await this.getCurrentBranch();
+    const status = await this.getStatus();
+    this.wsEmitter({
+      type: "git_status",
+      data: {
+        isRepo: true,
+        branch,
+        status,
+        stagedCount: status?.staged?.length || 0,
+        unstagedCount: (status?.unstaged?.length || 0) + (status?.untracked?.length || 0),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+  }
+  scheduleStatusUpdate() {
+    if (this._statusTimeout) {
+      clearTimeout(this._statusTimeout);
+    }
+    this._statusTimeout = setTimeout(() => {
+      this.broadcastUpdate();
+    }, 500);
+  }
+}
+function createGitManager(projectRoot, wsEmitter) {
+  return new GitManager(projectRoot, wsEmitter);
+}
+export {
+  createGitManager
+};