@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.490

package/src/git/git-types.ts

@@ -6,69 +6,21 @@
  * infer these values from agent transcripts in frontend code.
  */
 
-export type GitFailureReason =
-  | 'not_git_repo'
-  | 'git_not_installed'
-  | 'timeout'
-  | 'path_outside_repo'
-  | 'dirty_index_required'
-  | 'conflict'
-  | 'invalid_args'
-  | 'nothing_to_commit'
-  | 'git_command_failed';
+// Pure shape types now live in @adhdev/mesh-shared so the cloud (web-core) and
+// standalone (daemon-core) transports share ONE definition instead of hand-syncing
+// two. Re-exported here so existing `from './git-types'` / package imports keep
+// working unchanged. Daemon-specific types (GitSnapshot, GitCommandName, …) stay
+// local below and consume these re-exports.
+export type {
+  GitFailureReason,
+  GitRepoIdentity,
+  GitSubmoduleStatus,
+  GitUpstreamFreshness,
+  GitRepoStatus,
+  DaemonBuildBehind,
+} from '@adhdev/mesh-shared';
 
-export interface GitRepoIdentity {
-  workspace: string;
-  repoRoot: string | null;
-  isGitRepo: boolean;
-}
-
-export interface GitSubmoduleStatus {
-  /** Submodule path relative to repo root */
-  path: string;
-  /** Current commit SHA the submodule is at */
-  commit: string;
-  /** Path to the submodule repo (absolute) */
-  repoPath: string;
-  /** Whether the submodule has uncommitted changes */
-  dirty: boolean;
-  /** Whether the submodule commit differs from what the parent repo expects */
-  outOfSync: boolean;
-  /** Last checked timestamp */
-  lastCheckedAt: number;
-  /** Error message if submodule status could not be read */
-  error?: string;
-}
-
-export type GitUpstreamFreshness = 'fresh' | 'unchecked' | 'stale' | 'no_upstream' | 'unavailable';
-
-export interface GitRepoStatus extends GitRepoIdentity {
-  branch: string | null;
-  headCommit: string | null;
-  headMessage: string | null;
-  upstream: string | null;
-  /** Whether ahead/behind was verified against a freshly fetched upstream ref. */
-  upstreamStatus: GitUpstreamFreshness;
-  /** Timestamp for the fetch that refreshed upstream refs when upstreamStatus === 'fresh'. */
-  upstreamFetchedAt?: number;
-  /** Error from the last refresh attempt when upstreamStatus === 'stale'. */
-  upstreamFetchError?: string;
-  ahead: number;
-  behind: number;
-  staged: number;
-  modified: number;
-  untracked: number;
-  deleted: number;
-  renamed: number;
-  hasConflicts: boolean;
-  conflictFiles: string[];
-  stashCount: number;
-  lastCheckedAt: number;
-  /** Submodule statuses when auto-discover is enabled */
-  submodules?: GitSubmoduleStatus[];
-  error?: string;
-  reason?: GitFailureReason;
-}
+import type { GitRepoIdentity, GitRepoStatus, GitFailureReason, GitUpstreamFreshness } from '@adhdev/mesh-shared';
 
 export type GitFileChangeStatus =
   | 'added'

package/src/git/git-worktree.ts

