@adhdev/daemon-core 0.9.53 → 0.9.55

package/src/git/git-monitor.ts

@@ -0,0 +1,194 @@
+import type {
+  GitCompactSummary,
+  GitDiffSummary,
+  GitRepoStatus,
+  GitWorkspaceUpdate,
+  WorkspaceGitSubscriptionParams,
+} from './git-types.js';
+import { getGitDiffSummary } from './git-diff.js';
+import { getGitRepoStatus } from './git-status.js';
+import { createGitCompactSummary } from './git-summary.js';
+import type { GitDiffSummaryProvider, GitStatusProvider } from './git-snapshot-store.js';
+
+export const DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS = 5000;
+export const MIN_GIT_WORKSPACE_POLL_INTERVAL_MS = 1000;
+
+export interface NormalizeGitWorkspaceSubscriptionOptions {
+  defaultIntervalMs?: number;
+  minIntervalMs?: number;
+}
+
+export interface NormalizedWorkspaceGitSubscriptionParams extends Required<WorkspaceGitSubscriptionParams> {}
+
+export interface GitWorkspaceCacheEntry {
+  key: string;
+  workspace: string;
+  status: GitRepoStatus;
+  diffSummary?: GitDiffSummary;
+  compactSummary: GitCompactSummary;
+  seq: number;
+  timestamp: number;
+}
+
+export type GitWorkspaceUpdateListener = (update: GitWorkspaceUpdate, cacheEntry: GitWorkspaceCacheEntry) => void;
+
+export interface GitWorkspaceMonitorOptions {
+  getStatus?: GitStatusProvider;
+  getDiffSummary?: GitDiffSummaryProvider;
+  now?: () => number;
+  minIntervalMs?: number;
+  defaultIntervalMs?: number;
+  keyPrefix?: string;
+}
+
+export interface GitWorkspaceSubscription {
+  params: NormalizedWorkspaceGitSubscriptionParams;
+  refresh(): Promise<GitWorkspaceUpdate>;
+  getCached(): GitWorkspaceCacheEntry | undefined;
+  dispose(): void;
+}
+
+function defaultStatusProvider(workspace: string): Promise<GitRepoStatus> {
+  return getGitRepoStatus(workspace);
+}
+
+function defaultDiffSummaryProvider(workspace: string): Promise<GitDiffSummary> {
+  return getGitDiffSummary(workspace);
+}
+
+function normalizeIntervalMs(value: number | undefined, defaultIntervalMs: number, minIntervalMs: number): number {
+  const requested = Number.isFinite(value) ? Math.floor(value as number) : defaultIntervalMs;
+  return Math.max(minIntervalMs, requested > 0 ? requested : defaultIntervalMs);
+}
+
+export function normalizeGitWorkspaceSubscriptionParams(
+  params: WorkspaceGitSubscriptionParams,
+  options: NormalizeGitWorkspaceSubscriptionOptions = {},
+): NormalizedWorkspaceGitSubscriptionParams {
+  const minIntervalMs = Math.max(1, Math.floor(options.minIntervalMs ?? MIN_GIT_WORKSPACE_POLL_INTERVAL_MS));
+  const defaultIntervalMs = Math.max(minIntervalMs, Math.floor(options.defaultIntervalMs ?? DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS));
+
+  return {
+    workspace: params.workspace,
+    includeDiffSummary: Boolean(params.includeDiffSummary),
+    intervalMs: normalizeIntervalMs(params.intervalMs, defaultIntervalMs, minIntervalMs),
+  };
+}
+
+export class GitWorkspaceMonitor {
+  private readonly getStatusProvider: GitStatusProvider;
+  private readonly getDiffSummaryProvider: GitDiffSummaryProvider;
+  private readonly now: () => number;
+  private readonly minIntervalMs: number;
+  private readonly defaultIntervalMs: number;
+  private readonly keyPrefix: string;
+  private readonly cache = new Map<string, GitWorkspaceCacheEntry>();
+  private readonly listeners = new Set<GitWorkspaceUpdateListener>();
+  private seq = 0;
+
+  constructor(options: GitWorkspaceMonitorOptions = {}) {
+    this.getStatusProvider = options.getStatus ?? defaultStatusProvider;
+    this.getDiffSummaryProvider = options.getDiffSummary ?? defaultDiffSummaryProvider;
+    this.now = options.now ?? Date.now;
+    this.minIntervalMs = Math.max(1, Math.floor(options.minIntervalMs ?? MIN_GIT_WORKSPACE_POLL_INTERVAL_MS));
+    this.defaultIntervalMs = Math.max(
+      this.minIntervalMs,
+      Math.floor(options.defaultIntervalMs ?? DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS),
+    );
+    this.keyPrefix = options.keyPrefix ?? 'git';
+  }
+
+  async refresh(params: string | WorkspaceGitSubscriptionParams): Promise<GitWorkspaceUpdate> {
+    const normalized = this.normalize(typeof params === 'string' ? { workspace: params } : params);
+    const status = await this.getStatusProvider(normalized.workspace);
+    const diffSummary = normalized.includeDiffSummary
+      ? await this.getDiffSummaryProvider(normalized.workspace, status)
+      : undefined;
+    const compactSummary = createGitCompactSummary(status, diffSummary);
+    const timestamp = this.now();
+    const seq = ++this.seq;
+    const key = this.keyForWorkspace(normalized.workspace);
+    const update: GitWorkspaceUpdate = {
+      topic: 'workspace.git',
+      key,
+      workspace: normalized.workspace,
+      status,
+      diffSummary,
+      seq,
+      timestamp,
+    };
+    const cacheEntry: GitWorkspaceCacheEntry = {
+      key,
+      workspace: normalized.workspace,
+      status,
+      diffSummary,
+      compactSummary,
+      seq,
+      timestamp,
+    };
+
+    this.cache.set(normalized.workspace, cacheEntry);
+    this.emit(update, cacheEntry);
+    return update;
+  }
+
+  poll(params: string | WorkspaceGitSubscriptionParams): Promise<GitWorkspaceUpdate> {
+    return this.refresh(params);
+  }
+
+  getCached(workspace: string): GitWorkspaceCacheEntry | undefined {
+    return this.cache.get(workspace);
+  }
+
+  getCompactSummary(workspace: string): GitCompactSummary | undefined {
+    return this.cache.get(workspace)?.compactSummary;
+  }
+
+  onUpdate(listener: GitWorkspaceUpdateListener): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  createSubscription(
+    params: WorkspaceGitSubscriptionParams,
+    listener?: GitWorkspaceUpdateListener,
+  ): GitWorkspaceSubscription {
+    const normalized = this.normalize(params);
+    const scopedListener: GitWorkspaceUpdateListener | undefined = listener
+      ? (update, cacheEntry) => {
+          if (update.workspace === normalized.workspace) listener(update, cacheEntry);
+        }
+      : undefined;
+    const unsubscribe = scopedListener ? this.onUpdate(scopedListener) : () => undefined;
+
+    return {
+      params: normalized,
+      refresh: () => this.refresh(normalized),
+      getCached: () => this.getCached(normalized.workspace),
+      dispose: unsubscribe,
+    };
+  }
+
+  normalize(params: WorkspaceGitSubscriptionParams): NormalizedWorkspaceGitSubscriptionParams {
+    return normalizeGitWorkspaceSubscriptionParams(params, {
+      defaultIntervalMs: this.defaultIntervalMs,
+      minIntervalMs: this.minIntervalMs,
+    });
+  }
+
+  private keyForWorkspace(workspace: string): string {
+    return `${this.keyPrefix}:${workspace}`;
+  }
+
+  private emit(update: GitWorkspaceUpdate, cacheEntry: GitWorkspaceCacheEntry): void {
+    for (const listener of this.listeners) {
+      listener(update, cacheEntry);
+    }
+  }
+}
+
+export function createGitWorkspaceMonitor(options: GitWorkspaceMonitorOptions = {}): GitWorkspaceMonitor {
+  return new GitWorkspaceMonitor(options);
+}

package/src/git/git-snapshot-store.ts

@@ -0,0 +1,238 @@
+import type {
+  GitDiffSummary,
+  GitFileChange,
+  GitRepoStatus,
+  GitSnapshot,
+  GitSnapshotCompareSummary,
+  GitSnapshotReason,
+} from './git-types.js';
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export type GitStatusProvider = (workspace: string) => MaybePromise<GitRepoStatus>;
+export type GitDiffSummaryProvider = (workspace: string, status: GitRepoStatus) => MaybePromise<GitDiffSummary>;
+
+export interface GitSnapshotStoreOptions {
+  capacity?: number;
+  getStatus?: GitStatusProvider;
+  getDiffSummary?: GitDiffSummaryProvider;
+  now?: () => number;
+  idPrefix?: string;
+}
+
+export interface GitSnapshotCreateInput {
+  workspace: string;
+  reason: GitSnapshotReason;
+  sessionId?: string;
+  turnId?: string;
+  getStatus?: GitStatusProvider;
+  getDiffSummary?: GitDiffSummaryProvider;
+}
+
+export interface GitSnapshotListQuery {
+  workspace?: string;
+  sessionId?: string;
+  limit?: number;
+}
+
+export interface GitSnapshotStore {
+  create(input: GitSnapshotCreateInput): Promise<GitSnapshot>;
+  get(id: string): GitSnapshot | undefined;
+  compare(beforeSnapshotId: string, afterSnapshotId: string): GitSnapshotCompareSummary;
+  list(query?: GitSnapshotListQuery): GitSnapshot[];
+  clear(): void;
+}
+
+function normalizeCapacity(capacity: number | undefined): number {
+  return Math.max(1, Math.floor(capacity ?? 100));
+}
+
+function createEmptyDiffSummary(status: GitRepoStatus): GitDiffSummary {
+  return {
+    workspace: status.workspace,
+    repoRoot: status.repoRoot,
+    isGitRepo: status.isGitRepo,
+    files: [],
+    totalInsertions: 0,
+    totalDeletions: 0,
+    truncated: false,
+    lastCheckedAt: status.lastCheckedAt,
+    error: status.error,
+    reason: status.reason,
+  };
+}
+
+function changedFileKey(file: GitFileChange): string {
+  return `${file.oldPath ?? ''}\u0000${file.path}`;
+}
+
+function uniqueSorted(values: Iterable<string>): string[] {
+  return Array.from(new Set(Array.from(values).filter(Boolean))).sort((a, b) => a.localeCompare(b));
+}
+
+function plural(count: number, singular: string, pluralText = `${singular}s`): string {
+  return count === 1 ? singular : pluralText;
+}
+
+export function compareGitSnapshots(before: GitSnapshot, after: GitSnapshot): GitSnapshotCompareSummary {
+  const beforeFileKeys = new Set(before.diffSummary.files.map(changedFileKey));
+  const changedAfterFiles = after.diffSummary.files.filter((file) => !beforeFileKeys.has(changedFileKey(file)));
+
+  const addedFiles: string[] = [];
+  const modifiedFiles: string[] = [];
+  const deletedFiles: string[] = [];
+  const renamedFiles: Array<{ oldPath: string; path: string }> = [];
+  const untrackedFiles: string[] = [];
+  const conflictFilesFromDiff: string[] = [];
+
+  let totalInsertions = 0;
+  let totalDeletions = 0;
+
+  for (const file of changedAfterFiles) {
+    totalInsertions += file.insertions;
+    totalDeletions += file.deletions;
+
+    switch (file.status) {
+      case 'added':
+      case 'copied':
+        addedFiles.push(file.path);
+        break;
+      case 'modified':
+        modifiedFiles.push(file.path);
+        break;
+      case 'deleted':
+        deletedFiles.push(file.path);
+        break;
+      case 'renamed':
+        renamedFiles.push({ oldPath: file.oldPath ?? file.path, path: file.path });
+        break;
+      case 'untracked':
+        untrackedFiles.push(file.path);
+        break;
+      case 'conflict':
+        conflictFilesFromDiff.push(file.path);
+        break;
+    }
+  }
+
+  renamedFiles.sort((a, b) => `${a.oldPath}\u0000${a.path}`.localeCompare(`${b.oldPath}\u0000${b.path}`));
+  const conflictFiles = uniqueSorted([...after.status.conflictFiles, ...conflictFilesFromDiff]);
+  const changedFiles = changedAfterFiles.length;
+  const hasConflicts = after.status.hasConflicts || conflictFiles.length > 0;
+  const summaryParts: string[] = [];
+
+  if (changedFiles > 0) summaryParts.push(`${changedFiles} ${plural(changedFiles, 'file')} changed`);
+  if (addedFiles.length > 0) summaryParts.push(`${addedFiles.length} added`);
+  if (modifiedFiles.length > 0) summaryParts.push(`${modifiedFiles.length} modified`);
+  if (deletedFiles.length > 0) summaryParts.push(`${deletedFiles.length} deleted`);
+  if (renamedFiles.length > 0) summaryParts.push(`${renamedFiles.length} renamed`);
+  if (untrackedFiles.length > 0) summaryParts.push(`${untrackedFiles.length} untracked`);
+  if (hasConflicts) summaryParts.push(`${conflictFiles.length || 1} ${plural(conflictFiles.length || 1, 'conflict')}`);
+
+  return {
+    beforeSnapshotId: before.id,
+    afterSnapshotId: after.id,
+    workspace: after.workspace,
+    repoRoot: after.repoRoot,
+    changedFiles,
+    addedFiles: uniqueSorted(addedFiles),
+    modifiedFiles: uniqueSorted(modifiedFiles),
+    deletedFiles: uniqueSorted(deletedFiles),
+    renamedFiles,
+    untrackedFiles: uniqueSorted(untrackedFiles),
+    conflictFiles,
+    totalInsertions,
+    totalDeletions,
+    hasConflicts,
+    currentStatus: after.status,
+    summaryText: summaryParts.length > 0 ? summaryParts.join(', ') : 'No file-set changes between snapshots.',
+  };
+}
+
+export class InMemoryGitSnapshotStore implements GitSnapshotStore {
+  private readonly snapshots = new Map<string, GitSnapshot>();
+  private readonly order: string[] = [];
+  private readonly capacity: number;
+  private readonly now: () => number;
+  private readonly idPrefix: string;
+  private readonly getStatusProvider?: GitStatusProvider;
+  private readonly getDiffSummaryProvider?: GitDiffSummaryProvider;
+  private counter = 0;
+
+  constructor(options: GitSnapshotStoreOptions = {}) {
+    this.capacity = normalizeCapacity(options.capacity);
+    this.now = options.now ?? Date.now;
+    this.idPrefix = options.idPrefix ?? 'git-snapshot';
+    this.getStatusProvider = options.getStatus;
+    this.getDiffSummaryProvider = options.getDiffSummary;
+  }
+
+  async create(input: GitSnapshotCreateInput): Promise<GitSnapshot> {
+    const getStatus = input.getStatus ?? this.getStatusProvider;
+    if (!getStatus) {
+      throw new Error('GitSnapshotStore requires an injected getStatus provider');
+    }
+
+    const status = await getStatus(input.workspace);
+    const getDiffSummary = input.getDiffSummary ?? this.getDiffSummaryProvider;
+    const diffSummary = getDiffSummary ? await getDiffSummary(input.workspace, status) : createEmptyDiffSummary(status);
+    const createdAt = this.now();
+    const id = `${this.idPrefix}-${createdAt}-${++this.counter}`;
+    const snapshot: GitSnapshot = {
+      id,
+      workspace: input.workspace,
+      repoRoot: status.repoRoot ?? input.workspace,
+      sessionId: input.sessionId,
+      turnId: input.turnId,
+      reason: input.reason,
+      status,
+      diffSummary,
+      createdAt,
+    };
+
+    this.snapshots.set(id, snapshot);
+    this.order.push(id);
+    this.enforceCapacity();
+    return snapshot;
+  }
+
+  get(id: string): GitSnapshot | undefined {
+    return this.snapshots.get(id);
+  }
+
+  compare(beforeSnapshotId: string, afterSnapshotId: string): GitSnapshotCompareSummary {
+    const before = this.snapshots.get(beforeSnapshotId);
+    if (!before) throw new Error(`Unknown before snapshot: ${beforeSnapshotId}`);
+
+    const after = this.snapshots.get(afterSnapshotId);
+    if (!after) throw new Error(`Unknown after snapshot: ${afterSnapshotId}`);
+
+    return compareGitSnapshots(before, after);
+  }
+
+  list(query: GitSnapshotListQuery = {}): GitSnapshot[] {
+    const limit = Math.max(1, Math.floor(query.limit ?? this.capacity));
+    return this.order
+      .map((id) => this.snapshots.get(id))
+      .filter((snapshot): snapshot is GitSnapshot => Boolean(snapshot))
+      .filter((snapshot) => !query.workspace || snapshot.workspace === query.workspace)
+      .filter((snapshot) => !query.sessionId || snapshot.sessionId === query.sessionId)
+      .slice(-limit);
+  }
+
+  clear(): void {
+    this.snapshots.clear();
+    this.order.splice(0, this.order.length);
+  }
+
+  private enforceCapacity(): void {
+    while (this.order.length > this.capacity) {
+      const evictedId = this.order.shift();
+      if (evictedId) this.snapshots.delete(evictedId);
+    }
+  }
+}
+
+export function createGitSnapshotStore(options: GitSnapshotStoreOptions = {}): GitSnapshotStore {
+  return new InMemoryGitSnapshotStore(options);
+}

