codex-lens 0.1.0

package/dist/cli.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+import { createAggregator } from "./aggregator.js";
+import { createLogger } from "./lib/logger.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROXY_PORT = 8080;
+const logger = createLogger("CLI");
+async function findCodexBinary() {
+  const { execSync } = await import("child_process");
+  logger.debug("Searching for Codex binary...");
+  const candidates = [
+    "D:\\Software\\npm\\codex.cmd",
+    "C:\\Program Files\\nodejs\\codex.cmd",
+    join(process.env.APPDATA || "", "npm", "codex.cmd")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      logger.info(`Found Codex at: ${candidate}`);
+      return candidate;
+    }
+  }
+  try {
+    const result = execSync("where codex", { encoding: "utf-8" });
+    const lines = result.trim().split("\n");
+    if (lines.length > 0) {
+      logger.info(`Found Codex in PATH: ${lines[0].trim()}`);
+      return lines[0].trim();
+    }
+  } catch {
+  }
+  logger.warn('Codex not found, using "codex" command');
+  return "codex";
+}
+function findProjectRoot() {
+  let cwd = process.cwd();
+  while (cwd !== dirname(cwd)) {
+    if (existsSync(join(cwd, "package.json")) || existsSync(join(cwd, ".git")) || existsSync(join(cwd, "src"))) {
+      return cwd;
+    }
+    cwd = dirname(cwd);
+  }
+  return process.cwd();
+}
+async function main() {
+  logger.info("========================================");
+  logger.info("   Codex Viewer Starting");
+  logger.info("========================================");
+  const projectRoot = findProjectRoot();
+  logger.info(`Project root: ${projectRoot}`);
+  const codexBinary = await findCodexBinary();
+  const aggregator = createAggregator(codexBinary, projectRoot);
+  await aggregator.start(PROXY_PORT);
+  logger.info("All services started");
+  logger.info("Open http://localhost:5173 in browser");
+  logger.info("Press Ctrl+C to stop");
+  process.on("SIGINT", () => {
+    logger.info("Received SIGINT, shutting down...");
+    aggregator.stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    logger.info("Received SIGTERM, shutting down...");
+    aggregator.stop();
+    process.exit(0);
+  });
+}
+main().catch((error) => {
+  logger.errorWithStack("Fatal error:", error);
+  process.exit(1);
+});

package/dist/lib/diff-builder.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import { diffLines, diffWords, diffChars } from "diff";
+function generateLineDiff(oldContent, newContent) {
+  if (!oldContent && !newContent) {
+    return [];
+  }
+  const oldLines = (oldContent || "").split("\n");
+  const newLines = (newContent || "").split("\n");
+  const changes = diffLines(oldLines.join("\n"), newLines.join("\n"));
+  const result = [];
+  let oldLineNum = 1;
+  let newLineNum = 1;
+  for (const change of changes) {
+    const lines = change.value.split("\n").filter((l) => l !== "" || change.value === "\n");
+    for (const line of lines) {
+      if (change.added) {
+        result.push({
+          type: "added",
+          content: line,
+          oldLineNumber: null,
+          newLineNumber: newLineNum++
+        });
+      } else if (change.removed) {
+        result.push({
+          type: "removed",
+          content: line,
+          oldLineNumber: oldLineNum++,
+          newLineNumber: null
+        });
+      } else {
+        result.push({
+          type: "unchanged",
+          content: line,
+          oldLineNumber: oldLineNum++,
+          newLineNumber: newLineNum++
+        });
+      }
+    }
+  }
+  return result;
+}
+function generateWordDiff(oldContent, newContent) {
+  if (!oldContent && !newContent) {
+    return [];
+  }
+  const changes = diffWords(oldContent || "", newContent || "");
+  const result = [];
+  for (const change of changes) {
+    result.push({
+      type: change.added ? "added" : change.removed ? "removed" : "unchanged",
+      content: change.value
+    });
+  }
+  return result;
+}
+function generateCharDiff(oldContent, newContent) {
+  if (!oldContent && !newContent) {
+    return [];
+  }
+  const changes = diffChars(oldContent || "", newContent || "");
+  const result = [];
+  for (const change of changes) {
+    result.push({
+      type: change.added ? "added" : change.removed ? "removed" : "unchanged",
+      content: change.value
+    });
+  }
+  return result;
+}
+function formatDiffAsText(diff, options = {}) {
+  const { showLineNumbers = true, prefixAdded = "+ ", prefixRemoved = "- ", prefixUnchanged = "  " } = options;
+  return diff.map((line) => {
+    let prefix;
+    if (line.type === "added") {
+      prefix = prefixAdded;
+    } else if (line.type === "removed") {
+      prefix = prefixRemoved;
+    } else {
+      prefix = prefixUnchanged;
+    }
+    const lineNumStr = showLineNumbers ? `${String(line.oldLineNumber || "").padStart(4)} ${String(line.newLineNumber || "").padStart(4)} | ` : "";
+    return `${lineNumStr}${prefix}${line.content}`;
+  }).join("\n");
+}
+function getDiffStats(diff) {
+  const stats = {
+    added: 0,
+    removed: 0,
+    unchanged: 0
+  };
+  for (const line of diff) {
+    if (line.type === "added") {
+      stats.added++;
+    } else if (line.type === "removed") {
+      stats.removed++;
+    } else {
+      stats.unchanged++;
+    }
+  }
+  stats.total = stats.added + stats.removed + stats.unchanged;
+  return stats;
+}
+export {
+  formatDiffAsText,
+  generateCharDiff,
+  generateLineDiff,
+  generateWordDiff,
+  getDiffStats
+};

