cortexcode 0.9.1__tar.gz → 0.10.0__tar.gz

{cortexcode-0.9.1 → cortexcode-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortexcode
-Version: 0.9.1
+Version: 0.10.0
 Summary: Lightweight code indexing for AI assistants — build a searchable codegraph and grounded context
 Author-email: Naveen <naveen_joshi07@outlook.com>
 License: MIT

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/diagrams/architecture.py

@@ -35,6 +35,21 @@ def generate_architecture_diagram(index_data: dict[str, Any]) -> str:
                 lines.append(f"        {framework_id}[\"{framework.get('name', 'unknown')} ({framework.get('count', 0)})\"]")
             lines.append("    end")
 
+        # Nx project graph overlay
+        nx_graph = project_profile.get("nx_project_graph", {})
+        nx_projects = project_profile.get("nx_projects", [])
+        if nx_graph and nx_projects:
+            lines.append("    subgraph nx_workspace [Nx Workspace]")
+            for proj_name in nx_projects:
+                proj_id = sanitize_id(f"nx_{proj_name}")
+                lines.append(f"        {proj_id}[\"{proj_name}\"]")
+            lines.append("    end")
+            for proj_name, deps in nx_graph.items():
+                proj_id = sanitize_id(f"nx_{proj_name}")
+                for dep in deps[:10]:
+                    dep_id = sanitize_id(f"nx_{dep}")
+                    lines.append(f"        {proj_id} --> {dep_id}")
+
         return "\n".join(lines)
 
     files = index_data.get("files", {})

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/indexer.py

@@ -27,6 +27,7 @@ from cortexcode.indexing.resolution import (
     build_file_dependencies,
     build_type_map,
 )
+from cortexcode.indexing.nx_projects import parse_nx_workspace, build_nx_project_graph
 from cortexcode.plugins import plugin_registry
 
 
@@ -223,18 +224,32 @@ class CodeIndexer(IndexerExtractorMixin):
     
     def _build_index(self, root: Path) -> dict[str, Any]:
         """Build the final index structure."""
+        nx_workspace = parse_nx_workspace(root)
+        tsconfig_paths = nx_workspace.get("tsconfig_paths", {}) if nx_workspace else {}
+
+        def _build_file_deps(ts_paths=None):
+            return build_file_dependencies(self.file_symbols, ts_paths)
+
+        def _build_type_map(ts_paths=None):
+            return build_type_map(self.file_symbols, ts_paths)
+
+        def _build_project_profile(_root, file_deps, nx=None):
+            return build_project_profile(self.file_symbols, self.call_graph, file_deps, nx)
+
         result = build_index_result(
             root=root,
             file_symbols=self.file_symbols,
             call_graph=self.call_graph,
             timestamp=timestamp_now(),
             file_hashes=compute_hashes(root, self.file_symbols),
-            build_file_dependencies_fn=lambda: build_file_dependencies(self.file_symbols),
-            build_type_map_fn=lambda: build_type_map(self.file_symbols),
-            build_project_profile_fn=lambda _root, file_deps: build_project_profile(self.file_symbols, self.call_graph, file_deps),
+            build_file_dependencies_fn=lambda ts_paths=tsconfig_paths: _build_file_deps(ts_paths),
+            build_type_map_fn=lambda ts_paths=tsconfig_paths: _build_type_map(ts_paths),
+            build_project_profile_fn=lambda _root, file_deps, nx=nx_workspace: _build_project_profile(_root, file_deps, nx),
             language_map=LANGUAGE_MAP,
             regex_languages=REGEX_LANGUAGES,
             plugin_registry=plugin_registry,
+            nx_workspace=nx_workspace,
+            tsconfig_paths=tsconfig_paths,
         )
         # Add source code for context retrieval
         result["source_code"] = self.source_code

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/indexing/build.py

@@ -18,6 +18,8 @@ def build_index_result(
     language_map: LanguageMap,
     regex_languages: RegexLanguages,
     plugin_registry,
+    nx_workspace: dict[str, Any] | None = None,
+    tsconfig_paths: dict[str, str] | None = None,
 ) -> dict[str, Any]:
     languages = set()
     for file_path in file_symbols.keys():
@@ -30,9 +32,9 @@ def build_index_result(
         else:
             languages.add(ext.lstrip("."))
 
-    file_deps = build_file_dependencies_fn()
-    type_map = build_type_map_fn()
-    project_profile = build_project_profile_fn(root, file_deps)
+    file_deps = build_file_dependencies_fn(tsconfig_paths)
+    type_map = build_type_map_fn(tsconfig_paths)
+    project_profile = build_project_profile_fn(root, file_deps, nx_workspace)
 
     result = {
         "project_root": str(root),
@@ -48,4 +50,9 @@ def build_index_result(
     if type_map:
         result["type_map"] = type_map
 
+    if nx_workspace:
+        result["nx_workspace"] = nx_workspace
+        if tsconfig_paths:
+            result["nx_workspace"]["tsconfig_paths"] = tsconfig_paths
+
     return plugin_registry.run_post_processors(result)

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/indexing/defaults.py

@@ -4,7 +4,7 @@ DEFAULT_IGNORE_PATTERNS = {
     "*.egg-info", ".eggs", "*.pyc", "*.pyo",
     "node_modules", ".npm", ".yarn", ".pnpm-store", "bower_components",
     "dist", "build", "out", "output", "target", "bin", "obj",
-    ".build", "_build", "public/build", "lib",
+    ".build", "_build", "public/build",
     ".next", ".nuxt", ".svelte-kit", ".angular", ".turbo",
     ".parcel-cache", ".webpack", ".rollup.cache", ".vite",
     ".expo", ".gradle", "Pods", "DerivedData",

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/indexing/filtering.py

@@ -22,7 +22,7 @@ def should_ignore_file(
     rel_posix = rel_path.as_posix()
 
     for pattern in default_ignore_patterns:
-        if pattern in path_str or pattern in path_posix or pattern in rel_posix:
+        if pattern in rel_str or pattern in rel_posix:
             return True
 
     for pattern in exclude_patterns:

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/indexing/imports_exports.py

@@ -139,6 +139,13 @@ def find_js_exports(node: Any, exports: list[dict[str, Any]], get_node_name: Get
                                 name = export_clause_child.child_by_field_name("name")
                                 if name:
                                     exports.append({"name": name.text.decode("utf-8"), "type": "named"})
+            elif child.type == "export_clause":
+                # Barrel re-export: export { Button } from './lib/button'
+                for export_clause_child in child.children:
+                    if export_clause_child.type == "export_specifier":
+                        name = export_clause_child.child_by_field_name("name")
+                        if name:
+                            exports.append({"name": name.text.decode("utf-8"), "type": "re-export"})
             elif child.type == "variable_declaration":
                 for declaration_child in child.children:
                     if declaration_child.type == "variable_declarator":

cortexcode-0.10.0/cortexcode/indexing/nx_projects.py

@@ -0,0 +1,228 @@
+"""Nx monorepo workspace parsing and project graph extraction.
+
+Handles modern Nx workspaces (v15+) where project configuration lives in
+individual project.json files rather than a centralized workspace.json.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def _safe_json(path: Path) -> dict[str, Any] | None:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _find_project_jsons(root: Path) -> list[Path]:
+    """Find all project.json files under apps/ and libs/ directories."""
+    project_jsons: list[Path] = []
+    for candidate_dir in ("apps", "libs", "packages"):
+        candidate = root / candidate_dir
+        if candidate.is_dir():
+            for sub in candidate.rglob("project.json"):
+                project_jsons.append(sub)
+    return sorted(project_jsons)
+
+
+def parse_nx_workspace(root: Path) -> dict[str, Any] | None:
+    """Parse an Nx workspace and return project graph + path mappings.
+
+    Returns None if the directory does not look like an Nx workspace.
+    """
+    root = Path(root).resolve()
+    nx_json = root / "nx.json"
+    if not nx_json.exists():
+        return None
+
+    nx_config = _safe_json(nx_json) or {}
+
+    # Collect projects from project.json files
+    projects: dict[str, dict[str, Any]] = {}
+    for project_json_path in _find_project_jsons(root):
+        data = _safe_json(project_json_path)
+        if not data:
+            continue
+        name = data.get("name", project_json_path.parent.name)
+        projects[name] = {
+            "name": name,
+            "projectType": data.get("projectType", "library"),
+            "sourceRoot": data.get("sourceRoot", str(project_json_path.parent.relative_to(root))),
+            "tags": data.get("tags", []),
+            "implicitDependencies": data.get("implicitDependencies", []),
+            "root": str(project_json_path.parent.relative_to(root)).replace("\\", "/"),
+            "targets": data.get("targets", {}),
+            "project_json": str(project_json_path.relative_to(root)).replace("\\", "/"),
+        }
+
+    if not projects:
+        return None
+
+    # Parse tsconfig.base.json for path mappings
+    tsconfig_paths = _parse_tsconfig_paths(root)
+
+    return {
+        "nx_version": nx_config.get("nxVersion", nx_config.get("installationVersion")),
+        "projects": projects,
+        "tsconfig_paths": tsconfig_paths,
+        "namedInputs": nx_config.get("namedInputs", {}),
+        "targetDefaults": nx_config.get("targetDefaults", {}),
+    }
+
+
+def _parse_tsconfig_paths(root: Path) -> dict[str, str]:
+    """Parse tsconfig.base.json (or tsconfig.json) compilerOptions.paths.
+
+    Returns a mapping of alias -> relative directory path.
+    """
+    for tsconfig_name in ("tsconfig.base.json", "tsconfig.json"):
+        tsconfig = root / tsconfig_name
+        if not tsconfig.exists():
+            continue
+        data = _safe_json(tsconfig)
+        if not data:
+            continue
+        paths = data.get("compilerOptions", {}).get("paths", {})
+        result: dict[str, str] = {}
+        for alias, targets in paths.items():
+            if not targets:
+                continue
+            # Take the first mapping; remove trailing /index.ts if present
+            target = targets[0]
+            target = target.rstrip("/").replace("\\", "/")
+            if target.endswith("/index.ts") or target.endswith("/index.tsx") or target.endswith("/index.js"):
+                target = str(Path(target).parent).replace("\\", "/")
+            result[alias] = target
+        return result
+    return {}
+
+
+def nx_framework_from_executor(targets: dict[str, Any]) -> str | None:
+    """Infer framework from Nx target executors / generators."""
+    for target_name, target in targets.items():
+        executor = target.get("executor", "")
+        if not executor:
+            continue
+
+        if "@nx/angular" in executor or "@angular-devkit" in executor:
+            return "angular"
+        if "@nx/react" in executor or "@nx/webpack" in executor:
+            return "react"
+        if "@nx/next" in executor:
+            return "nextjs"
+        if "@nx/vue" in executor or "@nx/vite" in executor and "vue" in executor.lower():
+            return "vue"
+        if "@nx/nuxt" in executor:
+            return "nuxt"
+        if "@nx/expo" in executor:
+            return "expo"
+        if "@nx/react-native" in executor:
+            return "react-native"
+        if "@nx/nest" in executor or "@nestjs" in executor:
+            return "nestjs"
+        if "@nx/node" in executor or "@nx/express" in executor:
+            return "nodejs"
+        if "@nx/plugin" in executor:
+            return "nx-plugin"
+
+    return None
+
+
+def build_nx_project_graph(
+    workspace: dict[str, Any],
+    file_dependencies: dict[str, list[str]] | None = None,
+) -> dict[str, list[str]]:
+    """Build adjacency list of project -> dependent project names.
+
+    Uses both implicitDependencies from project.json and file-level imports
+    (when file_dependencies is provided) to derive cross-project edges.
+    """
+    projects = workspace.get("projects", {})
+    tsconfig_paths = workspace.get("tsconfig_paths", {})
+
+    # Build reverse lookups
+    alias_to_project: dict[str, str] = {}
+    for name, proj in projects.items():
+        for alias, target in tsconfig_paths.items():
+            if target.startswith(proj["root"] + "/") or target == proj["root"]:
+                alias_to_project[alias] = name
+
+    # Map file path -> project name
+    file_to_project: dict[str, str] = {}
+    for name, proj in projects.items():
+        root = proj["root"]
+        for file_path in (file_dependencies or {}).keys():
+            if file_path.startswith(root + "/") or file_path == root:
+                file_to_project[file_path] = name
+
+    graph: dict[str, set[str]] = {name: set() for name in projects}
+
+    # Implicit dependencies from project.json
+    for name, proj in projects.items():
+        for dep in proj.get("implicitDependencies", []):
+            if dep in projects:
+                graph[name].add(dep)
+
+    # Derive from file dependencies: if a file in project A imports a file in project B
+    if file_dependencies:
+        for source_file, target_files in file_dependencies.items():
+            source_proj = file_to_project.get(source_file)
+            if not source_proj:
+                continue
+            for target_file in target_files:
+                target_proj = file_to_project.get(target_file)
+                if target_proj and target_proj != source_proj:
+                    graph[source_proj].add(target_proj)
+
+    # Also derive from tsconfig alias usage in imports
+    # (file_dependencies already captures resolved files, so this is redundant
+    #  but kept as a fallback if file_deps resolution missed something)
+    return {name: sorted(deps) for name, deps in graph.items()}
+
+
+def detect_shell_app(workspace: dict[str, Any], project_graph: dict[str, list[str]] | None = None) -> str | None:
+    """Identify the likely shell / root application in an Nx workspace.
+
+    Heuristics (in order of priority):
+      1. A project tagged "shell" or "host" or "root".
+      2. An application with the most outgoing project dependencies.
+      3. An application named "shell", "host", "app", or matching the repo name.
+    """
+    projects = workspace.get("projects", {})
+    if not projects:
+        return None
+
+    apps = {n: p for n, p in projects.items() if p.get("projectType") == "application"}
+    if not apps:
+        return None
+
+    # 1. Tag-based detection
+    shell_tags = {"shell", "host", "root", "entry", "main"}
+    for name, proj in apps.items():
+        tags = {t.lower() for t in proj.get("tags", [])}
+        if tags & shell_tags:
+            return name
+
+    # 2. Most outgoing deps among apps
+    graph = project_graph or build_nx_project_graph(workspace)
+    if graph:
+        sorted_apps = sorted(
+            apps.keys(),
+            key=lambda n: len(graph.get(n, [])),
+            reverse=True,
+        )
+        if sorted_apps and graph.get(sorted_apps[0]):
+            return sorted_apps[0]
+
+    # 3. Name heuristic
+    for keyword in ("shell", "host", "app", "main", "root"):
+        for name in apps:
+            if keyword in name.lower():
+                return name
+
+    # Fallback: first application
+    return next(iter(apps))

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/indexing/pipeline.py

@@ -33,7 +33,7 @@ def index_file(
     except (UnicodeDecodeError, OSError):
         return None
 
-    rel_path = str(file_path.relative_to(root))
+    rel_path = file_path.relative_to(root).as_posix()
 
     plugin_symbols = plugin_registry.extract_symbols(content, ext, rel_path)
     if plugin_symbols is not None:

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/indexing/profile.py

@@ -1,6 +1,8 @@
 from pathlib import Path
 from typing import Any
 
+from .nx_projects import nx_framework_from_executor
+
 
 FRONTEND_FRAMEWORKS = {"react", "react-native", "nextjs", "angular", "expo", "flutter", "swiftui", "uikit", "remix"}
 
@@ -42,7 +44,7 @@ def normalize_framework(framework: str | None) -> str | None:
     return normalized
 
 
-def infer_file_role(rel_path: str, file_data: dict[str, Any]) -> str:
+def infer_file_role(rel_path: str, file_data: dict[str, Any], nx_workspace: dict[str, Any] | None = None) -> str:
     normalized_path = rel_path.replace("\\", "/").lower()
     file_name = Path(normalized_path).name
     symbols = file_data.get("symbols", [])
@@ -54,6 +56,27 @@ def infer_file_role(rel_path: str, file_data: dict[str, Any]) -> str:
         if isinstance(sym, dict) and sym.get("framework")
     }
 
+    # Nx monorepo: infer role from project type (app vs lib) and path
+    if nx_workspace:
+        projects = nx_workspace.get("projects", {})
+        for proj in projects.values():
+            root = proj.get("root", "")
+            if root and normalized_path.startswith(root.lower() + "/"):
+                ptype = proj.get("projectType", "")
+                tags = [t.lower() for t in proj.get("tags", [])]
+                if ptype == "application":
+                    return "app"
+                # Library roles from tags
+                if any(t in tags for t in ("ui", "frontend", "component")):
+                    return "ui"
+                if any(t in tags for t in ("data", "model", "entity", "db")):
+                    return "data"
+                if any(t in tags for t in ("api", "service", "controller", "route")):
+                    return "api"
+                if any(t in tags for t in ("util", "shared", "helper", "infra")):
+                    return "infra"
+                return "lib"
+
     if file_name in ("cli.py", "manage.py") or any(segment in normalized_path for segment in ("/cli/", "/commands/")):
         return "cli"
     if routes or any(segment in normalized_path for segment in ("/api/", "/routes/", "/route/", "/controllers/", "/handlers/", "/endpoints/")):
@@ -137,6 +160,7 @@ def build_project_profile(
     file_symbols: dict[str, Any],
     call_graph: dict[str, list[str]],
     file_deps: dict[str, list[str]],
+    nx_workspace: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     framework_counts: dict[str, int] = {}
     symbol_type_counts: dict[str, int] = {}
@@ -155,7 +179,7 @@ def build_project_profile(
         symbols = file_data.get("symbols", [])
         api_routes = file_data.get("api_routes", [])
         entities = file_data.get("entities", [])
-        role = infer_file_role(rel_path, file_data)
+        role = infer_file_role(rel_path, file_data, nx_workspace)
         role_by_file[rel_path] = role
 
         bucket = layer_stats.setdefault(role, {"files": 0, "symbols": 0, "routes": 0, "entities": 0})
@@ -189,6 +213,15 @@ def build_project_profile(
 
         entry_points.extend(infer_file_entry_points(rel_path, file_data, callers))
 
+    # Augment with Nx project-level framework detection from executors
+    if nx_workspace:
+        for project in nx_workspace.get("projects", {}).values():
+            fw = nx_framework_from_executor(project.get("targets", {}))
+            if fw:
+                nf = normalize_framework(fw)
+                if nf:
+                    framework_counts[nf] = framework_counts.get(nf, 0) + 1
+
     layer_dependencies: dict[tuple[str, str], int] = {}
     for source_file, target_files in file_deps.items():
         source_role = role_by_file.get(source_file, "core")
@@ -249,7 +282,7 @@ def build_project_profile(
 
     recommendations = build_recommendations(frameworks, route_samples, entity_samples, layers)
 
-    return {
+    profile = {
         "frameworks": frameworks,
         "symbol_types": [
             {"name": symbol_type, "count": count}
@@ -269,3 +302,15 @@ def build_project_profile(
         "entity_samples": entity_samples[:20],
         "recommendations": recommendations,
     }
+
+    # Add Nx project graph if available
+    if nx_workspace:
+        from cortexcode.indexing.nx_projects import build_nx_project_graph, detect_shell_app
+        nx_graph = build_nx_project_graph(nx_workspace, file_deps)
+        profile["nx_project_graph"] = nx_graph
+        profile["nx_projects"] = list(nx_workspace.get("projects", {}).keys())
+        shell = detect_shell_app(nx_workspace, nx_graph)
+        if shell:
+            profile["nx_shell_app"] = shell
+
+    return profile

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/indexing/resolution.py

@@ -33,6 +33,7 @@ def build_exports_by_file(file_symbols: dict[str, Any]) -> dict[str, dict[str, d
                     "defined_in": rel_path,
                     "type": exp.get("type", "export"),
                     "line": exp.get("line"),
+                    "source": exp.get("source"),
                 }
 
         exports_by_file[rel_path] = file_exports
@@ -74,7 +75,12 @@ def build_module_lookup(file_symbols: dict[str, Any]) -> dict[str, set[str]]:
     return module_lookup
 
 
-def candidate_module_keys(rel_path: str, imp: dict[str, Any]) -> list[str]:
+def candidate_module_keys(
+    rel_path: str,
+    imp: dict[str, Any],
+    tsconfig_paths: dict[str, str] | None = None,
+    root_path: str | None = None,
+) -> list[str]:
     module = str(imp.get("module", "")).strip()
     imported_names = [name for name in imp.get("imported", []) if name and name != "*"]
     if not module:
@@ -86,7 +92,7 @@ def candidate_module_keys(rel_path: str, imp: dict[str, Any]) -> list[str]:
 
     if module.startswith("."):
         dot_prefix = len(module) - len(module.lstrip("."))
-        remainder = module[dot_prefix:]
+        remainder = module[dot_prefix:].lstrip("/")
         base_dir = current_dir
         for _ in range(max(dot_prefix - 1, 0)):
             base_dir = base_dir.parent
@@ -99,6 +105,27 @@ def candidate_module_keys(rel_path: str, imp: dict[str, Any]) -> list[str]:
         for imported_name in imported_names:
             candidates.append(str(base_candidate / imported_name.replace(".", "/")))
     else:
+        # Nx / tsconfig path mapping: @scope/lib -> libs/scope/lib
+        if tsconfig_paths and module in tsconfig_paths:
+            mapped = tsconfig_paths[module]
+            candidates.append(mapped)
+            for imported_name in imported_names:
+                candidates.append(f"{mapped}/{imported_name.replace('.', '/')}")
+            return candidates
+        # Partial prefix match for sub-path imports like @scope/lib/sub
+        if tsconfig_paths and "/" in module:
+            parts = module.split("/")
+            # Handle scoped packages: @scope/lib/sub -> prefix is @scope/lib
+            prefix = "/".join(parts[:2]) if parts[0].startswith("@") else parts[0]
+            if prefix in tsconfig_paths:
+                mapped = tsconfig_paths[prefix]
+                suffix = module[len(prefix):].lstrip("/")
+                if suffix:
+                    candidates.append(f"{mapped}/{suffix.replace('.', '/')}")
+                else:
+                    candidates.append(mapped)
+                return candidates
+
         cleaned = module.replace("@/", "src/").replace("~/", "")
         candidates.append(cleaned)
         if "/" not in cleaned and "." in cleaned:
@@ -113,9 +140,10 @@ def resolve_import_to_files(
     rel_path: str,
     imp: dict[str, Any],
     module_lookup: dict[str, set[str]],
+    tsconfig_paths: dict[str, str] | None = None,
 ) -> list[str]:
     resolved_files = set()
-    for candidate in candidate_module_keys(rel_path, imp):
+    for candidate in candidate_module_keys(rel_path, imp, tsconfig_paths):
         normalized_candidate = normalize_module_key(candidate)
         if not normalized_candidate:
             continue
@@ -131,7 +159,29 @@ def resolve_import_to_files(
     return sorted(file_path for file_path in resolved_files if file_path != normalized_rel)
 
 
-def build_type_map(file_symbols: dict[str, Any]) -> dict[str, dict[str, Any]]:
+def _resolve_reexport_source(barrel_path: str, source: str, file_symbols: dict[str, Any]) -> str | None:
+    """Resolve a re-export source path like './lib/button' to an actual file path."""
+    if not source:
+        return None
+    source = source.lstrip("./")
+    dir_parts = barrel_path.split("/")[:-1]
+    while source.startswith("../"):
+        source = source[3:]
+        if dir_parts:
+            dir_parts.pop()
+    base = "/".join(dir_parts) + "/" + source if dir_parts else source
+    candidates = [base]
+    for ext in (".ts", ".tsx", ".js", ".jsx"):
+        candidates.append(base + ext)
+    for idx in ("index.ts", "index.tsx", "index.js", "index.jsx"):
+        candidates.append(base + "/" + idx)
+    for candidate in candidates:
+        if candidate in file_symbols:
+            return candidate
+    return None
+
+
+def build_type_map(file_symbols: dict[str, Any], tsconfig_paths: dict[str, str] | None = None) -> dict[str, dict[str, Any]]:
     exports_by_file = build_exports_by_file(file_symbols)
     module_lookup = build_module_lookup(file_symbols)
 
@@ -142,7 +192,7 @@ def build_type_map(file_symbols: dict[str, Any]) -> dict[str, dict[str, Any]]:
 
         for imp in file_data.get("imports", []):
             imported_names = imp.get("imported", [])
-            target_files = resolve_import_to_files(rel_path, imp, module_lookup)
+            target_files = resolve_import_to_files(rel_path, imp, module_lookup, tsconfig_paths)
             if not target_files:
                 continue
 
@@ -158,19 +208,34 @@ def build_type_map(file_symbols: dict[str, Any]) -> dict[str, dict[str, Any]]:
                     defn = target_exports[imported_name]
                     if defn["defined_in"] == rel_path:
                         continue
+                    # Trace re-exports through barrel files to actual definitions
+                    traced = defn
+                    depth = 0
+                    while traced.get("type") == "re-export" and traced.get("source") and depth < 3:
+                        resolved = _resolve_reexport_source(traced["defined_in"], traced["source"], file_symbols)
+                        if not resolved:
+                            break
+                        next_exports = exports_by_file.get(resolved, {})
+                        if imported_name not in next_exports:
+                            break
+                        traced = next_exports[imported_name]
+                        depth += 1
                     key = f"{rel_path}:{imported_name}"
                     type_map[key] = {
                         "imported_in": rel_path,
                         "name": imported_name,
-                        "defined_in": defn["defined_in"],
-                        "type": defn.get("type"),
-                        "line": defn.get("line"),
+                        "defined_in": traced["defined_in"],
+                        "type": traced.get("type"),
+                        "line": traced.get("line"),
                     }
 
     return type_map
 
 
-def build_file_dependencies(file_symbols: dict[str, Any]) -> dict[str, list[str]]:
+def build_file_dependencies(
+    file_symbols: dict[str, Any],
+    tsconfig_paths: dict[str, str] | None = None,
+) -> dict[str, list[str]]:
     deps = {}
     module_lookup = build_module_lookup(file_symbols)
 
@@ -183,7 +248,7 @@ def build_file_dependencies(file_symbols: dict[str, Any]) -> dict[str, list[str]
 
         dep_files = set()
         for imp in imports:
-            dep_files.update(resolve_import_to_files(rel_path, imp, module_lookup))
+            dep_files.update(resolve_import_to_files(rel_path, imp, module_lookup, tsconfig_paths))
 
         if dep_files:
             deps[rel_path] = sorted(dep_files)

{cortexcode-0.9.1 → cortexcode-0.10.0}/cortexcode/performance/performance_config.py

@@ -34,6 +34,26 @@ def detect_monorepo(root_path: Path) -> Optional[Dict[str, Any]]:
 
     nx_json = root_path / "nx.json"
     if nx_json.exists():
+        from cortexcode.indexing.nx_projects import parse_nx_workspace
+
+        nx_workspace = parse_nx_workspace(root_path)
+        if nx_workspace:
+            projects = nx_workspace.get("projects", {})
+            if projects:
+                # Use actual source roots as include patterns
+                patterns = []
+                for proj in projects.values():
+                    source_root = proj.get("sourceRoot", proj.get("root", ""))
+                    if source_root:
+                        patterns.append(f"{source_root}/**/*")
+                # Always include root-level configs (nx.json, tsconfig, package.json)
+                patterns.extend(["nx.json", "package.json", "tsconfig*.json"])
+                return {
+                    "type": "nx",
+                    "include_patterns": patterns,
+                    "nx_workspace": nx_workspace,
+                }
+        # Fallback: old-style nx.json with projects array (pre-Nx v15)
         try:
             data = json.loads(nx_json.read_text(encoding="utf-8"))
             projects = data.get("projects", [])