package/src/git/git-status.ts

@@ -0,0 +1,193 @@
+import type { GitRepoStatus } from './git-types.js';
+import { GitCommandError, resolveGitRepository, runGit } from './git-executor.js';
+
+export interface GitStatusOptions {
+  timeoutMs?: number;
+}
+
+export async function getGitRepoStatus(
+  workspace: string,
+  options: GitStatusOptions = {},
+): Promise<GitRepoStatus> {
+  const lastCheckedAt = Date.now();
+
+  try {
+    const repo = await resolveGitRepository(workspace, options);
+    const statusOutput = await runGit(repo, ['status', '--porcelain=v2', '--branch'], options);
+    const parsed = parsePorcelainV2Status(statusOutput.stdout);
+    const head = await readHead(repo, options);
+    const stashCount = await readStashCount(repo, options);
+
+    return {
+      workspace: repo.workspace,
+      repoRoot: repo.repoRoot,
+      isGitRepo: true,
+      branch: parsed.branch,
+      headCommit: head.commit,
+      headMessage: head.message,
+      upstream: parsed.upstream,
+      ahead: parsed.ahead,
+      behind: parsed.behind,
+      staged: parsed.staged,
+      modified: parsed.modified,
+      untracked: parsed.untracked,
+      deleted: parsed.deleted,
+      renamed: parsed.renamed,
+      hasConflicts: parsed.conflictFiles.length > 0,
+      conflictFiles: parsed.conflictFiles,
+      stashCount,
+      lastCheckedAt,
+    };
+  } catch (error) {
+    if (error instanceof GitCommandError) {
+      return emptyStatus(workspace, lastCheckedAt, error);
+    }
+    return emptyStatus(
+      workspace,
+      lastCheckedAt,
+      new GitCommandError('git_command_failed', 'Failed to read Git status', { cause: error }),
+    );
+  }
+}
+
+interface ParsedPorcelainStatus {
+  branch: string | null;
+  upstream: string | null;
+  ahead: number;
+  behind: number;
+  staged: number;
+  modified: number;
+  untracked: number;
+  deleted: number;
+  renamed: number;
+  conflictFiles: string[];
+}
+
+export function parsePorcelainV2Status(output: string): ParsedPorcelainStatus {
+  const parsed: ParsedPorcelainStatus = {
+    branch: null,
+    upstream: null,
+    ahead: 0,
+    behind: 0,
+    staged: 0,
+    modified: 0,
+    untracked: 0,
+    deleted: 0,
+    renamed: 0,
+    conflictFiles: [],
+  };
+
+  for (const line of output.split('\n')) {
+    if (!line) continue;
+
+    if (line.startsWith('# branch.head ')) {
+      const branch = line.slice('# branch.head '.length).trim();
+      parsed.branch = branch && branch !== '(detached)' ? branch : null;
+      continue;
+    }
+
+    if (line.startsWith('# branch.upstream ')) {
+      parsed.upstream = line.slice('# branch.upstream '.length).trim() || null;
+      continue;
+    }
+
+    if (line.startsWith('# branch.ab ')) {
+      const match = line.match(/\+(-?\d+)\s+-(-?\d+)/);
+      if (match) {
+        parsed.ahead = Number.parseInt(match[1] ?? '0', 10) || 0;
+        parsed.behind = Number.parseInt(match[2] ?? '0', 10) || 0;
+      }
+      continue;
+    }
+
+    if (line.startsWith('? ')) {
+      parsed.untracked += 1;
+      continue;
+    }
+
+    if (line.startsWith('u ')) {
+      const fields = line.split(' ');
+      const filePath = fields.slice(10).join(' ');
+      if (filePath) parsed.conflictFiles.push(filePath);
+      continue;
+    }
+
+    if (line.startsWith('1 ') || line.startsWith('2 ')) {
+      const fields = line.split(' ');
+      const xy = fields[1] ?? '..';
+      const indexStatus = xy[0] ?? '.';
+      const worktreeStatus = xy[1] ?? '.';
+
+      if (isStagedStatus(indexStatus)) parsed.staged += 1;
+      if (worktreeStatus === 'M' || worktreeStatus === 'T') parsed.modified += 1;
+      if (indexStatus === 'D' || worktreeStatus === 'D') parsed.deleted += 1;
+      if (indexStatus === 'R' || worktreeStatus === 'R') parsed.renamed += 1;
+      if (xy.includes('U')) {
+        const filePath = fields.slice(line.startsWith('2 ') ? 9 : 8).join(' ').split('\t')[0] ?? '';
+        if (filePath) parsed.conflictFiles.push(filePath);
+      }
+    }
+  }
+
+  parsed.conflictFiles = Array.from(new Set(parsed.conflictFiles));
+  return parsed;
+}
+
+async function readHead(
+  repo: { workspace: string; repoRoot: string | null; isGitRepo: boolean },
+  options: GitStatusOptions,
+): Promise<{ commit: string | null; message: string | null }> {
+  try {
+    const result = await runGit(repo, ['log', '-1', '--pretty=%h%x00%s'], options);
+    const text = result.stdout.trimEnd();
+    if (!text) return { commit: null, message: null };
+    const [commit, ...messageParts] = text.split('\0');
+    return {
+      commit: commit || null,
+      message: messageParts.join('\0') || null,
+    };
+  } catch {
+    return { commit: null, message: null };
+  }
+}
+
+async function readStashCount(
+  repo: { workspace: string; repoRoot: string | null; isGitRepo: boolean },
+  options: GitStatusOptions,
+): Promise<number> {
+  try {
+    const result = await runGit(repo, ['stash', 'list', '--format=%gd'], options);
+    return result.stdout.split('\n').filter((line) => line.trim().length > 0).length;
+  } catch {
+    return 0;
+  }
+}
+
+function isStagedStatus(status: string): boolean {
+  return status !== '.' && status !== '?' && status !== 'U';
+}
+
+function emptyStatus(workspace: string, lastCheckedAt: number, error: GitCommandError): GitRepoStatus {
+  return {
+    workspace,
+    repoRoot: null,
+    isGitRepo: false,
+    branch: null,
+    headCommit: null,
+    headMessage: null,
+    upstream: null,
+    ahead: 0,
+    behind: 0,
+    staged: 0,
+    modified: 0,
+    untracked: 0,
+    deleted: 0,
+    renamed: 0,
+    hasConflicts: false,
+    conflictFiles: [],
+    stashCount: 0,
+    lastCheckedAt,
+    error: error.stderr || error.message,
+    reason: error.reason,
+  };
+}

