homegraph 1.6.1 → 1.6.2

package/dist/resolution/index.js

@@ -57,6 +57,8 @@ const workspace_packages_1 = require("./workspace-packages");
 const errors_1 = require("../errors");
 const lru_cache_1 = require("./lru-cache");
 const grammars_1 = require("../extraction/grammars");
+const cpp_macro_visibility_1 = require("./cpp-macro-visibility");
+const c_feature_variants_1 = require("./c-feature-variants");
 /** Node kinds that can declare supertypes (extends/implements). */
 const SUPERTYPE_BEARING_KINDS = new Set([
     'class', 'struct', 'interface', 'trait', 'protocol', 'enum',
@@ -412,6 +414,8 @@ class ReferenceResolver {
         if (this.context) {
             (0, import_resolver_1.clearImportResolverMemos)(this.context);
             (0, name_matcher_1.clearNameMatcherMemos)(this.context);
+            (0, cpp_macro_visibility_1.clearCppMacroVisibility)(this.context);
+            (0, c_feature_variants_1.clearCFeatureVariantMemos)(this.context);
         }
     }
     /** `readFile` through the LRU content cache (null = read failed, also cached). */
@@ -852,6 +856,13 @@ class ReferenceResolver {
         if (this.isBuiltInOrExternal(ref)) {
             return null;
         }
+        // A C/C++ call that is a visible function-like macro is not a call.
+        // The include walk that decides this is bounded (Spec 0054).
+        if ((ref.language === 'c' || ref.language === 'cpp')
+            && ref.referenceKind === 'calls'
+            && (0, cpp_macro_visibility_1.isVisibleCppMacro)(ref, this.context)) {
+            return null;
+        }
         // CFML component paths in inheritance (#1152): `extends="coldbox.system.web.
         // Controller"` names the supertype by its dot-separated path (or `extends=
         // "../base"` by relative file path) — the graph indexes the class under its

package/dist/resolution/name-matcher.js

@@ -24,6 +24,7 @@ exports.matchMethodCall = matchMethodCall;
 exports.matchFuzzy = matchFuzzy;
 exports.dumpNameMatcherProfile = dumpNameMatcherProfile;
 exports.matchReference = matchReference;
+const c_feature_variants_1 = require("./c-feature-variants");
 /**
  * Ceiling on how many same-named definitions a FUZZY name-match strategy will
  * score. A name defined more times than this is "ubiquitous" — a method/symbol
@@ -361,6 +362,49 @@ function isLexicallyReachable(candidate, ref, context) {
     return (ref.filePath === candidate.filePath &&
         containers.some((p) => ref.line >= p.startLine && ref.line <= p.endLine));
 }
+/** Per-context memo: node id → file-scope `static` (C linkage). */
+const C_STATIC_MEMO = new WeakMap();
+/**
+ * A C function whose declaration line (or the line above it) is `static`.
+ * Another translation unit cannot call it. Fail open when the source is missing.
+ */
+function isStaticCFunction(candidate, context) {
+    let memo = C_STATIC_MEMO.get(context);
+    if (!memo) {
+        memo = new Map();
+        C_STATIC_MEMO.set(context, memo);
+    }
+    const hit = memo.get(candidate.id);
+    if (hit !== undefined)
+        return hit;
+    const lines = context.getFileLines?.(candidate.filePath) ?? context.readFile(candidate.filePath)?.split('\n') ?? [];
+    const head = [lines[candidate.startLine - 2] ?? '', lines[candidate.startLine - 1] ?? ''].join('\n');
+    const isStatic = /(^|[\s;}])static\s/.test(head);
+    memo.set(candidate.id, isStatic);
+    return isStatic;
+}
+/**
+ * Among same-named C/C++ function definitions, drop another file's `static`
+ * when a definition with external linkage remains, and drop a definition that
+ * exists only under a feature flag nothing in the project sets (Spec 0056).
+ * Same-file definitions stay. Any other language, or a non-call, is unchanged.
+ */
+function narrowCCallTargets(ref, candidates, context) {
+    if ((ref.language !== 'c' && ref.language !== 'cpp') || ref.referenceKind !== 'calls')
+        return candidates;
+    const funcs = candidates.filter((n) => n.kind === 'function');
+    if (funcs.length < 2)
+        return candidates;
+    const rest = candidates.filter((n) => n.kind !== 'function');
+    const visible = funcs.filter((n) => n.filePath === ref.filePath || !isStaticCFunction(n, context));
+    let pool = visible.length > 0 ? visible : funcs;
+    if (ref.language === 'c' && !(0, c_feature_variants_1.isOffByDefault)(ref.filePath, ref.line, context)) {
+        const plain = pool.filter((n) => !(0, c_feature_variants_1.isCFeatureVariant)(n, ref, context));
+        if (plain.length > 0 && plain.length < pool.length)
+            pool = plain;
+    }
+    return pool.length === funcs.length ? candidates : [...pool, ...rest];
+}
 /**
  * Try to resolve a reference by exact name match
  */
@@ -399,8 +443,9 @@ function matchByExactName(ref, context) {
     if (candidates.length > AMBIGUOUS_NAME_CEILING) {
         return null;
     }
-    // Multiple matches - try to narrow down
-    const bestMatch = findBestMatch(ref, candidates, context);
+    // Multiple matches - try to narrow down. C/C++ linkage runs first so a
+    // nearer file's `static` copy cannot beat the definition the call can see.
+    const bestMatch = findBestMatch(ref, narrowCCallTargets(ref, candidates, context), context);
     if (bestMatch) {
         // Lower confidence when the match is from a distant/unrelated module
         const proximity = computePathProximity(ref.filePath, bestMatch.filePath);
@@ -1065,6 +1110,8 @@ function getInferScanStates(context) {
 /** Drop the per-context scan states (see ReferenceResolver.clearCaches). */
 function clearNameMatcherMemos(context) {
     INFER_SCAN_STATES.delete(context);
+    C_STATIC_MEMO.delete(context);
+    (0, c_feature_variants_1.clearCFeatureVariantMemos)(context);
 }
 function memoPatterns(key, build) {
     const hit = PATTERN_MEMO.get(key);

package/dist/resolution/types.d.ts

@@ -91,6 +91,12 @@ export interface ResolutionContext {
      * callers fall back to splitting `readFile` themselves.
      */
     getFileLines?(filePath: string): string[] | null;
+    /**
+     * Whether `filePath` contains `text`, without reading the whole file when
+     * the host can answer cheaper. Optional; C feature-flag scans fall back to
+     * `readFile` (Spec 0056).
+     */
+    fileContains?(filePath: string, text: string): boolean;
     /**
      * The method-definition nodes matching `typeName::methodName` in `language` —
      * exactly `resolveMethodOnType`'s kind/language/qualifiedName-suffix filter,
@@ -249,6 +255,8 @@ export interface ImportMapping {
  * `export * from './other'`. Used by the resolver to chase
  * symbols through barrel files.
  */
+/** A `#define` recorded as a constant node's signature (C/C++ macro visibility). */
+export declare const CPP_DEFINE_SIGNATURE: RegExp;
 export type ReExport = {
     kind: 'named';
     /** Name as exported by THIS file. */

package/dist/resolution/types.js

@@ -5,4 +5,12 @@
  * Types for the reference resolution system.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CPP_DEFINE_SIGNATURE = void 0;
+/**
+ * Re-export from a file: `export { x } from './other'` or
+ * `export * from './other'`. Used by the resolver to chase
+ * symbols through barrel files.
+ */
+/** A `#define` recorded as a constant node's signature (C/C++ macro visibility). */
+exports.CPP_DEFINE_SIGNATURE = /^\s*#\s*define\b/;
 //# sourceMappingURL=types.js.map

package/dist/sync/watcher.d.ts

@@ -88,7 +88,30 @@ export interface WatchOptions {
      * sets it.
      */
     inertForTests?: boolean;
+    /**
+     * Indexed size and mtime for a project-relative path, or null when the
+     * file is not in the index. On Windows this drops watcher events whose
+     * size and modification time still match the index — NTFS last-access
+     * updates look like edits (Spec 0055). Absent means every event is kept.
+     */
+    indexedFingerprint?: (relPath: string) => {
+        size: number;
+        modifiedAt: number;
+    } | null;
 }
+/**
+ * True when a watcher event is only an NTFS last-access update: Windows,
+ * the file is already indexed, and its size and modification time still
+ * match. A missing stat, a missing index row, or any other platform is a
+ * real change (fail open).
+ */
+export declare function isAccessTimeOnlyChange(platform: NodeJS.Platform, onDisk: {
+    size: number;
+    mtimeMs: number;
+} | null, indexed: {
+    size: number;
+    modifiedAt: number;
+} | null): boolean;
 /**
  * Thrown by a `syncFn` to signal that the underlying sync couldn't acquire
  * the cross-process write lock (#449). The watcher treats this as "no
@@ -209,6 +232,7 @@ export declare class FileWatcher {
     private readonly onSyncError?;
     private readonly onDegraded?;
     private readonly inertForTests;
+    private readonly indexedFingerprint?;
     constructor(projectRoot: string, syncFn: (paths?: string[]) => Promise<{
         filesChanged: number;
         durationMs: number;
@@ -257,6 +281,12 @@ export declare class FileWatcher {
      * — it drops node_modules/dist/.git churn before any sync is scheduled.
      */
     private handleChange;
+    /**
+     * Windows ReadDirectoryChangesW reports a read as `change` when NTFS
+     * updates last-access time. Drop that event when size and mtime still
+     * match the index. Stat or lookup failure keeps the event.
+     */
+    private isAccessTimeOnly;
     /**
      * A deleted DIRECTORY arrives as one event on the directory's own path —
      * no source extension, so the source-file filter drops it, and the files

package/dist/sync/watcher.js

@@ -67,6 +67,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileWatcher = exports.LockUnavailableError = void 0;
 exports.__setFsWatchForTests = __setFsWatchForTests;
+exports.isAccessTimeOnlyChange = isAccessTimeOnlyChange;
 exports.__emitWatchEventForTests = __emitWatchEventForTests;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -186,6 +187,18 @@ function maxDirWatches() {
  */
 const liveWatchersForTests = new Map();
 const IS_TEST_RUNTIME = !!(process.env.VITEST || process.env.NODE_ENV === 'test');
+/**
+ * True when a watcher event is only an NTFS last-access update: Windows,
+ * the file is already indexed, and its size and modification time still
+ * match. A missing stat, a missing index row, or any other platform is a
+ * real change (fail open).
+ */
+function isAccessTimeOnlyChange(platform, onDisk, indexed) {
+    if (platform !== 'win32' || !onDisk || !indexed)
+        return false;
+    return onDisk.size === indexed.size
+        && Math.floor(onDisk.mtimeMs) === Math.floor(indexed.modifiedAt);
+}
 /**
  * Thrown by a `syncFn` to signal that the underlying sync couldn't acquire
  * the cross-process write lock (#449). The watcher treats this as "no
@@ -296,6 +309,7 @@ class FileWatcher {
     onSyncError;
     onDegraded;
     inertForTests;
+    indexedFingerprint;
     constructor(projectRoot, syncFn, options = {}) {
         this.projectRoot = projectRoot;
         this.syncFn = syncFn;
@@ -305,6 +319,7 @@ class FileWatcher {
         this.onSyncError = options.onSyncError;
         this.onDegraded = options.onDegraded;
         this.inertForTests = options.inertForTests ?? false;
+        this.indexedFingerprint = options.indexedFingerprint;
     }
     /**
      * Start watching for file changes.
@@ -528,6 +543,10 @@ class FileWatcher {
             this.maybeScheduleForRemovedDir(rel);
             return;
         }
+        if (this.isAccessTimeOnly(rel)) {
+            (0, errors_1.logDebug)('Ignoring Windows access-time watcher event', { file: rel });
+            return;
+        }
         (0, errors_1.logDebug)('File change detected', { file: rel });
         if (this.ready) {
             const now = Date.now();
@@ -539,6 +558,32 @@ class FileWatcher {
         }
         this.scheduleSync();
     }
+    /**
+     * Windows ReadDirectoryChangesW reports a read as `change` when NTFS
+     * updates last-access time. Drop that event when size and mtime still
+     * match the index. Stat or lookup failure keeps the event.
+     */
+    isAccessTimeOnly(rel) {
+        if (process.platform !== 'win32' || !this.indexedFingerprint)
+            return false;
+        let indexed;
+        try {
+            indexed = this.indexedFingerprint(rel);
+        }
+        catch {
+            return false;
+        }
+        let onDisk = null;
+        try {
+            const st = fs.statSync(path.join(this.projectRoot, rel));
+            if (st.isFile())
+                onDisk = { size: st.size, mtimeMs: st.mtimeMs };
+        }
+        catch {
+            onDisk = null;
+        }
+        return isAccessTimeOnlyChange(process.platform, onDisk, indexed);
+    }
     /**
      * A deleted DIRECTORY arrives as one event on the directory's own path —
      * no source extension, so the source-file filter drops it, and the files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homegraph",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Supercharge AI coding agents with semantic code intelligence — surgical context, fewer tool calls, faster answers. 100% local.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",