Index opted-in Android vendor source and cover Java/AIDL language cases

.github/workflows/ci.yml

@@ -89,6 +89,8 @@ jobs:
           __tests__/same-file-match-confidence.test.ts
           __tests__/mcp-idle-release-order.test.ts
           __tests__/aosp-*.test.ts
+          __tests__/android-platform-language-coverage.test.ts
+          __tests__/sync-import-retry.test.ts
           __tests__/kotlin-object-literal.test.ts
           __tests__/extraction.test.ts
           __tests__/resolution.test.ts

CHANGELOG.md

@@ -43,6 +43,9 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - Indexes built on machines set to different languages now agree. When a TypeScript `this.field.method()` call finds its type declared in two equally near apps, a C++ class names its base through an alias two headers declare differently, or a React Native module's Swift class has a copy in two app targets, the tie is now broken the same way everywhere. Before, it followed the system's language settings, so two machines could link the same call to different code. Thanks @bompus.
 - `codegraph sync` no longer fails with "FOREIGN KEY constraint failed" in a project whose code lazy-loads a workspace package, like Supabase Studio's `dynamic(() => import('icons').then((mod) => mod.EdgeFunctions))` or vben's `() => import('@vben/layouts').then((m) => m.IFrameView)`. Before, every sync after an edit in such a project rolled back, so the index stopped following your changes until a full re-index. Thanks @bompus for the report and @inth3shadows. (#2565)
 - `codegraph status`, and the status your agent sees through `codegraph_status`, now report uncommitted edits, new files and deletions in a project that sits in a folder of its git repository, like a monorepo package or an `app/` folder beside a `server/` one. Before, they said the index was up to date while `codegraph sync` found the very same changes. A file put back with git after a sync now shows as pending there too, and a project in a folder that its repository's `.gitignore` leaves out is checked file by file instead of always reading as unchanged. Thanks @innoxxicide for the report and the first fix. (#1636)
+- Android projects can opt their top-level vendor implementation source into indexing with `"include": ["vendor/"]` without broad include globs also admitting unrelated vendor dependencies, while nested dependencies and build output stay excluded and clean status checks avoid rereading unchanged vendor source.
+- Java generic inheritance and public nested interface calls now retain their valid links, cross-package calls to package-private methods are rejected, and annotated AIDL return methods are recognized; re-index affected projects after upgrading.
+
 - In VB.NET, every member of a `Structure` is now indexed, including its fields, properties, methods, constructors and nested enums. Before, only the first member was, so the rest could not be found and their callers looked empty.
 - In Delphi, a routine with an attribute on one of its parameters, like `const [ref] AValue: Integer` or DelphiMVCFramework's `const [MVCFromBody] Person: TPerson`, is now indexed with its calls, and so is every class member declared after it. Before, the routine was lost or its calls were credited to the file, the parameter showed up as a field of the class, and the members after it were missing. Thanks @stalexteam for the report. (#2545)
 - In Delphi, a `for … in` loop that declares its variable inline, like `for var lItem in AList do` or `for var lHandle: THandle in lHandles do`, now has its calls indexed, and a call on a typed loop variable reaches that type's method. Before, the whole loop was skipped, so a routine calling a method only from such a loop was missing from that method's callers. Thanks @stalexteam for the report. (#2546)

README.md

@@ -710,7 +710,9 @@ only revives embedded git repos, not plain source):
 
 CodeGraph discovers those files off disk, overriding `.gitignore`, on index,
 sync, and watch. An explicit `exclude` still wins, and built-in skips
-(`node_modules`, `dist`, `.git`) are never re-included.
+(`node_modules`, `dist`, `.git`) are never re-included. For Android platform
+trees, `"include": ["vendor/"]` explicitly includes project-root vendor
+implementations while keeping nested dependency and build directories skipped.
 
 Sometimes a directory shouldn't leave the index — you still want to find things
 in it — it just shouldn't *outrank* your real code. A `scripts/` or

__tests__/aosp-aidl.test.ts

@@ -408,18 +408,8 @@ describe('AOSP extension: findAidlImpl', () => {
         'package com.oem.vendor;\ninterface IVendorOnly {\n    void doVendorThing();\n}\n'
       );
       write(
-        // A Kotlin/Java implementer under vendor/ is deliberately NOT part
-        // of this fixture: CodeGraph's own core indexer (directory.ts,
-        // extraction/index.ts) ignores `vendor/` by default for every
-        // language, independent of this aosp extension — a Kotlin/Java
-        // implementer placed there would never produce an `unresolved_refs`
-        // hit no matter what this file discovers, and fixing that is a core
-        // indexing-policy change outside this fork's scope, not an aosp
-        // extension bug. This test only verifies the piece this extension
-        // DOES own: `findAidlFiles` walks its OWN file-system scan of
-        // `.aidl` files (which core never indexes for any repo) and must
-        // not silently drop a real vendor-tree declaration the way the
-        // previous `IGNORED_DIR_NAMES` did.
+        // This fixture isolates declaration discovery. A separate Android
+        // coverage test opts vendor/ implementation source into the core index.
         'src/UnrelatedNonVendor.kt',
         'package com.example.other\n\nclass UnrelatedNonVendor\n'
       );

codegraph-kernel/src/java.rs

@@ -678,6 +678,7 @@ impl<'t> Walker<'t> {
         let name = self.extract_name(node);
         let extra = Extra {
             docstring: preceding_docstring(node, self.src),
+            visibility: self.visibility_of(node),
             ..Extra::default()
         };
         let Some(row) = self.create_node("interface", &name, node, extra) else { return };
@@ -1058,7 +1059,7 @@ impl<'t> Walker<'t> {
                         None => child.named_child(0).into_iter().collect(),
                     };
                     for target in targets {
-                        let name = self.supertype_name(target);
+                        let name = strip_java_type_args(&self.supertype_name(target));
                         self.push_ref_at(class_row, &name, extends_kind, target);
                     }
                 }
@@ -1071,7 +1072,7 @@ impl<'t> Walker<'t> {
                         None => (0..child.named_child_count()).filter_map(|j| child.named_child(j)).collect(),
                     };
                     for iface in targets {
-                        let name = self.supertype_name(iface);
+                        let name = strip_java_type_args(&self.supertype_name(iface));
                         self.push_ref_at(class_row, &name, implements_kind, iface);
                     }
                 }
@@ -1707,6 +1708,16 @@ fn find_anonymous_class_body(node: Node) -> Option<Node> {
     None
 }
 
+/// Keep every qualified segment of a Java supertype while dropping type arguments.
+fn strip_java_type_args(raw: &str) -> String {
+    let mut depth = 0;
+    raw.chars().filter(|&ch| {
+        if ch == '<' { depth += 1; return false; }
+        if ch == '>' { depth -= 1; return false; }
+        depth == 0
+    }).collect::<String>().trim().to_string()
+}
+
 /// The `new ns.Foo<T>()` name normalization shared by instantiation /
 /// anonymous-class / decorator extraction: strip `<...` from the first `<`
 /// (index > 0), keep the segment after the last `.`/`::`, strip ONE leading

src/aosp/aidl.ts

@@ -122,7 +122,7 @@ export interface FindAidlImplResult {
 // itself ASCII, so the boundary check still does its job.
 const AIDL_INTERFACE_RE = /\binterface\s+([\p{L}\p{N}_$]+)\s*\{/gu;
 // AIDL method declarations: `<returnType> name(<params>);`, optional `oneway`.
-const AIDL_METHOD_RE = /^\s*(?:oneway\s+)?[\w<>[\],.\s]+?\s+([\p{L}\p{N}_$]+)\s*\([^;{]*\)\s*;/gmu;
+const AIDL_METHOD_RE = /^\s*(?:oneway\s+)?(?:@[\w.]+(?:\([^;]*?\))?\s+)*[\w<>[\],.\s]+?\s+([\p{L}\p{N}_$]+)\s*\([^;{]*\)\s*;/gmu;
 const AIDL_PACKAGE_RE = /^\s*package\s+([\p{L}\p{N}_.]+)\s*;/mu;
 // NOT a general-purpose "vendored third-party code" ignore list — this is an
 // AOSP-specific walker, and `vendor/` in an AOSP tree is a first-class,

src/aosp/hal.ts

@@ -42,7 +42,7 @@ import type { AospCandidate, FindAidlImplStatus, AidlDeclaration } from './aidl'
 // failed (the character right after the interface name is `e`, not `{`) —
 // the entire declaration went unmatched, not just mis-parsed.
 const HAL_INTERFACE_RE = /\binterface\s+([\p{L}\p{N}_$]+)(?:\s+extends\s+[\p{L}\p{N}_$.@:]+)?\s*\{/gu;
-const HAL_METHOD_RE = /^\s*(?:oneway\s+)?[\w<>[\],.\s]+?\s+([\p{L}\p{N}_$]+)\s*\([^;{]*\)\s*;/gmu;
+const HAL_METHOD_RE = /^\s*(?:oneway\s+)?(?:@[\w.]+(?:\([^;]*?\))?\s+)*[\w<>[\],.\s]+?\s+([\p{L}\p{N}_$]+)\s*\([^;{]*\)\s*;/gmu;
 // HIDL's package clause carries a version suffix (`package android.hardware.foo@1.0;`).
 // The bare package (with `@version` stripped) still needs to be captured for the
 // same-package-membership check, but the version itself is captured separately —

src/extraction/extraction-version.ts

@@ -21,4 +21,4 @@
  * turns the re-index hint into noise — keep it honest (see CLAUDE.md, "Honesty
  * in the product is load-bearing").
  */
-export const EXTRACTION_VERSION = 28;
+export const EXTRACTION_VERSION = 29;

src/extraction/index.ts

@@ -610,8 +610,10 @@ export function buildDefaultIgnore(rootDir: string): Ignore {
  * parent repo's own ignore rules must NOT apply — inside embedded child repos,
  * whose gitignore semantics their own `git ls-files` already enforced (#514).
  */
-function defaultsOnlyIgnore(): Ignore {
-  return excludeBuildOutputUnderSrc(ignore().add(DEFAULT_IGNORE_PATTERNS), null);
+function defaultsOnlyIgnore(allowVendor = false): Ignore {
+  // Only the project-root Android vendor tree is includable; nested vendor
+  // directories remain dependency trees at every depth.
+  return excludeBuildOutputUnderSrc(ignore().add(DEFAULT_IGNORE_PATTERNS.map((p) => allowVendor && p === 'vendor/' ? '/*/**/vendor/' : p)), null);
 }
 
 /**
@@ -700,6 +702,29 @@ function includeStaticRoots(patterns: string[]): string[] {
   return all.filter((r) => !all.some((other) => other !== r && r.startsWith(other)));
 }
 
+interface VendorInclude {
+  matcher: Ignore;
+  roots: string[];
+}
+
+/** Broad includes do not opt dependency trees in; root vendor source needs its own pattern. */
+function buildVendorInclude(patterns: string[]): VendorInclude | null {
+  const rooted = patterns.filter((p) => /^\/*vendor(?:\/|$)/i.test(p));
+  if (rooted.length === 0) return null;
+  return {
+    matcher: ignore().add(patterns.filter((p) => p.startsWith('!') || rooted.includes(p))),
+    roots: includeStaticRoots(rooted),
+  };
+}
+
+function permitsVendorInclude(rel: string, vendor: VendorInclude | null): boolean {
+  if (!/^vendor(?:\/|$)/i.test(rel)) return true;
+  if (!vendor) return false;
+  return rel.endsWith('/')
+    ? vendor.roots.some((root) => root.startsWith(rel) || rel.startsWith(root))
+    : vendor.matcher.ignores(rel);
+}
+
 /**
  * Actively discover the source files an `include` whitelist forces in. `git
  * ls-files` never lists gitignored files, so a filtered filesystem walk of just
@@ -716,24 +741,25 @@ function collectIncludedFiles(
   rootDir: string,
   include: Ignore,
   exclude: Ignore | null,
-  roots: string[],
+  patterns: string[],
   overrides: Record<string, Language>,
 ): Set<string> {
   const out = new Set<string>();
-  const defaults = defaultsOnlyIgnore();
+  const defaults = defaultsOnlyIgnore(true); // Explicit `include` may select AOSP vendor source.
+  const vendor = buildVendorInclude(patterns);
   const visited = new Set<string>();
 
   const consider = (abs: string, rel: string, isDir: boolean): void => {
     if (isDir) {
-      if (defaults.ignores(rel + '/')) return; // never node_modules/dist/… via include
+      if (defaults.ignores(rel + '/') || !permitsVendorInclude(rel + '/', vendor)) return;
       // An explicit `exclude` always wins over `include`; prune the whole subtree
       // here so a large excluded dir (a committed frontend's own vendored deps,
       // build output, …) is never walked — the per-file guard below still catches
       // anything a directory pattern doesn't, so this is a pure efficiency win.
       if (exclude && exclude.ignores(rel + '/')) return;
       walk(abs);
     } else {
-      if (defaults.ignores(rel)) return;
+      if (defaults.ignores(rel) || !permitsVendorInclude(rel, vendor)) return;
       if (!include.ignores(rel)) return;
       if (exclude && exclude.ignores(rel)) return;
       if (!isSourceFile(rel, overrides, rootDir)) return;
@@ -775,7 +801,7 @@ function collectIncludedFiles(
     }
   }
 
-  for (const root of roots) {
+  for (const root of includeStaticRoots(patterns)) {
     walk(root === '' ? rootDir : path.join(rootDir, root));
   }
   return out;
@@ -790,8 +816,7 @@ function collectIncludedFiles(
 function collectIncludedFilesForRoot(rootDir: string): Set<string> {
   const include = loadIncludeMatcher(rootDir);
   if (!include) return new Set();
-  const roots = includeStaticRoots(loadIncludePatterns(rootDir));
-  return collectIncludedFiles(rootDir, include, loadExcludeMatcher(rootDir), roots, loadExtensionOverrides(rootDir));
+  return collectIncludedFiles(rootDir, include, loadExcludeMatcher(rootDir), loadIncludePatterns(rootDir), loadExtensionOverrides(rootDir));
 }
 
 /**
@@ -971,6 +996,7 @@ export function preloadLanguagesForFiles(
 export class ScopeIgnore {
   private embedded: Array<{ root: string; matcher: Ignore }>;
   private defaults: Ignore = defaultsOnlyIgnore();
+  private includableDefaults: Ignore = defaultsOnlyIgnore(true);
   constructor(
     private rootMatcher: Ignore,
     embedded: Array<{ root: string; matcher: Ignore }>,
@@ -1000,6 +1026,7 @@ export class ScopeIgnore {
      * folder named `[draft]` or `a[b` read as a glob (or did not compile).
      */
     private gitIgnoredDirs: ReadonlySet<string> = new Set(),
+    private vendorInclude: VendorInclude | null = null,
   ) {
     // Longest root first so paths in nested embedded repos hit the innermost matcher.
     this.embedded = [...embedded].sort((a, b) => b.root.length - a.root.length);
@@ -1022,7 +1049,7 @@ export class ScopeIgnore {
     // User `include`: force first-party source in despite `.gitignore`. Never
     // resurfaces a built-in default-ignored dir (node_modules/dist/…), so an
     // include pattern can't accidentally pull in dependency/build trees.
-    if (this.include && !this.defaults.ignores(rel)) {
+    if (this.include && !this.includableDefaults.ignores(rel) && permitsVendorInclude(rel, this.vendorInclude)) {
       if (rel.endsWith('/')) {
         // A directory on (or leading to) an included subtree must stay walkable
         // so the watcher/walker descends to reach the forced-in files.
@@ -1068,6 +1095,7 @@ export function buildScopeIgnore(rootDir: string, embeddedRoots?: Iterable<strin
     include,
     include ? includeStaticRoots(loadIncludePatterns(rootDir)) : [],
     new Set(listGitIgnoredDirectories(rootDir)),
+    include ? buildVendorInclude(loadIncludePatterns(rootDir)) : null,
   );
 }
 
@@ -4087,7 +4115,15 @@ export class ExtractionOrchestrator {
       // Git supplies candidates, never the verdict. A committed deletion may
       // have been recreated locally; a previously indexed dirty path may have
       // vanished from git status after restore. Classify current disk vs DB once.
-      const candidates = new Set([...gitChanges.deleted, ...gitChanges.modified, ...gitChanges.added, ...dirtyPaths!]);
+      const gitCandidates = new Set([...gitChanges.deleted, ...gitChanges.modified, ...gitChanges.added, ...dirtyPaths!]);
+      const candidates = new Set(gitCandidates);
+      const include = loadIncludeMatcher(this.rootDir);
+      if (include) {
+        for (const file of collectIncludedFilesForRoot(this.rootDir)) candidates.add(file);
+        for (const file of this.queries.getAllFiles()) {
+          if (include.ignores(file.path)) candidates.add(file.path);
+        }
+      }
       const scope = this.scopedSyncMatcher();
       const overrides = loadExtensionOverrides(this.rootDir);
       for (const filePath of candidates) {
@@ -4097,6 +4133,18 @@ export class ExtractionOrchestrator {
           if (tracked) removed.push(filePath);
           continue;
         }
+        // Include-only candidates can be gitignored and need a disk check, but
+        // unchanged size/mtime avoids reading all vendor source on every status.
+        // Keep hashing paths Git or the dirty ledger explicitly reported.
+        if (tracked && !gitCandidates.has(filePath)) {
+          try {
+            const stat = fs.statSync(fullPath);
+            if (stat.size === tracked.size && Math.floor(stat.mtimeMs) === Math.floor(tracked.modifiedAt)) continue;
+          } catch (error) {
+            logDebug('Skipping unstattable file while detecting changes', { filePath, error: String(error) });
+            continue;
+          }
+        }
         let content: string | null;
         try { content = readSourceOrStamp(fullPath); }
         catch (error) {

src/extraction/tree-sitter.ts

@@ -2886,6 +2886,7 @@ export class TreeSitterExtractor {
 
     const interfaceNode = this.createNode(kind, name, node, {
       docstring,
+      visibility: this.language === 'java' ? this.extractor.getVisibility?.(node) : undefined,
       isExported,
     });
     if (!interfaceNode) return;
@@ -8006,7 +8007,9 @@ export class TreeSitterExtractor {
         const targets = typeList ? typeList.namedChildren : [child.namedChild(0)];
         for (const target of targets) {
           if (target) {
-            const name = supertypeName(target, this.source);
+            const name = this.language === 'java'
+              ? stripCppTemplateArgs(supertypeName(target, this.source))
+              : supertypeName(target, this.source);
             this.unresolvedReferences.push({
               fromNodeId: classId,
               referenceName: name,
@@ -8073,7 +8076,9 @@ export class TreeSitterExtractor {
         const targets = typeList ? typeList.namedChildren : child.namedChildren;
         for (const iface of targets) {
           if (iface) {
-            const name = supertypeName(iface, this.source);
+            const name = this.language === 'java'
+              ? stripCppTemplateArgs(supertypeName(iface, this.source))
+              : supertypeName(iface, this.source);
             this.unresolvedReferences.push({
               fromNodeId: classId,
               referenceName: name,