@adhdev/daemon-core 0.9.82-rc.32 → 0.9.82-rc.320

package/src/detection/ide-detector.ts

@@ -7,11 +7,14 @@
  * Migrated from @adhdev/core — this is now the single source of truth.
  */
 
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+import { existsSync, statSync } from 'fs';
 import { platform, homedir } from 'os';
 import * as path from 'path';
 import type { ProviderLoader } from '../providers/provider-loader.js';
+import { isKnownWin32GuiExe, readWin32IdeVersionFromDisk } from './win32-ide-version.js';
 
 // ─── Types ──────────────────────────────────────
 
@@ -73,25 +76,54 @@ function findCliCommand(command: string): string | null {
         const resolved = path.isAbsolute(candidate) ? candidate : path.resolve(candidate);
         return existsSync(resolved) ? resolved : null;
     }
-    try {
-        const result = execSync(
-            platform() === 'win32' ? `where ${trimmed}` : `which ${trimmed}`,
-            { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
-        ).trim();
-        return result.split('\n')[0] || null;
-    } catch {
-        return null;
+    const isWin = platform() === 'win32';
+    const paths = (process.env.PATH || '').split(isWin ? ';' : ':');
+    const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+    for (const p of paths) {
+        if (!p) continue;
+        for (const ext of exes) {
+            const fullPath = path.join(p, trimmed + ext);
+            try {
+                if (existsSync(fullPath)) {
+                    const stat = statSync(fullPath);
+                    if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+                        return fullPath;
+                    }
+                }
+            } catch { }
+        }
     }
+    return null;
 }
 
