sourcecode 0.3.0__tar.gz → 0.4.0__tar.gz

{sourcecode-0.3.0 → sourcecode-0.4.0}/.planning/ROADMAP.md

@@ -11,8 +11,8 @@ Sourcecode se construye en diez fases que van desde el scaffold del proyecto has
 - [x] **Fase 3: Clasificacion y Multi-Stack** - TypeClassifier, soporte monorepo/fullstack y niveles de confianza
 - [x] **Fase 4: Pulido y Publicacion** - Tests de integracion sobre proyectos reales, documentacion, CI/CD y publicacion en PyPI
 - [x] **Fase 5: Scanner Universal** - Ampliar stacks, ecosistemas y senales de deteccion para cubrir mas tipos de proyectos reales
-- [ ] **Fase 6: Dependencias Inteligentes** - Dependencias exactas, transitivas y resolucion multi-ecosistema con `--dependencies`
-- [ ] **Fase 7: Grafos de Codigo** - Grafo de modulos, imports, llamadas y jerarquias estructurales con `--graph-modules`
+- [x] **Fase 6: Dependencias Inteligentes** - Dependencias exactas, transitivas y resolucion multi-ecosistema con `--dependencies`
+- [x] **Fase 7: Grafos de Codigo** - Grafo de modulos, imports, llamadas y jerarquias estructurales con `--graph-modules`
 - [ ] **Fase 8: Documentacion Extraida** - Docstrings, comentarios y resúmenes de modulos consumibles por IA con `--docs`
 - [ ] **Fase 9: Metricas de Calidad** - LOC, complejidad, tests asociados y cobertura con `--full-metrics`
 - [ ] **Fase 10: Contexto Git y Operativo** - Historia git, volatilidad, CI/CD, Docker y metadata de entorno con `--git-history`
@@ -139,7 +139,14 @@ Plans:
   2. El output identifica nodos clave como funciones top-level, clases o entry points y, cuando sea factible con analisis seguro, relaciones de llamada o uso entre ellos
   3. En proyectos grandes o multi-stack, el analisis se degrada con seguridad mediante limites de profundidad/tamano en lugar de bloquearse o intentar parseo total no acotado
   4. El schema deja claro el nivel de confianza y el metodo de construccion del grafo (`ast`, `heuristic`, `unresolved`) para que el consumidor sepa cuanto confiar en cada arista
-**Plans**: 0 planes
+**Status**: COMPLETE — implemented 2026-04-08; module graph integrated behind `--graph-modules`, full suite green
+**Plans**: 4 planes
+
+Plans:
+- [x] 07-01: Base del grafo — schema, flag `--graph-modules` y analizador lazy desacoplado
+- [x] 07-02: Python y Node.js/TypeScript — imports internos, nodos de modulo y degradacion segura
+- [x] 07-03: Relaciones estructurales y soporte polyglot — llamadas simples, jerarquias basicas y soporte inicial Go/JVM
+- [x] 07-04: Integracion final — workspaces, limites de analisis, tests end-to-end y documentacion publica del contrato
 **UI hint**: no
 
 ### Fase 8: Documentacion Extraida
@@ -191,7 +198,7 @@ Las fases se ejecutan en orden numerico: 1 → 2 → 3 → 4 → 5 → 6 → 7
 | 4. Pulido y Publicacion | 3/3 | Complete   | 2026-04-07 |
 | 5. Scanner Universal | 4/4 | Complete   | 2026-04-07 |
 | 6. Dependencias Inteligentes | 4/4 | Complete | 2026-04-08 |
-| 7. Grafos de Codigo | 0/0 | Not planned | - |
+| 7. Grafos de Codigo | 4/4 | Complete | 2026-04-08 |
 | 8. Documentacion Extraida | 0/0 | Not planned | - |
 | 9. Metricas de Calidad | 0/0 | Not planned | - |
 | 10. Contexto Git y Operativo | 0/0 | Not planned | - |

{sourcecode-0.3.0 → sourcecode-0.4.0}/.planning/STATE.md

@@ -4,14 +4,14 @@ milestone: v1.0
 milestone_name: milestone
 status: in_progress
 stopped_at: Phase 05 execution complete; roadmap extended with future universal-analysis phases
