cortexcode 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

cortexcode/ai_docs/doc_generator.py

@@ -60,7 +60,7 @@ class AIDocGenerator:
             messages = prompts.generate_project_overview_prompt(index_data)
             output.overview = self._generate(messages, "overview")
             if output.overview:
-                (output_dir / "AI_OVERVIEW.md").write_text(output.overview)
+                (output_dir / "AI_OVERVIEW.md").write_text(output.overview, encoding="utf-8")
                 print("  -> AI_OVERVIEW.md")
         
         if "api" in docs:
@@ -68,7 +68,7 @@ class AIDocGenerator:
             messages = prompts.generate_api_docs_prompt(index_data)
             output.api_docs = self._generate(messages, "api")
             if output.api_docs:
-                (output_dir / "AI_API.md").write_text(output.api_docs)
+                (output_dir / "AI_API.md").write_text(output.api_docs, encoding="utf-8")
                 print("  -> AI_API.md")
         
         if "architecture" in docs:
@@ -76,7 +76,7 @@ class AIDocGenerator:
             messages = prompts.generate_architecture_prompt(index_data)
             output.architecture = self._generate(messages, "architecture")
             if output.architecture:
-                (output_dir / "AI_ARCHITECTURE.md").write_text(output.architecture)
+                (output_dir / "AI_ARCHITECTURE.md").write_text(output.architecture, encoding="utf-8")
                 print("  -> AI_ARCHITECTURE.md")
         
         if "flows" in docs:
@@ -84,7 +84,7 @@ class AIDocGenerator:
             messages = prompts.generate_flow_docs_prompt(index_data)
             output.flows = self._generate(messages, "flows")
             if output.flows:
-                (output_dir / "AI_FLOWS.md").write_text(output.flows)
+                (output_dir / "AI_FLOWS.md").write_text(output.flows, encoding="utf-8")
                 print("  -> AI_FLOWS.md")
         
         return output
@@ -107,7 +107,7 @@ class AIDocGenerator:
         result = self._generate(messages, f"module_{module_name}")
         
         if output_path and result:
-            Path(output_path).write_text(result)
+            Path(output_path).write_text(result, encoding="utf-8")
         
         return result
 

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/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/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/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/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/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/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/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/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/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/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", [])

cortexcode/reports/markdown/structure.py

@@ -4,6 +4,7 @@ from typing import Any
 
 def generate_structure_docs(index: dict[str, Any], output_path: Path) -> None:
     files = index.get("files", {})
+    profile = index.get("project_profile", {})
 
     lines = [
         "# Project Structure",
@@ -16,4 +17,30 @@ def generate_structure_docs(index: dict[str, Any], output_path: Path) -> None:
 
     lines.append("```")
 
+    # Nx monorepo section
+    nx_graph = profile.get("nx_project_graph")
+    nx_projects = profile.get("nx_projects")
+    if nx_projects:
+        lines.append("")
+        lines.append("## Nx Workspace")
+        lines.append("")
+        shell = profile.get("nx_shell_app")
+        if shell:
+            lines.append(f"**Shell / Root App:** `{shell}`")
+            lines.append("")
+        lines.append("### Projects")
+        lines.append("")
+        for name in nx_projects:
+            lines.append(f"- `{name}`")
+        lines.append("")
+        if nx_graph:
+            lines.append("### Project Dependencies")
+            lines.append("")
+            for proj, deps in nx_graph.items():
+                if deps:
+                    lines.append(f"- `{proj}` → {', '.join(f'`{d}`' for d in deps)}")
+                else:
+                    lines.append(f"- `{proj}` (no dependencies)")
+            lines.append("")
+
     output_path.write_text("\n".join(lines), encoding="utf-8")

cortexcode/reports/markdown/tech.py

@@ -10,15 +10,26 @@ def generate_tech_docs(index: dict[str, Any], output_path: Path) -> None:
     route_samples = project_profile.get("route_samples", [])
     entity_samples = project_profile.get("entity_samples", [])
 
+    nx_projects = project_profile.get("nx_projects")
+    nx_shell = project_profile.get("nx_shell_app")
+
     lines = [
         "# Technology Profile",
         "",
         f"**Project Root:** `{index.get('project_root', 'N/A')}`",
         f"**Languages:** {', '.join(index.get('languages', [])) or 'N/A'}",
+    ]
+
+    if nx_projects:
+        lines.append(f"**Workspace Type:** Nx Monorepo ({len(nx_projects)} projects)")
+        if nx_shell:
+            lines.append(f"**Shell App:** `{nx_shell}`")
+
+    lines.extend([
         "",
         "## Frameworks",
         "",
-    ]
+    ])
 
     if frameworks:
         for framework in frameworks:

