homegraph 1.6.2 → 1.6.4

package/dist/extraction/tree-sitter.js

@@ -47,6 +47,7 @@ const function_ref_1 = require("./function-ref");
 const generated_detection_1 = require("./generated-detection");
 const languages_1 = require("./languages");
 const c_cpp_1 = require("./languages/c-cpp");
+const jsdoc_type_tags_1 = require("./jsdoc-type-tags");
 const liquid_extractor_1 = require("./liquid-extractor");
 const razor_extractor_1 = require("./razor-extractor");
 const svelte_extractor_1 = require("./svelte-extractor");
@@ -1511,6 +1512,8 @@ class TreeSitterExtractor {
             return;
         // Extract type annotations (parameter types and return type)
         this.extractTypeAnnotations(node, funcNode.id);
+        // Spec 0066: JSDoc @returns/@param when the signature omitted types.
+        this.emitJsdocTypeFallbacks(funcNode.id, docstring);
         // Extract decorators applied to the function (rare in JS/TS but
         // present in Python `@decorator def f():` and Java/Kotlin
         // annotations on free functions).
@@ -1712,6 +1715,8 @@ class TreeSitterExtractor {
         }
         // Extract type annotations (parameter types and return type)
         this.extractTypeAnnotations(node, methodNode.id);
+        // Spec 0066: JSDoc @returns/@param when the signature omitted types.
+        this.emitJsdocTypeFallbacks(methodNode.id, docstring);
         // Extract decorators (`@Get('/list') list() {}`).
         this.extractDecoratorsFor(node, methodNode.id);
         // Push to stack and visit body
@@ -5636,7 +5641,8 @@ class TreeSitterExtractor {
     ]);
     /**
      * Extract type references from type annotations on a function/method/field node.
-     * Creates 'references' edges for parameter types, return types, and field types.
+     * Spec 0066: parameter / field types → `type_of`; return types → `returns`.
+     * Dart / Scala mixed signature walks stay `references` (out of this Spec).
      */
     extractTypeAnnotations(node, nodeId) {
         if (!this.extractor)
@@ -5668,6 +5674,7 @@ class TreeSitterExtractor {
         // `type_identifier` child, not a `type` field — so getChildByField below
         // finds neither. Walk the inner signature: param names / the method name are
         // `identifier` (not `type_identifier`), so only types surface.
+        // Spec 0066: leave as `references` (mixed return+param walk).
         if (this.language === 'dart') {
             let sig = node;
             if (node.type === 'method_signature') {
@@ -5677,7 +5684,7 @@ class TreeSitterExtractor {
                     c.type === 'constructor_signature' ||
                     c.type === 'factory_constructor_signature') ?? node;
             }
-            this.extractTypeRefsFromSubtree(sig, nodeId);
+            this.extractTypeRefsFromSubtree(sig, nodeId, 'references');
             return;
         }
         // Extract parameter type annotations. Scala curries — `def f(a)(implicit
@@ -5687,19 +5694,19 @@ class TreeSitterExtractor {
         if (this.language === 'scala') {
             for (const pc of node.namedChildren) {
                 if (pc.type === 'parameters')
-                    this.extractTypeRefsFromSubtree(pc, nodeId);
+                    this.extractTypeRefsFromSubtree(pc, nodeId, 'type_of');
             }
         }
         else {
             const params = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.paramsField || 'parameters');
             if (params) {
-                this.extractTypeRefsFromSubtree(params, nodeId);
+                this.extractTypeRefsFromSubtree(params, nodeId, 'type_of');
             }
         }
         // Extract return type annotation
         const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, this.extractor.returnField || 'return_type');
         if (returnType) {
-            this.extractTypeRefsFromSubtree(returnType, nodeId);
+            this.extractTypeRefsFromSubtree(returnType, nodeId, 'returns');
         }
         // Scala context bounds / type-parameter bounds: `def f[A: Monoid]`,
         // `[F[_]: Monad]`, `[A <: Foo]` carry the bound type inside `type_parameters`.
@@ -5711,13 +5718,46 @@ class TreeSitterExtractor {
         if (this.language === 'scala') {
             const typeParams = node.namedChildren.find((c) => c.type === 'type_parameters');
             if (typeParams) {
-                this.extractTypeRefsFromSubtree(typeParams, nodeId);
+                this.extractTypeRefsFromSubtree(typeParams, nodeId, 'type_of');
             }
         }
         // Extract direct type annotation (for class fields like `model: ITextModel`)
         const typeAnnotation = node.namedChildren.find((c) => c.type === 'type_annotation');
         if (typeAnnotation) {
-            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId);
+            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId, 'type_of');
+        }
+    }
+    /**
+     * Spec 0066: when the AST omitted return/param types, emit unresolved
+     * `returns` / `type_of` refs from JSDoc `@returns` / `@param {Type}`.
+     */
+    emitJsdocTypeFallbacks(fromNodeId, docstring) {
+        if (!docstring)
+            return;
+        const hasReturns = this.unresolvedReferences.some((r) => r.fromNodeId === fromNodeId && r.referenceKind === 'returns');
+        if (!hasReturns) {
+            const ret = (0, jsdoc_type_tags_1.parseJsdocReturns)(docstring);
+            if (ret) {
+                this.unresolvedReferences.push({
+                    fromNodeId,
+                    referenceName: ret,
+                    referenceKind: 'returns',
+                    line: 1,
+                    column: 0,
+                });
+            }
+        }
+        const hasTypeOf = this.unresolvedReferences.some((r) => r.fromNodeId === fromNodeId && r.referenceKind === 'type_of');
+        if (!hasTypeOf) {
+            for (const p of (0, jsdoc_type_tags_1.parseJsdocParams)(docstring)) {
+                this.unresolvedReferences.push({
+                    fromNodeId,
+                    referenceName: p.typeName,
+                    referenceKind: 'type_of',
+                    line: 1,
+                    column: 0,
+                });
+            }
         }
     }
     /**
@@ -5923,21 +5963,22 @@ class TreeSitterExtractor {
         // Find type_annotation child (covers TS `: Type`, Rust `: Type`, etc.)
         const typeAnnotation = node.namedChildren.find((c) => c.type === 'type_annotation');
         if (typeAnnotation) {
-            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId);
+            this.extractTypeRefsFromSubtree(typeAnnotation, nodeId, 'type_of');
         }
     }
     /**
      * Recursively walk a subtree and extract all type_identifier references.
      * Handles unions, intersections, generics, arrays, etc.
+     * Spec 0066: callers pass `returns` / `type_of` for signature positions.
      */
