sourcecode 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Genera mapas de contexto estructurado para agentes IA."""
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"

sourcecode/cli.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Optional, cast
 
 import typer
 
@@ -16,6 +16,8 @@ app = typer.Typer(
 )
 
 FORMAT_CHOICES = ["json", "yaml"]
+GRAPH_DETAIL_CHOICES = ["high", "medium", "full"]
+GRAPH_EDGE_CHOICES = {"imports", "calls", "contains", "extends"}
 
 
 def version_callback(value: bool) -> None:
@@ -51,6 +53,28 @@ def main(
         "--dependencies",
         help="Incluir dependencias directas, versiones exactas y transitivas cuando haya lockfiles compatibles",
     ),
+    graph_modules: bool = typer.Option(
+        False,
+        "--graph-modules",
+        help="Incluir grafo estructural de modulos, imports y relaciones simples del codigo",
+    ),
+    graph_detail: str = typer.Option(
+        "high",
+        "--graph-detail",
+        help="Nivel de detalle del grafo: high|medium|full",
+        show_default=True,
+    ),
+    max_nodes: Optional[int] = typer.Option(
+        None,
+        "--max-nodes",
+        help="Limite de nodos para `--graph-modules` en modos high/medium",
+        min=1,
+    ),
+    graph_edges: Optional[str] = typer.Option(
+        None,
+        "--graph-edges",
+        help="Tipos de arista para `--graph-modules` separados por comas: imports,calls,contains,extends",
+    ),
     no_redact: bool = typer.Option(
         False,
         "--no-redact",
@@ -80,6 +104,12 @@ def main(
             err=True,
         )
         raise typer.Exit(code=1)
+    if graph_detail not in GRAPH_DETAIL_CHOICES:
+        typer.echo(
+            f"Error: valor invalido '{graph_detail}' para --graph-detail. Opciones: {', '.join(GRAPH_DETAIL_CHOICES)}",
+            err=True,
+        )
+        raise typer.Exit(code=1)
 
     # Resolver y validar path
     target = path.resolve()
@@ -95,6 +125,7 @@ def main(
 
     from sourcecode.dependency_analyzer import DependencyAnalyzer
     from sourcecode.detectors import ProjectDetector, build_default_detectors
+    from sourcecode.graph_analyzer import GraphAnalyzer, GraphDetail
     from sourcecode.redactor import SecretRedactor, redact_dict
     from sourcecode.scanner import FileScanner
     from sourcecode.schema import AnalysisMetadata, EntryPoint, SourceMap, StackDetection
@@ -118,11 +149,48 @@ def main(
                 filtered[name] = value
         return filtered
 
+    def prune_workspace_paths(
+        tree: dict[str, Any], workspace_paths: list[str]
+    ) -> dict[str, Any]:
+        pruned = dict(tree)
+        for workspace_path in workspace_paths:
+            parts = [part for part in workspace_path.split("/") if part]
+            if not parts:
+                continue
+            node = pruned
+            for index, part in enumerate(parts):
+                if not isinstance(node, dict) or part not in node:
+                    break
+                if index == len(parts) - 1:
+                    node.pop(part, None)
+                    break
+                child = node.get(part)
+                if not isinstance(child, dict):
+                    break
+                node = child
+        return pruned
+
     file_tree = filter_sensitive_files(raw_tree)
     manifests = scanner.find_manifests()
     detector = ProjectDetector(build_default_detectors())
     workspace_analysis = WorkspaceAnalyzer().analyze(target, manifests)
     dependency_analyzer = DependencyAnalyzer() if dependencies else None
+    graph_analyzer = GraphAnalyzer() if graph_modules else None
+    parsed_graph_edges = (
+        {edge.strip() for edge in graph_edges.split(",") if edge.strip()}
+        if graph_edges
+        else None
+    )
+    if parsed_graph_edges is not None:
+        invalid_edges = sorted(parsed_graph_edges - GRAPH_EDGE_CHOICES)
+        if invalid_edges:
+            typer.echo(
+                "Error: valores invalidos para --graph-edges: "
+                f"{', '.join(invalid_edges)}. Opciones: {', '.join(sorted(GRAPH_EDGE_CHOICES))}",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+    graph_detail_typed = cast(GraphDetail, graph_detail)
 
     root_manifests = [
         manifest
@@ -142,6 +210,24 @@ def main(
         root_dependencies, root_summary = dependency_analyzer.analyze(target)
         dependency_records.extend(root_dependencies)
         dependency_summaries.append(root_summary)
+    module_graphs = []
+    if graph_analyzer is not None:
+        root_graph_tree = (
+            prune_workspace_paths(
+                file_tree,
+                [workspace.path for workspace in workspace_analysis.workspaces],
+            )
+            if workspace_analysis.workspaces
+            else file_tree
+        )
+        module_graphs.append(
+            graph_analyzer.analyze(
+                target,
+                root_graph_tree,
+                detail="full",
+                entry_points=entry_points,
+            )
+        )
 
     for workspace in workspace_analysis.workspaces:
         workspace_root = target / workspace.path
@@ -174,6 +260,17 @@ def main(
             )
             dependency_records.extend(workspace_dependencies)
             dependency_summaries.append(workspace_summary)
+        if graph_analyzer is not None:
+            workspace_graph = graph_analyzer.analyze(
+                workspace_root,
+                workspace_tree,
+                workspace=workspace.path,
+                detail="full",
+                entry_points=workspace_entry_points,
+            )
+            module_graphs.append(
+                graph_analyzer.prefix_graph(workspace_graph, workspace.path, workspace.path)
+            )
 
     stacks, project_type = detector.classify_results(
         file_tree,
@@ -186,6 +283,17 @@ def main(
         if dependency_analyzer is not None
         else None
     )
+    module_graph = (
+        graph_analyzer.merge_graphs(
+            module_graphs,
+            detail=graph_detail_typed,
+            edge_kinds=parsed_graph_edges,
+            max_nodes=max_nodes,
+            entry_points=entry_points,
+        )
+        if graph_analyzer is not None
+        else None
+    )
 
     # 3. Construir el schema
     metadata = AnalysisMetadata(analyzed_path=str(target))
@@ -197,6 +305,8 @@ def main(
         entry_points=entry_points,
         dependencies=dependency_records,
         dependency_summary=dependency_summary,
+        module_graph=module_graph,
+        module_graph_summary=module_graph.summary if module_graph is not None else None,
     )
 
     # 4. Serializar (con o sin modo compact)