-last_updated: "2026-04-08T10:10:00.000Z"
-last_activity: 2026-04-08 -- Phase 06 completed
+last_updated: "2026-04-08T11:25:00.000Z"
+last_activity: 2026-04-08 -- Phase 07 completed
 progress:
   total_phases: 10
-  completed_phases: 6
-  total_plans: 21
-  completed_plans: 21
-  percent: 60
+  completed_phases: 7
+  total_plans: 25
+  completed_plans: 25
+  percent: 70
 ---
 
 # Project State
@@ -21,16 +21,16 @@ progress:
 See: .planning/PROJECT.md (updated 2026-04-07)
 
 **Core value:** Un agente IA que recibe el output de esta herramienta llega al proyecto ya informado — no necesita preguntar lo obvio ni explorar ciegamente el codigo.
-**Current focus:** Fase 06 completada; siguiente paso natural: planificar grafos de codigo
+**Current focus:** Fase 07 completada; siguiente paso natural: planificar documentacion extraida
 
 ## Current Position
 
-Phase: 06 (dependencias-inteligentes) — COMPLETE
+Phase: 07 (grafos-de-codigo) — COMPLETE
 Plan: 4 of 4
-Status: Phase 06 complete
-Last activity: 2026-04-08 -- Phase 06 completed
+Status: Phase 07 complete
+Last activity: 2026-04-08 -- Phase 07 completed
 
-Progress: [██████░░░░] 60%
+Progress: [███████░░░] 70%
 
 ## Performance Metrics
 
@@ -95,6 +95,8 @@ None.
 - Phase 10 added: Contexto git y operativo — historia reciente, volatilidad, CI/CD y metadata segura bajo `--git-history`.
 - Phase 6 planned in 4 planes: base de schema/CLI, Node+Python, ecosistemas polyglot y cierre end-to-end con workspaces/docs.
 - Phase 6 completed: `--dependencies` ahora expone versiones declaradas/resueltas, transitivas conservadoras y contexto por workspace.
+- Phase 7 planned in 4 planes: base de schema/CLI, Python+Node, relaciones extra/polyglot y cierre end-to-end con workspaces/docs.
+- Phase 7 completed: `--graph-modules` ahora expone nodos, aristas, metodos y limitaciones del grafo con soporte por workspace.
 
 ### Blockers/Concerns
 
@@ -105,4 +107,4 @@ None.
 Last session: 2026-04-07T19:37:00Z
 Stopped at: Phase 04 execution complete — pytest green; docs and workflows added
 Resume file: None
-Next action: /gsd:plan-phase 7
+Next action: /gsd:plan-phase 8

sourcecode-0.4.0/.planning/phases/07-grafos-de-codigo/07-01-PLAN.md

