cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/git-staleness.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Git working tree vs index commit staleness (used by MCP resources, group status, etc.).
+ * Lives in core/ so application code does not depend on the MCP package layer.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkStaleness = checkStaleness;
+exports.checkStalenessAsync = checkStalenessAsync;
+exports.checkCwdMatch = checkCwdMatch;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const path_1 = __importDefault(require("path"));
+const repo_manager_js_1 = require("../storage/repo-manager.js");
+const git_js_1 = require("../storage/git.js");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/**
+ * Check how many commits the index is behind HEAD (synchronous; uses git CLI).
+ */
+function checkStaleness(repoPath, lastCommit) {
+    try {
+        const result = (0, node_child_process_1.execFileSync)('git', ['rev-list', '--count', `${lastCommit}..HEAD`], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        }).trim();
+        const commitsBehind = parseInt(result, 10) || 0;
+        if (commitsBehind > 0) {
+            return {
+                isStale: true,
+                commitsBehind,
+                hint: `⚠️ Index is ${commitsBehind} commit${commitsBehind > 1 ? 's' : ''} behind HEAD. Run analyze tool to update.`,
+            };
+        }
+        return { isStale: false, commitsBehind: 0 };
+    }
+    catch {
+        return { isStale: false, commitsBehind: 0 };
+    }
+}
+/**
+ * Async variant of {@link checkStaleness} — spawns git as a child process
+ * instead of blocking the event loop.  Used by `listRepos()` to check many
+ * repos in parallel (issue #1363: 200 repos × sync spawn ≈ 50 s).
+ */
+async function checkStalenessAsync(repoPath, lastCommit) {
+    try {
+        // Note: promisified execFile captures stdout/stderr by default (no stdio option needed,
+        // unlike the sync variant which requires explicit stdio: ['pipe','pipe','pipe']).
+        const { stdout } = await execFileAsync('git', ['rev-list', '--count', `${lastCommit}..HEAD`], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+            windowsHide: true,
+        });
+        const commitsBehind = parseInt(stdout.trim(), 10) || 0;
+        if (commitsBehind > 0) {
+            return {
+                isStale: true,
+                commitsBehind,
+                hint: `⚠️ Index is ${commitsBehind} commit${commitsBehind > 1 ? 's' : ''} behind HEAD. Run analyze tool to update.`,
+            };
+        }
+        return { isStale: false, commitsBehind: 0 };
+    }
+    catch {
+        return { isStale: false, commitsBehind: 0 };
+    }
+}
+/**
+ * Compare a sibling-clone HEAD against an indexed `lastCommit`. Returns
+ * `undefined` when the indexed commit is not reachable from the sibling
+ * (e.g. divergent branches, shallow clone, missing ref). The caller
+ * should treat `undefined` as "drift unknown" rather than "no drift".
+ */
+function commitsAheadOfIndexed(siblingPath, indexedCommit) {
+    if (!indexedCommit)
+        return undefined;
+    try {
+        const result = (0, node_child_process_1.execFileSync)('git', ['rev-list', '--count', `${indexedCommit}..HEAD`], {
+            cwd: siblingPath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        }).trim();
+        return parseInt(result, 10) || 0;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolve a working directory against the global registry. Returns:
+ *   - `match: 'path'`              when `cwd` is inside a registered entry's path
+ *   - `match: 'sibling-by-remote'` when `cwd` lives in a different on-disk clone
+ *                                   of the same repo (same `remoteUrl`)
+ *   - `match: 'none'`              when neither match applies
+ *
+ * For sibling-by-remote matches, the caller's HEAD and the drift vs the
+ * indexed `lastCommit` are also returned so the MCP layer can warn
+ * before serving silently-stale answers (issue: silent graph drift
+ * across sibling clones).
+ *
+ * `path` matches deliberately use the longest-prefix rule so a cwd
+ * inside a sub-path of a registered repo still matches that repo, not
+ * a coincidentally-aliased shorter entry.
+ */
+async function checkCwdMatch(cwd) {
+    // cwd-based discovery (spec §8): resolve the project root whose `.cgraphx/code/`
+    // index is nearest `cwd`, instead of reading a global registry.
+    const entries = await (0, repo_manager_js_1.readRegistry)({ startCwd: cwd });
+    if (entries.length === 0)
+        return { match: 'none' };
+    const isWin = process.platform === 'win32';
+    const norm = (p) => (isWin ? path_1.default.resolve(p).toLowerCase() : path_1.default.resolve(p));
+    const sep = path_1.default.sep;
+    const cwdResolved = path_1.default.resolve(cwd);
+    const cwdNorm = norm(cwdResolved);
+    // 1) Path-based match (longest prefix wins, boundary-safe).
+    let bestPath;
+    let bestLen = -1;
+    for (const e of entries) {
+        const p = norm(e.path);
+        if (cwdNorm === p || cwdNorm.startsWith(p.endsWith(sep) ? p : p + sep)) {
+            if (p.length > bestLen) {
+                bestPath = e;
+                bestLen = p.length;
+            }
+        }
+    }
+    if (bestPath)
+        return { match: 'path', entry: bestPath };
+    // 2) Sibling-by-remote: locate the cwd's git root using only ancestor
+    //    `.git` checks before shelling out. This keeps MCP startup from
+    //    running git in an unrelated launch cwd such as $HOME (#1138).
+    const cwdGitRoot = (0, git_js_1.findGitRootByDotGit)(cwdResolved);
+    if (!cwdGitRoot)
+        return { match: 'none' };
+    const cwdRemote = (0, git_js_1.getRemoteUrl)(cwdGitRoot);
+    if (!cwdRemote)
+        return { match: 'none' };
+    const sibling = entries.find((e) => e.remoteUrl === cwdRemote && norm(e.path) !== norm(cwdGitRoot));
+    if (!sibling)
+        return { match: 'none' };
+    const cwdHead = (0, git_js_1.getCurrentCommit)(cwdGitRoot) || undefined;
+    const drift = commitsAheadOfIndexed(cwdGitRoot, sibling.lastCommit);
+    // Same commit on both clones → still report match=sibling-by-remote
+    // (the relationship is real and useful to callers like list_repos /
+    // future tooling) but leave `hint` unset: there's nothing to warn
+    // about, and `maybeWarnSiblingDrift` already short-circuits this
+    // case independently. Surfacing a no-op hint would force callers
+    // to second-guess whether they need to display it.
+    let hint;
+    if (cwdHead && cwdHead === sibling.lastCommit) {
+        hint = undefined;
+    }
+    else if (drift && drift > 0) {
+        hint =
+            `⚠️ Index for "${sibling.name}" was built at ${sibling.path}; ` +
+                `your cwd (${cwdGitRoot}) is a sibling clone that is ${drift} commit${drift > 1 ? 's' : ''} ` +
+                `ahead of the indexed commit. Results may be stale or incorrect — re-run \`cgraph analyze\` ` +
+                `to refresh the index.`;
+    }
+    else {
+        hint =
+            `⚠️ Index for "${sibling.name}" was built at ${sibling.path}; ` +
+                `your cwd (${cwdGitRoot}) is a sibling clone whose HEAD differs from the indexed commit. ` +
+                `Results may be stale or incorrect — re-run \`cgraph analyze\` to refresh the index.`;
+    }
+    return {
+        match: 'sibling-by-remote',
+        entry: sibling,
+        cwdGitRoot,
+        cwdHead,
+        drift,
+        hint,
+    };
+}

package/dist/core/code/engine/core/graph/graph.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKnowledgeGraph = void 0;
+/** Fresh empty iterator per call — `[].values()` returns a new
+ *  exhausted iterator each invocation, so empty-type lookups don't
+ *  share a single already-exhausted iterator across callers. */
+function emptyRelIter() {
+    return [].values();
+}
+const createKnowledgeGraph = () => {
+    const nodeMap = new Map();
+    const relationshipMap = new Map();
+    // Per-type index maintained alongside `relationshipMap`. Bucket
+    // values are `Map<id, Relationship>` so per-type iteration is cheap
+    // and per-edge removal is O(1). See plan
+    // docs/plans/2026-04-20-002-perf-parse-heritage-mro-plan.md (Unit 1).
+    const relationshipsByType = new Map();
+    // Reverse-adjacency index: nodeId → Set<relId> of every edge where
+    // this node appears as source OR target. Maintained on writeRel /
+    // deleteRel so `removeNode` can delete a node's edges in
+    // O(edges-touching-node) instead of O(total-edges).
+    const edgeIdsByNode = new Map();
+    // File index: filePath → Set<nodeId>. Maintained on addNode /
+    // removeNode so `removeNodesByFile` reaches its file's nodes
+    // directly instead of scanning the whole node map.
+    const nodeIdsByFile = new Map();
+    // Private helpers that encode the dual-index invariants in one
+    // place. All mutation paths go through these — adding a new
+    // mutation method only needs to call the helper, not remember to
+    // touch every index.
+    const addToBucket = (map, key, value) => {
+        let bucket = map.get(key);
+        if (bucket === undefined) {
+            bucket = new Set();
+            map.set(key, bucket);
+        }
+        bucket.add(value);
+    };
+    const removeFromBucket = (map, key, value) => {
+        const bucket = map.get(key);
+        if (bucket === undefined)
+            return;
+        bucket.delete(value);
+        if (bucket.size === 0)
+            map.delete(key);
+    };
+    const writeRel = (rel) => {
+        relationshipMap.set(rel.id, rel);
+        let typeBucket = relationshipsByType.get(rel.type);
+        if (typeBucket === undefined) {
+            typeBucket = new Map();
+            relationshipsByType.set(rel.type, typeBucket);
+        }
+        typeBucket.set(rel.id, rel);
+        addToBucket(edgeIdsByNode, rel.sourceId, rel.id);
+        // Guard against a self-edge writing the same rel.id into the
+        // same Set twice — Set dedup handles it, but we skip explicitly
+        // for clarity.
+        if (rel.targetId !== rel.sourceId) {
+            addToBucket(edgeIdsByNode, rel.targetId, rel.id);
+        }
+    };
+    const deleteRel = (rel) => {
+        relationshipMap.delete(rel.id);
+        const typeBucket = relationshipsByType.get(rel.type);
+        if (typeBucket !== undefined) {
+            typeBucket.delete(rel.id);
+            if (typeBucket.size === 0)
+                relationshipsByType.delete(rel.type);
+        }
+        removeFromBucket(edgeIdsByNode, rel.sourceId, rel.id);
+        if (rel.targetId !== rel.sourceId) {
+            removeFromBucket(edgeIdsByNode, rel.targetId, rel.id);
+        }
+    };
+    const addNode = (node) => {
+        if (nodeMap.has(node.id))
+            return;
+        nodeMap.set(node.id, node);
+        const filePath = node.properties?.filePath;
+        if (typeof filePath === 'string' && filePath.length > 0) {
+            addToBucket(nodeIdsByFile, filePath, node.id);
+        }
+    };
+    const addRelationship = (relationship) => {
+        if (relationshipMap.has(relationship.id))
+            return;
+        writeRel(relationship);
+    };
+    /**
+     * Remove a single node and all relationships involving it.
+     * O(edges-touching-node) via the reverse-adjacency index — no full
+     * relationshipMap scan.
+     */
+    const removeNode = (nodeId) => {
+        const node = nodeMap.get(nodeId);
+        if (node === undefined)
+            return false;
+        nodeMap.delete(nodeId);
+        const filePath = node.properties?.filePath;
+        if (typeof filePath === 'string' && filePath.length > 0) {
+            removeFromBucket(nodeIdsByFile, filePath, nodeId);
+        }
+        const touchingEdgeIds = edgeIdsByNode.get(nodeId);
+        if (touchingEdgeIds !== undefined) {
+            // Snapshot the ids before iterating — deleteRel mutates the same
+            // Set via removeFromBucket, which would break mid-loop iteration.
+            for (const relId of [...touchingEdgeIds]) {
+                const rel = relationshipMap.get(relId);
+                if (rel !== undefined)
+                    deleteRel(rel);
+            }
+            edgeIdsByNode.delete(nodeId);
+        }
+        return true;
+    };
+    /**
+     * Remove a single relationship by id.
+     * Returns true if the relationship existed and was removed, false otherwise.
+     */
+    const removeRelationship = (relationshipId) => {
+        const rel = relationshipMap.get(relationshipId);
+        if (rel === undefined)
+            return false;
+        deleteRel(rel);
+        return true;
+    };
+    /**
+     * Remove all nodes (and their relationships) belonging to a file.
+     * O(file-nodes × avg-edges-per-node) via the file index — no full
+     * node-map scan.
+     */
+    const removeNodesByFile = (filePath) => {
+        const nodeIds = nodeIdsByFile.get(filePath);
+        if (nodeIds === undefined)
+            return 0;
+        // Snapshot before iterating — removeNode mutates nodeIdsByFile.
+        const snapshot = [...nodeIds];
+        for (const nodeId of snapshot)
+            removeNode(nodeId);
+        return snapshot.length;
+    };
+    return {
+        get nodes() {
+            return Array.from(nodeMap.values());
+        },
+        get relationships() {
+            return Array.from(relationshipMap.values());
+        },
+        iterNodes: () => nodeMap.values(),
+        iterRelationships: () => relationshipMap.values(),
+        iterRelationshipsByType: (type) => {
+            const bucket = relationshipsByType.get(type);
+            return bucket === undefined ? emptyRelIter() : bucket.values();
+        },
+        forEachNode(fn) {
+            nodeMap.forEach(fn);
+        },
+        forEachRelationship(fn) {
+            relationshipMap.forEach(fn);
+        },
+        forEachRelationshipFields(fn) {
+            relationshipMap.forEach((rel) => fn(rel.sourceId, rel.targetId, rel.type, rel.confidence));
+        },
+        getNode: (id) => nodeMap.get(id),
+        // O(1) count getters - avoid creating arrays just for length
+        get nodeCount() {
+            return nodeMap.size;
+        },
+        get relationshipCount() {
+            return relationshipMap.size;
+        },
+        addNode,
+        addRelationship,
+        removeNode,
+        removeNodesByFile,
+        removeRelationship,
+    };
+};
+exports.createKnowledgeGraph = createKnowledgeGraph;

package/dist/core/code/engine/core/graph/import-cycles.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findImportCycles = findImportCycles;
+function findCyclePath(component, adjacency) {
+    const allowed = new Set(component);
+    const start = component[0];
+    const parents = new Map([[start, null]]);
+    const queue = [start];
+    for (let index = 0; index < queue.length; index += 1) {
+        const node = queue[index];
+        for (const next of adjacency.get(node) ?? []) {
+            if (!allowed.has(next))
+                continue;
+            if (next === start) {
+                const path = [];
+                let cursor = node;
+                while (cursor !== null) {
+                    path.push(cursor);
+                    cursor = parents.get(cursor) ?? null;
+                }
+                path.reverse();
+                return [...path, start];
+            }
+            if (parents.has(next))
+                continue;
+            parents.set(next, node);
+            queue.push(next);
+        }
+    }
+    throw new Error('Invariant violation: no cycle found through SCC root.');
+}
+/**
+ * Return one deterministic concrete cycle for every cyclic strongly connected
+ * component in the file import graph.
+ */
+function findImportCycles(edges) {
+    const adjacency = new Map();
+    for (const { source, target } of edges) {
+        if (!source || !target)
+            continue;
+        const targets = adjacency.get(source) ?? new Set();
+        targets.add(target);
+        adjacency.set(source, targets);
+        if (!adjacency.has(target))
+            adjacency.set(target, new Set());
+    }
+    const sortedAdjacency = new Map([...adjacency].map(([node, targets]) => [node, [...targets].sort()]));
+    const reverseAdjacency = new Map();
+    for (const node of sortedAdjacency.keys())
+        reverseAdjacency.set(node, []);
+    for (const [source, targets] of sortedAdjacency) {
+        for (const target of targets)
+            reverseAdjacency.get(target).push(source);
+    }
+    for (const sources of reverseAdjacency.values())
+        sources.sort();
+    const visited = new Set();
+    const finishOrder = [];
+    const components = [];
+    for (const start of [...sortedAdjacency.keys()].sort()) {
+        if (visited.has(start))
+            continue;
+        visited.add(start);
+        const stack = [{ node: start, nextIndex: 0 }];
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            const neighbors = sortedAdjacency.get(frame.node) ?? [];
+            if (frame.nextIndex < neighbors.length) {
+                const next = neighbors[frame.nextIndex++];
+                if (!visited.has(next)) {
+                    visited.add(next);
+                    stack.push({ node: next, nextIndex: 0 });
+                }
+            }
+            else {
+                finishOrder.push(frame.node);
+                stack.pop();
+            }
+        }
+    }
+    visited.clear();
+    for (let index = finishOrder.length - 1; index >= 0; index -= 1) {
+        const start = finishOrder[index];
+        if (visited.has(start))
+            continue;
+        const component = [];
+        const stack = [start];
+        visited.add(start);
+        while (stack.length > 0) {
+            const node = stack.pop();
+            component.push(node);
+            for (const next of reverseAdjacency.get(node) ?? []) {
+                if (visited.has(next))
+                    continue;
+                visited.add(next);
+                stack.push(next);
+            }
+        }
+        component.sort();
+        components.push(component);
+    }
+    return components
+        .filter((component) => component.length > 1 || (sortedAdjacency.get(component[0]) ?? []).includes(component[0]))
+        .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .map((component) => findCyclePath(component, sortedAdjacency));
+}

package/dist/core/code/engine/core/graph/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/engine/core/index-freshness.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INDEX_INCOMPLETE_REASONS = void 0;
+exports.getIndexIncompleteReasons = getIndexIncompleteReasons;
+exports.INDEX_INCOMPLETE_REASONS = [];
+/**
+ * v1 手动全量重建,无增量/无 embeddings,索引恒完整。
+ * 保留函数签名以兼容 cli/status.ts 的调用点。
+ */
+function getIndexIncompleteReasons(_meta) {
+    return [];
+}