@vexdo/cli 0.1.2 → 0.1.4

package/dist/index.js

@@ -700,6 +700,29 @@ function formatElapsed(startedAt) {
   const seconds = Math.max(0, Math.round((Date.now() - startedAt) / 1e3));
   return `${String(seconds)}s`;
 }
+function buildVerboseStreamHandler(label) {
+  let partialLine = "";
+  return {
+    onData(chunk) {
+      partialLine += chunk.toString();
+      const lines = partialLine.split(/\r?\n/);
+      partialLine = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line) {
+          continue;
+        }
+        debug(`[codex:${label}] ${line}`);
+      }
+    },
+    flush() {
+      if (!partialLine) {
+        return;
+      }
+      debug(`[codex:${label}] ${partialLine}`);
+      partialLine = "";
+    }
+  };
+}
 async function checkCodexAvailable() {
   await new Promise((resolve, reject) => {
     execFileCb("codex", ["--version"], { timeout: CODEX_TIMEOUT_MS, encoding: "utf8" }, (error) => {
@@ -718,10 +741,13 @@ async function exec(opts) {
     debug(`[codex] starting (model=${opts.model}, cwd=${opts.cwd})`);
   }
   return await new Promise((resolve, reject) => {
+    let liveLogsAttached = false;
+    const stdoutHandler = buildVerboseStreamHandler("stdout");
+    const stderrHandler = buildVerboseStreamHandler("stderr");
     const heartbeat = opts.verbose ? setInterval(() => {
       debug(`[codex] still running (${formatElapsed(startedAt)})`);
     }, VERBOSE_HEARTBEAT_MS) : null;
-    execFileCb(
+    const child = execFileCb(
       "codex",
       args,
       { cwd: opts.cwd, timeout: CODEX_TIMEOUT_MS, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 },
@@ -729,14 +755,16 @@ async function exec(opts) {
         if (heartbeat) {
           clearInterval(heartbeat);
         }
+        stdoutHandler.flush();
+        stderrHandler.flush();
         const normalizedStdout = stdout.trimEnd();
         const normalizedStderr = stderr.trimEnd();
         if (opts.verbose) {
           debug(`[codex] finished in ${formatElapsed(startedAt)}`);
-          if (normalizedStdout) {
+          if (!liveLogsAttached && normalizedStdout) {
             debug(normalizedStdout);
           }
-          if (normalizedStderr) {
+          if (!liveLogsAttached && normalizedStderr) {
             debug(normalizedStderr);
           }
         }
@@ -755,18 +783,69 @@ async function exec(opts) {
         });
       }
     );
+    if (opts.verbose) {
+      const stdout = child.stdout;
+      const stderr = child.stderr;
+      if (stdout) {
+        liveLogsAttached = true;
+        stdout.on("data", stdoutHandler.onData);
+      }
+      if (stderr) {
+        liveLogsAttached = true;
+        stderr.on("data", stderrHandler.onData);
+      }
+    }
   });
 }
 
 // src/lib/gh.ts
 import { execFile as execFileCb2 } from "child_process";
 var GH_TIMEOUT_MS = 3e4;
+var GIT_TIMEOUT_MS = 3e4;
 var GhNotFoundError = class extends Error {
   constructor() {
     super("gh CLI not found. Install it: https://cli.github.com");
     this.name = "GhNotFoundError";
   }
 };
+var GitCommandError = class extends Error {
+  exitCode;
+  stderr;
+  constructor(args, exitCode, stderr) {
+    super(`git ${args.join(" ")} failed (exit ${String(exitCode)}): ${stderr}`);
+    this.name = "GitCommandError";
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+  }
+};
+async function execGit(args, cwd) {
+  await new Promise((resolve, reject) => {
+    execFileCb2("git", args, { cwd, timeout: GIT_TIMEOUT_MS, encoding: "utf8" }, (error, _stdout, stderr) => {
+      if (error) {
+        const exitCode = typeof error.code === "number" ? error.code : -1;
+        reject(new GitCommandError(args, exitCode, (stderr || error.message).trim()));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function isNoUpstreamError(error) {
+  const text = error.stderr.toLowerCase();
+  return text.includes("no upstream configured for branch") || text.includes("has no upstream branch");
+}
+async function pushCurrentBranch(cwd) {
+  try {
+    await execGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], cwd);
+    await execGit(["push"], cwd);
+  } catch (error) {
+    if (error instanceof GitCommandError && isNoUpstreamError(error)) {
+      await execGit(["push", "--set-upstream", "origin", "HEAD"], cwd);
+      return;
+    }
+    throw error;
+  }
+}
 async function checkGhAvailable() {
   await new Promise((resolve, reject) => {
     execFileCb2("gh", ["--version"], { timeout: GH_TIMEOUT_MS, encoding: "utf8" }, (error) => {
@@ -780,6 +859,11 @@ async function checkGhAvailable() {
 }
 async function createPr(opts) {
   const base = opts.base ?? "main";
+  try {
+    await pushCurrentBranch(opts.cwd);
+  } catch (error) {
+    throw new Error(`Failed to push current branch before creating PR: ${error instanceof Error ? error.message : String(error)}`);
+  }
   return await new Promise((resolve, reject) => {
     execFileCb2(
       "gh",
@@ -813,7 +897,7 @@ import path5 from "path";
 
 // src/lib/git.ts
 import { execFile as execFileCb3 } from "child_process";
-var GIT_TIMEOUT_MS = 3e4;
+var GIT_TIMEOUT_MS2 = 3e4;
 var GitError = class extends Error {
   command;
   exitCode;
@@ -828,7 +912,7 @@ var GitError = class extends Error {
 };
 async function exec2(args, cwd) {
   return new Promise((resolve, reject) => {
-    execFileCb3("git", args, { cwd, timeout: GIT_TIMEOUT_MS, encoding: "utf8" }, (error, stdout, stderr) => {
+    execFileCb3("git", args, { cwd, timeout: GIT_TIMEOUT_MS2, encoding: "utf8" }, (error, stdout, stderr) => {
       if (error) {
         const exitCode = typeof error.code === "number" ? error.code : -1;
         reject(new GitError(args, exitCode, (stderr || error.message).trim()));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vexdo/cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {