@adhdev/daemon-core 0.9.62 → 0.9.64

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.62",
+  "version": "0.9.64",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.62",
+  "version": "0.9.64",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/chat-commands.ts

@@ -344,6 +344,36 @@ function findLastMessageIndexBySignature(messages: ChatMessage[], signature: str
     return -1;
 }
 
+function isReadChatConversationAnchorMessage(message: ChatMessage | null | undefined): boolean {
+    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: ChatMessage[], tailLimit: number): ChatMessage[] {
+    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: ChatMessage[] = [];
+    const seenRoles = new Set<string>();
+    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: ChatMessage[], cursor: Required<ReadChatCursor>): {
     syncMode: ReadChatSyncMode;
     replaceFrom: number;
@@ -352,9 +382,7 @@ function buildBoundedTailSync(messages: ChatMessage[], cursor: Required<ReadChat
     lastMessageSignature: string;
 } {
     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,
@@ -495,8 +523,8 @@ function buildReadChatCommandResult(payload: Record<string, any>, args: any): Co
     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,

package/src/git/git-commands.ts

@@ -53,6 +53,14 @@ export interface GitStashPushResult extends GitRepoIdentity {
   lastCheckedAt: number;
 }
 
+export interface GitPushResult extends GitRepoIdentity {
+  remote: string;
+  branch: string;
+  output: string;
+  newBranch: boolean;
+  lastCheckedAt: number;
+}
+
 export interface GitCommandServices {
   getStatus?: (params: { workspace: string }) => Promise<GitRepoStatus> | GitRepoStatus;
   getDiffSummary?: (params: { workspace: string; staged?: boolean }) => Promise<GitDiffSummary> | GitDiffSummary;
@@ -88,6 +96,7 @@ export interface GitCommandServices {
   stashPop?: (params: { workspace: string; stashRef?: string }) => Promise<void>;
   checkoutFiles?: (params: { workspace: string; paths: string[] }) => Promise<{ checkedOut: string[] }>;
   getRemoteUrl?: (params: { workspace: string; remote?: string }) => Promise<{ remoteUrl: string; remote: string }>;
+  push?: (params: { workspace: string; remote?: string; branch?: string; setUpstream?: boolean }) => Promise<GitPushResult>;
 }
 
 type GitCommandFailure = {
@@ -107,7 +116,8 @@ type GitCommandSuccess =
   | { success: true; stash: GitStashPushResult }
   | { success: true; stashPopped: true }
   | { success: true; checkedOut: string[] }
-  | { success: true; remoteUrl: string; remote: string };
+  | { success: true; remoteUrl: string; remote: string }
+  | { success: true; push: GitPushResult };
 
 export type GitCommandResult = GitCommandSuccess | GitCommandFailure;
 
@@ -123,6 +133,7 @@ const GIT_COMMAND_NAMES = new Set<GitCommandName>([
   'git_stash_pop',
   'git_checkout_files',
   'git_remote_url',
+  'git_push',
 ]);
 
 const SNAPSHOT_REASONS = new Set<GitSnapshotReason>([
@@ -175,6 +186,8 @@ export function createDefaultGitCommandServices(): GitCommandServices {
     stashPop: async ({ workspace, stashRef }) => gitStashPop(workspace, stashRef),
     checkoutFiles: async ({ workspace, paths }) => gitCheckoutFiles(workspace, paths),
     getRemoteUrl: async ({ workspace, remote = 'origin' }) => gitGetRemoteUrl(workspace, remote),
+    push: async ({ workspace, remote = 'origin', branch, setUpstream = false }) =>
+      gitPush(workspace, remote, branch, setUpstream),
   };
 }
 
@@ -385,6 +398,21 @@ export async function handleGitCommand(
       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() : undefined;
+      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 !== undefined && !/^[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}`);
   }
@@ -512,6 +540,61 @@ async function gitGetRemoteUrl(workspace: string, remote: string): Promise<{ rem
   return { remoteUrl, remote };
 }
 
+async function gitPush(
+  workspace: string,
+  remote: string,
+  branch: string | undefined,
+  setUpstream: boolean,
+): Promise<GitPushResult> {
+  const lastCheckedAt = Date.now();
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot!;
+
+  // Resolve branch name if not provided
+  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: any) {
+    const errOutput = (err?.stdout ?? '') + (err?.stderr ?? '');
+    // --set-upstream hint: retry with --set-upstream automatically
+    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: '--since' | '--until', value: string | undefined): string[] {
   return value ? [`${flag}=${value}`] : [];
 }

package/src/git/git-types.ts

@@ -151,4 +151,5 @@ export type GitCommandName =
   | 'git_stash_push'
   | 'git_stash_pop'
   | 'git_checkout_files'
-  | 'git_remote_url';
+  | 'git_remote_url'
+  | 'git_push';