package/dist/lib/log-manager.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+const DEFAULT_LOG_DIR = join(homedir(), ".codex-viewer");
+class LogManager {
+  constructor(logDir = DEFAULT_LOG_DIR) {
+    this.logDir = logDir;
+    this.ensureLogDir();
+  }
+  ensureLogDir() {
+    if (!existsSync(this.logDir)) {
+      mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+  getLogFilePath(projectName) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    return join(this.logDir, `${projectName}_${timestamp}.jsonl`);
+  }
+  appendEntry(logFile, entry) {
+    try {
+      const dir = dirname(logFile);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      appendFileSync(logFile, JSON.stringify(entry) + "\n");
+    } catch (error) {
+      console.error("[LogManager] Failed to append entry:", error.message);
+    }
+  }
+  readLogFile(logFile) {
+    if (!existsSync(logFile)) {
+      return [];
+    }
+    try {
+      const content = readFileSync(logFile, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      return lines.map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+    } catch (error) {
+      console.error("[LogManager] Failed to read log file:", error.message);
+      return [];
+    }
+  }
+  listLogFiles(projectName) {
+    try {
+      if (!existsSync(this.logDir)) {
+        return [];
+      }
+      const files = readdirSync(this.logDir).filter((f) => f.startsWith(projectName + "_") && f.endsWith(".jsonl")).map((f) => {
+        const stats = statSync(join(this.logDir, f));
+        return {
+          name: f,
+          path: join(this.logDir, f),
+          size: stats.size,
+          modified: stats.mtime
+        };
+      }).sort((a, b) => b.modified - a.modified);
+      return files;
+    } catch (error) {
+      console.error("[LogManager] Failed to list log files:", error.message);
+      return [];
+    }
+  }
+  deleteOldLogs(projectName, keepCount = 10) {
+    try {
+      const files = this.listLogFiles(projectName);
+      const toDelete = files.slice(keepCount);
+      for (const file of toDelete) {
+        unlinkSync(file.path);
+        console.log(`[LogManager] Deleted old log: ${file.name}`);
+      }
+    } catch (error) {
+      console.error("[LogManager] Failed to delete old logs:", error.message);
+    }
+  }
+  getRecentLog(projectName) {
+    const files = this.listLogFiles(projectName);
+    if (files.length > 0) {
+      return files[0];
+    }
+    return null;
+  }
+  writeSessionMeta(logFile, meta) {
+    this.appendEntry(logFile, {
+      type: "session_meta",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...meta
+    });
+  }
+  writeApiRequest(logFile, request) {
+    this.appendEntry(logFile, {
+      type: "api_request",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...request
+    });
+  }
+  writeApiResponse(logFile, response) {
+    this.appendEntry(logFile, {
+      type: "api_response",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...response
+    });
+  }
+  writeFileChange(logFile, change) {
+    this.appendEntry(logFile, {
+      type: "file_change",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...change
+    });
+  }
+}
+function createLogManager(logDir) {
+  return new LogManager(logDir);
+}
+export {
+  LogManager,
+  createLogManager
+};

package/dist/lib/sse-parser.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+function parseSSEStream(data) {
+  if (!data || typeof data !== "string") {
+    return null;
+  }
+  const lines = data.split("\n");
+  const event = {
+    type: null,
+    data: null,
+    id: null,
+    retry: null
+  };
+  for (const line of lines) {
+    if (line.startsWith("event:")) {
+      event.type = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      const value = line.slice(5).trim();
+      try {
+        event.data = JSON.parse(value);
+      } catch {
+        event.data = value;
+      }
+    } else if (line.startsWith("id:")) {
+      event.id = line.slice(3).trim();
+    } else if (line.startsWith("retry:")) {
+      event.retry = parseInt(line.slice(7).trim(), 10);
+    }
+  }
+  if (event.type === "null" && !event.data) {
+    return null;
+  }
+  return event;
+}
+function parseSSELines(lines) {
+  const events = [];
+  for (const line of lines) {
+    const event = parseSSEStream(line);
+    if (event) {
+      events.push(event);
+    }
+  }
+  return events;
+}
+function extractDelta(event) {
+  if (!event || !event.data) return null;
+  if (event.data.type === "content_block_delta") {
+    return event.data.delta;
+  }
+  return null;
+}
+function extractToolUse(event) {
+  if (!event || !event.data) return null;
+  if (event.data.type === "tool_use") {
+    return event.data;
+  }
+  return null;
+}
+function extractMessage(event) {
+  if (!event || !event.data) return null;
+  if (event.data.type === "message") {
+    return event.data.message;
+  }
+  return null;
+}
+export {
+  extractDelta,
+  extractMessage,
+  extractToolUse,
+  parseSSELines,
+  parseSSEStream
+};