-    extractTypeRefsFromSubtree(node, fromNodeId) {
+    extractTypeRefsFromSubtree(node, fromNodeId, referenceKind = 'references') {
         if (node.type === 'type_identifier') {
             const typeName = (0, tree_sitter_helpers_1.getNodeText)(node, this.source);
             if (typeName && !this.BUILTIN_TYPES.has(typeName)) {
                 this.unresolvedReferences.push({
                     fromNodeId,
                     referenceName: typeName,
-                    referenceKind: 'references',
+                    referenceKind,
                     line: node.startPosition.row + 1,
                     column: node.startPosition.column,
                 });
@@ -5948,7 +5989,7 @@ class TreeSitterExtractor {
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (child) {
-                this.extractTypeRefsFromSubtree(child, fromNodeId);
+                this.extractTypeRefsFromSubtree(child, fromNodeId, referenceKind);
             }
         }
     }

package/dist/index.js

@@ -490,7 +490,37 @@ class HomeGraph {
                     this.db.beginBulkParseLoad();
                 let result;
                 try {
-                    result = await this.orchestrator.indexAll(options.onProgress, options.signal, options.verbose, walValve ? () => walValve.backpressure() : undefined, freshDb ? { dbPath: this.db.getPath(), fastInit } : null);
+                    result = await this.orchestrator.indexAll(options.onProgress, options.signal, options.verbose, walValve ? () => walValve.backpressure() : undefined, freshDb
+                        ? {
+                            dbPath: this.db.getPath(),
+                            fastInit,
+                            // Spec 0065: exclusive store-worker handoff (close main → worker → reopen).
+                            exclusiveHandoff: {
+                                release: () => {
+                                    this.db.closeForExclusiveWriter();
+                                },
+                                reclaim: () => {
+                                    this.db.reopenAfterExclusiveWriter({ fastInit });
+                                    this.queries.rebind(this.db.getDb());
+                                    (0, context_1.bindExtractionContext)(this.projectRoot, this.queries);
+                                    // ATTACH is per-connection. ohosApiDbPath survives rebind and
+                                    // would make attachOhosApiDb early-return while the schema
+                                    // is gone → "no such table: ohos_api.nodes". Clear then reattach.
+                                    const priorOhos = this.queries.getOhosApiDbPath();
+                                    this.queries.attachOhosApiDb(null);
+                                    if (priorOhos) {
+                                        this.queries.attachOhosApiDb(priorOhos);
+                                    }
+                                    else if ((0, graph_sources_1.graphSourceFlags)(this.graphSources).sdk) {
+                                        (0, arkts_1.restoreOhosApiDbAttach)(this.queries);
+                                        if (!this.queries.getOhosApiDbPath()) {
+                                            (0, arkts_1.attachExistingOhosApiDbForProject)(this.projectRoot, this.queries);
+                                        }
+                                    }
+                                },
+                            },
+                        }
+                        : null);
                 }
                 finally {
                     if (freshDb) {

package/dist/resolution/callback-synthesizer.d.ts

@@ -25,6 +25,18 @@ import type { Edge } from '../types';
 import type { QueryBuilder } from '../db/queries';
 import type { ResolutionContext } from './types';
 import { type MaybeYield } from './cooperative-yield';
+/**
+ * Spec 0045 A — ArkUI parent build/@Builder → child @Component/@Builder.
+ * Analog of react jsx-child: only static PascalCase call names that resolve to
+ * a unique in-repo component/builder; ambiguous names are dropped.
+ *
+ * Scan the enclosing @Component/@Builder struct (or Builder function) body —
+ * not only the `build()` method span — because ArkUI trailing lambdas
+ * (`Column() { Child() }`) are often attributed with tight method ranges that
+ * omit nested call sites.
+ */
+/** @internal exported for PERF kind-scan regression tests (resolveChild name-miss path). */
+export declare function arkuiChildComponentEdges(ctx: ResolutionContext, onYield: MaybeYield): Promise<Edge[]>;
 /** `has(...)` shape passed to pass gates — true when the project contains any of the languages. */
 type HasLang = (...ls: string[]) => boolean;
 /**

package/dist/resolution/callback-synthesizer.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SYNTH_PROGRESS_STEPS = exports.SYNTH_PASSES = void 0;
+exports.arkuiChildComponentEdges = arkuiChildComponentEdges;
 exports.synthesizeCallbackEdges = synthesizeCallbackEdges;
 const generated_detection_1 = require("../extraction/generated-detection");
 const strip_comments_1 = require("./strip-comments");
@@ -1018,6 +1019,7 @@ function isArkuiBuildParent(n) {
  * (`Column() { Child() }`) are often attributed with tight method ranges that
  * omit nested call sites.
  */
+/** @internal exported for PERF kind-scan regression tests (resolveChild name-miss path). */
 async function arkuiChildComponentEdges(ctx, onYield) {
     const edges = [];
     const seen = new Set();
@@ -1033,15 +1035,10 @@ async function arkuiChildComponentEdges(ctx, onYield) {
         return '';
     };
     const resolveChild = (name, fromFile, parentId) => {
+        // Name index only — miss returns null. Framework PascalCase calls
+        // (Column/Button/Text/…) dominate misses and must not full-scan kinds
+        // (Spec 0063). Same drop policy as ambiguous multi-match below.
         let candidates = ctx.getNodesByName(name).filter(isArkuiChildTarget);
-        if (candidates.length === 0) {
-            candidates = [
-                ...ctx.getNodesByKind('struct'),
-                ...ctx.getNodesByKind('component'),
-                ...ctx.getNodesByKind('function'),
-                ...ctx.getNodesByKind('method'),
-            ].filter((n) => n.name === name && isArkuiChildTarget(n));
-        }
         candidates = candidates.filter((n) => n.id !== parentId);
         // Dedupe by id — name index can surface the same row twice across caches.
         candidates = [...new Map(candidates.map((n) => [n.id, n])).values()];

package/dist/resolution/name-matcher.d.ts

@@ -30,6 +30,11 @@ export declare function isKnownLanguageFamily(lang: string): boolean;
  * returns `false` here and is left alone.
  */
 export declare function crossesKnownFamily(a: string, b: string): boolean;
+/**
+ * Spec 0066: resolve a return/param type name to a unique type node.
+ * Ambiguous same-named types → no edge (wrong type hub is worse than none).
+ */
+export declare function matchTypeEdge(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
 /**
  * Resolve a function-as-value reference (#756) — a function name used as a
  * callback/function-pointer value (`register(handler)`, `o->cb = handler`,

package/dist/resolution/name-matcher.js

@@ -9,6 +9,7 @@ exports.matchByFilePath = matchByFilePath;
 exports.sameLanguageFamily = sameLanguageFamily;
 exports.isKnownLanguageFamily = isKnownLanguageFamily;
 exports.crossesKnownFamily = crossesKnownFamily;
+exports.matchTypeEdge = matchTypeEdge;
 exports.matchFunctionRef = matchFunctionRef;
 exports.matchByExactName = matchByExactName;
 exports.matchByQualifiedName = matchByQualifiedName;
@@ -193,7 +194,10 @@ function crossesKnownFamily(a, b) {
  *    both-known filter so `.vue`/`.svelte` (own tag) importing `.ts` survives.
  */
 function applyLanguageGate(candidates, ref) {
-    if (ref.referenceKind === 'references' || ref.referenceKind === 'function_ref') {
+    if (ref.referenceKind === 'references' ||
+        ref.referenceKind === 'function_ref' ||
+        ref.referenceKind === 'returns' ||
+        ref.referenceKind === 'type_of') {
         return candidates.filter((c) => sameLanguageFamily(c.language, ref.language));
     }
     if (ref.referenceKind === 'imports') {
@@ -201,6 +205,57 @@ function applyLanguageGate(candidates, ref) {
     }
     return candidates;
 }
+/** Spec 0066 — targets for `returns` / `type_of` edges (type-as-node). */
+const TYPE_EDGE_KINDS = new Set([
+    'class',
+    'interface',
+    'type_alias',
+    'enum',
+    'struct',
+    'protocol',
+    'trait',
+    'component',
+]);
+/**
+ * Spec 0066: resolve a return/param type name to a unique type node.
+ * Ambiguous same-named types → no edge (wrong type hub is worse than none).
+ */
+function matchTypeEdge(ref, context) {
+    if (ref.referenceKind !== 'returns' && ref.referenceKind !== 'type_of')
+        return null;
+    const simple = ref.referenceName.includes('.') || ref.referenceName.includes('::')
+        ? (ref.referenceName.split(/[.:]+/).filter(Boolean).pop() ?? ref.referenceName)
+        : ref.referenceName;
+    let candidates = context
+        .getNodesByName(simple)
+        .filter((n) => TYPE_EDGE_KINDS.has(n.kind) && n.id !== ref.fromNodeId);
+    candidates = applyLanguageGate(candidates, ref);
+    if (candidates.length === 0)
+        return null;
+    // Qualified exact: unique_id-style `A.B.Foo` / `A::Foo` against qualifiedName.
+    if (ref.referenceName.includes('.') || ref.referenceName.includes('::')) {
+        const qnHits = candidates.filter((n) => n.qualifiedName === ref.referenceName ||
+            n.qualifiedName.endsWith(`.${simple}`) ||
+            n.qualifiedName.endsWith(`::${simple}`));
+        if (qnHits.length === 1) {
+            return {
+                original: ref,
+                targetNodeId: qnHits[0].id,
+                confidence: 0.95,
+                resolvedBy: 'qualified-name',
+            };
+        }
+    }
+    const ordered = preferCallSiteFile(candidates, ref.filePath);
+    if (ordered.length !== 1)
+        return null;
+    return {
+        original: ref,
+        targetNodeId: ordered[0].id,
+        confidence: 0.9,
+        resolvedBy: 'exact-match',
+    };
+}
 /**
  * Resolve a function-as-value reference (#756) — a function name used as a
  * callback/function-pointer value (`register(handler)`, `o->cb = handler`,
@@ -2078,6 +2133,10 @@ function matchReference(ref, context) {
     if (ref.referenceKind === 'function_ref') {
         return matchFunctionRef(ref, context);
     }
+    // Spec 0066: returns / type_of — unique type node only; no fuzzy fallthrough.
+    if (ref.referenceKind === 'returns' || ref.referenceKind === 'type_of') {
+        return matchTypeEdge(ref, context);
+    }
     // ArkTS chained UI attributes — emitted with a leading dot (`.titleStyle`,
     // `.width`) by the extractor — resolve ONLY to decorator-marked attribute
     // helpers: `@Extend`/`@Styles`/`@AnimatableExtend` functions (and global

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homegraph",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "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",
@@ -25,6 +25,8 @@
     "test:node-matrix": "bash scripts/test-node-matrix.sh",
     "test:explore-routing": "node scripts/run-explore-routing.mjs",
     "eval": "npm run build && npx tsx test/evaluation/runner.ts",
+    "eval:peak-mem": "node --disable-warning=MODULE_TYPELESS_PACKAGE_JSON --experimental-strip-types test/evaluation/index-peak-mem.ts",
+    "soak:photos": "node test/harmony-callgraph-soak/run.mjs",
     "clean": "node -e \"const fs=require('fs');fs.rmSync('dist',{recursive:true,force:true})\""
   },
   "keywords": [