package/src/git/git-summary.ts

@@ -0,0 +1,43 @@
+import type { GitCompactSummary, GitDiffSummary, GitRepoStatus } from './git-types.js';
+
+function countStatusChangedFiles(status: GitRepoStatus): number {
+  const conflictCount = status.conflictFiles.length > 0 ? status.conflictFiles.length : status.hasConflicts ? 1 : 0;
+  return status.staged + status.modified + status.untracked + status.deleted + status.renamed + conflictCount;
+}
+
+/**
+ * Build the small Git shape suitable for session lists and topic summaries.
+ *
+ * This helper intentionally preserves non-git/error information as plain fields
+ * instead of turning expected states (for example `not_git_repo`) into alarming
+ * derived messages.
+ */
+export function createGitCompactSummary(status: GitRepoStatus, diffSummary?: GitDiffSummary): GitCompactSummary {
+  const statusChangedFiles = countStatusChangedFiles(status);
+  const diffChangedFiles = diffSummary?.files.length ?? 0;
+  const changedFiles = Math.max(statusChangedFiles, diffChangedFiles);
+  const conflictCount = status.conflictFiles.length > 0 ? status.conflictFiles.length : status.hasConflicts ? 1 : 0;
+
+  return {
+    isGitRepo: status.isGitRepo,
+    repoRoot: status.repoRoot,
+    branch: status.branch,
+    dirty:
+      status.staged > 0 ||
+      status.modified > 0 ||
+      status.untracked > 0 ||
+      status.deleted > 0 ||
+      status.renamed > 0 ||
+      conflictCount > 0 ||
+      changedFiles > 0,
+    changedFiles,
+    ahead: status.ahead,
+    behind: status.behind,
+    hasConflicts: status.hasConflicts || conflictCount > 0,
+    lastCheckedAt: Math.max(status.lastCheckedAt, diffSummary?.lastCheckedAt ?? status.lastCheckedAt),
+    error: status.error ?? diffSummary?.error,
+    reason: status.reason ?? diffSummary?.reason,
+  };
+}
+
+export const summarizeGitStatus = createGitCompactSummary;