@@ -0,0 +1,141 @@
+---
+phase: 07-grafos-de-codigo
+plan: 01
+type: execute
+wave: 1
+depends_on: []
+files_modified:
+  - src/sourcecode/cli.py
+  - src/sourcecode/schema.py
+  - src/sourcecode/graph_analyzer.py
+  - src/sourcecode/serializer.py
+  - tests/test_graph_schema.py
+  - tests/test_cli.py
+autonomous: true
+requirements:
+  - GRAPH-01
+  - OUT-08
+
+must_haves:
+  truths:
+    - "La CLI expone `--graph-modules` sin encarecer `sourcecode .`"
+    - "El schema del grafo es opcional, claro y compatible hacia atras"
+    - "Existe un analizador lazy desacoplado para el grafo de codigo"
+  artifacts:
+    - path: "src/sourcecode/schema.py"
+      provides: "Modelo publico de nodos, aristas y summary del grafo"
+    - path: "src/sourcecode/cli.py"
+      provides: "Flag `--graph-modules` e integracion opt-in"
+    - path: "src/sourcecode/graph_analyzer.py"
+      provides: "Entrada comun del analisis estructural"
+    - path: "tests/test_graph_schema.py"
+      provides: "Cobertura del contrato y defaults del grafo"
+---
+
+<objective>
+Preparar la base de la fase 7: contrato de datos del grafo, flag CLI y esqueleto del analizador sin implementar todavia todas las relaciones por lenguaje.
+
+Purpose: Fijar una base comun para que los resolutores por lenguaje puedan crecer sin rehacer el contrato publico.
+
+Output: schema de grafo, CLI opt-in y analizador lazy desacoplado.
+</objective>
+
+<execution_context>
+@.codex/get-shit-done/workflows/execute-plan.md
+@.codex/get-shit-done/templates/summary.md
+</execution_context>
+
+<context>
+@.planning/ROADMAP.md
+@.planning/phases/07-grafos-de-codigo/07-RESEARCH.md
+@src/sourcecode/cli.py
+@src/sourcecode/schema.py
+@src/sourcecode/serializer.py
+</context>
+
+<tasks>
+
+<task type="auto" tdd="true">
+  <name>Tarea 1: Extender schema con nodos, aristas y summary</name>
+  <files>src/sourcecode/schema.py, tests/test_graph_schema.py</files>
+
+  <behavior>
+    - el output puede incluir un bloque de grafo sin romper consumidores actuales
+    - cada arista indica tipo, confianza y metodo de construccion
+    - el summary distingue entre analisis no solicitado, cobertura parcial y limites aplicados
+  </behavior>
+
+  <action>
+Crear tests RED para:
+
+- serializacion de nodos de modulo y funcion
+- serializacion de aristas `imports` y `calls`
+- `SourceMap` sin `--graph-modules` sigue siendo valido
+
+Implementar dataclasses o tipos equivalentes para:
+
+- nodos del grafo
+- aristas del grafo
+- resumen del analisis
+- campo opcional en `SourceMap`
+  </action>
+
+  <verify>
+    <automated>.venv/bin/python -m pytest tests/test_graph_schema.py -q</automated>
+  </verify>
+
+  <acceptance_criteria>
+    - El contrato del grafo es serializable, claro y extensible
+    - El schema previo sigue intacto cuando no se solicita analisis estructural
+  </acceptance_criteria>
+
+  <done>El modelo de datos del grafo queda fijado.</done>
+</task>
+
+<task type="auto" tdd="true">
+  <name>Tarea 2: Añadir flag CLI y analizador lazy</name>
+  <files>src/sourcecode/cli.py, src/sourcecode/graph_analyzer.py, tests/test_cli.py</files>
+
+  <behavior>
+    - `sourcecode . --graph-modules` activa el analizador estructural
+    - `sourcecode .` no hace trabajo extra ni rellena el bloque de grafo
+    - la salida sigue siendo valida en JSON/YAML y no invade `--compact`
+  </behavior>
+
+  <action>
+Crear tests RED para:
+
+- `--graph-modules` activa el analizador
+- sin flag, el analizador no se ejecuta
+- `--compact` no incluye el bloque pesado del grafo
+
+Implementar el esqueleto de `GraphAnalyzer` y conectarlo de forma lazy desde la CLI.
+  </action>
+
+  <verify>
+    <automated>.venv/bin/python -m pytest tests/test_cli.py tests/test_graph_schema.py -q</automated>
+  </verify>
+
+  <acceptance_criteria>
+    - El coste del grafo queda detras del flag
+    - La infraestructura base de la fase queda lista para parseo por lenguaje
+  </acceptance_criteria>
+
+  <done>La CLI ya tiene la puerta de entrada al grafo estructural.</done>
+</task>
+
+</tasks>
+
+<verification>
+## Verificacion global
+
+- `.venv/bin/python -m pytest tests/test_graph_schema.py tests/test_cli.py -q`
+- validar que `sourcecode .` sin flag no serializa bloque de grafo
+</verification>
+
+<success_criteria>
+## Success Criteria
+
+- Existe un contrato estable para grafos internos
+- `--graph-modules` queda integrado como opcion opt-in y lazy
+</success_criteria>

sourcecode-0.4.0/.planning/phases/07-grafos-de-codigo/07-01-SUMMARY.md

