sourcecode 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/cli.py

@@ -46,6 +46,16 @@ def main(
         "--compact",
         help="Output reducido (~500 tokens): tipo de proyecto, stacks, entradas y arbol nivel 1",
     ),
+    dependencies: bool = typer.Option(
+        False,
+        "--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",
+    ),
     no_redact: bool = typer.Option(
         False,
         "--no-redact",
@@ -88,7 +98,9 @@ def main(
     # --- Importar modulos de logica ---
     from dataclasses import asdict, replace
 
+    from sourcecode.dependency_analyzer import DependencyAnalyzer
     from sourcecode.detectors import ProjectDetector, build_default_detectors
+    from sourcecode.graph_analyzer import GraphAnalyzer
     from sourcecode.redactor import SecretRedactor, redact_dict
     from sourcecode.scanner import FileScanner
     from sourcecode.schema import AnalysisMetadata, EntryPoint, SourceMap, StackDetection
@@ -112,10 +124,33 @@ 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
 
     root_manifests = [
         manifest
@@ -129,6 +164,24 @@ def main(
     else:
         stacks, entry_points, _project_type = detector.detect(target, file_tree, detection_manifests)
 
+    dependency_records = []
+    dependency_summaries = []
+    if dependency_analyzer is not None:
+        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))
+
     for workspace in workspace_analysis.workspaces:
         workspace_root = target / workspace.path
         if not workspace_root.exists() or not workspace_root.is_dir():
@@ -153,6 +206,22 @@ def main(
             )
             for entry_point in workspace_entry_points
         )
+        if dependency_analyzer is not None:
+            workspace_dependencies, workspace_summary = dependency_analyzer.analyze(
+                workspace_root,
+                workspace=workspace.path,
+            )
+            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,
+                )
+            module_graphs.append(
+                graph_analyzer.prefix_graph(workspace_graph, workspace.path, workspace.path)
+            )
 
     stacks, project_type = detector.classify_results(
         file_tree,
@@ -160,6 +229,12 @@ def main(
         entry_points,
         project_type_override="monorepo" if workspace_analysis.is_monorepo else None,
     )
+    dependency_summary = (
+        dependency_analyzer.merge_summaries(dependency_summaries)
+        if dependency_analyzer is not None
+        else None
+    )
+    module_graph = graph_analyzer.merge_graphs(module_graphs) if graph_analyzer is not None else None
 
     # 3. Construir el schema
     metadata = AnalysisMetadata(analyzed_path=str(target))
@@ -169,6 +244,9 @@ def main(
         stacks=stacks,
         project_type=project_type,
         entry_points=entry_points,
+        dependencies=dependency_records,
+        dependency_summary=dependency_summary,
+        module_graph=module_graph,
     )
 
     # 4. Serializar (con o sin modo compact)