@adhdev/daemon-standalone 0.9.62 → 0.9.64

package/dist/index.js

@@ -33496,7 +33496,8 @@ var require_dist2 = __commonJS({
       "git_stash_push",
       "git_stash_pop",
       "git_checkout_files",
-      "git_remote_url"
+      "git_remote_url",
+      "git_push"
     ]);
     var SNAPSHOT_REASONS = /* @__PURE__ */ new Set([
       "session_baseline",
@@ -33542,7 +33543,8 @@ var require_dist2 = __commonJS({
         stashPush: async ({ workspace, message, includeUntracked = false }) => gitStashPush(workspace, message, includeUntracked),
         stashPop: async ({ workspace, stashRef }) => gitStashPop(workspace, stashRef),
         checkoutFiles: async ({ workspace, paths }) => gitCheckoutFiles(workspace, paths),
-        getRemoteUrl: async ({ workspace, remote = "origin" }) => gitGetRemoteUrl(workspace, remote)
+        getRemoteUrl: async ({ workspace, remote = "origin" }) => gitGetRemoteUrl(workspace, remote),
+        push: async ({ workspace, remote = "origin", branch, setUpstream = false }) => gitPush(workspace, remote, branch, setUpstream)
       };
     }
     var defaultGitCommandServices = createDefaultGitCommandServices();
@@ -33710,6 +33712,20 @@ var require_dist2 = __commonJS({
           if ("success" in remoteResult) return remoteResult;
           return { success: true, remoteUrl: remoteResult.remoteUrl, remote: remoteResult.remote };
         }
+        case "git_push": {
+          if (!services.push) return serviceNotImplemented(command);
+          const remote = typeof args?.remote === "string" && args.remote.trim() ? args.remote.trim() : "origin";
+          const branch = typeof args?.branch === "string" && args.branch.trim() ? args.branch.trim() : void 0;
+          const setUpstream = Boolean(args?.setUpstream);
+          if (!/^[a-zA-Z0-9_.\-]+$/.test(remote)) {
+            return failure("invalid_args", "remote must contain only alphanumeric characters, dots, hyphens, and underscores");
+          }
+          if (branch !== void 0 && !/^[a-zA-Z0-9/_.\-]+$/.test(branch)) {
+            return failure("invalid_args", "branch must contain only alphanumeric characters, slashes, dots, hyphens, and underscores");
+          }
+          const pushResult = await runService(() => services.push({ workspace, remote, branch, setUpstream }));
+          return "success" in pushResult ? pushResult : { success: true, push: pushResult };
+        }
         default:
           return failure("invalid_args", `Unknown Git command: ${command}`);
       }
@@ -33812,6 +33828,49 @@ var require_dist2 = __commonJS({
       }
       return { remoteUrl, remote };
     }
+    async function gitPush(workspace, remote, branch, setUpstream) {
+      const lastCheckedAt = Date.now();
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      let resolvedBranch = branch;
+      if (!resolvedBranch) {
+        const branchResult = await runGit(repo, ["symbolic-ref", "--short", "HEAD"], { cwd: repoRoot });
+        resolvedBranch = branchResult.stdout.trim();
+        if (!resolvedBranch) {
+          throw new GitCommandError("git_command_failed", "Cannot push: not on a branch (detached HEAD)");
+        }
+      }
+      const pushArgs = ["push"];
+      if (setUpstream) pushArgs.push("--set-upstream");
+      pushArgs.push(remote, resolvedBranch);
+      let output = "";
+      let newBranch = false;
+      try {
+        const result = await runGit(repo, pushArgs, { cwd: repoRoot });
+        output = (result.stdout + result.stderr).trim();
+        newBranch = /\[new branch\]/i.test(output);
+      } catch (err) {
+        const errOutput = (err?.stdout ?? "") + (err?.stderr ?? "");
+        if (!setUpstream && /no upstream branch|set-upstream/i.test(errOutput)) {
+          const retryArgs = ["push", "--set-upstream", remote, resolvedBranch];
+          const retryResult = await runGit(repo, retryArgs, { cwd: repoRoot });
+          output = (retryResult.stdout + retryResult.stderr).trim();
+          newBranch = /\[new branch\]/i.test(output);
+        } else {
+          throw new GitCommandError("git_command_failed", errOutput || err?.message || "git push failed");
+        }
+      }
+      return {
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        remote,
+        branch: resolvedBranch,
+        output,
+        newBranch,
+        lastCheckedAt
+      };
+    }
     function formatOptionalGitLogRangeArg(flag, value) {
       return value ? [`${flag}=${value}`] : [];
     }
@@ -40051,9 +40110,34 @@ ${effect.notification.body || ""}`.trim();
       }
       return -1;
     }
+    function isReadChatConversationAnchorMessage(message) {
+      if (!message) return false;
+      const role = String(message.role || "").trim().toLowerCase();
+      if (role !== "user" && role !== "assistant") return false;
+      const kind = String(message.kind || "standard").trim().toLowerCase();
+      return !kind || kind === "standard";
+    }
+    function buildVisibleReadChatTailMessages(messages, tailLimit) {
+      const totalMessages = messages.length;
+      if (tailLimit <= 0 || totalMessages <= tailLimit) return messages;
+      const tailMessages = messages.slice(-tailLimit);
+      if (tailMessages.some(isReadChatConversationAnchorMessage)) return tailMessages;
+      const hiddenMessages = messages.slice(0, totalMessages - tailLimit);
+      const anchors = [];
+      const seenRoles = /* @__PURE__ */ new Set();
+      for (let index = hiddenMessages.length - 1; index >= 0 && anchors.length < 2; index -= 1) {
+        const message = hiddenMessages[index];
+        if (!isReadChatConversationAnchorMessage(message)) continue;
+        const role = String(message.role || "").trim().toLowerCase();
+        if (seenRoles.has(role)) continue;
+        seenRoles.add(role);
+        anchors.unshift(message);
+      }
+      return anchors.length > 0 ? [...anchors, ...tailMessages] : tailMessages;
+    }
     function buildBoundedTailSync(messages, cursor) {
       const totalMessages = messages.length;
-      const tailMessages = cursor.tailLimit > 0 && totalMessages > cursor.tailLimit ? messages.slice(-cursor.tailLimit) : messages;
+      const tailMessages = buildVisibleReadChatTailMessages(messages, cursor.tailLimit);
       return {
         syncMode: "full",
         replaceFrom: 0,
@@ -40175,8 +40259,8 @@ ${effect.notification.body || ""}`.trim();
       const messages = collapseReplayDuplicatesFromReadChat(normalizeReadChatMessages(validatedPayload));
       const cursor = normalizeReadChatCursor(args);
       if (!cursor.knownMessageCount && !cursor.lastMessageSignature && cursor.tailLimit > 0 && messages.length > cursor.tailLimit) {
-        const tailMessages = messages.slice(-cursor.tailLimit);
-        const lastMessageSignature = getChatMessageSignature(tailMessages[tailMessages.length - 1]);
+        const tailMessages = buildVisibleReadChatTailMessages(messages, cursor.tailLimit);
+        const lastMessageSignature = getChatMessageSignature(messages[messages.length - 1]);
         return {
           success: true,
           ...validatedPayload,