@@ -0,0 +1,52 @@
+---
+phase: 07-grafos-de-codigo
+plan: 01
+subsystem: api
+tags: [graph, schema, cli, lazy-loading]
+requires:
+  - phase: 06-dependencias-inteligentes
+    provides: bloques opt-in en schema/CLI y analizador desacoplado
+provides:
+  - Modelo publico de grafo estructural
+  - Flag CLI `--graph-modules`
+  - GraphAnalyzer base
+affects: [schema, cli, output]
+tech-stack:
+  added: []
+  patterns: [lazy-analysis, backward-compatible-schema]
+key-files:
+  created:
+    - src/sourcecode/graph_analyzer.py
+    - tests/test_graph_schema.py
+  modified:
+    - src/sourcecode/schema.py
+    - src/sourcecode/cli.py
+    - tests/test_cli.py
+key-decisions:
+  - "El grafo vive en `module_graph` como bloque opcional del schema"
+  - "El comando base no construye el grafo salvo que el usuario active `--graph-modules`"
+patterns-established:
+  - "Analisis estructural pesado detras de flag opt-in"
+requirements-completed: [GRAPH-01, OUT-08]
+duration: 14min
+completed: 2026-04-08
+---
+
+# Phase 07-01 Summary
+
+**Base del grafo: schema, CLI y analizador lazy**
+
+## Accomplishments
+
+- Se añadieron `GraphNode`, `GraphEdge`, `ModuleGraphSummary` y `ModuleGraph` al schema público.
+- La CLI incorpora `--graph-modules` sin penalizar `sourcecode .`.
+- Se creó `GraphAnalyzer` como punto de entrada común para el análisis estructural.
+- `compact_view()` sigue excluyendo el bloque pesado del grafo.
+
+## Verification
+
+- `.venv/bin/python -m pytest tests/test_graph_schema.py tests/test_cli.py -q`
+
+## Notes
+
+- La fase reutiliza el patrón opt-in introducido en dependencias para mantener el producto rápido por defecto.

sourcecode-0.4.0/.planning/phases/07-grafos-de-codigo/07-02-PLAN.md