{cortexcode-0.9.0.dist-info → cortexcode-0.10.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cortexcode
-Version: 0.9.0
-Summary: Lightweight code indexing for AI assistants — save 90%+ tokens with structured context
+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
 Project-URL: Homepage, https://github.com/naveen-joshi/cortexcode
@@ -55,44 +55,36 @@ Dynamic: license-file
   <h1 align="center">CortexCode</h1>
   <p align="center">
     <strong>Lightweight code indexing for AI assistants</strong><br>
-    Save 90%+ tokens by giving AI agents structured context instead of raw source files.
+    Build a searchable codegraph, generate documentation, and give AI assistants grounded context.
   </p>
 </p>
 
-<p align="center">
-  <a href="https://pypi.org/project/cortexcode/"><img src="https://img.shields.io/pypi/v/cortexcode?style=flat-square&color=blue" alt="PyPI"></a>
-  <a href="https://pypi.org/project/cortexcode/"><img src="https://img.shields.io/pypi/pyversions/cortexcode?style=flat-square" alt="Python"></a>
-  <a href="https://github.com/naveen-joshi/cortexcode/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License"></a>
-  <a href="https://github.com/naveen-joshi/cortexcode"><img src="https://img.shields.io/github/stars/naveen-joshi/cortexcode?style=flat-square" alt="Stars"></a>
-  <a href="https://marketplace.visualstudio.com/items?itemName=cortexcode.cortexcode-vscode"><img src="https://img.shields.io/visual-studio-marketplace/v/cortexcode.cortexcode-vscode?style=flat-square" alt="VS Code"></a>
-</p>
-
 ---
 
 ## The Problem
 
 AI coding assistants (Copilot, Cursor, Windsurf, etc.) need to understand your codebase. The current approach: **dump entire source files into the context window**. This is:
 
-- **Expensive** — A 150-file project can cost 200K+ tokens per query
-- **Slow** — More tokens = slower responses
-- **Wasteful** — Most of those tokens are irrelevant to the question
+- **Noisy** — Important signals are buried inside large files
+- **Fragile** — Assistants miss architecture, relationships, and runtime surface area
+- **Hard to reuse** — Raw file dumps do not become a durable project map
 
 ## The Solution
 
-CortexCode indexes your codebase using **AST parsing** (tree-sitter) and provides a structured, searchable index. Instead of feeding 200K tokens of raw code, you feed **~500 tokens of relevant context**.
+CortexCode indexes your codebase using **AST parsing** (tree-sitter) and builds a structured, searchable codegraph. You can explore symbols, trace flows, generate docs and diagrams, produce CodeWiki pages, and connect AI tools through MCP.
 
 ```
 ┌─────────────────────────────────────────────────┐
 │  Without CortexCode          With CortexCode    │
 │                                                  │
-│  200,000 tokens    →         500 tokens          │
-│  $0.006/query      →         $0.00002/query      │
-│  All files dumped  →         Only relevant syms  │
-│  No structure      →         Call graph + types   │
+│  Raw files only    →         Searchable codegraph │
+│  Manual digging    →         Linked symbols       │
+│  Ad-hoc prompts    →         Reusable context     │
+│  No project map    →         Docs + diagrams      │
 └─────────────────────────────────────────────────┘
 ```
 
-Run `cortexcode stats` on your project to see your actual savings.
+Run `cortexcode index` on your project to generate the codegraph and start exploring.
 
 ## Quick Start
 
@@ -108,9 +100,6 @@ cd cortexcode && pip install -e .
 cd your-project
 cortexcode index
 
-# See token savings
-cortexcode stats
-
 # Get context for AI
 cortexcode context "handleAuth"
 
@@ -159,24 +148,14 @@ Parses source code into structured symbols using tree-sitter grammars.
 - **Entities** — Database models and ORM definitions
 - **Framework Detection** — React components, Angular services, etc.
 
-### Token Savings
+### Project Exploration & Context
 
-CortexCode dramatically reduces the tokens needed to give AI assistants useful context:
+Use CortexCode to inspect structure and answer practical questions about a codebase:
 
-```bash
-$ cortexcode stats
-
-╭──────── Token Savings Analysis ────────╮
-│ Source files         154 files          │
-│ Raw project tokens   203,847            │
-│ Full index tokens    45,291             │
-│ Context query tokens 487                │
-│                                         │
-│ Tokens saved         203,360            │
-│ Savings              99.8%              │
-│ Compression ratio    418.6x             │
-╰─────────────────────────────────────────╯
-```
+- **Context lookup** — Pull relevant symbols and files for a query
+- **Call graph tracing** — Follow how behavior moves across modules
+- **Architecture visibility** — Inspect routes, entities, dependencies, and layers
+- **Reusable index** — Keep a structured project map that tools can build on
 
 ### Interactive HTML Documentation
 
@@ -211,7 +190,6 @@ cortexcode wiki --no-modules       # Skip per-module pages (faster)
 - **Mermaid diagrams** — Auto-generated flow diagrams
 - **Concept mapping** — Maps technical concepts to symbols and files
 - **Concept search** — Ask "how does authentication work?" and get grounded answers
-- **Token tracking** — See exactly how many tokens each page used
 
 **Output:** `.cortexcode/wiki/index.html` — Open directly or serve locally.
 
@@ -262,12 +240,12 @@ CortexCode supports both a short form (`cc`) and full form (`cortexcode`). Comma
 | Command | Description |
 |---------|-------------|
 | `cc analyze context [query]` | Get relevant context for AI |
-| `cc analyze context [query] --tokens` | Show token savings for query |
+| `cc analyze context [query] --tokens` | Show context size estimates for a query |
 | `cc analyze search [query]` | Grep-like symbol search with type/file filters |
 | `cc analyze find [query]` | Semantic search by meaning ("auth handler") |
 | `cc analyze diff` | Show changed symbols since last commit |
 | `cc analyze diff --ref HEAD~3` | Compare against any git ref |
-| `cc analyze stats` | Show project stats and token savings |
+| `cc analyze stats` | Show project index and analysis stats |
 | `cc analyze scan` | Scan dependencies for security warnings |
 | `cc analyze trace <symbol>` | Trace code flow through call graph |
 | `cc analyze flow <concept>` | Analyze code flow grouped by file |
@@ -372,7 +350,7 @@ Add to `~/.windsurf/config.json`:
 
 ```bash
 # Paste this output into your AI chat
-cortexcode context "useAuth" --tokens
+cortexcode context "useAuth"
 ```
 
 ### 2. JSON Index (programmatic)
@@ -569,7 +547,6 @@ CortexCode respects `.gitignore` files (including nested ones) and has built-in
 ## Roadmap
 
 - [x] MCP server for direct AI agent integration
-- [x] Tiktoken-based accurate token counting
 - [x] Semantic search over symbols (TF-IDF + synonym expansion)
 - [x] Cross-file type inference
 - [x] Git diff-aware context (show only changed symbols)

{cortexcode-0.9.0.dist-info → cortexcode-0.10.0.dist-info}/RECORD

@@ -6,7 +6,7 @@ cortexcode/context.py,sha256=CEX__dc21fdSLNg-Ec48ROTBILzEDufKPKANah_0HKk,342
 cortexcode/dashboard.py,sha256=NNK4EhgBo3gBuwwntT5wIi7ZlX1ThHVlbxn6q0c-HdE,5361
 cortexcode/docs.py,sha256=GT6GxWK7r-Zq-9VqxaLFAo9Yzh11kgwUgdaz46H4NmI,912
 cortexcode/git_diff.py,sha256=YEEZM2yKYztE-T7rI5iBf2NluY4G1WIjlp-DprZ-6Rs,5742
-cortexcode/indexer.py,sha256=lcw6iGF1rPpBpvyX9XnAKBnjl6Yatv9RpB78VceQFyo,10477
+cortexcode/indexer.py,sha256=riiIOXytAri_HXKpQGjCwo9HTgL0hFJCQ03ZLKvllHs,11182
 cortexcode/lsp_server.py,sha256=mAPk78OVWQodBjBI3WhqEjrwjXrb0MF630IYDZ8_MLM,11102
 cortexcode/main.py,sha256=G7iiyXkE9c5Oe6cI4HnH6g4yXOCRih2O_Hihx9an82M,43380
 cortexcode/performance.py,sha256=tkr7RMjIuutQqcNO8wgLBNzNMFXti7y9CkiSetPam_A,706
@@ -26,7 +26,7 @@ cortexcode/advanced_analysis/advanced_analysis_security.py,sha256=ZkXbzZHim7KnHs
 cortexcode/ai_docs/__init__.py,sha256=W68LGb82g2wVOsvm3DfMd9esntVfgZH4cwDzcAxRpGg,472
 cortexcode/ai_docs/config.py,sha256=7qwDS2t7q6t-eQepBi51PsV9uTggrtzsD_JI7jH8_6k,3388
 cortexcode/ai_docs/doc_cache.py,sha256=Im4nhro2sT0uytq0rajRntd3v6KUCmspS4VDmQWeHl8,1220
-cortexcode/ai_docs/doc_generator.py,sha256=O8Yy_okZf5Kcc2sLK6LN87JyWAZCS83H-l0dwdMbu1o,7018
+cortexcode/ai_docs/doc_generator.py,sha256=8zelx0xH6tCrEeAPyYuzWb5a7rejPT5AjfmPu2znZ64,7108
 cortexcode/ai_docs/doc_lookup.py,sha256=L_q4o_tYb_UK3l7CT-ZQBdKZPzCL7oH30LkaCxYoVdI,1067
 cortexcode/ai_docs/doc_models.py,sha256=jNGOposSsYrcrzC7UJ_81PP2yP9lzZtJ3dsxfbV7cio,339
 cortexcode/ai_docs/explainer.py,sha256=rMPab2N9UkfeY6NrmiaM2OZNElRUKqv7ZXVuzUnq6bo,9557
@@ -72,7 +72,7 @@ cortexcode/context/context_format.py,sha256=4cH-MEDZbdDTYunUxDqgB0Wvm7CP9b_lVkyV
 cortexcode/context/context_query.py,sha256=iu4nUdRS5-gQ2CKJBB5EcjeNsSsAZTDhpAD3DGfIogA,7047
 cortexcode/context/context_tokens.py,sha256=xN69ADHUn7rUlKmDJN6q7HY_I4fX9QzJyoz0Hkv6WEw,2217
 cortexcode/diagrams/__init__.py,sha256=xKmWh67Kt8ngSnNuOQ1ff2uwzZJ9boxepQsPNu6vm7I,1143
-cortexcode/diagrams/architecture.py,sha256=xx5yekiAF-VF0LxC9dbXsKjKskOlXQRuS6jlefoRPY8,2482
+cortexcode/diagrams/architecture.py,sha256=lP_4DAqj7lzi2baxE8tpNiJs7akp31HuFULqznAKSMw,3221
 cortexcode/diagrams/call_graph.py,sha256=zcHYLKR_Sl7d8LCf5VDt0ZixgrgxrQZwpJd-YMj7FwE,2449
 cortexcode/diagrams/class_diagram.py,sha256=3Wj6Q2pI8BtqxPd220xW_1V4hvij4961_miYgZW3Pzg,2527
 cortexcode/diagrams/dependencies.py,sha256=aA2nK6BkWmZ2AiT11gSn1Y9fEdPzKac1_dWsQ2UHUvE,1098
@@ -92,28 +92,29 @@ cortexcode/docs/javascript.py,sha256=8BW1RkSV3nYFO4-ZT-ToGo_J0vBGZjJLicoUyfxsOFw
 cortexcode/docs/javascript_sections.py,sha256=3WFSYft9jRMDoFhHssKoLjoZI7JYbCXu1s3a2A4Iftg,20326
 cortexcode/docs/templates.py,sha256=9OHgXzYl_dYUBbfa-vaEgrREGtHTKuWBdcbdUyE55LY,15055
 cortexcode/indexing/__init__.py,sha256=gflZkukf26TCFhdoaaVzPghiUBRuCNNzJHfBAL0nlG4,2384
-cortexcode/indexing/build.py,sha256=RB_6daCcZxm-32HqDIhRt8CL_hzSAzqtm2UXHnhEMfQ,1415
+cortexcode/indexing/build.py,sha256=qekM5ce27HzeQqltqowoTPFjEnoLNGo9TTpVmdBFyII,1720
 cortexcode/indexing/calls.py,sha256=zJAXfSKH7kPpAGoWhSC9l-VYa5rVnMmjRYQnSoelG6c,1144
 cortexcode/indexing/config.py,sha256=Hr1Ip2dfQUVolIkKX-KOkiNa9YF7Hd5FQoBtbkCmpdo,700
-cortexcode/indexing/defaults.py,sha256=mBO8sCiQIfP6vLrUNAGLiG12OGkssiVEmXjziJjcn2Y,974
+cortexcode/indexing/defaults.py,sha256=5chctf4NCO13scI67x_7BZ6q8crXMdohQ_08RKR58ok,967
 cortexcode/indexing/dispatch.py,sha256=03bgGwIjc0GQdDOgsWo4aBeXZtn_Lr5Pr15cfqfSXmM,1262
 cortexcode/indexing/entities.py,sha256=OqrFCyJag12g-p1MdXM7J6JFXspBMuxxtGJufWWv6AE,3351
 cortexcode/indexing/extensions.py,sha256=Th_xfWIjz1lGYxNeeaq7oAssvr28AVSC5Ix4pPf-dGI,157
 cortexcode/indexing/extractor_mixin.py,sha256=-VznExUzl2dPqANJLFh3DhHqbcBqRawFAADBOyX2wA4,14518
-cortexcode/indexing/filtering.py,sha256=s6weCqElN7f-5nN4Ud4kTT9U2PsgW93p4qrxwmF2YFs,2439
+cortexcode/indexing/filtering.py,sha256=xWaMYuDq_b3F1zxDmjgI7QtYeRu-UmpUWiSePhvN8Dg,2413
 cortexcode/indexing/frameworks.py,sha256=fiVLSvUasEg1SVk2qAD9iOc54Vdp9wQJSO4UJ0u_5Wk,10061
 cortexcode/indexing/gitignore.py,sha256=LNe_9NLI0nfbGxcauEIPzHdOa4B4d0ROPaByAJj76wc,2139
-cortexcode/indexing/imports_exports.py,sha256=0AAHHbxcRq5wvxtw7WYQZcsEmXuCD1Gv5bVWpvZnq1g,6867
+cortexcode/indexing/imports_exports.py,sha256=gloMMVLaEXLyiL6xvx6EIxmwVSQX_wH_La2ADRgEZHk,7332
 cortexcode/indexing/incremental.py,sha256=2CqwzN4AJJiDY7xEv4wE6ZOkfNZLuI1h94Kl5RZgQvI,1578
 cortexcode/indexing/languages.py,sha256=VY-51IrhPn4ZHNSX8MQhapW5nthQ7Fe8iHqdYa4qg04,1324
 cortexcode/indexing/metadata.py,sha256=kvw7tm6nbtL1uNqNTff2Iki0c4SyfWpoEQ4Em52IPcw,3514
 cortexcode/indexing/nodes.py,sha256=dGfEscBjTGbeN-Cs6U84ap7KuQ6SZAWzFFc7MDDShKU,202
+cortexcode/indexing/nx_projects.py,sha256=z7qAg0h8LN4eFRIW8v_ZiCmpw_7JZcDhYRZeTG4JGQM,8405
 cortexcode/indexing/output.py,sha256=UiMVoBojdPRPmX4KfeYp-E4WR5ajyBiYUwzxm88OGrU,515
 cortexcode/indexing/params.py,sha256=tMh6wBAAnKqf1hjKcap9Z9Mpb3_W0lBkf9hHAutRmaQ,921
 cortexcode/indexing/parsers.py,sha256=29JuPThW308LRzCAzDamOkY4aE17S-m6zgxc7Ni9l7Y,554
-cortexcode/indexing/pipeline.py,sha256=EfettW_jcHkqRMAw8HNYvL6scddVFkLl_PL1bBAc-FM,3268
-cortexcode/indexing/profile.py,sha256=P6BatbLwHg04Xl313_kAnlYu6rhp5vZggQG2H3AYH80,10126
-cortexcode/indexing/resolution.py,sha256=Vmjt_-iCJj4vRlYkh4uDIS3iivWt0rb4EObfYRB8qbk,6784
+cortexcode/indexing/pipeline.py,sha256=Yjr4HkGOavoE86-QCt5JDIP1YgEoljhLD3VaUH_F0Ls,3274
+cortexcode/indexing/profile.py,sha256=zi-QIER03tu2SpvH71GLmeiMI6f5xV44b8VxrCzcuTg,12183
+cortexcode/indexing/resolution.py,sha256=zvAxsQffjXg9-icraHWYyPvsE30xVlQoEFaFNKPVDK0,9712
 cortexcode/indexing/routes.py,sha256=I7Umx04EgT42nuUb-Plwr8TPJBn7Pzwo1AAmKn2Kdig,5317
 cortexcode/indexing/session.py,sha256=e1KnjMK-5jxbUS1SXhpKoQTOjxiEn3rExZTJYwJn2NY,744
 cortexcode/indexing/storage.py,sha256=BZe5iNsM-ZrE7yOxBtmt1AKHoxfD2NKfTtTFKTl8q6o,418
@@ -140,7 +141,7 @@ cortexcode/mcp/mcp_server.py,sha256=RM7PGxRqpijgxc_GS3r-8ax42myEl-uDnKiXgRkpPx4,
 cortexcode/mcp/mcp_tool_handlers.py,sha256=QOA1-dWMl_iE65y1y7Gq79fICbSq4H1n0v5HqLsbdWw,9304
 cortexcode/mcp/mcp_transport.py,sha256=-ep5iL4z6lP0gahFq_3fb_fruh8kNrQMEBpK1HoPCpo,1864
 cortexcode/performance/__init__.py,sha256=GZZQcGoR-JxST8dvKMBZE-XiEQFSiMn34tcLoQYBIq0,796
-cortexcode/performance/performance_config.py,sha256=T28Jg-3-5Hn50wdBD5-So1o9FFDZhSzt81iH09wh_7g,4931
+cortexcode/performance/performance_config.py,sha256=In90r5ZvJ3FMmSiXaPLg8tbqQ-ggYudQdzbo8hRj5eI,5892
 cortexcode/performance/performance_index_storage.py,sha256=ChRyY4iVhaLKskulGnoRQ5W7DjPVmmulZyv_83_OFF4,2151
 cortexcode/performance/performance_preview.py,sha256=i5IFXzUwuq6pJn_RZ3i8dT7Baq0dybmwVQhDPZNTUf4,2186
 cortexcode/reports/__init__.py,sha256=bYDMzLA8-wijUDc2_2g7ZBmtVWNfG6ZM1yCcdGJWdzA,369
@@ -153,8 +154,8 @@ cortexcode/reports/markdown/api.py,sha256=yxAlNS2s6JTlebkZbQIIiykuJXDwWj5FqXQIq3
 cortexcode/reports/markdown/flows.py,sha256=0XHrztcreIqTdpDXEUqR1n54HQqsS9KFc5OOSXMYnY4,1876
 cortexcode/reports/markdown/insights.py,sha256=dGHEbqOu9gojOojrM9c_ee77nAui5IZckMsNhslcP-E,2412
 cortexcode/reports/markdown/readme.py,sha256=RaLTpOSfTMy-8AbvnNoHbOGLcZ9ZjPj7xISMD4JOcek,2289
-cortexcode/reports/markdown/structure.py,sha256=A3DW2iEsevRmEvhucjIxYbX6oFXht2SXaF6hx2Pw5uA,406
-cortexcode/reports/markdown/tech.py,sha256=kvNkDI6YgBnvUXioCKPpCW-hKVj5xuxpRTaQNNTzFSo,3043
+cortexcode/reports/markdown/structure.py,sha256=ETOaHbdDW8xsEf2GSyrZT0CCaUT24TsYV70Ibn5Xldg,1375
+cortexcode/reports/markdown/tech.py,sha256=G6DQTt_Q7xpYb4ZsEdRuZVQIUQk3cB2yTcedDWBOiJg,3361
 cortexcode/reports/site/__init__.py,sha256=04hogJ20YLdkqpqknYqYsN2eDZdrHNJ5ZGBiMzaST3k,162
 cortexcode/reports/site/generator.py,sha256=QFjGMJZC4RPOoU0Eme09ZpLJiyrJsYdzvPWJrI6ZbUM,25044
 cortexcode/reports/site/viz.py,sha256=bb64-nkL6QwBd_WrFYpKtgQJcfucRqLAfa0CxEsW5_k,29758
@@ -165,9 +166,9 @@ cortexcode/terminal/headers.py,sha256=Yk9IGniMCiZD45V_yc1mjM3WjHimxoe9vL3CE5NAWv
 cortexcode/terminal/prompts.py,sha256=KRwjLipbO5Ihv3ycp1T2nGQtoGmKPP1ZNXb3BUz4oF4,359
 cortexcode/terminal/reports.py,sha256=4nLu0fBqDWKuQowX78VqX1nBaJl2zrTt9vEYCVP--O0,10135
 cortexcode/terminal/stats.py,sha256=PooaYP-OqaewhwypnUHESOrdwwICvggb3n2HdqEQxrc,1365
-cortexcode-0.9.0.dist-info/licenses/LICENSE,sha256=DWE8vkHgP2ChQTJHFWtrutLbuHQUBsU_InyfesP4neo,1067
-cortexcode-0.9.0.dist-info/METADATA,sha256=u5zgfzIujTGkuokhAX-zdrZ6jGHwvLr1CHc-2T-CO9Q,21856
-cortexcode-0.9.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-cortexcode-0.9.0.dist-info/entry_points.txt,sha256=3TfwRp96e7ICJDUoJpcAu3NXVGT6HcyvHVU3pQ_vftg,78
-cortexcode-0.9.0.dist-info/top_level.txt,sha256=r8FxzjLfKhRXXcORnECtGo7i2zKYXlV7v1XnIJ0SOc0,11
-cortexcode-0.9.0.dist-info/RECORD,,
+cortexcode-0.10.0.dist-info/licenses/LICENSE,sha256=DWE8vkHgP2ChQTJHFWtrutLbuHQUBsU_InyfesP4neo,1067
+cortexcode-0.10.0.dist-info/METADATA,sha256=32uIm5U-rW0nuwDBubZyxiEKYpNgvPdziSYHpkItn2E,20649
+cortexcode-0.10.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cortexcode-0.10.0.dist-info/entry_points.txt,sha256=3TfwRp96e7ICJDUoJpcAu3NXVGT6HcyvHVU3pQ_vftg,78
+cortexcode-0.10.0.dist-info/top_level.txt,sha256=r8FxzjLfKhRXXcORnECtGo7i2zKYXlV7v1XnIJ0SOc0,11
+cortexcode-0.10.0.dist-info/RECORD,,