@adhdev/daemon-core 0.9.82-rc.44 → 0.9.82-rc.441

package/src/git/git-commands.ts

@@ -42,8 +42,12 @@ export interface GitLogResult extends GitRepoIdentity {
 }
 
 export interface GitCheckpointResult extends GitRepoIdentity {
-  commit: string;
+  commit?: string;
   message: string;
+  status?: 'created' | 'skipped';
+  skipped?: boolean;
+  noop?: boolean;
+  reason?: 'nothing_to_commit';
   lastCheckedAt: number;
 }
 
@@ -62,9 +66,9 @@ export interface GitPushResult extends GitRepoIdentity {
 }
 
 export interface GitCommandServices {
-  getStatus?: (params: { workspace: string; refreshUpstream?: boolean }) => Promise<GitRepoStatus> | GitRepoStatus;
-  getDiffSummary?: (params: { workspace: string; staged?: boolean }) => Promise<GitDiffSummary> | GitDiffSummary;
-  getDiffFile?: (params: { workspace: string; path: string; staged?: boolean }) => Promise<GitFileDiff> | GitFileDiff;
+  getStatus?: (params: { workspace: string; refreshUpstream?: boolean; includeSubmodules?: boolean; submoduleIgnorePaths?: string[] }) => Promise<GitRepoStatus> | GitRepoStatus;
+  getDiffSummary?: (params: { workspace: string; staged?: boolean; base?: string }) => Promise<GitDiffSummary> | GitDiffSummary;
+  getDiffFile?: (params: { workspace: string; path: string; staged?: boolean; base?: string }) => Promise<GitFileDiff> | GitFileDiff;
   createSnapshot?: (params: {
     workspace: string;
     reason: GitSnapshotReason;
@@ -106,7 +110,10 @@ type GitCommandFailure = {
 };
 
 type GitCommandSuccess =
-  | { success: true; status: GitRepoStatus }
+  // reporterPlatform/reporterArch carry the responding daemon's process.platform/
+  // process.arch so a mesh coordinator probing this node over P2P can self-heal the
+  // node's userOverrides.platform/arch (the fields capability-tag routing reads).
+  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string }
   | { success: true; diffSummary: GitDiffSummary }
   | { success: true; diff: GitFileDiff }
   | { success: true; snapshot: GitSnapshot }
@@ -172,8 +179,8 @@ const defaultSnapshotStore = createGitSnapshotStore({
 export function createDefaultGitCommandServices(): GitCommandServices {
   return {
     getStatus: ({ workspace, refreshUpstream }) => getGitRepoStatus(workspace, { refreshUpstream }),
-    getDiffSummary: ({ workspace }) => getGitDiffSummary(workspace),
-    getDiffFile: ({ workspace, path: filePath }) => getGitFileDiff(workspace, filePath),
+    getDiffSummary: ({ workspace, base }) => getGitDiffSummary(workspace, base ? { baseRef: base } : {}),
+    getDiffFile: ({ workspace, path: filePath, base }) => getGitFileDiff(workspace, filePath, base ? { baseRef: base } : {}),
     createSnapshot: ({ workspace, reason, sessionId, turnId }) => defaultSnapshotStore.create({
       workspace,
       reason,
@@ -290,13 +297,30 @@ export async function handleGitCommand(
   switch (command) {
     case 'git_status': {
       if (!services.getStatus) return serviceNotImplemented(command);
-      const status = await runService(() => services.getStatus!({ workspace, refreshUpstream: optionalBoolean(args?.refreshUpstream) }));
-      return 'success' in status ? status : { success: true, status };
+      const submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths)
+        ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string' && value.trim().length > 0)
+        : undefined;
+      const statusParams: { workspace: string; refreshUpstream?: boolean; includeSubmodules?: boolean; submoduleIgnorePaths?: string[] } = { workspace };
+      const refreshUpstream = optionalBoolean(args?.refreshUpstream);
+      const includeSubmodules = optionalBoolean(args?.includeSubmodules);
+      if (refreshUpstream !== undefined) statusParams.refreshUpstream = refreshUpstream;
+      if (includeSubmodules !== undefined) statusParams.includeSubmodules = includeSubmodules;
+      if (submoduleIgnorePaths && submoduleIgnorePaths.length > 0) statusParams.submoduleIgnorePaths = submoduleIgnorePaths;
+      const status = await runService(() => services.getStatus!(statusParams));
+      if ('success' in status) return status;
+      // Carry the responding daemon's real platform/arch alongside the git
+      // status. A mesh coordinator dispatches `git_status` to each member over
+      // P2P on every explicit graph refresh, so this is the recurring live
+      // channel that lets a member self-report its OS to the coordinator — which
+      // stamps it onto the node's userOverrides.platform/arch (the fields
+      // buildMeshNodeCapabilityTags reads). These are siblings of `status`, not
+      // part of GitRepoStatus, so the git payload shape is untouched.
+      return { success: true, status, reporterPlatform: process.platform, reporterArch: process.arch };
     }
 
     case 'git_diff_summary': {
       if (!services.getDiffSummary) return serviceNotImplemented(command);
-      const diffSummary = await runService(() => services.getDiffSummary!({ workspace, staged: optionalBoolean(args?.staged) }));
+      const diffSummary = await runService(() => services.getDiffSummary!({ workspace, staged: optionalBoolean(args?.staged), base: optionalString(args?.base) }));
       return 'success' in diffSummary ? diffSummary : { success: true, diffSummary };
     }
 
@@ -438,10 +462,22 @@ async function gitCheckpoint(
   const repo = await resolveGitRepository(workspace);
   const repoRoot = repo.repoRoot!;
 
-  const statusResult = await getGitRepoStatus(workspace);
+  // Decision-then-mutate path: this conflict / dirty-submodule precheck gates a real
+  // `git add` + `git commit`. Bypass the C1 TTL cache so the checkpoint never proceeds
+  // on a stale "clean" verdict.
+  const statusResult = await getGitRepoStatus(workspace, { forceFresh: true });
   if (statusResult.hasConflicts) {
     throw new GitCommandError('conflict', 'Repository has conflicts — resolve before checkpointing');
   }
+  const dirtySubmodules = (statusResult.submodules || []).filter(submodule => submodule.dirty);
+  if (dirtySubmodules.length > 0) {
+    const paths = dirtySubmodules.map(submodule => submodule.path).join(', ');
+    throw new GitCommandError(
+      'dirty_index_required',
+      `Repository has dirty submodules that must be checkpointed first: ${paths}. ` +
+      'Checkpoint or commit each dirty submodule, then checkpoint this repository to record gitlink changes.',
+    );
+  }
 
   const addArgs = includeUntracked ? ['-A'] : ['-u'];
   await runGit(repo, ['add', ...addArgs], { cwd: repoRoot });
@@ -455,10 +491,17 @@ async function gitCheckpoint(
   } catch (err: any) {
     const output = (err?.stdout || '') + (err?.stderr || '');
     if (/nothing to commit/i.test(output)) {
-      throw new GitCommandError('nothing_to_commit', 'Nothing to commit — working tree is clean.', {
-        stdout: err?.stdout,
-        stderr: err?.stderr,
-      });
+      return {
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        message: fullMsg,
+        status: 'skipped',
+        skipped: true,
+        noop: true,
+        reason: 'nothing_to_commit',
+        lastCheckedAt: Date.now(),
+      };
     }
     throw err;
   }
@@ -469,6 +512,7 @@ async function gitCheckpoint(
     isGitRepo: true,
     commit: commitSha,
     message: fullMsg,
+    status: 'created',
     lastCheckedAt: Date.now(),
   };
 }

package/src/git/git-diff.ts

@@ -1,7 +1,7 @@
 import { readFile, realpath } from 'node:fs/promises';
 import * as path from 'node:path';
 import type { GitDiffSummary, GitFileChange, GitFileChangeStatus } from './git-types.js';
-import { GitCommandError, isPathInside, resolveGitRepository, runGit } from './git-executor.js';
+import { GIT_STATUS_TIMEOUT_MS, GitCommandError, isPathInside, resolveGitRepository, runGit } from './git-executor.js';
 
 const DEFAULT_MAX_FILES = 200;
 const DEFAULT_MAX_BYTES = 200_000;
@@ -10,6 +10,35 @@ export interface GitDiffOptions {
   timeoutMs?: number;
   maxFiles?: number;
   maxBytes?: number;
+  /**
+   * When set, diff `<baseRef>...HEAD` (merge-base range — "what this branch
+   * adds on top of base") instead of the working tree. Staged/untracked
+   * sections do not apply in this mode.
+   */
+  baseRef?: string;
+}
+
+/**
+ * Diff collection fans out an even larger parallel git burst than status (up to five
+ * concurrent spawns — name-status/numstat × unstaged/staged + ls-files — plus its own
+ * `rev-parse --show-toplevel`) and runs concurrently with the status path. On Windows the
+ * per-spawn cost alone can exceed the 5s `execGitRaw` default, so — exactly like
+ * getGitRepoStatus — give the collection path the larger status budget unless the caller
+ * pinned a timeout. Without this, a slow-but-healthy Windows worktree times out on the diff
+ * burst and the catch below flattens it to `repoRoot:null, isGitRepo:false`, dropping the
+ * diff while the (already-hardened) status block reports isGitRepo:true — an asymmetric
+ * failure that reads as "not a git repo" for diff only.
+ */
+function withCollectionTimeout(options: GitDiffOptions): GitDiffOptions {
+  return options.timeoutMs === undefined ? { ...options, timeoutMs: GIT_STATUS_TIMEOUT_MS } : options;
+}
+
+function validateBaseRef(ref: string): string {
+  const trimmed = ref.trim();
+  if (!trimmed || trimmed.startsWith('-') || trimmed.includes('..') || !/^[A-Za-z0-9][A-Za-z0-9._/@-]*$/.test(trimmed)) {
+    throw new GitCommandError('invalid_args', `Invalid base ref: ${ref}`);
+  }
+  return trimmed;
 }
 
 export interface GitFileDiffResult {
@@ -40,16 +69,41 @@ export async function getGitDiffSummary(
   options: GitDiffOptions = {},
 ): Promise<GitDiffSummary> {
   const lastCheckedAt = Date.now();
+  const effectiveOptions = withCollectionTimeout(options);
 
   try {
-    const repo = await resolveGitRepository(workspace, options);
+    const repo = await resolveGitRepository(workspace, effectiveOptions);
     const repoRoot = repo.repoRoot!;
+
+    if (options.baseRef) {
+      const range = `${validateBaseRef(options.baseRef)}...HEAD`;
+      const [nameStatus, numstat] = await Promise.all([
+        runGit(repo, ['diff', '--no-ext-diff', '--name-status', range, '--'], { ...effectiveOptions, cwd: repoRoot }),
+        runGit(repo, ['diff', '--no-ext-diff', '--numstat', range, '--'], { ...effectiveOptions, cwd: repoRoot }),
+      ]);
+      const outputBytes = byteLength(nameStatus.stdout + numstat.stdout);
+      const changes = combineDiffEntries(nameStatus.stdout, numstat.stdout, false);
+      const maxFiles = normalizePositiveInteger(options.maxFiles, DEFAULT_MAX_FILES);
+      const maxBytes = normalizePositiveInteger(options.maxBytes, DEFAULT_MAX_BYTES);
+      const files = changes.slice(0, maxFiles);
+      return {
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        files,
+        totalInsertions: files.reduce((sum, file) => sum + file.insertions, 0),
+        totalDeletions: files.reduce((sum, file) => sum + file.deletions, 0),
+        truncated: changes.length > files.length || outputBytes > maxBytes,
+        lastCheckedAt,
+      };
+    }
+
     const [unstagedNameStatus, unstagedNumstat, stagedNameStatus, stagedNumstat, untracked] = await Promise.all([
-      runGit(repo, ['diff', '--no-ext-diff', '--name-status'], { ...options, cwd: repoRoot }),
-      runGit(repo, ['diff', '--no-ext-diff', '--numstat'], { ...options, cwd: repoRoot }),
-      runGit(repo, ['diff', '--cached', '--no-ext-diff', '--name-status'], { ...options, cwd: repoRoot }),
-      runGit(repo, ['diff', '--cached', '--no-ext-diff', '--numstat'], { ...options, cwd: repoRoot }),
-      runGit(repo, ['ls-files', '--others', '--exclude-standard'], { ...options, cwd: repoRoot }),
+      runGit(repo, ['diff', '--no-ext-diff', '--name-status'], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ['diff', '--no-ext-diff', '--numstat'], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ['diff', '--cached', '--no-ext-diff', '--name-status'], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ['diff', '--cached', '--no-ext-diff', '--numstat'], { ...effectiveOptions, cwd: repoRoot }),
+      runGit(repo, ['ls-files', '--others', '--exclude-standard'], { ...effectiveOptions, cwd: repoRoot }),
     ]);
 
     const outputBytes = byteLength(
@@ -101,21 +155,37 @@ export async function getGitFileDiff(
   options: GitDiffOptions = {},
 ): Promise<GitFileDiffResult> {
   const lastCheckedAt = Date.now();
-  const repo = await resolveGitRepository(workspace, options);
+  const effectiveOptions = withCollectionTimeout(options);
+  const repo = await resolveGitRepository(workspace, effectiveOptions);
   const repoRoot = repo.repoRoot!;
   const selected = await resolveRepoFilePath(repoRoot, filePath);
   const maxBytes = normalizePositiveInteger(options.maxBytes, DEFAULT_MAX_BYTES);
 
+  if (options.baseRef) {
+    const range = `${validateBaseRef(options.baseRef)}...HEAD`;
+    const result = await runGit(repo, ['diff', '--no-ext-diff', range, '--', selected.relativePath], { ...effectiveOptions, cwd: repoRoot });
+    const bounded = truncateText(result.stdout, maxBytes);
+    return {
+      workspace: repo.workspace,
+      repoRoot,
+      isGitRepo: true,
+      path: selected.relativePath,
+      diff: bounded.text,
+      truncated: bounded.truncated,
+      lastCheckedAt,
+    };
+  }
+
   const [unstaged, staged] = await Promise.all([
-    runGit(repo, ['diff', '--no-ext-diff', '--', selected.relativePath], { ...options, cwd: repoRoot }),
-    runGit(repo, ['diff', '--cached', '--no-ext-diff', '--', selected.relativePath], { ...options, cwd: repoRoot }),
+    runGit(repo, ['diff', '--no-ext-diff', '--', selected.relativePath], { ...effectiveOptions, cwd: repoRoot }),
+    runGit(repo, ['diff', '--cached', '--no-ext-diff', '--', selected.relativePath], { ...effectiveOptions, cwd: repoRoot }),
   ]);
 
   let diff = [unstaged.stdout, staged.stdout].filter((part) => part.length > 0).join('\n');
 
   if (!diff) {
     const untracked = await runGit(repo, ['ls-files', '--others', '--exclude-standard', '--', selected.relativePath], {
-      ...options,
+      ...effectiveOptions,
       cwd: repoRoot,
     });
     const untrackedFiles = untracked.stdout.split('\n').filter(Boolean);

package/src/git/git-executor.ts

@@ -10,6 +10,18 @@ const execFileAsync = promisify(execFile);
 const DEFAULT_TIMEOUT_MS = 5_000;
 const DEFAULT_MAX_BUFFER = 1024 * 1024;
 
+/**
+ * Timeout for status-collection git commands (status/log/submodule/stash/fetch).
+ * The default 5s is fine for porcelain status, but on Windows the `git` subprocess
+ * spawn itself is pathologically slow (measured: `submodule status` ~3.5s, cold
+ * `log -1` ~4.2s) and overlaps with refreshUpstream fetches — a single command
+ * routinely exceeds 5s, which previously collapsed the whole status to all-null and
+ * dropped the node from the mesh graph. Give the collection path a much larger
+ * budget so a slow-but-healthy repo never reads as "not a git repo". Windows gets a
+ * larger budget than POSIX because the spawn cost is OS-specific, not repo-specific.
+ */
+export const GIT_STATUS_TIMEOUT_MS = process.platform === 'win32' ? 30_000 : 20_000;
+
 export interface GitExecutorOptions {
   timeoutMs?: number;
   maxBuffer?: number;