@meistrari/tela-cli 0.7.43 → 0.7.45

package/dist/index.js

@@ -2267,12 +2267,14 @@ var require_git = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.buildGitSshCommand = buildGitSshCommand;
     exports2.isSshRemoteUrl = isSshRemoteUrl;
+    exports2.getRemoteUrl = getRemoteUrl;
     exports2.findRepositoryRoot = findRepositoryRoot;
     exports2.getRepositoryRoot = getRepositoryRoot;
     exports2.assertGitRepository = assertGitRepository;
     exports2.cloneRepository = cloneRepository;
     exports2.getOriginUrl = getOriginUrl;
     exports2.fetchOrigin = fetchOrigin;
+    exports2.fetchRemote = fetchRemote;
     exports2.fetchAllRemotes = fetchAllRemotes;
     exports2.getWorktreeStatus = getWorktreeStatus;
     exports2.isWorktreeDirty = isWorktreeDirty;
@@ -2281,6 +2283,10 @@ var require_git = __commonJS({
     exports2.unstageMatching = unstageMatching;
     exports2.getCurrentBranch = getCurrentBranch;
     exports2.getUpstreamBranch = getUpstreamBranch;
+    exports2.getPushBranch = getPushBranch;
+    exports2.refExists = refExists;
+    exports2.getAheadBehind = getAheadBehind;
+    exports2.getCommitCount = getCommitCount;
     exports2.pullCurrentBranch = pullCurrentBranch;
     exports2.pullDefaultBranch = pullDefaultBranch;
     exports2.getShortStatus = getShortStatus;
@@ -2348,6 +2354,9 @@ var require_git = __commonJS({
       }
       return result.stdout.trim() || null;
     }
+    async function getRemoteUrl(cwd, remote) {
+      return await getRemoteUrlInternal(cwd, remote);
+    }
     async function remoteRequiresConfiguredSsh(cwd, remote) {
       const remoteUrl = await getRemoteUrlInternal(cwd, remote);
       return Boolean(remoteUrl && isSshRemoteUrl(remoteUrl));
@@ -2420,6 +2429,14 @@ var require_git = __commonJS({
         sshHostKeyPolicy: "accept-new"
       });
     }
+    async function fetchRemote(cwd, remote, sshPrivateKeyPath) {
+      await runGitCommand(["fetch", remote, "--prune"], {
+        cwd,
+        requireConfiguredSsh: await remoteRequiresConfiguredSsh(cwd, remote),
+        sshPrivateKeyPath,
+        sshHostKeyPolicy: "accept-new"
+      });
+    }
     async function fetchAllRemotes(cwd, sshPrivateKeyPath) {
       await runGitCommand(["fetch", "--all", "--prune"], {
         cwd,
@@ -2465,6 +2482,38 @@ var require_git = __commonJS({
       }
       return result.stdout.trim() || null;
     }
+    async function getPushBranch(cwd) {
+      const result = await runGitCommand(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{push}"], { cwd, allowFailure: true });
+      if (result.exitCode !== 0) {
+        return null;
+      }
+      return result.stdout.trim() || null;
+    }
+    async function refExists(cwd, ref) {
+      const result = await runGitCommand(["rev-parse", "--verify", "--quiet", ref], {
+        cwd,
+        allowFailure: true
+      });
+      return result.exitCode === 0;
+    }
+    async function getAheadBehind(cwd, ref) {
+      if (!await refExists(cwd, ref)) {
+        return { aheadCount: 0, behindCount: 0 };
+      }
+      const result = await runGitCommand(["rev-list", "--left-right", "--count", `HEAD...${ref}`], { cwd });
+      const [aheadRaw, behindRaw] = result.stdout.trim().split(/\s+/);
+      return {
+        aheadCount: Number.parseInt(aheadRaw ?? "0", 10) || 0,
+        behindCount: Number.parseInt(behindRaw ?? "0", 10) || 0
+      };
+    }
+    async function getCommitCount(cwd, ref = "HEAD") {
+      const result = await runGitCommand(["rev-list", "--count", ref], { cwd, allowFailure: true });
+      if (result.exitCode !== 0) {
+        return 0;
+      }
+      return Number.parseInt(result.stdout.trim(), 10) || 0;
+    }
     async function pullCurrentBranch(cwd, sshPrivateKeyPath) {
       await runGitCommand(["pull", "--ff-only"], {
         cwd,
@@ -2555,26 +2604,27 @@ var require_git = __commonJS({
     }
     function buildFallbackCommitMessage(files) {
       if (files.length === 0) {
-        return "Update repository files";
+        return "chore: update repository files";
       }
       if (files.length === 1) {
-        return `Update ${(0, node_path_1.basename)(files[0]) || files[0]}`;
+        return `chore: update ${(0, node_path_1.basename)(files[0]) || files[0]}`;
       }
-      return `Update ${(0, node_path_1.basename)(files[0]) || files[0]} and ${files.length - 1} other files`;
+      return `chore: update ${(0, node_path_1.basename)(files[0]) || files[0]} and ${files.length - 1} other files`;
     }
     async function commitWithMessage(cwd, message) {
-      await runGitCommand(["commit", "-F", "-"], {
+      await runGitCommand(["commit", "--no-verify", "-F", "-"], {
         cwd,
         input: message
       });
     }
-    async function pushBranch(cwd, branch, setUpstream, sshPrivateKeyPath) {
-      const args = setUpstream ? ["push", "--set-upstream", "origin", branch] : ["push"];
-      const requireConfiguredSsh = setUpstream ? await remoteRequiresConfiguredSsh(cwd, "origin") : await upstreamRequiresConfiguredSsh(cwd);
+    async function pushBranch(cwd, branch, setUpstream, sshPrivateKeyPath, remote = "origin") {
+      const args = setUpstream ? ["push", "--set-upstream", remote, branch] : ["push"];
+      const requireConfiguredSsh = sshPrivateKeyPath ? await anyRemoteRequiresConfiguredSsh(cwd) : setUpstream ? await remoteRequiresConfiguredSsh(cwd, remote) : await upstreamRequiresConfiguredSsh(cwd);
       await runGitCommand(args, {
         cwd,
         requireConfiguredSsh,
-        sshPrivateKeyPath
+        sshPrivateKeyPath,
+        sshHostKeyPolicy: "accept-new"
       });
     }
     async function getHeadShortSha(cwd) {
@@ -3208,33 +3258,73 @@ var require_commit_message = __commonJS({
   "../../packages/agent/dist/commit-message.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isConventionalCommitMessage = isConventionalCommitMessage;
+    exports2.normalizeConventionalCommitMessage = normalizeConventionalCommitMessage;
     exports2.generateCommitMessageWithClaude = generateCommitMessageWithClaude;
     exports2.fallbackCommitMessageFromFiles = fallbackCommitMessageFromFiles;
     var node_path_1 = require("node:path");
     var process_1 = require_process();
+    var conventionalCommitPattern = /^(?:build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(?:\([^)]+\))?!?:\s+\S/;
     function firstNonEmptyLine(input) {
       return input.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
     }
+    function splitCommitMessage(message) {
+      const lines = message.trim().split(/\r?\n/);
+      const subjectIndex = lines.findIndex((line) => Boolean(line.trim()));
+      if (subjectIndex === -1) {
+        return { subject: "", body: "" };
+      }
+      return {
+        subject: lines[subjectIndex].trim(),
+        body: lines.slice(subjectIndex + 1).join("\n").trim()
+      };
+    }
+    function cleanCommitSubject(message) {
+      const rawSubject = splitCommitMessage(message).subject;
+      const subject = rawSubject.replace(/^["'`]+|["'`]+$/g, "").replace(/^commit message:\s*/i, "").replace(/^[-*]\s+/, "").replace(/\s+/g, " ").replace(/[.!?]$/, "").trim();
+      if (!subject) {
+        return "update repository files";
+      }
+      return `${subject.charAt(0).toLowerCase()}${subject.slice(1)}`;
+    }
+    function isConventionalCommitMessage(message) {
+      return conventionalCommitPattern.test(firstNonEmptyLine(message));
+    }
+    function normalizeConventionalCommitMessage(message) {
+      const trimmed = message.trim();
+      if (!trimmed) {
+        return "chore: update repository files";
+      }
+      if (isConventionalCommitMessage(trimmed)) {
+        return trimmed;
+      }
+      const { body } = splitCommitMessage(trimmed);
+      const subject = `chore: ${cleanCommitSubject(trimmed)}`;
+      return body ? `${subject}
+
+${body}` : subject;
+    }
     async function generateCommitMessageWithClaude(context) {
       const claudePath = await (0, process_1.resolveExecutable)("claude");
       if (!claudePath) {
         throw new Error("Claude CLI is not available");
       }
-      const prompt = `You are writing a git commit message for already staged changes.
+      const prompt = `You are writing a git commit message for pushable changes.
 
 Recent git status:
 ${context.status || "<empty>"}
 
-Recent git diff --cached:
+Recent git diff:
 ${context.diff || "<empty>"}
 
 Recent git log:
 ${context.log || "<empty>"}
 
-Write exactly one short natural-language git commit message.
-- Do not use conventional commit prefixes like feat:, fix:, or chore:
+Write exactly one short Conventional Commit message.
+- Format the first line as <type>: <subject>
+- Use a lowercase type such as feat, fix, docs, refactor, test, chore, or perf
 - Focus on the purpose of the change
-- Keep it concise
+- Keep the first line under 72 characters when possible
 - Return only the commit message text`;
       const result = await (0, process_1.runCommand)([
         claudePath,
@@ -3249,16 +3339,16 @@ Write exactly one short natural-language git commit message.
       if (!message) {
         throw new Error("Claude returned an empty commit message");
       }
-      return message;
+      return normalizeConventionalCommitMessage(message);
     }
     function fallbackCommitMessageFromFiles(files) {
       if (files.length === 0) {
-        return "Update repository files";
+        return "chore: update repository files";
       }
       if (files.length === 1) {
-        return `Update ${(0, node_path_1.basename)(files[0]) || files[0]}`;
+        return `chore: update ${(0, node_path_1.basename)(files[0]) || files[0]}`;
       }
-      return `Update ${(0, node_path_1.basename)(files[0]) || files[0]} and ${files.length - 1} other files`;
+      return `chore: update ${(0, node_path_1.basename)(files[0]) || files[0]} and ${files.length - 1} other files`;
     }
   }
 });
@@ -3269,10 +3359,11 @@ var require_push = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.previewPush = previewPush;
+    exports2.preparePushPreview = preparePushPreview;
     exports2.pushRepository = pushRepository;
     var commit_message_1 = require_commit_message();
     var git_1 = require_git();
-    var process_1 = require_process();
+    var errors_1 = require_errors();
     var PUSH_ARTIFACT_ROOTS = ["input", "output"];
     var PUSH_INCLUDED_PATHSPECS = [
       ".",
@@ -3281,14 +3372,6 @@ var require_push = __commonJS({
       ":(exclude)output",
       ":(exclude)output/**"
     ];
-    function shouldRetryCommit(error) {
-      if (!(error instanceof process_1.CommandError)) {
-        return false;
-      }
-      const details = `${error.result.stdout}
-${error.result.stderr}`.toLowerCase();
-      return details.includes("hook") || details.includes("pre-commit") || details.includes("modified") || details.includes("stashed changes conflicted");
-    }
     async function resolveCommitMessage(repoRoot, options, mode = "staged") {
       if (options.mode === "manual" && options.manualMessage?.trim()) {
         return {
@@ -3307,7 +3390,7 @@ ${error.result.stderr}`.toLowerCase();
         const generatedMessage = await generateCommitMessage({ status, diff, log });
         if (generatedMessage.trim()) {
           return {
-            message: generatedMessage.trim(),
+            message: (0, commit_message_1.normalizeConventionalCommitMessage)(generatedMessage),
             source: "claude"
           };
         }
@@ -3332,8 +3415,72 @@ ${error.result.stderr}`.toLowerCase();
       await (0, git_1.stageAllMatching)(repoRoot, PUSH_INCLUDED_PATHSPECS);
       await (0, git_1.unstageMatching)(repoRoot, PUSH_ARTIFACT_ROOTS);
     }
-    async function previewPush(options) {
-      const repoRoot = await (0, git_1.getRepositoryRoot)(options.cwd ?? process.cwd());
+    function getUpstreamRemoteName(upstream) {
+      if (!upstream) {
+        return null;
+      }
+      const separator = upstream.indexOf("/");
+      return separator > 0 ? upstream.slice(0, separator) : null;
+    }
+    async function inspectPushRemoteState(repoRoot, branch, upstream, sshPrivateKeyPath) {
+      const pushRef = await (0, git_1.getPushBranch)(repoRoot);
+      const compareRef = pushRef ?? upstream ?? `origin/${branch}`;
+      const remoteName = getUpstreamRemoteName(compareRef) ?? "origin";
+      const setUpstream = !upstream;
+      const remoteUrl = await (0, git_1.getRemoteUrl)(repoRoot, remoteName);
+      if (!remoteUrl) {
+        return {
+          branch,
+          upstream,
+          remoteName,
+          compareRef,
+          setUpstream,
+          aheadCount: 0,
+          behindCount: 0
+        };
+      }
+      await (0, git_1.fetchRemote)(repoRoot, remoteName, sshPrivateKeyPath);
+      if (!await (0, git_1.refExists)(repoRoot, compareRef)) {
+        return {
+          branch,
+          upstream,
+          remoteName,
+          compareRef,
+          setUpstream,
+          aheadCount: await (0, git_1.getCommitCount)(repoRoot),
+          behindCount: 0
+        };
+      }
+      const counts = await (0, git_1.getAheadBehind)(repoRoot, compareRef);
+      return {
+        branch,
+        upstream,
+        remoteName,
+        compareRef,
+        setUpstream,
+        ...counts
+      };
+    }
+    function assertPushRemoteCurrent(state) {
+      if (state.behindCount === 0) {
+        return;
+      }
+      throw (0, errors_1.createUserFacingError)({
+        code: "push_remote_ahead",
+        summary: state.aheadCount > 0 ? "Remote branch has diverged." : "Remote branch has new commits.",
+        details: `${state.compareRef ?? "The push target"} is ${state.behindCount} commit${state.behindCount === 1 ? "" : "s"} ahead of the local branch.`,
+        fixes: [
+          "Run `git pull --rebase --autostash`, resolve conflicts if needed, then retry Push."
+        ]
+      });
+    }
+    function getReusableRemoteState(state, branch, upstream) {
+      if (!state || state.branch !== branch || state.upstream !== upstream) {
+        return null;
+      }
+      return state;
+    }
+    async function buildPushPreview(repoRoot, options, mode) {
       const [worktreeStatus, statusCounts] = await Promise.all([
         (0, git_1.getShortStatus)(repoRoot, PUSH_INCLUDED_PATHSPECS),
         (0, git_1.getStatusCounts)(repoRoot, PUSH_INCLUDED_PATHSPECS)
@@ -3349,15 +3496,24 @@ ${error.result.stderr}`.toLowerCase();
         detached = true;
       }
       const upstream = detached ? null : await (0, git_1.getUpstreamBranch)(repoRoot);
-      const hasChanges = Boolean(worktreeStatus.trim());
+      const remoteState = branch && !detached ? await inspectPushRemoteState(repoRoot, branch, upstream, options.sshPrivateKeyPath) : null;
+      if (remoteState) {
+        assertPushRemoteCurrent(remoteState);
+      }
+      const hasChanges = mode === "staged" ? await (0, git_1.hasStagedChanges)(repoRoot, PUSH_INCLUDED_PATHSPECS) : Boolean(worktreeStatus.trim());
+      const willCommit = hasChanges;
+      const willPushExistingCommits = !willCommit && Boolean(remoteState && remoteState.aheadCount > 0);
       let suggestedMessage;
       let messageSource;
       let fallbackReason;
       if (hasChanges) {
-        const resolved = await resolveCommitMessage(repoRoot, options, "worktree");
+        const resolved = await resolveCommitMessage(repoRoot, options, mode);
         suggestedMessage = resolved.message;
         messageSource = resolved.source;
         fallbackReason = resolved.fallbackReason;
+      } else if (willPushExistingCommits) {
+        suggestedMessage = await (0, git_1.getHeadCommitMessage)(repoRoot);
+        messageSource = "manual";
       }
       return {
         repoRoot,
@@ -3369,39 +3525,56 @@ ${error.result.stderr}`.toLowerCase();
         statusCounts,
         suggestedMessage,
         messageSource,
-        fallbackReason
+        fallbackReason,
+        aheadCount: remoteState?.aheadCount ?? 0,
+        behindCount: remoteState?.behindCount ?? 0,
+        willCommit,
+        willPushExistingCommits,
+        remoteState: remoteState ?? void 0
       };
     }
+    async function previewPush(options) {
+      const repoRoot = await (0, git_1.getRepositoryRoot)(options.cwd ?? process.cwd());
+      return await buildPushPreview(repoRoot, options, "worktree");
+    }
+    async function preparePushPreview(options) {
+      const repoRoot = await (0, git_1.getRepositoryRoot)(options.cwd ?? process.cwd());
+      await stagePushableChanges(repoRoot);
+      return await buildPushPreview(repoRoot, options, "staged");
+    }
     async function pushRepository(options) {
       const repoRoot = await (0, git_1.getRepositoryRoot)(options.cwd ?? process.cwd());
+      const branch = await (0, git_1.getCurrentBranch)(repoRoot);
+      const upstream = await (0, git_1.getUpstreamBranch)(repoRoot);
+      const remoteState = getReusableRemoteState(options.remoteState, branch, upstream) ?? await inspectPushRemoteState(repoRoot, branch, upstream, options.sshPrivateKeyPath);
+      assertPushRemoteCurrent(remoteState);
       await stagePushableChanges(repoRoot);
       if (!await (0, git_1.hasStagedChanges)(repoRoot, PUSH_INCLUDED_PATHSPECS)) {
+        if (remoteState.aheadCount > 0) {
+          const message2 = options.resolvedMessage?.message ?? options.manualMessage?.trim() ?? await (0, git_1.getHeadCommitMessage)(repoRoot);
+          await (0, git_1.pushBranch)(repoRoot, branch, remoteState.setUpstream, options.sshPrivateKeyPath, remoteState.remoteName ?? "origin");
+          return {
+            repoRoot,
+            branch,
+            message: message2,
+            retriedCommit: false,
+            commitSha: await (0, git_1.getHeadShortSha)(repoRoot),
+            upstream: await (0, git_1.getUpstreamBranch)(repoRoot),
+            messageSource: options.resolvedMessage?.source ?? "manual",
+            fallbackReason: options.resolvedMessage?.fallbackReason
+          };
+        }
         throw new Error("No changes to push.");
       }
       const resolvedMessage = options.resolvedMessage ?? await resolveCommitMessage(repoRoot, options);
       const message = resolvedMessage.message;
-      let retriedCommit = false;
-      try {
-        await (0, git_1.commitWithMessage)(repoRoot, message);
-      } catch (error) {
-        if (!shouldRetryCommit(error)) {
-          throw error;
-        }
-        retriedCommit = true;
-        await stagePushableChanges(repoRoot);
-        if (!await (0, git_1.hasStagedChanges)(repoRoot, PUSH_INCLUDED_PATHSPECS)) {
-          throw new Error("No changes to push.");
-        }
-        await (0, git_1.commitWithMessage)(repoRoot, message);
-      }
-      const branch = await (0, git_1.getCurrentBranch)(repoRoot);
-      const upstream = await (0, git_1.getUpstreamBranch)(repoRoot);
-      await (0, git_1.pushBranch)(repoRoot, branch, !upstream, options.sshPrivateKeyPath);
+      await (0, git_1.commitWithMessage)(repoRoot, message);
+      await (0, git_1.pushBranch)(repoRoot, branch, remoteState.setUpstream, options.sshPrivateKeyPath, remoteState.remoteName ?? "origin");
       return {
         repoRoot,
         branch,
         message,
-        retriedCommit,
+        retriedCommit: false,
         commitSha: await (0, git_1.getHeadShortSha)(repoRoot),
         upstream: await (0, git_1.getUpstreamBranch)(repoRoot),
         messageSource: resolvedMessage.source,
@@ -6726,23 +6899,25 @@ var require_cli = __commonJS({
         });
       }
       const mode = resolvePushMode(options);
+      const config = await (0, config_1.resolveAgentConfig)();
       const preview = await (0, push_1.previewPush)({
         cwd: repoRoot,
         mode,
-        manualMessage: options.message?.trim() || void 0
+        manualMessage: options.message?.trim() || void 0,
+        sshPrivateKeyPath: config.gitSshKey?.privateKeyPath
       });
-      if (!preview.hasChanges) {
-        throw (0, errors_1.createUserFacingError)({
-          code: "push_no_changes",
-          summary: "No changes to push."
-        });
-      }
       if (preview.detached) {
         throw (0, errors_1.createUserFacingError)({
           code: "push_detached_head",
           summary: "Detached HEAD; check out a branch before pushing."
         });
       }
+      if (!preview.hasChanges && !preview.willPushExistingCommits) {
+        throw (0, errors_1.createUserFacingError)({
+          code: "push_no_changes",
+          summary: "No changes to push."
+        });
+      }
       if (!options.json) {
         write(io.stdout, renderPushPreview(preview));
       }
@@ -6756,15 +6931,24 @@ var require_cli = __commonJS({
       if (options.dryRun) {
         const result2 = {
           ok: true,
+          repoRoot: preview.repoRoot,
           branch: preview.branch,
+          upstream: preview.upstream,
+          statusCounts: preview.statusCounts,
+          worktreeStatus: preview.worktreeStatus,
           commitMessage: resolvedMessage,
+          messageSource: preview.messageSource,
+          fallbackReason: preview.fallbackReason,
+          aheadCount: preview.aheadCount,
+          behindCount: preview.behindCount,
+          willCommit: preview.willCommit,
+          willPushExistingCommits: preview.willPushExistingCommits,
           nextActions: ["Run `tela agent push` without `--dry-run` when the plan looks correct."]
         };
         if (options.json)
           emitJson(io, result2);
         return 0;
       }
-      const config = await (0, config_1.resolveAgentConfig)();
       const push = await (0, push_1.pushRepository)({
         cwd: repoRoot,
         mode: "manual",
@@ -6774,12 +6958,17 @@ var require_cli = __commonJS({
           source: preview.messageSource ?? (options.message ? "manual" : "fallback"),
           fallbackReason: preview.fallbackReason
         },
-        sshPrivateKeyPath: config.gitSshKey?.privateKeyPath
+        sshPrivateKeyPath: config.gitSshKey?.privateKeyPath,
+        remoteState: preview.remoteState
       });
       const result = {
         ok: true,
+        repoRoot: push.repoRoot,
         branch: push.branch,
+        upstream: push.upstream,
         commitMessage: push.message,
+        messageSource: push.messageSource,
+        fallbackReason: push.fallbackReason,
         commitSha: push.commitSha,
         retriedCommit: push.retriedCommit,
         nextActions: ["Run `tela agent feedback --list` to inspect feedback for the pushed commit."]
@@ -7229,6 +7418,7 @@ var require_dist2 = __commonJS({
     __exportStar(require_push(), exports2);
     __exportStar(require_run(), exports2);
     __exportStar(require_sync(), exports2);
+    __exportStar(require_commit_message(), exports2);
     var config_1 = require_config2();
     Object.defineProperty(exports2, "getDefaultAgentCloneRoot", { enumerable: true, get: function() {
       return config_1.getDefaultAgentCloneRoot;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/tela-cli",
-  "version": "0.7.43",
+  "version": "0.7.45",
   "description": "Tela command line tools for local state and agent workflows.",
   "license": "UNLICENSED",
   "repository": {