@adhdev/daemon-core 0.9.82-rc.45 → 0.9.82-rc.450

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/change-impact-config.ts

@@ -0,0 +1,354 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+import * as yaml from 'js-yaml';
+
+/**
+ * "Change Impact" — config-driven classification of which git changes between the
+ * live daemon's build commit and the workspace HEAD actually require a daemon
+ * rebuild/restart (vs. a web-only redeploy, vs. nothing).
+ *
+ * The daemon-core git surface only knows the FACTS (which files / packages changed
+ * between buildCommit..HEAD). The POLICY — which packages are daemon-runtime, which
+ * are web-only, which root files are non-runtime, and what command to recommend —
+ * is declarative config injected from outside. This keeps git-status.ts repo-agnostic
+ * while preserving ADHDev's exact built-in behavior when no config is present.
+ *
+ * SECURITY: config is declarative only. JSON/YAML are parsed; arbitrary JS config
+ * (.js) is intentionally NOT supported, so loading a config can never execute code.
+ */
+
+/** A change-impact classification bucket. */
+export type ChangeImpactKind = 'daemon' | 'web' | 'none';
+
+/**
+ * Recommended action for a given impact classification. `recommendedAction` is the
+ * stable classification key (always one of daemon|web|none, NOT config-overridable);
+ * config customizes only the human-facing `recommendedCommand` recipe.
+ */
+export interface ChangeImpactTarget {
+    /** Human-facing command/recipe to act on the impact (e.g. deploy + restart). */
+    recommendedCommand: string;
+}
+
+export interface ChangeImpactConfig {
+    /**
+     * Package names (the `<name>` in `packages/<name>/`) whose change means the
+     * daemon runtime is stale and must be rebuilt/redeployed + restarted. When
+     * provided, this REPLACES the built-in daemon-runtime set.
+     */
+    daemonRuntimePackages?: string[];
+    /**
+     * Package names that are web-only — a change to one does not require a daemon
+     * restart, only a web redeploy. When provided, this REPLACES the built-in
+     * web-only set.
+     */
+    webOnlyPackages?: string[];
+    /**
+     * Glob patterns for root-level (non-package) files that demonstrably cannot
+     * change what the daemon runtime executes (markers, docs, license text). These
+     * are added on top of the built-in non-runtime root-file detection.
+     */
+    nonRuntimeRootFilePatterns?: string[];
+    /** Recommended action/command per impact classification. Missing keys fall back to built-in defaults. */
+    impactTargets?: Partial<Record<ChangeImpactKind, ChangeImpactTarget>>;
+}
+
+export interface ChangeImpactConfigLoadResult {
+    config?: ChangeImpactConfig;
+    source: string;
+    sourceType: 'repo_file' | 'unavailable' | 'invalid';
+    path?: string;
+    error?: string;
+    /**
+     * Stable identity of the config SOURCE, used as part of a cache key so a config
+     * edit invalidates any cached impact evaluation. Combines the resolved path and
+     * its mtime (or the path for the unavailable/invalid case).
+     */
+    sourceKey: string;
+}
+
+export const CHANGE_IMPACT_CONFIG_LOCATIONS = [
+    '.adhdev/change-impact.json',
+    '.adhdev/change-impact.yaml',
+    '.adhdev/change-impact.yml',
+    '.adhdev/repo-mesh-change-impact.json',
+    '.adhdev/repo-mesh-change-impact.yaml',
+    '.adhdev/repo-mesh-change-impact.yml',
+];
+
+export const CHANGE_IMPACT_CONFIG_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    title: 'ADHDev Change Impact Config',
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        daemonRuntimePackages: { type: 'array', items: { type: 'string', minLength: 1 } },
+        webOnlyPackages: { type: 'array', items: { type: 'string', minLength: 1 } },
+        nonRuntimeRootFilePatterns: { type: 'array', items: { type: 'string', minLength: 1 } },
+        impactTargets: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                daemon: { $ref: '#/$defs/target' },
+                web: { $ref: '#/$defs/target' },
+                none: { $ref: '#/$defs/target' },
+            },
+        },
+    },
+    $defs: {
+        target: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['recommendedCommand'],
+            properties: {
+                recommendedCommand: { type: 'string', minLength: 1 },
+            },
+        },
+    },
+} as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isStringArray(value: unknown): value is string[] {
+    return Array.isArray(value) && value.every(v => typeof v === 'string' && v.length > 0);
+}
+
+function validateTarget(value: unknown, key: string, errors: string[]): ChangeImpactTarget | undefined {
+    if (!isRecord(value)) {
+        errors.push(`impactTargets.${key} must be an object`);
+        return undefined;
+    }
+    const { recommendedCommand } = value;
+    if (typeof recommendedCommand !== 'string' || !recommendedCommand.length) {
+        errors.push(`impactTargets.${key}.recommendedCommand must be a non-empty string`);
+        return undefined;
+    }
+    // recommendedAction is the fixed classification key; config supplies only the command.
+    for (const k of Object.keys(value)) {
+        if (k !== 'recommendedCommand') errors.push(`impactTargets.${key}.${k} is not a recognized field (only recommendedCommand)`);
+    }
+    return { recommendedCommand };
+}
+
+export function validateChangeImpactConfig(raw: unknown, source = 'inline'): { valid: boolean; errors: string[]; config?: ChangeImpactConfig } {
+    const errors: string[] = [];
+    if (!isRecord(raw)) {
+        return { valid: false, errors: [`${source}: config must be an object`] };
+    }
+    const config: ChangeImpactConfig = {};
+
+    if (raw.daemonRuntimePackages !== undefined) {
+        if (isStringArray(raw.daemonRuntimePackages)) config.daemonRuntimePackages = [...raw.daemonRuntimePackages];
+        else errors.push('daemonRuntimePackages must be an array of non-empty strings');
+    }
+    if (raw.webOnlyPackages !== undefined) {
+        if (isStringArray(raw.webOnlyPackages)) config.webOnlyPackages = [...raw.webOnlyPackages];
+        else errors.push('webOnlyPackages must be an array of non-empty strings');
+    }
+    if (raw.nonRuntimeRootFilePatterns !== undefined) {
+        if (isStringArray(raw.nonRuntimeRootFilePatterns)) config.nonRuntimeRootFilePatterns = [...raw.nonRuntimeRootFilePatterns];
+        else errors.push('nonRuntimeRootFilePatterns must be an array of non-empty strings');
+    }
+    if (raw.impactTargets !== undefined) {
+        if (!isRecord(raw.impactTargets)) {
+            errors.push('impactTargets must be an object');
+        } else {
+            const targets: Partial<Record<ChangeImpactKind, ChangeImpactTarget>> = {};
+            for (const key of Object.keys(raw.impactTargets)) {
+                if (key !== 'daemon' && key !== 'web' && key !== 'none') {
+                    errors.push(`impactTargets.${key} is not a recognized impact kind (daemon|web|none)`);
+                    continue;
+                }
+                const target = validateTarget(raw.impactTargets[key], key, errors);
+                if (target) targets[key as ChangeImpactKind] = target;
+            }
+            if (Object.keys(targets).length) config.impactTargets = targets;
+        }
+    }
+    // Reject unknown top-level keys to catch typos early (mirrors additionalProperties:false).
+    for (const key of Object.keys(raw)) {
+        if (!['daemonRuntimePackages', 'webOnlyPackages', 'nonRuntimeRootFilePatterns', 'impactTargets'].includes(key)) {
+            errors.push(`unknown config key '${key}'`);
+        }
+    }
+
+    return { valid: errors.length === 0, errors, config: errors.length === 0 ? config : undefined };
+}
+
+function parseConfigText(path: string, text: string): unknown {
+    if (/\.json$/i.test(path)) return JSON.parse(text);
+    return yaml.load(text);
+}
+
+/**
+ * Locate and load the Change Impact config for a repo root. Declarative only —
+ * never executes config. Returns a sourceKey suitable for cache invalidation:
+ * config path + mtime, or the sentinel for the missing/invalid case.
+ */
+export function loadChangeImpactConfig(repoRoot: string): ChangeImpactConfigLoadResult {
+    for (const relative of CHANGE_IMPACT_CONFIG_LOCATIONS) {
+        const configPath = join(repoRoot, relative);
+        if (!existsSync(configPath)) continue;
+        try {
+            const text = readFileSync(configPath, 'utf-8');
+            let mtimeMs = 0;
+            try {
+                mtimeMs = statSync(configPath).mtimeMs;
+            } catch {
+                // Best-effort; fall back to content length so edits still perturb the key.
+                mtimeMs = text.length;
+            }
+            const parsed = parseConfigText(configPath, text);
+            const validation = validateChangeImpactConfig(parsed, relative);
+            if (!validation.valid) {
+                return {
+                    source: relative,
+                    sourceType: 'invalid',
+                    path: configPath,
+                    error: validation.errors.join('; '),
+                    sourceKey: `invalid:${configPath}:${mtimeMs}`,
+                };
+            }
+            return {
+                config: validation.config,
+                source: relative,
+                sourceType: 'repo_file',
+                path: configPath,
+                sourceKey: `file:${configPath}:${mtimeMs}`,
+            };
+        } catch (error: any) {
+            return {
+                source: relative,
+                sourceType: 'invalid',
+                path: configPath,
+                error: error?.message || String(error),
+                sourceKey: `error:${configPath}`,
+            };
+        }
+    }
+    return {
+        source: 'unavailable',
+        sourceType: 'unavailable',
+        error: `No change-impact config found. Checked: ${CHANGE_IMPACT_CONFIG_LOCATIONS.join(', ')}`,
+        sourceKey: 'unavailable',
+    };
+}
+
+/**
+ * Translate a config glob pattern into a RegExp matched against a forward-slash
+ * file path. Supports `**` (any path segments), `*` (any chars except `/`), and
+ * `?` (single non-slash char). No brace/character-class expansion — declarative,
+ * minimal, predictable. All other characters are matched literally.
+ */
+export function globToRegExp(pattern: string): RegExp {
+    let out = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                // `**` → any sequence of characters including path separators.
+                out += '.*';
+                i++;
+                // Swallow a trailing slash after `**/` so `**/x` also matches `x`.
+                if (pattern[i + 1] === '/') i++;
+            } else {
+                out += '[^/]*';
+            }
+        } else if (ch === '?') {
+            out += '[^/]';
+        } else if ('.+^${}()|[]\\'.includes(ch)) {
+            out += '\\' + ch;
+        } else {
+            out += ch;
+        }
+    }
+    return new RegExp(`^${out}$`);
+}
+
+export interface ChangeImpactConfigSuggestion {
+    /** A non-executable, declarative config draft a human can save verbatim. */
+    suggestedConfig: ChangeImpactConfig;
+    /** Per-field human-facing rationale for the proposed classification. */
+    notes: string[];
+    /** Package directories discovered under `packages/` (and `oss/packages/`). */
+    discoveredPackages: { daemon: string[]; web: string[]; unclassified: string[] };
+}
+
+function listPackageDirs(packagesRoot: string): string[] {
+    try {
+        return readdirSync(packagesRoot, { withFileTypes: true })
+            .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+            .map(entry => entry.name);
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Inspect a repo's package layout and propose a reasonable, declarative Change
+ * Impact config draft. This is heuristic scaffold ONLY — it never executes
+ * anything and the draft must be reviewed/saved by a human before it takes
+ * effect. The heuristic mirrors ADHDev's own conventions:
+ *   - `web-*` / `*-web` packages → web-only (web redeploy, no daemon restart)
+ *   - everything else under packages/ → daemon-runtime (rebuild + restart)
+ *   - docs/license/marker root files → non-runtime
+ * Callers are expected to prune the draft to their actual runtime topology.
+ */
+export function suggestChangeImpactConfig(repoRoot: string): ChangeImpactConfigSuggestion {
+    const notes: string[] = [];
+    const daemon = new Set<string>();
+    const web = new Set<string>();
+    const unclassified: string[] = [];
+
+    const roots = ['packages', join('oss', 'packages')];
+    for (const rel of roots) {
+        const packagesRoot = join(repoRoot, rel);
+        if (!existsSync(packagesRoot)) continue;
+        for (const name of listPackageDirs(packagesRoot)) {
+            if (/(^web[-.]|[-.]web$)/i.test(name) || /dashboard|frontend|ui$/i.test(name)) {
+                web.add(name);
+            } else {
+                daemon.add(name);
+            }
+        }
+    }
+
+    const daemonRuntimePackages = [...daemon].sort();
+    const webOnlyPackages = [...web].sort();
+
+    if (!daemonRuntimePackages.length && !webOnlyPackages.length) {
+        notes.push('No packages/ or oss/packages/ directories found — defaulting to an empty draft you should fill in by hand.');
+    } else {
+        if (daemonRuntimePackages.length) notes.push(`Classified ${daemonRuntimePackages.length} package(s) as daemon-runtime (change → rebuild/redeploy + restart).`);
+        if (webOnlyPackages.length) notes.push(`Classified ${webOnlyPackages.length} web-* package(s) as web-only (change → web redeploy, no daemon restart).`);
+        notes.push('Heuristic only: confirm each package actually matches its bucket before saving.');
+    }
+
+    const nonRuntimeRootFilePatterns = [
+        '*.md',
+        'docs/**',
+        'LICENSE',
+        'LICENSE.*',
+        '.gitignore',
+    ];
+    notes.push('nonRuntimeRootFilePatterns lists root files that demonstrably cannot change daemon runtime behavior; extend with your repo markers.');
+
+    const suggestedConfig: ChangeImpactConfig = {
+        ...(daemonRuntimePackages.length ? { daemonRuntimePackages } : {}),
+        ...(webOnlyPackages.length ? { webOnlyPackages } : {}),
+        nonRuntimeRootFilePatterns,
+        impactTargets: {
+            daemon: { recommendedCommand: 'rebuild + redeploy the daemon, then restart it' },
+            web: { recommendedCommand: 'redeploy the web app (no daemon restart required)' },
+            none: { recommendedCommand: 'no action required' },
+        },
+    };
+
+    return {
+        suggestedConfig,
+        notes,
+        discoveredPackages: { daemon: daemonRuntimePackages, web: webOnlyPackages, unclassified },
+    };
+}