-function getIdeVersion(cliCommand: string): string | null {
+/**
+ * Resolve an IDE version on demand (NOT at boot).
+ *
+ * Order of preference, all spawn-free where possible:
+ *  1. win32: read the bundled product.json/package.json next to the exe.
+ *  2. Otherwise spawn `<cli> --version` — but ONLY when the binary is not a
+ *     known GUI executable (the #4 guard), so we never boot an IDE window.
+ *
+ * `win32ProcessNames` is provider.json `processNames.win32` (type → exe names),
+ * used to recognise GUI executables. Callers that have a ProviderLoader can
+ * pass `providerLoader.getWinProcessNames()`.
+ */
+export async function getIdeVersion(
+    cliCommand: string,
+    win32ProcessNames: Record<string, string[]> = {},
+): Promise<string | null> {
+    if (platform() === 'win32') {
+        const fromDisk = readWin32IdeVersionFromDisk(cliCommand);
+        if (fromDisk) return fromDisk;
+        // Refuse to spawn a known GUI exe — it would launch the IDE window.
+        if (isKnownWin32GuiExe(cliCommand, win32ProcessNames)) return null;
+    }
     try {
-        const result = execSync(`"${cliCommand}" --version`, {
+        const { stdout } = await execAsync(`"${cliCommand}" --version`, {
             encoding: 'utf-8',
             timeout: 10000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-        return result.split('\n')[0] || null;
+        });
+        return stdout.trim().split('\n')[0] || null;
     } catch {
         return null;
     }
@@ -152,7 +184,14 @@ export async function detectIDEs(providerLoader?: ProviderLoader): Promise<IDEIn
         const installed = os === 'darwin'
             ? !!(resolvedCli || appPath)
             : !!resolvedCli;
-        const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
+        // Boot-time IDE detection must NOT spawn `<cli> --version`. On Windows
+        // the resolved "CLI" is frequently the GUI Electron exe (case-insensitive
+        // FS matches `...\cursor\cursor.exe` against `Cursor.exe`), and running it
+        // with `--version` boots the IDE window. `installed` is decided purely by
+        // existsSync above, and the dashboard drops `version` anyway — the only
+        // real version consumer is provider-loader.resolve() at CDP attach time,
+        // which fetches the version lazily. So leave it null here.
+        const version: string | null = null;
 
         results.push({
             id: def.id,

package/src/detection/win32-ide-version.ts

@@ -0,0 +1,106 @@
+/**
+ * ADHDev — Windows IDE version detection (execution-free)
+ *
+ * On Windows the resolved "CLI" for a VS Code fork (Cursor, Antigravity, …)
+ * frequently resolves to the GUI Electron executable itself, because the
+ * case-insensitive filesystem matches `...\cursor\cursor.exe` against the
+ * real `Cursor.exe`. Running `<that exe> --version` boots the GUI instead of
+ * printing a version (Electron ignores the unknown flag and opens a window).
+ *
+ * To learn the version WITHOUT spawning anything, we read the bundled
+ * `product.json` / `package.json` that ship next to the executable. VS Code
+ * forks embed their version there. This is a pure filesystem read.
+ *
+ * It also exposes a guard so any remaining `--version` exec path can refuse to
+ * spawn a binary that is a known GUI executable for an IDE provider.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Candidate locations for the version manifest relative to the GUI exe dir.
+ * VS Code forks place `resources/app/{product,package}.json` next to the exe.
+ */
+function manifestCandidates(exeDir: string): string[] {
+  return [
+    path.join(exeDir, 'resources', 'app', 'product.json'),
+    path.join(exeDir, 'resources', 'app', 'package.json'),
+    // Some packagings keep product.json one level up.
+    path.join(exeDir, 'product.json'),
+  ];
+}
+
+function parseVersionFromManifest(raw: string): string | null {
+  try {
+    const json = JSON.parse(raw) as Record<string, unknown>;
+    // product.json forks expose the IDE's own version here; package.json
+    // exposes the upstream VS Code engine version. Prefer the former.
+    const candidate = json.version;
+    if (typeof candidate === 'string' && candidate.trim()) {
+      return candidate.trim();
+    }
+  } catch {
+    /* not valid JSON — ignore */
+  }
+  return null;
+}
+
+/**
+ * Read an IDE version from disk (no process spawn).
+ *
+ * @param exePath Absolute path to the GUI executable (or any path inside the
+ *   IDE install dir — we read the manifest relative to its directory).
+ * @returns The version string, or null if it could not be determined.
+ */
+export function readWin32IdeVersionFromDisk(exePath: string): string | null {
+  if (!exePath) return null;
+  let exeDir: string;
+  try {
+    exeDir = fs.statSync(exePath).isDirectory() ? exePath : path.dirname(exePath);
+  } catch {
+    exeDir = path.dirname(exePath);
+  }
+  for (const candidate of manifestCandidates(exeDir)) {
+    try {
+      if (!fs.existsSync(candidate)) continue;
+      const version = parseVersionFromManifest(fs.readFileSync(candidate, 'utf-8'));
+      if (version) return version;
+    } catch {
+      /* ignore unreadable manifest */
+    }
+  }
+  return null;
+}
+
+/**
+ * True when `binPath` resolves to a known GUI executable for some IDE.
+ *
+ * Used as a safety net: any code path about to run `<bin> --version` must skip
+ * the spawn when the binary is actually the GUI Electron exe, since that would
+ * launch the IDE window. Comparison is case-insensitive on the basename
+ * (Windows filesystem semantics) against every provider's `processNames.win32`.
+ *
+ * @param binPath Resolved binary path that would be exec'd.
+ * @param win32ProcessNames Map of provider type → list of GUI exe names
+ *   (from provider.json `processNames.win32`, e.g. `["Cursor.exe"]`).
+ */
+export function isKnownWin32GuiExe(
+  binPath: string | null | undefined,
+  win32ProcessNames: Record<string, string[]>,
+): boolean {
+  if (!binPath) return false;
+  // Use win32 basename semantics regardless of host OS: this matches Windows
+  // paths even when the daemon-core test/CI host is POSIX (where `/` is the
+  // only separator). On the real win32 target this is identical to basename().
+  const base = path.win32.basename(binPath).toLowerCase();
+  if (!base.endsWith('.exe')) return false;
+  for (const names of Object.values(win32ProcessNames)) {
+    for (const name of names) {
+      if (typeof name === 'string' && name.toLowerCase() === base) {
+        return true;
+      }
+    }
+  }
+  return false;
+}

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;
@@ -172,8 +176,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 +294,22 @@ 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) }));
+      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));
       return 'success' in status ? status : { success: true, status };
     }
 
     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 };
     }
 
@@ -442,6 +455,15 @@ async function gitCheckpoint(
   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 +477,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 +498,7 @@ async function gitCheckpoint(
     isGitRepo: true,
     commit: commitSha,
     message: fullMsg,
+    status: 'created',
     lastCheckedAt: Date.now(),
   };
 }

package/src/git/git-diff.ts

@@ -10,6 +10,20 @@ 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;
+}
+
+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 {
@@ -44,6 +58,30 @@ export async function getGitDiffSummary(
   try {
     const repo = await resolveGitRepository(workspace, options);
     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, '--'], { ...options, cwd: repoRoot }),
+        runGit(repo, ['diff', '--no-ext-diff', '--numstat', range, '--'], { ...options, 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 }),
@@ -106,6 +144,21 @@ export async function getGitFileDiff(
   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], { ...options, 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 }),

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;