sourcecode 0.19.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/cli.py

@@ -75,6 +75,11 @@ def main(
         "--graph-edges",
         help="Tipos de arista para `--graph-modules` separados por comas: imports,calls,contains,extends",
     ),
+    no_tree: bool = typer.Option(
+        False,
+        "--no-tree",
+        help="Suprimir file_tree y file_paths del output (ideal con --dependencies en proyectos grandes)",
+    ),
     no_redact: bool = typer.Option(
         False,
         "--no-redact",
@@ -151,6 +156,11 @@ def main(
         "--code-notes",
         help="Extraer anotaciones TODO/FIXME/HACK/NOTE/DEPRECATED/WARNING/BUG/XXX/OPTIMIZE con ubicacion y simbolo envolvente, y detectar ADRs en docs/decisions/, docs/adr/ y similares",
     ),
+    agent: bool = typer.Option(
+        False,
+        "--agent",
+        help="Modo agente: selecciona automaticamente --compact --dependencies --env-map --code-notes y activa --no-tree en proyectos Java/Gradle o grandes",
+    ),
 ) -> None:
     """Genera un mapa de contexto estructurado del proyecto en formato JSON o YAML."""
     # Validar formato
@@ -221,6 +231,16 @@ def main(
     _java_min_depth = 8
     effective_depth = max(depth, _java_min_depth) if _is_java and depth < _java_min_depth else depth
 
+    # --agent: auto-select flags based on project characteristics
+    if agent:
+        compact = True
+        if _is_java:
+            no_tree = True
+        _agent_flags = ["--compact", "--dependencies", "--env-map", "--code-notes"]
+        if no_tree:
+            _agent_flags.append("--no-tree")
+        typer.echo(f"[agent] {' '.join(_agent_flags)}", err=True)
+
     scanner = FileScanner(target, max_depth=effective_depth)
     raw_tree = scanner.scan_tree()
 
@@ -594,7 +614,7 @@ def main(
 
     # 4. Serializar (con o sin modo compact)
     if compact:
-        data = compact_view(sm)
+        data = compact_view(sm, no_tree=no_tree)
         # Aplicar redaccion sobre el dict del compact view
         if not no_redact:
             data = redact_dict(data)
@@ -602,6 +622,9 @@ def main(
     else:
         # Redactar sobre el dict serializado (SEC-01, SEC-03)
         raw_dict = asdict(sm)
+        if no_tree:
+            raw_dict.pop("file_tree", None)
+            raw_dict.pop("file_paths", None)
         if not no_redact:
             raw_dict = redact_dict(raw_dict)
 

sourcecode/dependency_analyzer.py

@@ -34,6 +34,7 @@ class DependencyAnalyzer:
             self._analyze_go,
             self._analyze_dotnet,
             self._analyze_java,
+            self._analyze_gradle,
         ):
             handler_records, handler_limitations = handler(root)
             records.extend(replace(record, workspace=workspace) for record in handler_records)
@@ -925,6 +926,47 @@ class DependencyAnalyzer:
                 result.append(resolved)
         return self._dedupe(result)
 
+    def _parse_maven_properties(self, root_elem: ET.Element, ns: str) -> dict[str, str]:
+        properties: dict[str, str] = {}
+        props_elem = root_elem.find(f"{ns}properties")
+        if props_elem is not None:
+            for prop in props_elem:
+                tag = prop.tag.replace(ns, "") if ns else prop.tag
+                if prop.text:
+                    properties[tag] = prop.text.strip()
+        return properties
+
+    def _resolve_maven_version(self, version_raw: Optional[str], properties: dict[str, str]) -> Optional[str]:
+        if not version_raw:
+            return None
+        if not version_raw.startswith("${"):
+            return version_raw
+        prop_name = version_raw[2:-1] if version_raw.endswith("}") else None
+        if prop_name and prop_name in properties:
+            return properties[prop_name]
+        return None
+
+    def _parse_dependency_management(
+        self, root_elem: ET.Element, ns: str, properties: dict[str, str]
+    ) -> dict[str, str]:
+        dm_versions: dict[str, str] = {}
+        dm_elem = root_elem.find(f"{ns}dependencyManagement")
+        if dm_elem is None:
+            return dm_versions
+        deps_elem = dm_elem.find(f"{ns}dependencies")
+        if deps_elem is None:
+            return dm_versions
+        for dep in deps_elem.findall(f"{ns}dependency"):
+            group_id = (dep.findtext(f"{ns}groupId") or "").strip()
+            artifact_id = (dep.findtext(f"{ns}artifactId") or "").strip()
+            if not group_id or not artifact_id:
+                continue
+            version_raw = (dep.findtext(f"{ns}version") or "").strip() or None
+            resolved = self._resolve_maven_version(version_raw, properties)
+            if resolved:
+                dm_versions[f"{group_id}:{artifact_id}"] = resolved
+        return dm_versions
+
     def _analyze_java(self, root: Path) -> tuple[list[DependencyRecord], list[str]]:
         pom = root / "pom.xml"
         if not pom.exists():
@@ -938,6 +980,9 @@ class DependencyAnalyzer:
         ns_match = re.match(r"\{[^}]+\}", root_elem.tag)
         ns = ns_match.group(0) if ns_match else ""
 
+        properties = self._parse_maven_properties(root_elem, ns)
+        dm_versions = self._parse_dependency_management(root_elem, ns, properties)
+
         records: list[DependencyRecord] = []
         deps_elem = root_elem.find(f"{ns}dependencies")
         if deps_elem is None:
@@ -949,8 +994,9 @@ class DependencyAnalyzer:
             if not group_id or not artifact_id:
                 continue
             version_raw = (dep.findtext(f"{ns}version") or "").strip() or None
-            # Versiones interpoladas con propiedades Maven (${...}) no son resolvibles estáticamente
-            declared = version_raw if version_raw and not version_raw.startswith("${") else None
+            declared = self._resolve_maven_version(version_raw, properties)
+            if declared is None:
+                declared = dm_versions.get(f"{group_id}:{artifact_id}")
             scope_text = (dep.findtext(f"{ns}scope") or "compile").strip().lower()
             scope = "dev" if scope_text == "test" else "direct"
             records.append(
@@ -969,6 +1015,115 @@ class DependencyAnalyzer:
             limitations.append("java: pom.xml sin dependencias parseables (puede usar BOM o propiedades)")
         return records, limitations
 
+    def _analyze_gradle(self, root: Path) -> tuple[list[DependencyRecord], list[str]]:
+        for filename in ("build.gradle", "build.gradle.kts"):
+            gradle_file = root / filename
+            if gradle_file.exists():
+                try:
+                    content = gradle_file.read_text(encoding="utf-8", errors="replace")
+                except OSError:
+                    return [], [f"gradle: error al leer {filename}"]
+                props = self._parse_gradle_properties(root, content)
+                records = self._parse_gradle_dependencies(content, props, filename)
+                return records, ["gradle: sin lockfile compatible; dependencias transitivas no disponibles"]
+        return [], []
+
+    def _parse_gradle_properties(self, root: Path, content: str) -> dict[str, str]:
+        props: dict[str, str] = {}
+        # gradle.properties file (key=value format)
+        gp = root / "gradle.properties"
+        if gp.exists():
+            try:
+                for line in gp.read_text(encoding="utf-8", errors="replace").splitlines():
+                    stripped = line.strip()
+                    if stripped and not stripped.startswith("#") and "=" in stripped:
+                        k, _, v = stripped.partition("=")
+                        props[k.strip()] = v.strip()
+            except OSError:
+                pass
+        # Variables declared in the build file itself.
+        # Match: val/var/def x = "v", or bare x = "v" anywhere (ext blocks, top-level).
+        # Negative lookbehind (?<![.\w]) prevents matching mid-expression (e.g. obj.field = "v").
+        for m in re.finditer(r"""(?:(?:val|var|def)\s+)?(?<![.\w])(\w+)\s*=\s*["']([^"']+)["']""", content):
+            props.setdefault(m.group(1), m.group(2))
+        return props
+
+    def _resolve_gradle_version(self, version_raw: Optional[str], props: dict[str, str]) -> Optional[str]:
+        if not version_raw:
+            return None
+        # ${varName} — Groovy string interpolation
+        m = re.fullmatch(r"\$\{(\w+)\}", version_raw)
+        if m:
+            return props.get(m.group(1))
+        # $varName — Kotlin string interpolation
+        m = re.fullmatch(r"\$(\w+)", version_raw)
+        if m:
+            return props.get(m.group(1))
+        return version_raw
+
+    def _parse_gradle_dependencies(
+        self, content: str, props: dict[str, str], manifest_path: str
+    ) -> list[DependencyRecord]:
+        _DIRECT = frozenset({
+            "implementation", "api", "compileOnly", "runtimeOnly", "compile", "provided",
+            "compileClasspath", "runtimeClasspath",
+        })
+        _DEV = frozenset({
+            "testImplementation", "testRuntimeOnly", "testCompileOnly", "testApi",
+            "testCompile", "androidTestImplementation", "annotationProcessor", "kapt",
+            "debugImplementation", "releaseImplementation",
+        })
+        all_scopes = _DIRECT | _DEV
+        records: list[DependencyRecord] = []
+
+        # String notation: scope("group:artifact") or scope("group:artifact:version")
+        str_pat = re.compile(
+            r"""(\w+)\s*\(?\s*["']([A-Za-z][\w.\-]*:[A-Za-z][\w.\-]*)(?::([^"'\s)]+))?["']"""
+        )
+        for m in str_pat.finditer(content):
+            scope_kw = m.group(1)
+            if scope_kw not in all_scopes:
+                continue
+            parts = m.group(2).split(":")
+            if len(parts) < 2:
+                continue
+            group_id, artifact_id = parts[0].strip(), parts[1].strip()
+            if not group_id or not artifact_id:
+                continue
+            version = self._resolve_gradle_version(m.group(3), props)
+            records.append(DependencyRecord(
+                name=f"{group_id}:{artifact_id}",
+                ecosystem="java",
+                scope="dev" if scope_kw in _DEV else "direct",
+                declared_version=version,
+                source="manifest",
+                manifest_path=manifest_path,
+            ))
+
+        # Map notation: scope(group: "g", name: "a", version: "v")  — Groovy uses ':', Kotlin uses '='
+        map_pat = re.compile(
+            r"""(\w+)\s*\(?\s*group\s*[=:]\s*["']([^"']+)["']\s*,\s*name\s*[=:]\s*["']([^"']+)["']"""
+            r"""(?:\s*,\s*version\s*[=:]\s*["']([^"']+)["'])?"""
+        )
+        for m in map_pat.finditer(content):
+            scope_kw = m.group(1)
+            if scope_kw not in all_scopes:
+                continue
+            group_id, artifact_id = m.group(2).strip(), m.group(3).strip()
+            if not group_id or not artifact_id:
+                continue
+            version = self._resolve_gradle_version(m.group(4), props)
+            records.append(DependencyRecord(
+                name=f"{group_id}:{artifact_id}",
+                ecosystem="java",
+                scope="dev" if scope_kw in _DEV else "direct",
+                declared_version=version,
+                source="manifest",
+                manifest_path=manifest_path,
+            ))
+
+        return self._dedupe(records)
+
     def _load_yaml_file(self, path: Path) -> Optional[dict[str, Any]]:
         if not path.exists():
             return None

sourcecode/serializer.py

@@ -54,27 +54,31 @@ def to_yaml(sm: SourceMap) -> str:
     return stream.getvalue()
 
 
-def compact_view(sm: SourceMap) -> dict[str, Any]:
+def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
     """Proyeccion compacta del SourceMap (~500-700 tokens).
 
     Incluye: schema_version, project_type, stacks, entry_points,
     project_summary (siempre), architecture_summary (siempre),
-    dependency_summary (cuando requested=True),
-    file_tree_depth1 (backward compat).
+    dependency_summary + key_dependencies (cuando requested=True),
+    file_tree_depth1 (omitido si no_tree=True).
 
     Excluye: dependencies (lista larga), docs, module_graph.
     """
-    depth1: dict[str, Any] = {}
-    for name, value in sm.file_tree.items():
-        if isinstance(value, dict):
-            depth1[name] = {}
-        else:
-            depth1[name] = None
+    depth1: dict[str, Any] | None = None
+    if not no_tree:
+        depth1 = {}
+        for name, value in sm.file_tree.items():
+            if isinstance(value, dict):
+                depth1[name] = {}
+            else:
+                depth1[name] = None
 
     dep_summary_dict: Any = None
+    key_deps: Any = None
     if sm.dependency_summary is not None and sm.dependency_summary.requested:
         dep_summary_dict = asdict(sm.dependency_summary)
         dep_summary_dict.pop("dependencies", None)
+        key_deps = [asdict(d) for d in sm.key_dependencies]
 
     env_summary_dict: Any = None
     if sm.env_summary is not None and sm.env_summary.requested:
@@ -84,18 +88,21 @@ def compact_view(sm: SourceMap) -> dict[str, Any]:
     if sm.code_notes_summary is not None and sm.code_notes_summary.requested:
         code_notes_summary_dict = asdict(sm.code_notes_summary)
 
-    return {
+    result: dict[str, Any] = {
         "schema_version": sm.metadata.schema_version,
         "project_type": sm.project_type,
         "project_summary": sm.project_summary,
         "architecture_summary": sm.architecture_summary,
         "stacks": [asdict(stack) for stack in sm.stacks],
         "entry_points": [asdict(entry_point) for entry_point in sm.entry_points],
-        "file_tree_depth1": depth1,
         "dependency_summary": dep_summary_dict,
+        "key_dependencies": key_deps,
         "env_summary": env_summary_dict,
         "code_notes_summary": code_notes_summary_dict,
     }
+    if not no_tree:
+        result["file_tree_depth1"] = depth1
+    return result
 
 
 def normalize_source_map(sm: SourceMap) -> SourceMap:

{sourcecode-0.19.0.dist-info → sourcecode-0.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.19.0
+Version: 0.20.0
 Summary: Genera un mapa de contexto estructurado de proyectos de software para agentes IA
 License: MIT
 Requires-Python: >=3.9
@@ -81,7 +81,7 @@ sourcecode --version
 
 ## What It Detects
 
-- Stacks: Node.js, Python, Go, Rust, Java, PHP, Ruby, and Dart.
+- Stacks: Node.js, Python, Go, Rust, Java (Maven `pom.xml` and Gradle `build.gradle`/`build.gradle.kts`), PHP, Ruby, and Dart.
 - Frameworks associated with each stack when enough signals are present.
 - `project_type`: `webapp`, `api`, `library`, `cli`, `fullstack`, `monorepo`, or `unknown`.
 - Relevant `entry_points`, such as `main.py`, `cmd/api/main.go`, or `app/page.tsx`.
@@ -111,6 +111,8 @@ sourcecode --version
 | `--env-map` | off | Map all environment variables referenced in source code: key name, required/optional status, inferred type (`string`, `int`, `bool`, `url`, `path`, `enum`), functional category (`database`, `auth`, `cache`, `storage`, `service`, `observability`, `feature_flag`, `server`, `general`), default value when present, and source file locations. Supplements with descriptions from `.env.example`, `.env.sample`, and similar reference files. |
 | `--code-notes` | off | Extract inline code annotations — `TODO`, `FIXME`, `HACK`, `NOTE`, `DEPRECATED`, `WARNING`, `XXX`, `BUG`, `OPTIMIZE` — with file path, line number, annotation text, and the nearest enclosing function or class. Also detects Architecture Decision Records (ADRs) in `docs/decisions/`, `docs/adr/`, `adr/`, and similar directories, extracting title, status, and summary. |
 | `--depth INTEGER` | `4` | Maximum file tree depth. Range: 1–20. |
+| `--no-tree` | off | Suppress `file_tree`, `file_paths` (and `file_tree_depth1` in `--compact`) from the output. Ideal with `--dependencies` on large projects to get dependency data without a multi-thousand-line file tree. |
+| `--agent` | off | Agent mode: auto-selects `--compact --dependencies --env-map --code-notes` and adds `--no-tree` automatically for Java/Gradle projects or large repositories. Prints selected flags to stderr. Can be combined with other flags (e.g. `--agent --git-context`). |
 | `--no-redact` | off | Disable secret redaction (enabled by default). |
 | `--version` | — | Show version and exit. |
 
@@ -123,8 +125,8 @@ The full schema (`SourceMap`) includes the following fields:
 | Field | Type | Description |
 |-------|------|-------------|
 | `metadata` | object | Schema version, timestamp, `sourcecode` version, and analyzed path. |
-| `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`. |
+| `file_tree` | object | Repository tree where `null` represents a file and `{}` represents a directory. Suppressed when `--no-tree` is active. |
+| `file_paths` | array | Flat list of all project paths derived from `file_tree`, with forward-slash separators. Respects `--depth`. Suppressed when `--no-tree` is active. |
 | `project_summary` | string\|null | Deterministic natural-language description of the project. Includes: manifest/README description when available, detected architecture pattern (`layered`, `mvc`, `hexagonal`, `fullstack`), business domain names inferred from directory structure, entry points (when no domains are detected), and dependency count. 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`. |
@@ -223,7 +225,7 @@ ADR detection looks for Markdown files in `docs/decisions/`, `docs/adr/`, `adr/`
 
 ## Compact Mode
 
-`--compact` returns a reduced JSON view optimized for LLM prompts (~500-700 tokens). It excludes the full `dependencies` list, `docs`, and `module_graph`, while retaining the fields most useful for project orientation. When optional flags are also active, their summaries are included: `dependency_summary` (with `--dependencies`), `env_summary` (with `--env-map`), and `code_notes_summary` (with `--code-notes`).
+`--compact` returns a reduced JSON view optimized for LLM prompts. It excludes the full `dependencies` list, `docs`, and `module_graph`, while retaining the fields most useful for project orientation. When optional flags are also active, their summaries are included: `dependency_summary` + `key_dependencies` (with `--dependencies`), `env_summary` (with `--env-map`), and `code_notes_summary` (with `--code-notes`). Adding `--no-tree` further removes `file_tree_depth1`, bringing the output to ~500-800 tokens depending on how many flags are active.
 
 Real output from a Python FastAPI project:
 
@@ -266,7 +268,7 @@ Real output from a Python FastAPI project:
 }
 ```
 
-When `--compact --dependencies` is used, `dependency_summary` is populated instead of `null`.
+When `--compact --dependencies` is used, `dependency_summary` is populated and `key_dependencies` lists the top-15 direct dependencies with resolved versions. Add `--no-tree` to drop `file_tree_depth1` for the smallest possible context footprint.
 
 ## Docs Mode
 
@@ -444,15 +446,27 @@ In a monorepo, each stack includes its own `root` and `workspace`, and one of th
 
 Different modes optimize for different tradeoffs between context size and depth of information.
 
-**`--compact` — minimal context (~500-700 tokens)**
+**`--agent` — zero-config mode for AI pipelines**
+
+Best for: running `sourcecode` from inside an agent without knowing the project in advance. Auto-selects the right flag combination based on detected stack and project size.
+
+```bash
+sourcecode --agent .
+sourcecode --agent --git-context .   # add git context on top of auto-selected flags
+```
+
+On a Java/Gradle project the output is: `--compact --dependencies --env-map --code-notes --no-tree` (~800 tokens). On a Node/Python project: same without `--no-tree` (~900 tokens including depth-1 tree). Selected flags are always printed to stderr so the agent can log them.
+
+**`--compact` — minimal context**
 
 Best for: initial orientation, deciding what to explore next, fast handoffs between agents.
 
-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.
+Includes: `project_summary`, `architecture_summary`, `stacks`, `entry_points`, `file_tree_depth1`, and — when the respective flags are active — `dependency_summary` + `key_dependencies`, `env_summary`, `code_notes_summary`.
 
 ```bash
 sourcecode --compact .
-sourcecode --compact --dependencies .
+sourcecode --compact --dependencies .           # + key dependencies with versions
+sourcecode --compact --dependencies --no-tree . # smallest footprint: no file tree
 ```
 
 **Full output — deep analysis**

{sourcecode-0.19.0.dist-info → sourcecode-0.20.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-sourcecode/__init__.py,sha256=K3oF2tC36Se4IiYU6MvNhrg4EoK_jaLeik_nUWPID4Y,100
+sourcecode/__init__.py,sha256=dzKShGXdjPL26nODQDz1WcEo-41T1Cel-cSD0xF9gPg,100
 sourcecode/architecture_analyzer.py,sha256=zxgqeqn2FhIUDn06X-whjGKiXbrHFkRlzZcr2zKd0Gw,16874
 sourcecode/architecture_summary.py,sha256=r9IciS9z-7h8xpiME7DKBLhLV36xzXtSzbZ1cRDWklo,11709
 sourcecode/classifier.py,sha256=fcp2wIq198wq3Rsh_bDmZIK_W5UI6FEL5oqm1RrQfpA,6846
-sourcecode/cli.py,sha256=pB0NmyaH-gCrHCFlNxYSMfuArM6nitv6PyrMLkYKKRs,25429
+sourcecode/cli.py,sha256=_FKnSNHqtLH6wJ2IA_7NR7-TUICCitildIMpSZt4IP8,26360
 sourcecode/code_notes_analyzer.py,sha256=rRd8bFYV0krjlxxQV0wenwE9K7pVpUQSR7KvSvUQKw4,9226
 sourcecode/coverage_parser.py,sha256=q0LeZJaX1bnntLu-ImksdBsMlpsVmk_iUfSaB4eaJGo,19702
-sourcecode/dependency_analyzer.py,sha256=KITti0XLHK3RvZGqAUseWnlFLXGFyv5FqvSK5R6PB1g,41147
+sourcecode/dependency_analyzer.py,sha256=2TYBIpenhfWf_TVBZZfq3T0SHFv8xCKFIyn1XnFHG6s,48146
 sourcecode/doc_analyzer.py,sha256=Ec3orx6vBKsh5cNM3-F4y2Got2KuKx8w3dErwtdtM-A,19891
 sourcecode/env_analyzer.py,sha256=JZxBOuIxnM0xw0IaJFL6LiPJBErL848L3XoTOHGBqZI,13554
 sourcecode/git_analyzer.py,sha256=S9PGt8RDasBQYQUsZh9-H_KWVlPvzwR4jgM7TKN9ZCk,7643
@@ -16,7 +16,7 @@ sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
 sourcecode/scanner.py,sha256=Ga4jDRAOhkcwlRmlE2ko6cE39qKy0aI4iE1lGBWmAlk,6410
 sourcecode/schema.py,sha256=dnNdnQxJtBv0PRVWi6-xnpr16dj6IsUGbso9PeeEolA,15743
 sourcecode/semantic_analyzer.py,sha256=SRQSGJzEi4ZsGvb7U3qvnRiKHabz4hvIzCqiG92x9K8,79349
-sourcecode/serializer.py,sha256=edOfD25lUKkZ0gIjFcjqWmY4yHSnOKvudzNisvW_RYg,13456
+sourcecode/serializer.py,sha256=ck0gK3PV-rY5UrAvykKh8x56Lb1135J23xzbcEsvUW8,13772
 sourcecode/summarizer.py,sha256=2Yz5xJ1bhtJLlrUpKcd74wijypRRo9GJmGT8u971EW0,11572
 sourcecode/tree_utils.py,sha256=xla45Whq24j6U9kEgTztJXkMpmOEDieAulKxP3nl89s,935
 sourcecode/workspace.py,sha256=fQlVoNx8S-fSHpKoJ0JBvEHCFkxszH0KZVJed1i3TRk,6845
@@ -39,7 +39,7 @@ sourcecode/detectors/rust.py,sha256=V23NO6Y8NsrhrUlGC2feUEcNK63hf3gc1y3jI4tes1Q,
 sourcecode/detectors/systems.py,sha256=nYaKbGDFu0EOXFcd_1doWFT3tTUdkbxc2DjHUF5TcqQ,1627
 sourcecode/detectors/terraform.py,sha256=cxORPR_zVLOJpHlh4e9JnFpkQsn_UnqMMom5yG65hZ4,1693
 sourcecode/detectors/tooling.py,sha256=hIvop80No22pqyGVJ32NKliSdjkHRePQkIRroqG01bY,1875
-sourcecode-0.19.0.dist-info/METADATA,sha256=cv1q6sPPTkTruEdpHr8JioUXmXuSec5dPAhAw9NXoW8,25900
-sourcecode-0.19.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.19.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
-sourcecode-0.19.0.dist-info/RECORD,,
+sourcecode-0.20.0.dist-info/METADATA,sha256=KzFy_Iwj3H4eEWomjdYtE_XMb94isl55ekXSIHKOQ58,27548
+sourcecode-0.20.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-0.20.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
+sourcecode-0.20.0.dist-info/RECORD,,