sourcecode 0.1.0__py3-none-any.whl

sourcecode/workspace.py

@@ -0,0 +1,166 @@
+"""Descubrimiento de workspaces y señales de monorepo."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from sourcecode.scanner import DEFAULT_EXCLUDES
+
+
+@dataclass
+class WorkspaceCandidate:
+    """Subdirectorio candidato a workspace."""
+
+    path: str
+    reason: str
+    depth: int
+
+
+@dataclass
+class WorkspaceAnalysis:
+    """Resultado del análisis de workspaces."""
+
+    is_monorepo: bool
+    markers: list[str] = field(default_factory=list)
+    workspaces: list[WorkspaceCandidate] = field(default_factory=list)
+
+
+class WorkspaceAnalyzer:
+    """Detecta workspaces y señales de monorepo con recursión limitada."""
+
+    def __init__(self, max_depth: int = 3) -> None:
+        self.max_depth = max_depth
+
+    def analyze(self, root: Path, manifests: list[str]) -> WorkspaceAnalysis:
+        markers = self._detect_markers(root)
+        candidates: dict[str, WorkspaceCandidate] = {}
+
+        for candidate in self._workspace_candidates_from_manifests(root, manifests):
+            candidates[candidate.path] = candidate
+
+        for candidate in self._workspace_candidates_from_markers(root, markers):
+            candidates.setdefault(candidate.path, candidate)
+
+        workspaces = sorted(candidates.values(), key=lambda item: item.path)
+        return WorkspaceAnalysis(is_monorepo=bool(markers), markers=markers, workspaces=workspaces)
+
+    def _detect_markers(self, root: Path) -> list[str]:
+        markers: list[str] = []
+        for filename in ("pnpm-workspace.yaml", "go.work", "turbo.json", "lerna.json"):
+            if (root / filename).exists():
+                markers.append(filename)
+
+        cargo = root / "Cargo.toml"
+        if cargo.exists():
+            content = cargo.read_text(encoding="utf-8", errors="replace")
+            if "[workspace]" in content:
+                markers.append("Cargo.toml[workspace]")
+        return markers
+
+    def _workspace_candidates_from_manifests(
+        self, root: Path, manifests: list[str]
+    ) -> list[WorkspaceCandidate]:
+        candidates: list[WorkspaceCandidate] = []
+        for manifest in manifests:
+            try:
+                relative = Path(manifest).resolve().relative_to(root.resolve())
+            except ValueError:
+                continue
+            if len(relative.parts) <= 1:
+                continue
+            workspace = relative.parts[0]
+            if self._is_allowed_workspace(workspace):
+                candidates.append(
+                    WorkspaceCandidate(path=workspace, reason=f"manifest:{relative.name}", depth=1)
+                )
+        return candidates
+
+    def _workspace_candidates_from_markers(
+        self, root: Path, markers: list[str]
+    ) -> list[WorkspaceCandidate]:
+        candidates: list[WorkspaceCandidate] = []
+        if "pnpm-workspace.yaml" in markers:
+            candidates.extend(self._from_pnpm_workspace(root))
+        if "go.work" in markers:
+            candidates.extend(self._from_go_work(root))
+        if "Cargo.toml[workspace]" in markers:
+            candidates.extend(self._from_cargo_workspace(root))
+        return [candidate for candidate in candidates if self._is_allowed_workspace(candidate.path)]
+
+    def _from_pnpm_workspace(self, root: Path) -> list[WorkspaceCandidate]:
+        content = (root / "pnpm-workspace.yaml").read_text(encoding="utf-8", errors="replace")
+        patterns = []
+        for line in content.splitlines():
+            stripped = line.strip().strip("'\"")
+            if stripped.startswith("- "):
+                patterns.append(stripped[2:].strip("'\""))
+
+        candidates: list[WorkspaceCandidate] = []
+        for pattern in patterns:
+            for path in self._resolve_pattern(root, pattern):
+                candidates.append(
+                    WorkspaceCandidate(path=path, reason="marker:pnpm-workspace.yaml", depth=len(Path(path).parts))
+                )
+        return candidates
+
+    def _from_go_work(self, root: Path) -> list[WorkspaceCandidate]:
+        content = (root / "go.work").read_text(encoding="utf-8", errors="replace")
+        candidates: list[WorkspaceCandidate] = []
+        for line in content.splitlines():
+            stripped = line.strip()
+            if stripped.startswith("use "):
+                target = stripped.replace("use ", "", 1).strip().strip("()")
+                if target and target != ".":
+                    rel = target.removeprefix("./").rstrip("/")
+                    candidates.append(
+                        WorkspaceCandidate(path=rel, reason="marker:go.work", depth=len(Path(rel).parts))
+                    )
+            elif stripped.startswith("./"):
+                rel = stripped.removeprefix("./").rstrip()
+                candidates.append(
+                    WorkspaceCandidate(path=rel, reason="marker:go.work", depth=len(Path(rel).parts))
+                )
+        return candidates
+
+    def _from_cargo_workspace(self, root: Path) -> list[WorkspaceCandidate]:
+        content = (root / "Cargo.toml").read_text(encoding="utf-8", errors="replace")
+        candidates: list[WorkspaceCandidate] = []
+        in_members = False
+        for line in content.splitlines():
+            stripped = line.strip()
+            if stripped.startswith("members"):
+                in_members = True
+            if in_members:
+                for quote in ('"', "'"):
+                    if quote in stripped:
+                        parts = [segment for segment in stripped.split(quote) if segment and segment not in {"[", "]", ",", "members = "}]
+                        for part in parts:
+                            if "/" in part or "*" in part:
+                                for path in self._resolve_pattern(root, part):
+                                    candidates.append(
+                                        WorkspaceCandidate(path=path, reason="marker:Cargo.toml[workspace]", depth=len(Path(path).parts))
+                                    )
+                if "]" in stripped:
+                    in_members = False
+        return candidates
+
+    def _resolve_pattern(self, root: Path, pattern: str) -> list[str]:
+        matches: list[str] = []
+        for candidate in root.glob(pattern):
+            if not candidate.is_dir():
+                continue
+            try:
+                relative = candidate.resolve().relative_to(root.resolve())
+            except ValueError:
+                continue
+            if 1 <= len(relative.parts) <= self.max_depth:
+                rel = str(relative)
+                if self._is_allowed_workspace(rel):
+                    matches.append(rel)
+        return sorted(set(matches))
+
+    def _is_allowed_workspace(self, relative_path: str) -> bool:
+        parts = Path(relative_path).parts
+        if not parts or len(parts) > self.max_depth:
+            return False
+        return all(part not in DEFAULT_EXCLUDES for part in parts)

sourcecode-0.1.0.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: sourcecode
+Version: 0.1.0
+Summary: Genera un mapa de contexto estructurado de proyectos de software para agentes IA
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: pathspec>=1.0
+Requires-Dist: ruamel-yaml>=0.18
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: typer>=0.24
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.15; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sourcecode
+
+`sourcecode` genera un mapa de contexto estructurado de un proyecto de software para que un agente pueda entender rapido su stack, puntos de entrada y forma del repositorio.
+
+## Instalacion
+
+```bash
+pip install sourcecode
+```
+
+Requiere Python `3.9+`.
+
+## Uso rapido
+
+Analizar el directorio actual en JSON:
+
+```bash
+sourcecode .
+```
+
+Generar una vista compacta para prompts o handoff:
+
+```bash
+sourcecode --compact .
+```
+
+Analizar otro directorio y escribir YAML a fichero:
+
+```bash
+sourcecode --format yaml --output sourcecode.yaml /ruta/al/proyecto
+```
+
+Mostrar version:
+
+```bash
+sourcecode --version
+```
+
+Opciones principales:
+
+- `--format json|yaml`: formato de salida.
+- `--output PATH`: escribe a fichero en vez de `stdout`.
+- `--compact`: devuelve una vista reducida con `schema_version`, `project_type`, `stacks`, `entry_points` y `file_tree_depth1`.
+- `--depth INTEGER`: profundidad maxima del arbol de ficheros.
+- `--no-redact`: desactiva la redaccion de secretos.
+
+## Que detecta
+
+- Stacks: Node.js, Python, Go, Rust, Java, PHP, Ruby y Dart.
+- Frameworks asociados al stack cuando hay senales suficientes.
+- `project_type`: `webapp`, `api`, `library`, `cli`, `fullstack`, `monorepo` o `unknown`.
+- `entry_points` relevantes, como `main.py`, `cmd/api/main.go` o `app/page.tsx`.
+- Workspaces y roots por stack en repos multi-stack o monorepo.
+
+## Ejemplo compacto
+
+Salida real de un fixture Next.js:
+
+```json
+{
+  "schema_version": "1.0",
+  "project_type": "webapp",
+  "stacks": [
+    {
+      "stack": "nodejs",
+      "detection_method": "manifest",
+      "confidence": "high",
+      "frameworks": [
+        { "name": "Next.js", "source": "package.json" },
+        { "name": "React", "source": "package.json" }
+      ],
+      "package_manager": "pnpm",
+      "manifests": ["package.json"],
+      "primary": true,
+      "root": ".",
+      "workspace": null,
+      "signals": [
+        "manifest:package.json",
+        "framework:Next.js",
+        "framework:React",
+        "package_manager:pnpm",
+        "entry:app/page.tsx"
+      ]
+    }
+  ],
+  "entry_points": [
+    {
+      "path": "app/page.tsx",
+      "stack": "nodejs",
+      "kind": "web",
+      "source": "package.json"
+    }
+  ],
+  "file_tree_depth1": {
+    "pnpm-lock.yaml": null,
+    "package.json": null,
+    "app": {}
+  }
+}
+```
+
+## Ejemplo monorepo
+
+En un monorepo, cada stack incluye su `root` y `workspace`, y uno de ellos queda marcado como `primary`.
+
+```json
+{
+  "project_type": "monorepo",
+  "stacks": [
+    {
+      "stack": "nodejs",
+      "primary": true,
+      "root": "apps/web",
+      "workspace": "apps/web"
+    },
+    {
+      "stack": "python",
+      "primary": false,
+      "root": "packages/api",
+      "workspace": "packages/api"
+    }
+  ],
+  "entry_points": [
+    { "path": "apps/web/app/page.tsx", "stack": "nodejs", "kind": "web" },
+    { "path": "packages/api/main.py", "stack": "python", "kind": "cli" }
+  ]
+}
+```
+
+## Output
+
+El schema completo incluye:
+
+- `metadata`: version de schema, timestamp, version de `sourcecode` y ruta analizada.
+- `file_tree`: arbol del repositorio donde `null` representa un fichero y un objeto representa un directorio.
+- `stacks`: detecciones por ecosistema con confianza, frameworks, manifests, `primary`, `root`, `workspace` y `signals`.
+- `project_type`: clasificacion general del proyecto.
+- `entry_points`: entradas detectadas por stack.
+
+La referencia detallada esta en [docs/schema.md](/Users/user/Documents/workspace/atlas/atlas-cli/docs/schema.md).
+
+## Desarrollo
+
+Instalacion editable con dependencias de desarrollo:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Validacion local:
+
+```bash
+ruff check src tests
+mypy src
+pytest -q
+```

sourcecode-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+sourcecode/__init__.py,sha256=zFh8ACgMMXbAd5f8rHwMQHBQ6irzFx0iQ1NkQc34ff8,99
+sourcecode/classifier.py,sha256=GgJE9DjsMkXgK8DIprr1cfa_FiQBZsd_4ZxzyGYw1b8,6405
+sourcecode/cli.py,sha256=sf1nf-BmPWzscFvoScNkKIlfU10wepOgTfFE-lf4NO4,6962
+sourcecode/redactor.py,sha256=abSf5jH_IzYzpjF3lEN6hCwdXxvmyHs-3DHz9fd8Mic,2883
+sourcecode/scanner.py,sha256=TvcuD77m_NF8OlTj3XH1b_jO0qrto8c90fND96ecqb0,6182
+sourcecode/schema.py,sha256=E2_EnuYWHWZOLarxENvL5S66QBkZIpyV1BzKetCJWIY,2487
+sourcecode/serializer.py,sha256=hezTYOAAvZ2yPn7Te7Eu42ajbMhVCsUkuUZtqx4wjAs,3085
+sourcecode/tree_utils.py,sha256=5WHQc2L-AGqxKFfYYcQftE6hETxgUxP9MWDuaThcAUw,991
+sourcecode/workspace.py,sha256=1L4xH38gU89fLeMYSuF3ft7lSdCyTfMfJ9NQt5q4Ric,6904
+sourcecode/detectors/__init__.py,sha256=RMSr1E3uIK7MvfAQdVo4lfkcDptW3tBzLPFZwQju6C4,1455
+sourcecode/detectors/base.py,sha256=mLqDNil8VkFRNbzwO2wPbmw_aaVg3WR_WzzRjU58xbU,1070
+sourcecode/detectors/dart.py,sha256=77KDgBY-xkbzLjs0Emw6c0NuQY-tQZR5PCHa9r0t2OE,1476
+sourcecode/detectors/go.py,sha256=oifvbih6i4yrUO2zQs3kVXEdirr6jVriiV1fJ_-NF2I,1748
+sourcecode/detectors/heuristic.py,sha256=Phimturkvi5ZwNdt005TizYTrllZk1pqHpfXOkFZJbc,1943
+sourcecode/detectors/java.py,sha256=XdONBlcBb0Vo-2hvG77Fw00X41d2KlHFCPXJCuzwAl0,3547
+sourcecode/detectors/nodejs.py,sha256=2LDNoqrQcOm_ne66PKdIDBJR_7XEFTfB42Luhz2IoEg,3885
+sourcecode/detectors/parsers.py,sha256=CQhhFGk8lSXruIfLe571-1HOId3W0ssnY2ioHMGtOrg,2338
+sourcecode/detectors/php.py,sha256=6l5pFlUuKrrC6XlWPSgYTEnnPm3hoFxMM4DRAnjL4nM,1920
+sourcecode/detectors/project.py,sha256=Fu3N_5ZKtv5b0F7i8Om36k_SZKvm24nRURkHyLogp6Q,5379
+sourcecode/detectors/python.py,sha256=DMrlKXapsaRu8jVmO-w-FfnFVXTmQnmpQTaV2PBvIZA,4875
+sourcecode/detectors/ruby.py,sha256=3_Hd5YqlErpTtyTRcUTPnMp1TF92hT-TnYYeclLbF1c,1625
+sourcecode/detectors/rust.py,sha256=iUz9lE4HfBy8CBaDwGhfh6kLsNIovrH2ay2v3y6qNDc,2298
+sourcecode-0.1.0.dist-info/METADATA,sha256=vCBUxFWpWLh7zfzltWS3LzBsT019LuhlNz89Lr-15aI,4179
+sourcecode-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-0.1.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
+sourcecode-0.1.0.dist-info/RECORD,,

sourcecode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sourcecode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sourcecode = sourcecode.cli:app