@adhdev/daemon-core 0.9.62 → 0.9.64

package/dist/git/git-commands.d.ts

@@ -32,6 +32,13 @@ export interface GitStashPushResult extends GitRepoIdentity {
     message: string;
     lastCheckedAt: number;
 }
+export interface GitPushResult extends GitRepoIdentity {
+    remote: string;
+    branch: string;
+    output: string;
+    newBranch: boolean;
+    lastCheckedAt: number;
+}
 export interface GitCommandServices {
     getStatus?: (params: {
         workspace: string;
@@ -90,6 +97,12 @@ export interface GitCommandServices {
         remoteUrl: string;
         remote: string;
     }>;
+    push?: (params: {
+        workspace: string;
+        remote?: string;
+        branch?: string;
+        setUpstream?: boolean;
+    }) => Promise<GitPushResult>;
 }
 type GitCommandFailure = {
     success: false;
@@ -130,6 +143,9 @@ type GitCommandSuccess = {
     success: true;
     remoteUrl: string;
     remote: string;
+} | {
+    success: true;
+    push: GitPushResult;
 };
 export type GitCommandResult = GitCommandSuccess | GitCommandFailure;
 export declare function createDefaultGitCommandServices(): GitCommandServices;

package/dist/git/git-types.d.ts

@@ -110,4 +110,4 @@ export interface GitWorkspaceUpdate {
     seq: number;
     timestamp: number;
 }
-export type GitCommandName = 'git_status' | 'git_diff_summary' | 'git_diff_file' | 'git_snapshot_create' | 'git_snapshot_compare' | 'git_log' | 'git_checkpoint' | 'git_stash_push' | 'git_stash_pop' | 'git_checkout_files' | 'git_remote_url';
+export type GitCommandName = 'git_status' | 'git_diff_summary' | 'git_diff_file' | 'git_snapshot_create' | 'git_snapshot_compare' | 'git_log' | 'git_checkpoint' | 'git_stash_push' | 'git_stash_pop' | 'git_checkout_files' | 'git_remote_url' | 'git_push';

package/dist/index.js

@@ -5642,7 +5642,8 @@ var GIT_COMMAND_NAMES = /* @__PURE__ */ new Set([
   "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",
@@ -5688,7 +5689,8 @@ function createDefaultGitCommandServices() {
     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();
@@ -5856,6 +5858,20 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
       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}`);
   }
@@ -5958,6 +5974,49 @@ async function gitGetRemoteUrl(workspace, remote) {
   }
   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}`] : [];
 }
@@ -12283,9 +12342,34 @@ function findLastMessageIndexBySignature(messages, signature) {
   }
   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,
@@ -12407,8 +12491,8 @@ function buildReadChatCommandResult(payload, args) {
   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,