cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/storage/git.js

@@ -0,0 +1,555 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInferredRepoName = exports.parseRepoNameFromUrl = exports.sanitizeRepoName = exports.getCurrentBranch = exports.getDefaultBranch = exports.getRemoteOriginUrl = exports.hasGitDir = exports.findGitRootByDotGit = exports.resolveRepoIdentityRoot = exports.getCoreExcludesFilePath = exports.getGitInfoExcludePath = exports.getCanonicalRepoRoot = exports.getGitRoot = exports.getRemoteUrl = exports.getCurrentCommit = exports.isGitRepo = exports.isWorkingTreeDirty = void 0;
+exports.parseDiffHunks = parseDiffHunks;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+// Git utilities for repository detection, commit tracking, and diff analysis
+const chompGitOutput = (value) => value.toString().replace(/\r?\n$/, '');
+/**
+ * True when the working tree has uncommitted changes that analyze would
+ * re-index, even at a matching HEAD. Excludes the paths GitNexus writes during
+ * analyze (.cgraphx/, .claude/, .cursor/, AGENTS.md, CLAUDE.md, and the
+ * repo-local .agents/ mirror) so its own output never counts as dirty
+ * (regression vs PR #1233 behavior). The entire .agents/ tree is excluded,
+ * matching the .claude/ treatment, because the skill mirror writes across
+ * .agents/skills/ and deeper paths. Conservative on any git failure. Shared
+ * so `analyze`'s fast-path gate and `status`'s freshness report agree on what
+ * "dirty" means.
+ */
+const isWorkingTreeDirty = (repoPath) => {
+    try {
+        const out = (0, child_process_1.execFileSync)('git', [
+            'status',
+            '--porcelain',
+            '--',
+            '.',
+            ':(exclude).cgraphx',
+            ':(exclude).cgraphx/**',
+            ':(exclude).claude',
+            ':(exclude).claude/**',
+            ':(exclude).cursor',
+            ':(exclude).cursor/**',
+            ':(exclude)AGENTS.md',
+            ':(exclude)CLAUDE.md',
+            ':(exclude).agents',
+            ':(exclude).agents/**',
+        ], {
+            cwd: repoPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+            encoding: 'utf8',
+        });
+        return out.trim().length > 0;
+    }
+    catch {
+        return true; // conservative on git failure
+    }
+};
+exports.isWorkingTreeDirty = isWorkingTreeDirty;
+const isGitRepo = (repoPath) => {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', {
+            cwd: repoPath,
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isGitRepo = isGitRepo;
+const getCurrentCommit = (repoPath) => {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse HEAD', {
+            cwd: repoPath,
+            // Suppress stderr -- without an explicit stdio option, Node's execSync
+            // forwards the child's stderr to the parent process (documented behaviour).
+            // When repoPath is not inside a git worktree, git prints
+            // "fatal: not a git repository" to stderr, which leaks to the user's
+            // terminal even though the error is caught here (#1172).
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        return '';
+    }
+};
+exports.getCurrentCommit = getCurrentCommit;
+/**
+ * Get a stable canonical identifier for the repo's `origin` remote, if any.
+ *
+ * Used to fingerprint two on-disk clones as the same logical repository
+ * (prevents silent graph drift across sibling clones — see #2054). `path` alone
+ * is unreliable: worktrees, "clean clone for indexing" hygiene, and
+ * multi-agent workspaces routinely have the same repo at multiple
+ * absolute paths. The remote URL is the only on-disk signal that
+ * survives those conventions.
+ *
+ * Normalisation strategy:
+ *   - Strip a trailing `.git` so `https://x/y` and `https://x/y.git` collapse.
+ *   - Strip a trailing `/` for the same reason.
+ *   - `git@github.com:foo/bar` and `https://github.com/foo/bar` are
+ *     intentionally NOT collapsed — they are different remotes from
+ *     git's perspective and we don't want to assert equivalence.
+ *   - Lower-case the host portion so `GitHub.com` and `github.com`
+ *     don't desync; preserves case in path because some hosts
+ *     (Bitbucket Server) treat repo paths case-sensitively.
+ *
+ * Returns `undefined` when there is no origin remote, the directory
+ * isn't a git repo, or git itself isn't available.
+ */
+const getRemoteUrl = (repoPath) => {
+    let raw;
+    try {
+        raw = (0, child_process_1.execSync)('git config --get remote.origin.url', {
+            cwd: repoPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        return undefined;
+    }
+    if (!raw)
+        return undefined;
+    let normalised = raw.replace(/\/$/, '').replace(/\.git$/, '');
+    // Lower-case the host segment of `scheme://[user@]host[:port]/...`
+    // and the host segment of `git@host:owner/repo` SCP form.
+    // SSH user-segment regex deliberately accepts the common
+    // `git@`/`<alnum>-_@` cases. Less common usernames (e.g. with
+    // dots) fall through to the URL-form branch — they will simply
+    // not get host-case normalisation, which is acceptable: the raw
+    // `git config` output is still a valid fingerprint, just slightly
+    // less collapsible across host casings.
+    const sshMatch = normalised.match(/^(git@|[a-zA-Z0-9_-]+@)([^:/]+)(:.+)$/);
+    if (sshMatch) {
+        normalised = `${sshMatch[1]}${sshMatch[2].toLowerCase()}${sshMatch[3]}`;
+    }
+    else {
+        const urlMatch = normalised.match(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^/]+)(\/.*)?$/);
+        if (urlMatch) {
+            normalised = `${urlMatch[1]}${urlMatch[2].toLowerCase()}${urlMatch[3] ?? ''}`;
+        }
+    }
+    return normalised;
+};
+exports.getRemoteUrl = getRemoteUrl;
+/**
+ * Find the git repository root from any path inside the repo
+ */
+const getGitRoot = (fromPath) => {
+    const resolved = path_1.default.resolve(fromPath);
+    // Avoid git rev-parse --show-toplevel trimming trailing spaces from the
+    // repository root on Windows; callers that need identity keys canonicalize
+    // this value with realpath before comparing it.
+    if ((0, exports.hasGitDir)(resolved))
+        return resolved;
+    try {
+        const raw = chompGitOutput((0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd: fromPath,
+            // Suppress stderr -- see getCurrentCommit comment and #1172.
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }));
+        // On Windows, git returns /d/Projects/Foo — path.resolve normalizes to D:\Projects\Foo
+        return path_1.default.resolve(raw);
+    }
+    catch {
+        return null;
+    }
+};
+exports.getGitRoot = getGitRoot;
+/**
+ * Get the *canonical* repository root, dereferencing git worktrees.
+ *
+ * Unlike `getGitRoot` (which uses `git rev-parse --show-toplevel` and
+ * returns the WORKTREE's root when called inside a linked worktree),
+ * this uses `git rev-parse --git-common-dir` — the shared `.git`
+ * directory, identical for the main checkout and every linked
+ * worktree — and returns its parent.
+ *
+ * Why it matters (#1259): when `cgraph analyze` runs inside a
+ * worktree (e.g. `/repo/wt-feature/`), deriving `repoName` from
+ * `path.basename(getGitRoot(cwd))` registers the project under the
+ * worktree's directory slug (`wt-feature`) instead of the canonical
+ * repo's basename (`repo`). Each worktree then re-registers as a
+ * "different" project, AGENTS.md is rewritten with the wrong MCP URI,
+ * and Claude-Code-style worktree workflows silently accumulate
+ * duplicate registry entries.
+ *
+ * Returns `null` when the path is not inside a git repository or
+ * `git` is not available, so callers can chain safely:
+ * `getCanonicalRepoRoot(p) ?? getGitRoot(p) ?? p`.
+ *
+ * `--path-format=absolute` is required because `--git-common-dir`
+ * returns a path *relative to cwd* by default (e.g. `../.git` when
+ * called from a worktree), which would resolve to the wrong absolute
+ * path if the caller later resolved it from a different directory.
+ */
+const getCanonicalRepoRoot = (fromPath) => {
+    try {
+        const commonDir = chompGitOutput((0, child_process_1.execSync)('git rev-parse --path-format=absolute --git-common-dir', {
+            cwd: fromPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }));
+        if (!commonDir)
+            return null;
+        // Common dir is `<repo>/.git` for both the main checkout and all
+        // linked worktrees. Its parent is the canonical repo root.
+        return path_1.default.dirname(path_1.default.resolve(commonDir));
+    }
+    catch {
+        return null;
+    }
+};
+exports.getCanonicalRepoRoot = getCanonicalRepoRoot;
+// getGitInfoExcludePath/getCoreExcludesFilePath are called once per repo
+// PER language/contract extractor during group sync (#2606) — an N-repo
+// group fans out to 6+ extractors each calling these, so an uncached
+// execSync per call turns into O(extractors × repos) blocking subprocess
+// spawns. Both resolve to the same value for the same fromPath for the
+// life of the process (git config/exclude files don't change mid-run), so
+// memoize by fromPath. ponytail: process-lifetime cache, never invalidated
+// — fine for one-shot CLI runs; the long-lived MCP server would need a
+// TTL or explicit invalidation if a user edits core.excludesFile mid-session.
+const gitInfoExcludePathCache = new Map();
+const coreExcludesFilePathCache = new Map();
+/**
+ * Path to the repo's `$GIT_COMMON_DIR/info/exclude` file — git's own
+ * per-repo, untracked exclude list (same tier as `.gitignore` in
+ * precedence, but never committed, so it works even when the caller has
+ * no write access to the repo's tracked content). Shared across every
+ * linked worktree of a repo, matching git's own resolution (#2606).
+ *
+ * Returns `null` when `fromPath` is not inside a git repository or `git`
+ * is unavailable; callers should treat that the same as "no file".
+ */
+const getGitInfoExcludePath = (fromPath) => {
+    const cached = gitInfoExcludePathCache.get(fromPath);
+    if (cached !== undefined)
+        return cached;
+    let result;
+    try {
+        const commonDir = chompGitOutput((0, child_process_1.execSync)('git rev-parse --path-format=absolute --git-common-dir', {
+            cwd: fromPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }));
+        result = commonDir ? path_1.default.join(path_1.default.resolve(commonDir), 'info', 'exclude') : null;
+    }
+    catch {
+        result = null;
+    }
+    gitInfoExcludePathCache.set(fromPath, result);
+    return result;
+};
+exports.getGitInfoExcludePath = getGitInfoExcludePath;
+/**
+ * Path to git's own global, all-repos ignore file: the value of
+ * `core.excludesFile` (any config scope — system/global/local, resolved
+ * the same way `git` itself would from `fromPath`), or git's documented
+ * default of `$XDG_CONFIG_HOME/git/ignore` when unset (gitignore(5)).
+ * Lowest-precedence source, mirroring git's own behavior (#2606).
+ *
+ * Never throws: an unset key or unavailable `git` falls through to the
+ * default path, which is always computable without `git`.
+ */
+const getCoreExcludesFilePath = (fromPath) => {
+    const cached = coreExcludesFilePathCache.get(fromPath);
+    if (cached !== undefined)
+        return cached;
+    let result;
+    try {
+        const configured = chompGitOutput((0, child_process_1.execSync)('git config --get --type=path core.excludesFile', {
+            cwd: fromPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        }));
+        if (configured)
+            result = configured;
+    }
+    catch {
+        // Unset, or git unavailable — fall through to git's documented default.
+    }
+    if (!result) {
+        const xdgConfigHome = process.env.XDG_CONFIG_HOME || path_1.default.join(os_1.default.homedir(), '.config');
+        result = path_1.default.join(xdgConfigHome, 'git', 'ignore');
+    }
+    coreExcludesFilePathCache.set(fromPath, result);
+    return result;
+};
+exports.getCoreExcludesFilePath = getCoreExcludesFilePath;
+/**
+ * Resolve `fromPath` to the directory whose basename should drive the
+ * registry name (#1259) — the *identity root*. Three outcomes:
+ *
+ *   1. `fromPath` IS the canonical checkout root → returns it unchanged.
+ *   2. `fromPath` is a linked-worktree root (has its own `.git` entry, but
+ *      `git rev-parse --git-common-dir` points at a different `.git`) →
+ *      returns the canonical repo root.
+ *   3. `fromPath` is anything else — an arbitrary subdir under a git repo,
+ *      a non-git folder, a plain-folder root of an unrelated parent
+ *      checkout — returns `fromPath` unchanged.
+ *
+ * Why not just use `getCanonicalRepoRoot` directly? Because `git rev-parse
+ * --git-common-dir` resolves the same canonical root for ANY path inside
+ * a git repo, including unrelated subdirs. Using it for registry-name
+ * derivation would silently re-key a plain-folder subdir analyze under
+ * the parent git's basename, defeating the plain-folder intent
+ * (regressing the #1232/#1233 fix). The "is this path a tree root"
+ * gate confines the canonical-root collapse to exactly the cases where
+ * #1259 matters: main checkouts and linked worktrees.
+ */
+const resolveRepoIdentityRoot = (fromPath) => {
+    const resolved = path_1.default.resolve(fromPath);
+    const canonical = (0, exports.getCanonicalRepoRoot)(resolved);
+    if (!canonical)
+        return resolved; // non-git → use as-is
+    if (canonical === resolved)
+        return canonical; // canonical checkout
+    if ((0, exports.hasGitDir)(resolved))
+        return canonical; // linked worktree (has .git file)
+    return resolved; // arbitrary subdir under a git repo → preserve as-is
+};
+exports.resolveRepoIdentityRoot = resolveRepoIdentityRoot;
+/**
+ * Find a git root by checking only `.git` entries on the ancestor chain.
+ *
+ * Unlike `getGitRoot`, this does not spawn `git`, so MCP can cheaply decide
+ * whether a launch cwd is a worktree before running any subprocess there.
+ */
+const findGitRootByDotGit = (fromPath) => {
+    let current = path_1.default.resolve(fromPath);
+    try {
+        if (!(0, fs_1.statSync)(current).isDirectory()) {
+            current = path_1.default.dirname(current);
+        }
+    }
+    catch {
+        return null;
+    }
+    while (true) {
+        try {
+            (0, fs_1.statSync)(path_1.default.join(current, '.git'));
+            return current;
+        }
+        catch {
+            const parent = path_1.default.dirname(current);
+            if (parent === current)
+                return null;
+            current = parent;
+        }
+    }
+};
+exports.findGitRootByDotGit = findGitRootByDotGit;
+/**
+ * Check whether a directory contains a .git entry (file or folder).
+ *
+ * This is intentionally a simple filesystem check rather than running
+ * `git rev-parse`, so it works even when git is not installed or when
+ * the directory is a git-worktree root (which has a .git file, not a
+ * directory).  Use `isGitRepo` for a definitive git answer.
+ *
+ * @param dirPath - Absolute path to the directory to inspect.
+ * @returns `true` when `.git` is present, `false` otherwise.
+ */
+const hasGitDir = (dirPath) => {
+    try {
+        (0, fs_1.statSync)(path_1.default.join(dirPath, '.git'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.hasGitDir = hasGitDir;
+/**
+ * Read `remote.origin.url` from a git repository, or `null` if not a
+ * git repo, has no `origin` remote, or git is unavailable.
+ *
+ * Used by the registry-name inference path (#979) to recover a
+ * meaningful repo name when `path.basename(repoPath)` is generic
+ * (e.g. monorepo subprojects, git worktrees, Gas-Town-style
+ * `<rig>/refinery/rig/` layouts).
+ */
+const getRemoteOriginUrl = (repoPath) => {
+    try {
+        const url = (0, child_process_1.execSync)('git config --get remote.origin.url', {
+            cwd: repoPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+        return url || null;
+    }
+    catch {
+        return null;
+    }
+};
+exports.getRemoteOriginUrl = getRemoteOriginUrl;
+/**
+ * Best-effort detection of the repository's default branch (#243).
+ *
+ * Reads `git symbolic-ref --short refs/remotes/origin/HEAD`, which resolves to
+ * the short ref `origin/<branch>` that the local `origin/HEAD` points at, and
+ * strips the `origin/` prefix. This is a purely local lookup — it never makes a
+ * network call. Returns `null` when there is no git repo, no `origin` remote, no
+ * `origin/HEAD` (e.g. it was never set by clone, or the repo is detached), or
+ * git is unavailable, so callers can fall back to a configured/default branch.
+ */
+const getDefaultBranch = (repoPath) => {
+    try {
+        const ref = (0, child_process_1.execSync)('git symbolic-ref --short refs/remotes/origin/HEAD', {
+            cwd: repoPath,
+            // Suppress stderr -- see getCurrentCommit comment and #1172. Without it,
+            // git prints "fatal: ref refs/remotes/origin/HEAD is not a symbolic ref"
+            // to the user's terminal on repos that never set origin/HEAD.
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+        if (!ref)
+            return null;
+        return ref.startsWith('origin/') ? ref.slice('origin/'.length) : ref;
+    }
+    catch {
+        return null;
+    }
+};
+exports.getDefaultBranch = getDefaultBranch;
+/**
+ * Name of the currently checked-out branch, or `null` when HEAD is detached
+ * (CI checkouts, `git checkout <sha>`), the directory is not a git worktree, or
+ * git is unavailable.
+ *
+ * `git rev-parse --abbrev-ref HEAD` prints the literal `HEAD` for a detached
+ * checkout. We map that (and empty output) to `null` so callers fall back to the
+ * flat/default index rather than ever creating a branch literally named
+ * "HEAD" (#2106).
+ */
+const getCurrentBranch = (repoPath) => {
+    try {
+        const branch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            cwd: repoPath,
+            // Suppress stderr -- see getCurrentCommit comment and #1172.
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+        if (!branch || branch === 'HEAD')
+            return null;
+        return branch;
+    }
+    catch {
+        return null;
+    }
+};
+exports.getCurrentBranch = getCurrentBranch;
+/**
+ * Sanitize a repository name to prevent argument injection and ensure
+ * cross-platform filesystem compatibility.
+ *
+ * 1. Strips leading dashes to prevent git command-line argument injection
+ *    (e.g., --upload-pack=evil).
+ * 2. Replaces characters that are unsafe for directory names across
+ *    platforms (Windows/macOS/Linux) with underscores.
+ * 3. Blocks path traversal segments ("." and "..") and Windows reserved
+ *    names (e.g., CON, NUL) to prevent directory escape.
+ */
+const sanitizeRepoName = (name) => {
+    // 1. Prevent argument injection by stripping leading dashes.
+    // 2. Remove characters that are not alphanumerics, dots, underscores, or dashes.
+    const sanitized = name.replace(/^-+/, '').replace(/[^a-zA-Z0-9._-]/g, '_');
+    // 3. Block path traversal segments and Windows reserved names.
+    // Windows reserved names like CON, PRN, AUX, NUL, COM1-9, LPT1-9 cannot
+    // be used as directory names on Windows even if they have an extension.
+    const reserved = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\..*)?$/i;
+    if (!sanitized || sanitized === '.' || sanitized === '..' || reserved.test(sanitized)) {
+        return 'unknown';
+    }
+    return sanitized;
+};
+exports.sanitizeRepoName = sanitizeRepoName;
+/**
+ * Parse a repository name out of a git remote URL. Handles common shapes
+ * including SSH (git@host:owner/repo.git) and HTTPS (https://host/owner/repo.git).
+ *
+ * Returns a sanitized, filesystem-safe name or null if no name could be inferred.
+ * Returning null (rather than 'unknown') allows callers to use ?? null-coalescing
+ * for fallbacks without risk of registry collisions on 'unknown'.
+ */
+const parseRepoNameFromUrl = (url) => {
+    if (!url)
+        return null;
+    const trimmed = url.trim();
+    if (!trimmed)
+        return null;
+    // Strip trailing slashes without a regex to avoid polynomial-ReDoS on
+    // pathological inputs like `https://x.com/y` + '/'.repeat(1e6).
+    let end = trimmed.length;
+    while (end > 0 && trimmed.charCodeAt(end - 1) === 47 /* '/' */)
+        end--;
+    let cleaned = trimmed.slice(0, end);
+    // Strip trailing .git (case-insensitive)
+    if (cleaned.toLowerCase().endsWith('.git')) {
+        cleaned = cleaned.slice(0, -4);
+    }
+    // Last path segment, handling colons for SSH URLs and path traversal.
+    // Split on both / and : to consistently extract the last part.
+    const candidate = cleaned.split(/[/:]/).pop() || '';
+    if (!candidate)
+        return null;
+    const safe = (0, exports.sanitizeRepoName)(candidate);
+    return safe === 'unknown' ? null : safe;
+};
+exports.parseRepoNameFromUrl = parseRepoNameFromUrl;
+/**
+ * Convenience wrapper: derive a registry-friendly name from the repo's
+ * `origin` remote, or `null` when it cannot be inferred.
+ */
+const getInferredRepoName = (repoPath) => {
+    return (0, exports.parseRepoNameFromUrl)((0, exports.getRemoteOriginUrl)(repoPath));
+};
+exports.getInferredRepoName = getInferredRepoName;
+/**
+ * Parse unified diff output (with -U0) into per-file hunk ranges.
+ * Extracts the new-file line ranges from @@ hunk headers.
+ */
+function parseDiffHunks(diffOutput) {
+    const files = [];
+    let current = null;
+    for (const line of diffOutput.split('\n')) {
+        if (line.startsWith('+++ b/')) {
+            current = { filePath: line.slice(6), hunks: [] };
+            files.push(current);
+        }
+        else if (line.startsWith('@@') && current) {
+            const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+            if (match) {
+                const start = parseInt(match[1], 10);
+                const count = match[2] !== undefined ? parseInt(match[2], 10) : 1;
+                if (count > 0) {
+                    current.hunks.push({ startLine: start, endLine: start + count - 1 });
+                }
+            }
+        }
+    }
+    return files;
+}