sourcecode 0.9.0__tar.gz → 0.10.0__tar.gz

{sourcecode-0.9.0 → sourcecode-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.9.0
+Version: 0.10.0
 Summary: Genera un mapa de contexto estructurado de proyectos de software para agentes IA
 License: MIT
 Requires-Python: >=3.9
@@ -94,7 +94,7 @@ sourcecode --version
 | `PATH` | `.` | Directory to analyze. |
 | `--format json\|yaml` | `json` | Output format. |
 | `--output PATH` | stdout | Write to a file instead of stdout. |
-| `--compact` | off | Reduced output (~500-700 tokens): `schema_version`, `project_type`, `project_summary`, `stacks`, `entry_points`, `file_paths`, `file_tree_depth1`, and `dependency_summary` when available. |
+| `--compact` | off | Reduced output (~500-700 tokens): `schema_version`, `project_type`, `project_summary`, `architecture_summary`, `stacks`, `entry_points`, `file_tree_depth1`, and `dependency_summary` when available. |
 | `--dependencies` | off | Include direct dependencies, resolved versions, and transitive relationships when lockfiles make that possible. Also populates `key_dependencies`. |
 | `--graph-modules` | off | Include a structural module graph with imports and simple relations. |
 | `--graph-detail high\|medium\|full` | `high` | Graph detail level: summarized (high), balanced (medium), or full-fidelity (full). |
@@ -118,6 +118,7 @@ The full schema (`SourceMap`) includes the following fields:
 | `file_tree` | object | Repository tree where `null` represents a file and `{}` represents a directory. |
 | `file_paths` | array | Flat list of all project paths derived from `file_tree`, with forward-slash separators. Always present; respects `--depth`. |
 | `project_summary` | string\|null | Deterministic natural-language description of the project generated from detected stacks, entry points, and dependencies. Present when stacks are detected. |
+| `architecture_summary` | string\|null | Static summary of the main execution flow, orchestrated modules, and output produced by the project. Present when enough structural evidence is available. |
 | `stacks` | array | Stack detections with confidence, frameworks, manifests, `primary`, `root`, `workspace`, and `signals`. |
 | `project_type` | string\|null | Overall project classification. |
 | `entry_points` | array | Detected entry points by stack. |
@@ -155,6 +156,7 @@ Real output from a Python FastAPI project:
   "schema_version": "1.0",
   "project_type": "api",
   "project_summary": "API en Python (FastAPI). Entry points: src/main.py. 12 dependencias (python).",
+  "architecture_summary": null,
   "stacks": [
     {
       "stack": "python",
@@ -179,7 +181,6 @@ Real output from a Python FastAPI project:
       "source": "manifest"
     }
   ],
-  "file_paths": ["pyproject.toml", "src/main.py", "src/routes.py", "tests/test_main.py"],
   "file_tree_depth1": {
     "pyproject.toml": null,
     "src": {},
@@ -371,7 +372,7 @@ Different modes optimize for different tradeoffs between context size and depth
 
 Best for: initial orientation, deciding what to explore next, fast handoffs between agents.
 
-Includes: `project_summary` (instant project description), `stacks`, `entry_points`, `file_paths` (flat path list for easy grep/reasoning), `file_tree_depth1`, and `dependency_summary` when `--dependencies` was also requested.
+Includes: `project_summary` (instant project description), `architecture_summary` (execution-oriented static summary), `stacks`, `entry_points`, `file_tree_depth1`, and `dependency_summary` when `--dependencies` was also requested.
 
 ```bash
 sourcecode --compact .
@@ -404,9 +405,9 @@ sourcecode --docs --docs-depth full .   # include methods
 - `"Aplicacion web en Node.js (Next.js, React). Entry points: app/page.tsx."`
 - `"Monorepo con 2 workspaces en Node.js, Python."`
 
-**`file_paths` field**
+**`architecture_summary` field**
 
-`file_paths` is a flat list of all project paths (forward-slash separated). It is easier for LLMs to reason about than the nested `file_tree` dict — grep it, count by extension, or identify modules by path pattern without recursive traversal.
+`architecture_summary` is a static 3-5 line summary oriented to execution flow. It answers what the main entry point does, which modules it orchestrates, and what the project produces. In compact mode it replaces the low-signal value that `file_paths` used to occupy.
 
 **`key_dependencies` field**
 

{sourcecode-0.9.0 → sourcecode-0.10.0}/README.md

@@ -78,7 +78,7 @@ sourcecode --version
 | `PATH` | `.` | Directory to analyze. |
 | `--format json\|yaml` | `json` | Output format. |
 | `--output PATH` | stdout | Write to a file instead of stdout. |
-| `--compact` | off | Reduced output (~500-700 tokens): `schema_version`, `project_type`, `project_summary`, `stacks`, `entry_points`, `file_paths`, `file_tree_depth1`, and `dependency_summary` when available. |
+| `--compact` | off | Reduced output (~500-700 tokens): `schema_version`, `project_type`, `project_summary`, `architecture_summary`, `stacks`, `entry_points`, `file_tree_depth1`, and `dependency_summary` when available. |
 | `--dependencies` | off | Include direct dependencies, resolved versions, and transitive relationships when lockfiles make that possible. Also populates `key_dependencies`. |
 | `--graph-modules` | off | Include a structural module graph with imports and simple relations. |
 | `--graph-detail high\|medium\|full` | `high` | Graph detail level: summarized (high), balanced (medium), or full-fidelity (full). |
@@ -102,6 +102,7 @@ The full schema (`SourceMap`) includes the following fields:
 | `file_tree` | object | Repository tree where `null` represents a file and `{}` represents a directory. |
 | `file_paths` | array | Flat list of all project paths derived from `file_tree`, with forward-slash separators. Always present; respects `--depth`. |
 | `project_summary` | string\|null | Deterministic natural-language description of the project generated from detected stacks, entry points, and dependencies. Present when stacks are detected. |
+| `architecture_summary` | string\|null | Static summary of the main execution flow, orchestrated modules, and output produced by the project. Present when enough structural evidence is available. |
 | `stacks` | array | Stack detections with confidence, frameworks, manifests, `primary`, `root`, `workspace`, and `signals`. |
 | `project_type` | string\|null | Overall project classification. |
 | `entry_points` | array | Detected entry points by stack. |
@@ -139,6 +140,7 @@ Real output from a Python FastAPI project:
   "schema_version": "1.0",
   "project_type": "api",
   "project_summary": "API en Python (FastAPI). Entry points: src/main.py. 12 dependencias (python).",
+  "architecture_summary": null,
   "stacks": [
     {
       "stack": "python",
@@ -163,7 +165,6 @@ Real output from a Python FastAPI project:
       "source": "manifest"
     }
   ],
-  "file_paths": ["pyproject.toml", "src/main.py", "src/routes.py", "tests/test_main.py"],
   "file_tree_depth1": {
     "pyproject.toml": null,
     "src": {},
@@ -355,7 +356,7 @@ Different modes optimize for different tradeoffs between context size and depth
 
 Best for: initial orientation, deciding what to explore next, fast handoffs between agents.
 
-Includes: `project_summary` (instant project description), `stacks`, `entry_points`, `file_paths` (flat path list for easy grep/reasoning), `file_tree_depth1`, and `dependency_summary` when `--dependencies` was also requested.
+Includes: `project_summary` (instant project description), `architecture_summary` (execution-oriented static summary), `stacks`, `entry_points`, `file_tree_depth1`, and `dependency_summary` when `--dependencies` was also requested.
 
 ```bash
 sourcecode --compact .
@@ -388,9 +389,9 @@ sourcecode --docs --docs-depth full .   # include methods
 - `"Aplicacion web en Node.js (Next.js, React). Entry points: app/page.tsx."`
 - `"Monorepo con 2 workspaces en Node.js, Python."`
 
-**`file_paths` field**
+**`architecture_summary` field**
 
-`file_paths` is a flat list of all project paths (forward-slash separated). It is easier for LLMs to reason about than the nested `file_tree` dict — grep it, count by extension, or identify modules by path pattern without recursive traversal.
+`architecture_summary` is a static 3-5 line summary oriented to execution flow. It answers what the main entry point does, which modules it orchestrates, and what the project produces. In compact mode it replaces the low-signal value that `file_paths` used to occupy.
 
 **`key_dependencies` field**
 

{sourcecode-0.9.0 → sourcecode-0.10.0}/docs/schema.md

@@ -3,7 +3,7 @@
 
 `sourcecode` serializa un objeto `SourceMap` con schema `1.0`.
 
-Los campos **siempre presentes** son: `metadata`, `file_tree`, `file_paths`, `stacks`, `project_type`, `entry_points` y `project_summary`.
+Los campos **siempre presentes** son: `metadata`, `file_tree`, `file_paths`, `stacks`, `project_type`, `entry_points`, `project_summary` y `architecture_summary`.
 
 Los campos **opcionales** dependen de los flags activos en la invocacion:
 
@@ -28,6 +28,7 @@ Los campos **opcionales** dependen de los flags activos en la invocacion:
   "project_type": "webapp",
   "entry_points": [],
   "project_summary": "Aplicacion web en Nodejs (Next.js). Entry points: app/page.tsx.",
+  "architecture_summary": null,
   "dependencies": [],
   "dependency_summary": null,
   "key_dependencies": [],
@@ -47,6 +48,7 @@ Campos:
 - `project_type`: clasificacion general del proyecto. Siempre presente (puede ser `null`).
 - `entry_points`: puntos de entrada relevantes. Siempre presente (puede ser lista vacia).
 - `project_summary`: descripcion en lenguaje natural del proyecto generada deterministicamente. Presente cuando hay stacks detectados; `null` si no (Phase 9).
+- `architecture_summary`: resumen arquitectonico estatico del flujo principal, modulos orquestados y output producido. `null` si no hay evidencia suficiente (Phase 13).
 - `dependencies`: dependencias detectadas. Solo presente con `--dependencies`; lista vacia por defecto.
 - `dependency_summary`: resumen del analisis de dependencias. Solo presente con `--dependencies`; `null` por defecto.
 - `key_dependencies`: top-15 dependencias directas relevantes. Solo presente con `--dependencies`; lista vacia por defecto (Phase 9).
@@ -61,7 +63,7 @@ Campos:
 {
   "schema_version": "1.0",
   "generated_at": "2026-04-07T19:41:05.686277+00:00",
-  "sourcecode_version": "0.9.0",
+  "sourcecode_version": "0.10.0",
   "analyzed_path": "/abs/path/to/project"
 }
 ```
@@ -232,7 +234,8 @@ Cada elemento de `entry_points` sigue este shape:
   "path": "app/page.tsx",
   "stack": "nodejs",
   "kind": "web",
-  "source": "package.json"
+  "source": "package.json",
+  "confidence": "high"
 }
 ```
 
@@ -242,6 +245,7 @@ Campos:
 - `stack`: stack al que pertenece.
 - `kind`: tipo de entry point, por ejemplo `web`, `api`, `cli` o `entry`.
 - `source`: origen de la deteccion.
+- `confidence`: confianza del entry point detectado (`high`, `medium` o `low`).
 
 ## dependencies
 
@@ -536,13 +540,9 @@ Con `--compact`, la salida omite `metadata`, el arbol completo, `dependencies`,
   "schema_version": "1.0",
   "project_type": "webapp",
   "project_summary": "Aplicacion web en Nodejs (Next.js, React). Entry points: app/page.tsx.",
+  "architecture_summary": null,
   "stacks": [],
   "entry_points": [],
-  "file_paths": [
-    "package.json",
-    "app/page.tsx",
-    "app/layout.tsx"
-  ],
   "file_tree_depth1": {
     "package.json": null,
     "app": {}
@@ -556,16 +556,17 @@ Campos incluidos en el modo compacto:
 - `schema_version`: version del schema.
 - `project_type`: clasificacion general.
 - `project_summary`: descripcion NL del proyecto. Siempre incluido (Phase 9).
+- `architecture_summary`: resumen arquitectonico estatico del flujo principal. Siempre incluido; puede ser `null` si la evidencia es insuficiente (Phase 13).
 - `stacks`: stacks detectados serializados.
 - `entry_points`: entry points serializados.
-- `file_paths`: lista plana de todos los paths con separador forward-slash. Siempre incluido (Phase 9).
 - `file_tree_depth1`: solo el primer nivel del `file_tree`. Se conserva por compatibilidad retroactiva.
 - `dependency_summary`: resumen de dependencias cuando `--dependencies` esta activo y `dependency_summary.requested == True`; `null` en cualquier otro caso (Phase 9).
 
 Campos **excluidos** en modo compacto aunque se combinen con otros flags:
 
 - `metadata`
-- `file_tree` (sustituido por `file_tree_depth1` y `file_paths`)
+- `file_tree` (sustituido por `file_tree_depth1`)
+- `file_paths`
 - `dependencies`
 - `key_dependencies`
 - `module_graph`
@@ -582,7 +583,7 @@ Ejemplo de salida para un monorepo con web Node.js y API Python con `--dependenc
   "metadata": {
     "schema_version": "1.0",
     "generated_at": "2026-04-07T19:41:05.686277+00:00",
-    "sourcecode_version": "0.9.0",
+    "sourcecode_version": "0.10.0",
     "analyzed_path": "/abs/path/to/project"
   },
   "file_tree": {

{sourcecode-0.9.0 → sourcecode-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "0.9.0"
+version = "0.10.0"
 description = "Genera un mapa de contexto estructurado de proyectos de software para agentes IA"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-0.9.0 → sourcecode-0.10.0}/src/sourcecode/__init__.py

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

sourcecode-0.10.0/src/sourcecode/architecture_summary.py

@@ -0,0 +1,248 @@
+"""Resumen arquitectonico estatico y compacto para consumo LLM."""
+from __future__ import annotations
+
+import ast
+import re
+from pathlib import Path
+from typing import Any
+
+from sourcecode.schema import EntryPoint, SourceMap, StackDetection
+from sourcecode.tree_utils import flatten_file_tree
+
+_TOOLING_PREFIXES = (".claude/", ".vscode/", "bin/")
+_PYTHON_EXTENSIONS = {".py"}
+_NODE_EXTENSIONS = {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
+_GO_EXTENSIONS = {".go"}
+
+
+class ArchitectureSummarizer:
+    """Construye un resumen arquitectonico estatico de 3-5 lineas."""
+
+    def __init__(self, root: Path) -> None:
+        self.root = root
+
+    def generate(self, sm: SourceMap) -> str | None:
+        try:
+            return self._build_summary(sm)
+        except Exception:
+            return None
+
+    def _build_summary(self, sm: SourceMap) -> str | None:
+        file_paths = [
+            path for path in flatten_file_tree(sm.file_tree)
+            if not self._is_tooling_path(path)
+        ]
+        if not file_paths:
+            return None
+
+        entry_points = [
+            entry for entry in sm.entry_points
+            if not self._is_tooling_path(entry.path)
+        ]
+        if not entry_points:
+            fallback = self._infer_fallback_entry_points(file_paths, sm.stacks)
+            entry_points = fallback[:1]
+
+        if not entry_points:
+            return "Arquitectura no inferida con suficiente evidencia estatica."
+
+        entry_point = entry_points[0]
+        content = self._read_file(entry_point.path)
+        if content is None:
+            return f"Entry point principal: {entry_point.path}. Arquitectura no inferida con suficiente evidencia estatica."
+
+        lines = [self._describe_entry_point(entry_point, sm.project_type)]
+        suffix = Path(entry_point.path).suffix
+        if suffix in _PYTHON_EXTENSIONS:
+            lines.extend(self._summarize_python_entry(entry_point.path, content))
+        elif suffix in _NODE_EXTENSIONS:
+            lines.extend(self._summarize_node_entry(entry_point.path, content))
+        elif suffix in _GO_EXTENSIONS:
+            lines.extend(self._summarize_go_entry(entry_point.path, content))
+        else:
+            lines.append("Orquesta modulos internos no detallados por el analisis estatico disponible.")
+
+        unique_lines: list[str] = []
+        seen: set[str] = set()
+        for line in lines:
+            line = line.strip()
+            if not line or line in seen:
+                continue
+            seen.add(line)
+            unique_lines.append(line)
+        return "\n".join(unique_lines[:5]) if unique_lines else None
+
+    def _summarize_python_entry(self, path: str, content: str) -> list[str]:
+        try:
+            tree = ast.parse(content)
+        except SyntaxError:
+            return ["Orquesta modulos Python, pero el entry point no pudo parsearse por completo."]
+
+        package_prefix = self._python_package_prefix(path)
+        imported_modules: list[str] = []
+        optional_analyzers: list[str] = []
+        uses_serializer = False
+        uses_redactor = False
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom) and isinstance(node.module, str):
+                if package_prefix and node.module.startswith(package_prefix):
+                    imported_modules.append(node.module.rsplit(".", 1)[-1])
+                if node.module == "sourcecode.serializer":
+                    uses_serializer = True
+                if node.module == "sourcecode.redactor":
+                    uses_redactor = True
+            elif isinstance(node, ast.Assign):
+                optional = self._extract_optional_analyzer(node)
+                if optional:
+                    optional_analyzers.append(optional)
+
+        lines: list[str] = []
+        core_modules = self._format_module_list(imported_modules)
+        if core_modules:
+            lines.append(f"Orquesta modulos internos: {core_modules}.")
+        if optional_analyzers:
+            lines.append(f"Activa analisis opcionales: {', '.join(optional_analyzers)}.")
+        if uses_serializer:
+            output_line = "Produce un SourceMap serializado en JSON/YAML y una vista compacta."
+            if uses_redactor:
+                output_line = "Produce un SourceMap serializado en JSON/YAML y una vista compacta con redaccion de secretos."
+            lines.append(output_line)
+        elif not lines:
+            lines.append("Orquesta modulos Python internos sin un patron de salida claramente inferible.")
+        return lines
+
+    def _summarize_node_entry(self, path: str, content: str) -> list[str]:
+        imports = re.findall(r"""from\s+['"](\.?\.?/[^'"]+)['"]|require\(['"](\.?\.?/[^'"]+)['"]\)""", content)
+        modules = [item for pair in imports for item in pair if item]
+        lines: list[str] = []
+        if modules:
+            formatted = self._format_module_list([self._module_label(module) for module in modules])
+            if formatted:
+                lines.append(f"Orquesta modulos internos: {formatted}.")
+        lines.append("Produce la salida principal del entry point JavaScript/TypeScript detectado.")
+        return lines
+
+    def _summarize_go_entry(self, path: str, content: str) -> list[str]:
+        imports = re.findall(r'"([^"]+)"', content)
+        internal = [module for module in imports if not module.startswith(("fmt", "net/", "os", "context"))]
+        lines: list[str] = []
+        if internal:
+            formatted = self._format_module_list([self._module_label(module) for module in internal])
+            if formatted:
+                lines.append(f"Orquesta paquetes internos: {formatted}.")
+        lines.append("Produce la salida principal del binario Go detectado.")
+        return lines
+
+    def _describe_entry_point(self, entry_point: EntryPoint, project_type: str | None) -> str:
+        if entry_point.kind == "cli" or entry_point.path.endswith("cli.py"):
+            return f"Entry point principal: {entry_point.path} expone la CLI del proyecto."
+        if entry_point.kind == "web":
+            return f"Entry point principal: {entry_point.path} arranca la interfaz web."
+        if project_type == "api" or entry_point.kind == "server":
+            return f"Entry point principal: {entry_point.path} arranca el servicio principal."
+        if entry_point.kind == "binary":
+            return f"Entry point principal: {entry_point.path} arranca el binario principal."
+        return f"Entry point principal: {entry_point.path} coordina el flujo principal del proyecto."
+
+    def _extract_optional_analyzer(self, node: ast.Assign) -> str | None:
+        value = node.value
+        if not isinstance(value, ast.IfExp):
+            return None
+        if not isinstance(value.test, ast.Name):
+            return None
+        if not isinstance(value.body, ast.Call):
+            return None
+        if not isinstance(value.body.func, ast.Name):
+            return None
+        analyzer_name = value.body.func.id
+        if not analyzer_name.endswith("Analyzer"):
+            return None
+        return f"{analyzer_name} (--{value.test.id.replace('_', '-')})"
+
+    def _infer_fallback_entry_points(
+        self, file_paths: list[str], stacks: list[StackDetection]
+    ) -> list[EntryPoint]:
+        candidates: list[EntryPoint] = []
+        stack_name = stacks[0].stack if stacks else "unknown"
+        ordered_paths = sorted(file_paths, key=self._fallback_priority)
+        for path in ordered_paths:
+            if path.endswith(("cli.py", "__main__.py", "main.py")):
+                candidates.append(
+                    EntryPoint(
+                        path=path,
+                        stack=stack_name,
+                        kind="cli",
+                        source="convention",
+                        confidence="medium",
+                    )
+                )
+            elif path.endswith(("app/page.tsx", "pages/index.js", "server.js")):
+                candidates.append(
+                    EntryPoint(
+                        path=path,
+                        stack=stack_name,
+                        kind="web" if "page" in path or "pages/" in path else "server",
+                        source="convention",
+                        confidence="medium",
+                    )
+                )
+            elif path.endswith("main.go"):
+                candidates.append(
+                    EntryPoint(
+                        path=path,
+                        stack=stack_name,
+                        kind="binary",
+                        source="convention",
+                        confidence="medium",
+                    )
+                )
+        return candidates
+
+    def _fallback_priority(self, path: str) -> tuple[int, int, str]:
+        return (
+            0 if "/cli.py" in path or path.endswith("cli.py") else 1,
+            0 if path.startswith("src/") else 1,
+            path,
+        )
+
+    def _format_module_list(self, modules: list[str]) -> str:
+        normalized = [self._module_label(module) for module in modules]
+        filtered = [module for module in normalized if module and not self._is_tooling_path(module)]
+        if not filtered:
+            return ""
+        ordered: list[str] = []
+        seen: set[str] = set()
+        for module in filtered:
+            if module not in seen:
+                seen.add(module)
+                ordered.append(module)
+        return ", ".join(ordered[:8])
+
+    def _module_label(self, module: str) -> str:
+        cleaned = module.strip().strip("./")
+        if "/" in cleaned:
+            return cleaned.split("/")[-1]
+        if "." in cleaned:
+            return cleaned.rsplit(".", 1)[-1]
+        return cleaned
+
+    def _python_package_prefix(self, path: str) -> str:
+        parts = Path(path).parts
+        if len(parts) >= 3 and parts[0] == "src":
+            return f"{parts[1]}."
+        if len(parts) >= 2:
+            return f"{parts[0]}."
+        return ""
+
+    def _read_file(self, relative_path: str) -> str | None:
+        try:
+            return (self.root / relative_path).read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return None
+
+    def _is_tooling_path(self, path: str | None) -> bool:
+        if not path:
+            return False
+        normalized = path.strip().lstrip("/")
+        return normalized.startswith(_TOOLING_PREFIXES)

{sourcecode-0.9.0 → sourcecode-0.10.0}/src/sourcecode/cli.py

@@ -473,9 +473,10 @@ def main(
                 semantic_summary=sem_sum,
             )
 
-    # Phase 9: LLM Output Quality — poblar campos derivados
-    from sourcecode.summarizer import ProjectSummarizer
-    from sourcecode.tree_utils import flatten_file_tree
+    # Phase 9: LLM Output Quality — poblar campos derivados
+    from sourcecode.architecture_summary import ArchitectureSummarizer
+    from sourcecode.summarizer import ProjectSummarizer
+    from sourcecode.tree_utils import flatten_file_tree
 
     # LQN-01: lista plana de paths del file_tree con separador forward-slash
     sm.file_paths = [
@@ -495,8 +496,9 @@ def main(
 
         sm.key_dependencies = sorted(direct_deps, key=_dep_sort_key)[:15]
 
-    # LQN-02: resumen NL deterministico
-    sm.project_summary = ProjectSummarizer().generate(sm)
+    # LQN-02: resumen NL deterministico
+    sm.project_summary = ProjectSummarizer(target).generate(sm)
+    sm.architecture_summary = ArchitectureSummarizer(target).generate(sm)
 
     # 4. Serializar (con o sin modo compact)
     if compact:

{sourcecode-0.9.0 → sourcecode-0.10.0}/src/sourcecode/detectors/go.py

@@ -39,7 +39,13 @@ class GoDetector(AbstractDetector):
         ]
         preferred = [path for path in entry_candidates if path.startswith("cmd/")] or entry_candidates
         entry_points = [
-            EntryPoint(path=path, stack="go", kind="binary", source="go.mod")
+            EntryPoint(
+                path=path,
+                stack="go",
+                kind="binary",
+                source="convention",
+                confidence="medium",
+            )
             for path in unique_strings(preferred)
         ]
         stack = StackDetection(

{sourcecode-0.9.0 → sourcecode-0.10.0}/src/sourcecode/detectors/nodejs.py

@@ -77,20 +77,33 @@ class NodejsDetector(AbstractDetector):
     def _collect_entry_points(
         self, context: DetectionContext, package_json: dict[str, Any]
     ) -> list[EntryPoint]:
-        candidate_paths: list[str] = []
+        entry_points: list[EntryPoint] = []
+        seen: set[str] = set()
         main = package_json.get("main")
         if isinstance(main, str) and main.strip():
-            candidate_paths.append(main.strip())
+            path = main.strip()
+            if path_exists_in_tree(context.file_tree, path):
+                seen.add(path)
+                entry_points.append(
+                    EntryPoint(
+                        path=path,
+                        stack="nodejs",
+                        kind="server",
+                        source="package.json",
+                        confidence="high",
+                    )
+                )
 
+        convention_candidates: list[str] = []
         bin_field = package_json.get("bin")
         if isinstance(bin_field, str) and bin_field.strip():
-            candidate_paths.append(bin_field.strip())
+            convention_candidates.append(bin_field.strip())
         elif isinstance(bin_field, dict):
-            candidate_paths.extend(
+            convention_candidates.extend(
                 str(value).strip() for value in bin_field.values() if isinstance(value, str) and value.strip()
             )
 
-        candidate_paths.extend(
+        convention_candidates.extend(
             [
                 "server.js",
                 "src/index.js",
@@ -103,11 +116,17 @@ class NodejsDetector(AbstractDetector):
             ]
         )
 
-        entry_points: list[EntryPoint] = []
-        for path in unique_strings(candidate_paths):
-            if path_exists_in_tree(context.file_tree, path):
-                kind = "web" if path.startswith(("app/", "pages/")) else "server"
-                entry_points.append(
-                    EntryPoint(path=path, stack="nodejs", kind=kind, source="package.json")
+        for path in unique_strings(convention_candidates):
+            if path in seen or not path_exists_in_tree(context.file_tree, path):
+                continue
+            kind = "web" if path.startswith(("app/", "pages/")) else "server"
+            entry_points.append(
+                EntryPoint(
+                    path=path,
+                    stack="nodejs",
+                    kind=kind,
+                    source="convention",
+                    confidence="medium",
                 )
+            )
         return entry_points

{sourcecode-0.9.0 → sourcecode-0.10.0}/src/sourcecode/detectors/python.py

@@ -132,7 +132,7 @@ class PythonDetector(AbstractDetector):
         return {match.lower() for match in matches}
 
     def _collect_entry_points(self, context: DetectionContext) -> list[EntryPoint]:
-        candidates: list[str] = []
+        declared_candidates: list[str] = []
         pyproject = load_toml_file(context.root / "pyproject.toml")
         if pyproject:
             project = pyproject.get("project", {})
@@ -142,16 +142,38 @@ class PythonDetector(AbstractDetector):
                     for value in scripts.values():
                         if isinstance(value, str) and ":" in value:
                             module, _callable = value.split(":", 1)
-                            candidates.append(module.replace(".", "/") + ".py")
+                            declared_candidates.append(module.replace(".", "/") + ".py")
 
-        candidates.extend(["__main__.py", "main.py", "app.py", "manage.py", "src/main.py"])
         entry_points: list[EntryPoint] = []
-        for path in unique_strings(candidates):
+        declared = set()
+        for path in unique_strings(declared_candidates):
             if path_exists_in_tree(context.file_tree, path):
-                kind = "cli" if path.endswith(("__main__.py", "main.py")) else "app"
+                declared.add(path)
+                kind = "cli" if path.endswith(("__main__.py", "main.py", "cli.py")) else "app"
                 entry_points.append(
-                    EntryPoint(path=path, stack="python", kind=kind, source="manifest")
+                    EntryPoint(
+                        path=path,
+                        stack="python",
+                        kind=kind,
+                        source="pyproject.toml",
+                        confidence="high",
+                    )
                 )
+
+        convention_candidates = ["cli.py", "__main__.py", "main.py", "app.py", "manage.py", "src/main.py"]
+        for path in unique_strings(convention_candidates):
+            if path in declared or not path_exists_in_tree(context.file_tree, path):
+                continue
+            kind = "cli" if path.endswith(("__main__.py", "main.py", "cli.py")) else "app"
+            entry_points.append(
+                EntryPoint(
+                    path=path,
+                    stack="python",
+                    kind=kind,
+                    source="convention",
+                    confidence="medium",
+                )
+            )
         return entry_points
 
     def _detect_package_manager(

{sourcecode-0.9.0 → sourcecode-0.10.0}/src/sourcecode/schema.py

@@ -66,6 +66,7 @@ class EntryPoint:
     stack: str
     kind: str = "entry"
     source: str = "manifest"
+    confidence: Literal["high", "medium", "low"] = "high"
 
 
 @dataclass
@@ -322,6 +323,7 @@ class SourceMap:
     # Phase 9: LLM Output Quality
     file_paths: list[str] = field(default_factory=list)
     project_summary: Optional[str] = None
+    architecture_summary: Optional[str] = None
     key_dependencies: list[DependencyRecord] = field(default_factory=list)
     # Phase 10: Code Quality Metrics
     file_metrics: list[FileMetrics] = field(default_factory=list)