@@ -35,12 +35,62 @@ export interface WorktreeCreateOptions {
     meshName: string;
     /** Override the auto-resolved target directory */
     targetDir?: string;
+    /**
+     * Remote to fetch+compare the base branch against before branching.
+     * Default: 'origin'.
+     */
+    remote?: string;
+    /**
+     * When true (default) and `baseBranch` is given, fetch the base branch from
+     * `remote` and, if the local base branch is strictly behind the remote
+     * (no divergence), branch the worktree from the remote-tracking ref instead
+     * of the stale local ref. The decision is always surfaced via `baseSync`.
+     * Set false to preserve the legacy "branch from local ref, never fetch"
+     * behavior.
+     */
+    syncBaseFromRemote?: boolean;
+}
+
+/**
+ * How the worktree's start point was resolved relative to the remote base.
+ * Surfaced so the coordinator can detect a stale base node before dispatching
+ * work onto a worktree built on a behind/diverged base.
+ */
+export interface WorktreeBaseSync {
+    /** The base branch name requested (e.g. 'main'). */
+    branch: string;
+    /** The remote compared against (e.g. 'origin'). */
+    remote: string;
+    /** The actual ref/commit-ish used as the worktree branch start point. */
+    startRef: string;
+    /** Whether `git fetch <remote> <branch>` succeeded. */
+    fetched: boolean;
+    /** Local base-branch SHA before clone, if the local ref exists. */
+    localSha?: string;
+    /** Remote-tracking base-branch SHA after fetch, if it exists. */
+    remoteSha?: string;
+    /** Commits the local base ref is behind the remote (0 when up-to-date/ahead). */
+    behindBy: number;
+    /** Commits the local base ref is ahead of the remote. */
+    aheadBy: number;
+    /** What was done with the base ref. */
+    action:
+        | 'up_to_date'
+        | 'local_behind_used_remote'
+        | 'local_ahead_used_local'
+        | 'diverged_used_local'
+        | 'no_remote_ref_used_local'
+        | 'no_local_ref_used_remote';
+    /** Human-readable warning when the base was stale/diverged. */
+    warning?: string;
 }
 
 export interface WorktreeCreateResult {
     success: true;
     worktreePath: string;
     branch: string;
+    /** Present when `baseBranch` was given and base sync resolution ran. */
+    baseSync?: WorktreeBaseSync;
 }
 
 export interface WorktreeEntry {
@@ -83,15 +133,139 @@ export function resolveWorktreePath(repoRoot: string, meshName: string, branch:
     return path.join(parentDir, WORKTREE_DIR_NAME, safeMeshName, safeBranch);
 }
 
+// ─── Base sync (anti-stale-base) ─────────────────
+
+/** Run a git command, returning ok/stdout/stderr instead of throwing. */
+async function tryGit(cwd: string, args: string[]): Promise<{ ok: boolean; stdout: string; stderr: string }> {
+    try {
+        const { stdout, stderr } = await execFileAsync('git', args, {
+            cwd,
+            encoding: 'utf8',
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_BUFFER,
+            windowsHide: true,
+        });
+        return { ok: true, stdout: (stdout || '').trim(), stderr: (stderr || '').trim() };
+    } catch (error: any) {
+        return {
+            ok: false,
+            stdout: typeof error?.stdout === 'string' ? error.stdout.trim() : '',
+            stderr: typeof error?.stderr === 'string' ? error.stderr.trim() : (error?.message || ''),
+        };
+    }
+}
+
+/**
+ * Fetch the base branch from the remote and decide what to branch the new
+ * worktree from. Without this, `git worktree add -b <branch> main` always uses
+ * the local `refs/heads/main`, so a base node whose local main is behind a
+ * cross-machine-pushed origin/main produces a worktree on a STALE base —
+ * unaware of already-converged work, forcing a rebase before its push can
+ * fast-forward.
+ *
+ * Resolution (no history rewrite, never mutates the checked-out local branch):
+ *   - local strictly behind remote → branch from the remote-tracking ref.
+ *   - local ahead / up-to-date / no remote ref → branch from the local ref.
+ *   - diverged → branch from local + emit a warning for the coordinator.
+ */
+async function resolveWorktreeBaseStartPoint(
+    repoRoot: string,
+    baseBranch: string,
+    remote: string,
+): Promise<WorktreeBaseSync> {
+    const fetchResult = await tryGit(repoRoot, ['fetch', remote, baseBranch]);
+    const fetched = fetchResult.ok;
+
+    const localRev = await tryGit(repoRoot, ['rev-parse', '--verify', '--quiet', `refs/heads/${baseBranch}`]);
+    const remoteRev = await tryGit(repoRoot, ['rev-parse', '--verify', '--quiet', `refs/remotes/${remote}/${baseBranch}`]);
+    const localSha = localRev.ok && localRev.stdout ? localRev.stdout : undefined;
+    const remoteSha = remoteRev.ok && remoteRev.stdout ? remoteRev.stdout : undefined;
+    const remoteRef = `${remote}/${baseBranch}`;
+
+    const base: WorktreeBaseSync = {
+        branch: baseBranch,
+        remote,
+        startRef: baseBranch,
+        fetched,
+        localSha,
+        remoteSha,
+        behindBy: 0,
+        aheadBy: 0,
+        action: 'up_to_date',
+    };
+
+    const fetchWarn = fetched ? '' : ` (warning: git fetch ${remote} ${baseBranch} failed: ${fetchResult.stderr || 'unknown error'})`;
+
+    // No remote-tracking ref → nothing to compare; keep legacy local behavior.
+    if (!remoteSha) {
+        return {
+            ...base,
+            action: 'no_remote_ref_used_local',
+            ...(fetched ? {} : { warning: `Could not fetch ${remoteRef}${fetchWarn}; worktree branched from local ${baseBranch}.` }),
+        };
+    }
+
+    // Base branch only exists on the remote → branch from the remote ref.
+    if (!localSha) {
+        return {
+            ...base,
+            startRef: remoteRef,
+            action: 'no_local_ref_used_remote',
+        };
+    }
+
+    if (localSha === remoteSha) {
+        return base; // up_to_date
+    }
+
+    const localIsAncestor = (await tryGit(repoRoot, ['merge-base', '--is-ancestor', localSha, remoteSha])).ok;
+    const remoteIsAncestor = (await tryGit(repoRoot, ['merge-base', '--is-ancestor', remoteSha, localSha])).ok;
+    const behindBy = Number((await tryGit(repoRoot, ['rev-list', '--count', `${localSha}..${remoteSha}`])).stdout) || 0;
+    const aheadBy = Number((await tryGit(repoRoot, ['rev-list', '--count', `${remoteSha}..${localSha}`])).stdout) || 0;
+
+    if (localIsAncestor && !remoteIsAncestor) {
+        // Local strictly behind — THE stale-base fix: branch from the remote tip.
+        return {
+            ...base,
+            startRef: remoteRef,
+            behindBy,
+            aheadBy,
+            action: 'local_behind_used_remote',
+            warning: `Base node local ${baseBranch} was behind ${remoteRef} by ${behindBy} commit(s); worktree branched from ${remoteRef} (${remoteSha.slice(0, 8)}) instead of stale local ${localSha.slice(0, 8)}.${fetchWarn}`,
+        };
+    }
+
+    if (remoteIsAncestor) {
+        // Local ahead of remote (or remote is an ancestor) — local has the newer work.
+        return { ...base, behindBy, aheadBy, action: 'local_ahead_used_local' };
+    }
+
+    // Diverged: neither is an ancestor of the other. Don't silently pick a side —
+    // keep local (preserve local-only commits) and warn so the coordinator rebases.
+    return {
+        ...base,
+        behindBy,
+        aheadBy,
+        action: 'diverged_used_local',
+        warning: `Base node local ${baseBranch} (${localSha.slice(0, 8)}) has DIVERGED from ${remoteRef} (${remoteSha.slice(0, 8)}): behind ${behindBy}, ahead ${aheadBy}. Worktree branched from local; a rebase onto ${remoteRef} will be required before its push can fast-forward.${fetchWarn}`,
+    };
+}
+
 // ─── Create ─────────────────────────────────────
 
 /**
  * Create a new git worktree with a fresh branch.
  *
- * Runs: git worktree add <targetDir> -b <branch> [baseBranch]
+ * Runs: git worktree add <targetDir> -b <branch> [startRef]
+ *
+ * When `baseBranch` is given and `syncBaseFromRemote` is not disabled, the
+ * start point is resolved against the remote first (see
+ * resolveWorktreeBaseStartPoint) so a stale local base does not produce a stale
+ * worktree. The resolution is returned as `baseSync`.
  */
 export async function createWorktree(opts: WorktreeCreateOptions): Promise<WorktreeCreateResult> {
     const { repoRoot, branch, baseBranch, meshName } = opts;
+    const remote = (opts.remote || 'origin').trim() || 'origin';
     const targetDir = opts.targetDir || resolveWorktreePath(repoRoot, meshName, branch);
 
     if (existsSync(targetDir)) {
@@ -101,9 +275,16 @@ export async function createWorktree(opts: WorktreeCreateOptions): Promise<Workt
     // Ensure parent directory exists
     await mkdir(path.dirname(targetDir), { recursive: true });
 
+    let baseSync: WorktreeBaseSync | undefined;
+    let startRef = baseBranch;
+    if (baseBranch && opts.syncBaseFromRemote !== false) {
+        baseSync = await resolveWorktreeBaseStartPoint(repoRoot, baseBranch, remote);
+        startRef = baseSync.startRef;
+    }
+
     const args = ['worktree', 'add', targetDir, '-b', branch];
-    if (baseBranch) {
-        args.push(baseBranch);
+    if (startRef) {
+        args.push(startRef);
     }
 
     try {
@@ -116,8 +297,11 @@ export async function createWorktree(opts: WorktreeCreateOptions): Promise<Workt
         });
     } catch (error: any) {
         const stderr = typeof error.stderr === 'string' ? error.stderr : '';
-        // Clean error messages for common failures
         if (/already exists/i.test(stderr)) {
+            // Distinguish directory-collision (TOCTOU race) from branch-already-exists
+            if (existsSync(targetDir)) {
+                throw new Error(`Worktree target directory was created concurrently: ${targetDir}`);
+            }
             throw new Error(`Branch '${branch}' already exists or is checked out in another worktree`);
         }
         throw new Error(`git worktree add failed: ${stderr.trim() || error.message}`);
@@ -127,6 +311,7 @@ export async function createWorktree(opts: WorktreeCreateOptions): Promise<Workt
         success: true,
         worktreePath: targetDir,
         branch,
+        ...(baseSync ? { baseSync } : {}),
     };
 }
 
@@ -170,6 +355,10 @@ export async function removeWorktree(repoRoot: string, worktreePath: string, opt
         const stdout = typeof error.stdout === 'string' ? error.stdout : '';
         const detail = `${stderr}\n${stdout}\n${error.message || ''}`;
         if (opts.allowSubmoduleForceFallback && SUBMODULE_WORKTREE_REMOVE_RE.test(detail)) {
+            process.stderr.write(
+                `[adhdev-mesh] WARNING: git worktree remove --force fallback for submodule worktree '${worktreePath}'. `
+                + `Any uncommitted changes inside submodules will be lost.\n`,
+            );
             try {
                 await execFileAsync('git', ['worktree', 'remove', '--force', worktreePath], {
                     cwd: repoRoot,
@@ -250,6 +439,74 @@ export function parseWorktreeListOutput(output: string): WorktreeEntry[] {
     return entries;
 }
 
+// ─── Branch ref deletion ────────────────────────
+
+export interface BranchRefDeleteResult {
+    /** True if the branch ref no longer exists after this call. */
+    deleted: boolean;
+    /** Why it was (not) deleted, for surfacing in the cleanup result. */
+    reason: string;
+    /** True when a forced delete (`-D`) was needed (e.g. squash/patch-equivalent merge). */
+    forced?: boolean;
+}
+
+/**
+ * Delete a local branch ref after its worktree was removed.
+ *
+ * SAFETY: this is only meant to be called once the caller has independently
+ * verified that the branch is fully merged / its content is contained in the
+ * default ref (no work loss). It first tries the safe `git branch -d`, which
+ * refuses to delete a branch git itself does not consider merged. If
+ * `safeDeleteOnly` is false (the caller proved containment by patch-equivalence,
+ * which `-d` cannot see), it falls back to `git branch -D`. When the branch is
+ * already gone, this reports `deleted: true` idempotently.
+ */
+export async function deleteBranchRef(
+    repoRoot: string,
+    branch: string,
+    opts: { safeDeleteOnly?: boolean } = {},
+): Promise<BranchRefDeleteResult> {
+    const name = (branch || '').trim();
+    if (!name) return { deleted: false, reason: 'empty_branch_name' };
+
+    // Idempotent: nothing to delete if the ref does not exist.
+    try {
+        await execFileAsync('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${name}`], {
+            cwd: repoRoot, encoding: 'utf8', timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER, windowsHide: true,
+        });
+    } catch {
+        return { deleted: true, reason: 'branch_ref_absent' };
+    }
+
+    // Try the safe delete first — git refuses if it cannot see the branch as merged.
+    try {
+        await execFileAsync('git', ['branch', '-d', name], {
+            cwd: repoRoot, encoding: 'utf8', timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER, windowsHide: true,
+        });
+        return { deleted: true, reason: 'safe_deleted_merged_branch' };
+    } catch (error: any) {
+        const stderr = typeof error?.stderr === 'string' ? error.stderr : '';
+        const notMerged = /not fully merged/i.test(stderr) || /not fully merged/i.test(String(error?.message || ''));
+        if (!notMerged) {
+            return { deleted: false, reason: `branch_delete_failed: ${stderr.trim() || error?.message || 'unknown error'}` };
+        }
+        // git -d refused. Only force when the caller proved containment another way
+        // (e.g. squash/cherry-pick/patch-equivalent merge that -d cannot detect).
+        if (opts.safeDeleteOnly) {
+            return { deleted: false, reason: 'branch_not_merged_per_git_safe_delete_only' };
+        }
+        try {
+            await execFileAsync('git', ['branch', '-D', name], {
+                cwd: repoRoot, encoding: 'utf8', timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER, windowsHide: true,
+            });
+            return { deleted: true, reason: 'force_deleted_patch_equivalent_branch', forced: true };
+        } catch (forceError: any) {
+            const fErr = typeof forceError?.stderr === 'string' ? forceError.stderr : forceError?.message;
+            return { deleted: false, reason: `branch_force_delete_failed: ${String(fErr || 'unknown error').trim()}` };
+        }
+    }
+}
+
 // ─── Prune ──────────────────────────────────────
 
 async function pruneWorktrees(repoRoot: string): Promise<void> {

package/src/git/index.ts

@@ -26,6 +26,22 @@ export type { GitCommandResult as GitExecutorCommandResult, GitExecutorOptions,
 export { getGitRepoStatus, parsePorcelainV2Status } from './git-status.js';
 export type { GitStatusOptions } from './git-status.js';
 
+export {
+  CHANGE_IMPACT_CONFIG_LOCATIONS,
+  CHANGE_IMPACT_CONFIG_SCHEMA,
+  globToRegExp,
+  loadChangeImpactConfig,
+  suggestChangeImpactConfig,
+  validateChangeImpactConfig,
+} from './change-impact-config.js';
+export type {
+  ChangeImpactConfig,
+  ChangeImpactConfigLoadResult,
+  ChangeImpactConfigSuggestion,
+  ChangeImpactKind,
+  ChangeImpactTarget,
+} from './change-impact-config.js';
+
 export { getGitDiffSummary, getGitFileDiff } from './git-diff.js';
 export type { GitDiffOptions, GitFileDiffResult } from './git-diff.js';
 
@@ -82,6 +98,7 @@ export {
   resolveWorktreePath,
 } from './git-worktree.js';
 export type {
+  WorktreeBaseSync,
   WorktreeCreateOptions,
   WorktreeCreateResult,
   WorktreeEntry,