@@ -0,0 +1,134 @@
+---
+phase: 07-grafos-de-codigo
+plan: 02
+type: execute
+wave: 2
+depends_on:
+  - 07-01
+files_modified:
+  - src/sourcecode/graph_analyzer.py
+  - src/sourcecode/tree_utils.py
+  - tests/test_graph_analyzer_python_node.py
+  - tests/test_integration_graph_modules.py
+autonomous: true
+requirements:
+  - GRAPH-01
+  - GRAPH-03
+
+must_haves:
+  truths:
+    - "Python y Node.js/TypeScript exponen grafo de imports internos entre modulos"
+    - "El analisis distingue aristas internas de externas o no resueltas"
+    - "Los parseos degradan con seguridad ante sintaxis no soportada o archivos grandes"
+  artifacts:
+    - path: "src/sourcecode/graph_analyzer.py"
+      provides: "Resolucion inicial de imports para Python y Node.js/TypeScript"
+    - path: "tests/test_graph_analyzer_python_node.py"
+      provides: "Cobertura unitaria de modulos y aristas de imports"
+    - path: "tests/test_integration_graph_modules.py"
+      provides: "Smoke e integracion CLI para los lenguajes prioritarios"
+---
+
+<objective>
+Implementar la primera oleada fuerte del grafo sobre los ecosistemas mas rentables para analisis local: Python y Node.js/TypeScript.
+
+Purpose: Entregar valor practico rapido con imports internos y modulos relevantes antes de ampliar el modelo a relaciones mas profundas.
+
+Output: parseo de imports, nodos de modulo y salida estable para Python y Node.
+</objective>
+
+<execution_context>
+@.codex/get-shit-done/workflows/execute-plan.md
+@.codex/get-shit-done/templates/summary.md
+</execution_context>
+
+<context>
+@.planning/ROADMAP.md
+@.planning/phases/07-grafos-de-codigo/07-RESEARCH.md
+@.planning/phases/07-grafos-de-codigo/07-01-PLAN.md
+@src/sourcecode/graph_analyzer.py
+@src/sourcecode/tree_utils.py
+@src/sourcecode/detectors/python.py
+@src/sourcecode/detectors/nodejs.py
+</context>
+
+<tasks>
+
+<task type="auto" tdd="true">
+  <name>Tarea 1: Grafo de imports para Python</name>
+  <files>src/sourcecode/graph_analyzer.py, tests/test_graph_analyzer_python_node.py, tests/test_integration_graph_modules.py</files>
+
+  <behavior>
+    - `import` y `from ... import ...` entre modulos internos generan aristas `imports`
+    - funciones y clases top-level relevantes aparecen como nodos cuando el AST es valido
+    - errores de parseo no rompen el analisis global
+  </behavior>
+
+  <action>
+Crear fixtures/tests RED para:
+
+- paquete Python con imports relativos e internos
+- modulo con funciones top-level y una clase
+- archivo con sintaxis rota o no soportada que deba degradar a warning
+
+Implementar parseo con `ast` estandar y linking de modulos internos por path.
+  </action>
+
+  <verify>
+    <automated>.venv/bin/python -m pytest tests/test_graph_analyzer_python_node.py -q -k python</automated>
+  </verify>
+
+  <acceptance_criteria>
+    - Python entrega imports internos fiables y nodos utiles
+    - El analisis soporta degradacion segura ante parseo fallido
+  </acceptance_criteria>
+
+  <done>Python queda cubierto para el grafo de modulos.</done>
+</task>
+
+<task type="auto" tdd="true">
+  <name>Tarea 2: Grafo de imports para Node.js y TypeScript</name>
+  <files>src/sourcecode/graph_analyzer.py, src/sourcecode/tree_utils.py, tests/test_graph_analyzer_python_node.py, tests/test_integration_graph_modules.py</files>
+
+  <behavior>
+    - `import ... from` y `require()` internos generan aristas `imports`
+    - TypeScript y JavaScript comparten un modelo comun de modulo
+    - rutas relativas se resuelven sin depender de bundlers ni toolchains
+  </behavior>
+
+  <action>
+Crear fixtures/tests RED para:
+
+- proyecto TS con imports relativos
+- proyecto JS con `require()`
+- caso con alias o import no resoluble que deba quedar marcado como `unresolved`
+
+Implementar parseo textual seguro y resolucion interna por convenciones de archivos (`index`, extensiones `.js/.ts/.tsx`).
+  </action>
+
+  <verify>
+    <automated>.venv/bin/python -m pytest tests/test_graph_analyzer_python_node.py -q -k "node or typescript"</automated>
+  </verify>
+
+  <acceptance_criteria>
+    - Node.js/TypeScript ya no se quedan sin grafo estructural basico
+    - Las aristas ambiguas se etiquetan en lugar de inventarse
+  </acceptance_criteria>
+
+  <done>Node.js y TypeScript quedan cubiertos para imports internos.</done>
+</task>
+
+</tasks>
+
+<verification>
+## Verificacion global
+
+- `.venv/bin/python -m pytest tests/test_graph_analyzer_python_node.py tests/test_integration_graph_modules.py -q`
+</verification>
+
+<success_criteria>
+## Success Criteria
+
+- Python y Node.js/TypeScript cubren imports internos con degradacion segura
+- El grafo ya entrega valor practico en los lenguajes mas comunes
+</success_criteria>

sourcecode-0.4.0/.planning/phases/07-grafos-de-codigo/07-02-SUMMARY.md

@@ -0,0 +1,48 @@
+---
+phase: 07-grafos-de-codigo
+plan: 02
+subsystem: graph
+tags: [python, nodejs, typescript, imports]
+requires:
+  - phase: 07-grafos-de-codigo
+    provides: schema del grafo y CLI lazy
+provides:
+  - Grafo de imports para Python
+  - Grafo de imports para Node.js y TypeScript
+  - Nodos de modulo, funcion y clase en lenguajes prioritarios
+affects: [graph, output]
+tech-stack:
+  added: []
+  patterns: [ast-python, heuristic-node-resolution]
+key-files:
+  created:
+    - tests/test_graph_analyzer_python_node.py
+    - tests/test_integration_graph_modules.py
+  modified:
+    - src/sourcecode/graph_analyzer.py
+key-decisions:
+  - "Python usa `ast` estandar para imports, funciones, clases y llamadas simples"
+  - "Node.js/TypeScript usa resolucion textual segura para imports relativos y `require()`"
+requirements-completed: [GRAPH-01, GRAPH-03]
+duration: 20min
+completed: 2026-04-08
+---
+
+# Phase 07-02 Summary
+
+**Python y Node.js/TypeScript con imports internos y nodos útiles**
+
+## Accomplishments
+
+- Python ahora expone imports internos, funciones top-level, clases, `contains`, `calls` y `extends` cuando el AST lo permite.
+- Node.js y TypeScript resuelven imports relativos y `require()` sin toolchains externas.
+- Los parse errors e imports no resolubles se registran en `module_graph.summary.limitations`.
+- Se añadieron tests unitarios e integración CLI para ambos ecosistemas.
+
+## Verification
+
+- `.venv/bin/python -m pytest tests/test_graph_analyzer_python_node.py tests/test_integration_graph_modules.py -q`
+
+## Notes
+
+- Se priorizó valor práctico y trazabilidad sobre profundidad semántica total.

sourcecode-0.4.0/.planning/phases/07-grafos-de-codigo/07-03-PLAN.md

@@ -0,0 +1,131 @@
+---
+phase: 07-grafos-de-codigo
+plan: 03
+type: execute
+wave: 3
+depends_on:
+  - 07-01
+files_modified:
+  - src/sourcecode/graph_analyzer.py
+  - tests/test_graph_analyzer_polyglot.py
+  - tests/test_integration_graph_modules.py
+autonomous: true
+requirements:
+  - GRAPH-02
+  - GRAPH-03
+
+must_haves:
+  truths:
+    - "El grafo incorpora relaciones estructurales adicionales sin prometer semantica completa"
+    - "Go y JVM reciben soporte inicial al menos para imports y tipos principales"
+    - "Las aristas indican metodo y confianza segun el parser usado"
+  artifacts:
+    - path: "src/sourcecode/graph_analyzer.py"
+      provides: "Relaciones de llamada/jerarquia seguras y soporte polyglot inicial"
+    - path: "tests/test_graph_analyzer_polyglot.py"
+      provides: "Cobertura unitaria de Go y JVM, mas relaciones extra"
+---
+
+<objective>
+Ampliar el grafo con relaciones estructurales adicionales y soporte inicial para otros lenguajes ya soportados por el scanner.
+
+Purpose: Subir el valor del grafo sin caer en promesas de semantica total ni analisis interprocedural costoso.
+
+Output: llamadas simples, jerarquias basicas y cobertura inicial para Go/JVM.
+</objective>
+
+<execution_context>
+@.codex/get-shit-done/workflows/execute-plan.md
+@.codex/get-shit-done/templates/summary.md
+</execution_context>
+
+<context>
+@.planning/ROADMAP.md
+@.planning/phases/07-grafos-de-codigo/07-RESEARCH.md
+@.planning/phases/07-grafos-de-codigo/07-02-PLAN.md
+@src/sourcecode/graph_analyzer.py
+@src/sourcecode/detectors/go.py
+@src/sourcecode/detectors/java.py
+@src/sourcecode/detectors/jvm_ext.py
+</context>
+
+<tasks>
+
+<task type="auto" tdd="true">
+  <name>Tarea 1: Relaciones de llamadas y jerarquias basicas</name>
+  <files>src/sourcecode/graph_analyzer.py, tests/test_graph_analyzer_polyglot.py</files>
+
+  <behavior>
+    - funciones top-level pueden generar aristas `calls` simples cuando el AST lo permita
+    - clases y herencia simple pueden emitir aristas `extends` o `contains`
+    - el metodo de construccion queda explicitado como `ast` o `heuristic`
+  </behavior>
+
+  <action>
+Crear tests RED para:
+
+- modulo Python con una funcion que llama a otra
+- clase que hereda de otra en un caso simple
+- caso ambiguo que deba quedarse sin arista en vez de inferirse mal
+
+Implementar solo relaciones sintacticas baratas y defendibles.
+  </action>
+
+  <verify>
+    <automated>.venv/bin/python -m pytest tests/test_graph_analyzer_polyglot.py -q -k "calls or extends"</automated>
+  </verify>
+
+  <acceptance_criteria>
+    - El grafo gana profundidad sin vender precision falsa
+    - La semantica de las aristas queda trazable por metodo y confianza
+  </acceptance_criteria>
+
+  <done>El grafo ya no se limita solo a imports.</done>
+</task>
+
+<task type="auto" tdd="true">
+  <name>Tarea 2: Soporte inicial para Go y JVM</name>
+  <files>src/sourcecode/graph_analyzer.py, tests/test_graph_analyzer_polyglot.py, tests/test_integration_graph_modules.py</files>
+
+  <behavior>
+    - Go expone imports y funciones top-level razonables
+    - Java/Kotlin/Scala exponen imports y tipos principales cuando la estructura sea clara
+    - cuando falte precision, el grafo marca `heuristic` o `unresolved`
+  </behavior>
+
+  <action>
+Crear fixtures/tests RED para:
+
+- paquete Go con imports internos
+- clase Java o Kotlin con imports y tipo principal
+- caso JVM ambiguo que degrade a cobertura parcial
+
+Implementar soporte inicial priorizando robustez y coste bajo.
+  </action>
+
+  <verify>
+    <automated>.venv/bin/python -m pytest tests/test_graph_analyzer_polyglot.py -q -k "go or java or kotlin or scala"</automated>
+  </verify>
+
+  <acceptance_criteria>
+    - Go y JVM tienen al menos una base de grafo util
+    - La salida sigue siendo honesta sobre cobertura y limites
+  </acceptance_criteria>
+
+  <done>La fase ya cubre grafo estructural inicial en varios stacks.</done>
+</task>
+
+</tasks>
+
+<verification>
+## Verificacion global
+
+- `.venv/bin/python -m pytest tests/test_graph_analyzer_polyglot.py tests/test_integration_graph_modules.py -q`
+</verification>
+
+<success_criteria>
+## Success Criteria
+
+- El grafo incorpora relaciones mas utiles que simples imports
+- Go y JVM reciben soporte inicial sin romper el presupuesto de analisis
+</success_criteria>

sourcecode-0.4.0/.planning/phases/07-grafos-de-codigo/07-03-SUMMARY.md

@@ -0,0 +1,46 @@
+---
+phase: 07-grafos-de-codigo
+plan: 03
+subsystem: graph
+tags: [go, jvm, extends, calls, polyglot]
+requires:
+  - phase: 07-grafos-de-codigo
+    provides: analizador base y cobertura Python/Node
+provides:
+  - Soporte inicial Go para imports y funciones top-level
+  - Soporte inicial JVM para imports y jerarquias basicas
+  - Relaciones estructurales adicionales mas alla de imports
+affects: [graph]
+tech-stack:
+  added: []
+  patterns: [polyglot-heuristics, explicit-confidence]
+key-files:
+  created:
+    - tests/test_graph_analyzer_polyglot.py
+  modified:
+    - src/sourcecode/graph_analyzer.py
+key-decisions:
+  - "Go se resuelve a nivel de modulo usando `go.mod` y paths internos del mismo modulo"
+  - "JVM se cubre de forma inicial con imports y `extends` basicos via parseo textual seguro"
+requirements-completed: [GRAPH-02, GRAPH-03]
+duration: 18min
+completed: 2026-04-08
+---
+
+# Phase 07-03 Summary
+
+**Relaciones estructurales adicionales y cobertura polyglot inicial**
+
+## Accomplishments
+
+- Go ahora expone imports internos y funciones top-level razonables.
+- Java/Kotlin/Scala incorporan imports y relaciones `extends` simples cuando pueden resolverse localmente.
+- El grafo gana profundidad con `contains`, `calls` y `extends` sin depender de compiladores ni indexadores externos.
+
+## Verification
+
+- `.venv/bin/python -m pytest tests/test_graph_analyzer_polyglot.py -q`
+
+## Notes
+
+- La cobertura sigue siendo conservadora: cuando no hay certeza suficiente, el análisis deja limitaciones explícitas.