reponexia 0.1.0__py3-none-any.whl

reponexia/pipeline.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+
+from .cache import cache_key
+from .redact import redact
+from .summarize.base import ModuleContext, RepoContext, Summarizer
+from .summarize.context import build_module_contexts
+from .summarize.skeleton import MAX_LINES_FOR_LLM, skeletonize
+
+# Teto de linhas de um snippet enviado ao LLM (mesmo abaixo do limite de esqueleto).
+MAX_SNIPPET_LINES = 200
+
+
+def _symbols_by_file(graph: dict) -> dict[str, list[dict]]:
+    result: dict[str, list[dict]] = {}
+    for symbol in graph.get("symbols", []):
+        result.setdefault(symbol["file"], []).append(symbol)
+    return result
+
+
+# Lê o arquivo do disco, esqueletiza se for grande, fatia e redige segredos.
+# O LLM nunca vê o repositório inteiro.
+def _snippet(root: Path, path: str, symbols: list[dict]) -> str | None:
+    try:
+        text = (root / path).read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return None
+
+    if text.count("\n") + 1 > MAX_LINES_FOR_LLM:
+        text = skeletonize(text, symbols)
+
+    lines = text.splitlines()[:MAX_SNIPPET_LINES]
+    return redact("\n".join(lines))
+
+
+def attach_snippets(contexts: list[ModuleContext], graph: dict) -> list[ModuleContext]:
+    root = Path(graph["root"])
+    by_file = _symbols_by_file(graph)
+
+    attached = []
+    for ctx in contexts:
+        snippets = []
+        for path in ctx.files:
+            snippet = _snippet(root, path, by_file.get(path, []))
+            if snippet:
+                snippets.append(f"# {path}\n{snippet}")
+        attached.append(replace(ctx, snippets=tuple(snippets)))
+    return attached
+
+
+def _module_hash(graph: dict, files: tuple[str, ...]) -> str:
+    hashes = {file["path"]: file.get("hash", "") for file in graph.get("files", [])}
+    return cache_key(*[hashes.get(path, "") for path in files])
+
+
+# Pipeline hierárquico: sumariza módulo a módulo e depois o repo a partir desses
+# resumos. Cache por hash de módulo evita re-chamar o LLM sem mudança.
+def build_narrative(
+    graph: dict,
+    summarizer: Summarizer,
+    *,
+    cache=None,
+    verbose: bool = False,
+) -> dict:
+    contexts = attach_snippets(build_module_contexts(graph), graph)
+    model = getattr(summarizer, "model", "")
+
+    modules: dict[str, str] = {}
+    for ctx in contexts:
+        key = cache_key("module", model, _module_hash(graph, ctx.files))
+        cached = cache.get(key) if cache else None
+        if cached is not None:
+            if verbose:
+                print(f"[cache] modulo {ctx.name}")
+            modules[ctx.name] = cached
+            continue
+
+        text = summarizer.summarize_module(ctx)
+        modules[ctx.name] = text
+        if cache is not None:
+            cache.set(key, text)
+
+    repo_context = RepoContext(
+        name=Path(graph["root"]).name or graph["root"],
+        languages=tuple(graph.get("languages", [])),
+        file_count=len(graph.get("files", [])),
+        module_summaries=tuple(
+            f"## {name}\n{text}" for name, text in modules.items()
+        ),
+    )
+
+    repo_key = cache_key("repo", model, graph.get("repo_hash", ""))
+    cached_repo = cache.get(repo_key) if cache else None
+    if cached_repo is None:
+        cached_repo = summarizer.summarize_repo(repo_context)
+        if cache is not None:
+            cache.set(repo_key, cached_repo)
+
+    return {"repo": cached_repo, "modules": modules}

reponexia/redact.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import re
+
+PLACEHOLDER = "[REDACTED]"
+
+# Regex de padrões comuns de segredo. Configuráveis via o parâmetro `patterns`,
+# para quando existir um arquivo de config (por ora o default cobre os casos do DESIGN).
+PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"AKIA[0-9A-Z]{16}"),                    # AWS access key
+    re.compile(r"sk-[A-Za-z0-9]{20,}"),                 # chave estilo OpenAI
+    re.compile(r"ghp_[A-Za-z0-9]{36}"),                 # GitHub token
+    re.compile(r"xox[baprs]-[A-Za-z0-9-]+"),            # Slack token
+    re.compile(                                         # bloco de chave privada
+        r"-----BEGIN[^-]*PRIVATE KEY-----.*?-----END[^-]*PRIVATE KEY-----",
+        re.DOTALL,                                      # o corpo tem quebras de linha
+    ),
+    re.compile(                                         # connection string com senha
+        r"\b(?:postgres(?:ql)?|mysql|mongodb|redis)://[^:\s]+:[^@\s]+@[^\s]+"
+    ),
+)
+
+
+# Substitui todo segredo detectado por um marcador fixo.
+def redact(text: str, patterns: tuple[re.Pattern[str], ...] = PATTERNS) -> str:
+    for pattern in patterns:
+        text = pattern.sub(PLACEHOLDER, text)
+    return text

reponexia/render/__init__.py

@@ -0,0 +1,4 @@
+from .markdown import render_markdown
+from .mermaid import render_mermaid
+
+__all__ = ["render_markdown", "render_mermaid"]

reponexia/render/markdown.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+from collections import defaultdict
+from pathlib import PurePosixPath
+
+TOP_FILES=10
+
+def render_markdown(graph:dict, narrative: dict | None = None) -> str:
+    sections=[
+        _header(graph),
+        _entry_points(graph),
+        _top_files(graph),
+        _modules(graph),
+        _dependencies(graph),
+        _warnings(graph),
+    ]
+    # O bloco do LLM é opcional: no --dry-run não existe.
+    if narrative:
+        sections.append(_narrative(narrative))
+    return "\n\n".join(section for section in sections if section) + "\n"
+
+def _header(graph: dict) -> str:
+    name = PurePosixPath(graph["root"]).name or graph["root"]
+    languages = ", ".join(graph.get("languages", [])) or "nenhuma"
+
+    return "\n".join([
+        f"# Onboarding: {name}",
+        "",
+        f"- schema: {graph['schema_version']}",
+        f"- repo_hash: {graph['repo_hash'][:12]}" if graph.get("repo_hash") else "",
+        f"- linguagens: {languages}",
+        f"- arquivos: {len(graph.get('files', []))}",
+        f"- símbolos: {len(graph.get('symbols', []))}",
+        f"- dependências internas: {len(graph.get('edges', []))}",
+        f"- entry points: {len(graph.get('entry_points', []))}",
+    ])
+
+def _entry_points(graph: dict) -> str:
+    entries = graph.get("entry_points", [])
+    if not entries:
+        return ""
+
+    lines = ["## Entry points", "", "| path | kind | evidência |", "|---|---|---|"]
+    for entry in sorted(entries, key=lambda e: (e["path"], e["kind"])):
+        lines.append(f"| `{entry['path']}` | {entry['kind']} | `{entry['evidence']}` |")
+    return "\n".join(lines)
+
+
+# Mais centrais primeiro, desempate por path.
+def _top_files(graph: dict) -> str:
+    metrics = graph.get("metrics", [])
+    if not metrics:
+        return ""
+
+    top = sorted(metrics, key=lambda m: (-m["page_rank"], m["path"]))[:TOP_FILES]
+
+    lines = [
+        "## Arquivos centrais",
+        "",
+        "| path | fan_in | fan_out | page_rank |",
+        "|---|---|---|---|",
+    ]
+    for metric in top:
+        lines.append(
+            f"| `{metric['path']}` | {metric['fan_in']} | {metric['fan_out']} | "
+            f"{metric['page_rank']:.6f} |"
+        )
+    return "\n".join(lines)
+
+
+def _modules(graph: dict) -> str:
+    files = graph.get("files", [])
+    if not files:
+        return ""
+
+    symbols_by_file: dict[str, int] = defaultdict(int)
+    for symbol in graph.get("symbols", []):
+        symbols_by_file[symbol["file"]] += 1
+
+    groups: dict[str, list[dict]] = defaultdict(list)
+    for file in files:
+        parent = str(PurePosixPath(file["path"]).parent)
+        groups["(raiz)" if parent == "." else parent].append(file)
+
+    lines = ["## Módulos"]
+    for module in sorted(groups):
+        members = sorted(groups[module], key=lambda f: f["path"])
+        total_symbols = sum(symbols_by_file[file["path"]] for file in members)
+        lines.append("")
+        lines.append(
+            f"### `{module}` ({_count(len(members), 'arquivo', 'arquivos')}, "
+            f"{_count(total_symbols, 'símbolo', 'símbolos')})"
+        )
+        for file in members:
+            lines.append(f"- `{file['path']}` — {file['loc']} linhas")
+    return "\n".join(lines)
+
+
+# Concordância simples para os contadores do cabeçalho de módulo.
+def _count(n: int, singular: str, plural: str) -> str:
+    return f"{n} {singular if n == 1 else plural}"
+
+
+# Arestas agrupadas por origem.
+def _dependencies(graph: dict) -> str:
+    edges = graph.get("edges", [])
+    if not edges:
+        return ""
+
+    by_source: dict[str, list[dict]] = defaultdict(list)
+    for edge in edges:
+        by_source[edge["from"]].append(edge)
+
+    lines = ["## Dependências internas"]
+    for source in sorted(by_source):
+        lines.append("")
+        lines.append(f"### `{source}`")
+        for edge in sorted(by_source[source], key=lambda e: (e["to"], e["line"])):
+            lines.append(f"- linha {edge['line']} → `{edge['to']}`")
+    return "\n".join(lines)
+
+def _warnings(graph: dict) -> str:
+    warnings = graph.get("warnings", [])
+    if not warnings:
+        return ""
+
+    lines = ["## Avisos"]
+    for warning in warnings:
+        path = warning.get("path")
+        where = f"`{path}`: " if path else ""
+        lines.append(f"- {where}{warning['message']}")
+    return "\n".join(lines)
+
+
+# Seções narrativas produzidas pelo LLM (repo + módulos).
+def _narrative(narrative: dict) -> str:
+    lines = ["## Visão geral (LLM)", "", (narrative.get("repo") or "").strip()]
+
+    modules = narrative.get("modules") or {}
+    if modules:
+        lines += ["", "## Módulos (resumo LLM)"]
+        for name in sorted(modules):
+            lines += ["", f"### `{name}`", "", (modules[name] or "").strip()]
+
+    return "\n".join(lines)

reponexia/render/mermaid.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+# Evita espaguete: só os N arquivos mais centrais (PageRank) + entry points.
+DEFAULT_TOP_N = 50
+
+
+# Renderiza as dependências internas como um grafo Mermaid.
+def render_mermaid(graph: dict, top_n: int = DEFAULT_TOP_N) -> str:
+    edges = graph.get("edges", [])
+    entry_points = {entry["path"] for entry in graph.get("entry_points", [])}
+
+    # Nós = arquivos ligados por arestas + entry points.
+    paths = {edge["from"] for edge in edges} | {edge["to"] for edge in edges}
+    paths |= entry_points
+    if not paths:
+        return "graph LR\n    %% nenhuma dependencia interna detectada\n"
+
+    # Filtro top-N por PageRank; entry points sempre ficam.
+    metrics = graph.get("metrics", [])
+    if metrics and top_n > 0:
+        ranked = sorted(metrics, key=lambda m: (-m["page_rank"], m["path"]))
+        keep = {m["path"] for m in ranked[:top_n]} | entry_points
+        paths &= keep
+        edges = [e for e in edges if e["from"] in paths and e["to"] in paths]
+        if not paths:
+            return "graph LR\n    %% nenhuma dependencia interna detectada\n"
+
+    # IDs determinísticos: ordem alfabética, sem depender do path no nó.
+    node_id = {path: f"n{index}" for index, path in enumerate(sorted(paths))}
+
+    lines = ["graph LR"]
+    for path in sorted(paths):
+        # Entry points ganham formato de estádio para se destacarem.
+        if path in entry_points:
+            lines.append(f'    {node_id[path]}(["{path}"])')
+        else:
+            lines.append(f'    {node_id[path]}["{path}"]')
+
+    # Uma seta por par origem/destino, em ordem estável.
+    pairs = {(edge["from"], edge["to"]) for edge in edges}
+    for source, target in sorted(pairs):
+        lines.append(f"    {node_id[source]} --> {node_id[target]}")
+
+    return "\n".join(lines) + "\n"

reponexia/summarize/__init__.py

@@ -0,0 +1,3 @@
+from .base import ModuleContext, RepoContext, Summarizer, SymbolRef
+
+__all__ = ["ModuleContext", "RepoContext", "Summarizer", "SymbolRef"]

reponexia/summarize/base.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass(frozen=True)
+class SymbolRef:
+    name: str
+    kind: str
+    line: int
+    file: str
+
+
+@dataclass(frozen=True)
+class ModuleContext:
+    name: str
+    files: tuple[str, ...]
+    symbols: tuple[SymbolRef, ...]
+    imports_out: tuple[str, ...]
+    imports_in: tuple[str, ...]
+    # Snippets já redigidos/esqueletizados; vazio no modo estrutural.
+    snippets: tuple[str, ...] = ()
+
+
+# Resumo do repositório é montado a partir dos resumos de módulo (hierárquico),
+# por isso carrega os textos e não o código bruto.
+@dataclass(frozen=True)
+class RepoContext:
+    name: str
+    languages: tuple[str, ...]
+    file_count: int
+    module_summaries: tuple[str, ...]
+
+
+class Summarizer(Protocol):
+    def summarize_module(self, module: ModuleContext) -> str: ...
+
+    def summarize_repo(self, ctx: RepoContext) -> str: ...

reponexia/summarize/context.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from collections import defaultdict
+
+from ..modules import group_files_by_module
+from .base import ModuleContext, SymbolRef
+
+
+# Monta o contexto resumido por módulo a partir do grafo.
+# Por quê: o LLM recebe resumo estrutural (símbolos/imports), nunca o código inteiro.
+def build_module_contexts(graph: dict) -> list[ModuleContext]:
+    files_by_module = group_files_by_module(graph.get("files", []))
+
+    # Mapa arquivo -> módulo, para atribuir símbolos e arestas ao módulo certo.
+    module_of_file = {
+        file["path"]: name
+        for name, members in files_by_module.items()
+        for file in members
+    }
+
+    # Um balde por módulo. Sets evitam import duplicado (A importa B 2x).
+    symbols_by_module: dict[str, list[SymbolRef]] = defaultdict(list)
+    out_by_module: dict[str, set[str]] = defaultdict(set)
+    in_by_module: dict[str, set[str]] = defaultdict(set)
+
+    for symbol in graph.get("symbols", []):
+        module = module_of_file.get(symbol["file"])
+        if module is None:
+            continue
+        symbols_by_module[module].append(
+            SymbolRef(
+                name=symbol["name"],
+                kind=symbol["kind"],
+                line=symbol["line"],
+                file=symbol["file"],
+            )
+        )
+
+    for edge in graph.get("edges", []):
+        source = module_of_file.get(edge["from"])
+        target = module_of_file.get(edge["to"])
+        # Import dentro do mesmo módulo não é dependência entre módulos.
+        if source is None or target is None or source == target:
+            continue
+        out_by_module[source].add(target)
+        in_by_module[target].add(source)
+
+    return [
+        ModuleContext(
+            name=name,
+            files=tuple(file["path"] for file in members),
+            symbols=tuple(symbols_by_module[name]),
+            imports_out=tuple(sorted(out_by_module[name])),
+            imports_in=tuple(sorted(in_by_module[name])),
+        )
+        for name, members in sorted(files_by_module.items())
+    ]

reponexia/summarize/litellm_impl.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+
+from .base import ModuleContext, RepoContext
+
+
+class SummarizerError(RuntimeError):
+    """Falha ao obter resumo do LLM (após os retries)."""
+
+
+class BudgetExceeded(SummarizerError):
+    """O orçamento de tokens configurado seria estourado."""
+
+
+def _estimate_tokens(text: str) -> int:
+    # ponytail: estimativa chars/4; trocar por tokenizer real se o custo precisar ser exato
+    return max(1, len(text) // 4)
+
+
+# Implementação única sobre o litellm, que já abstrai OpenAI/Anthropic/Ollama.
+# O Protocol Summarizer existe só para permitir mock/offline nos testes.
+class LiteLLMSummarizer:
+    def __init__(
+        self,
+        model: str,
+        *,
+        max_tokens: int = 1_000_000,
+        retries: int = 3,
+        call: Callable[[str], str] | None = None,
+        sleep: Callable[[float], None] = time.sleep,
+    ) -> None:
+        self.model = model
+        self.max_tokens = max_tokens
+        self.retries = retries
+        self.spent = 0
+        self._call = call or self._litellm_call
+        self._sleep = sleep
+
+    # Chamada real; o import fica lazy para testar sem o litellm instalado.
+    def _litellm_call(self, prompt: str) -> str:
+        import litellm
+
+        response = litellm.completion(
+            model=self.model,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=1024,
+        )
+        return response.choices[0].message.content or ""
+
+    # Executa com retry/backoff e contabiliza o orçamento antes de devolver.
+    def _complete(self, prompt: str) -> str:
+        for attempt in range(self.retries + 1):
+            try:
+                text = self._call(prompt)
+            except Exception as err:  # noqa: BLE001 - qualquer falha de provider
+                if attempt == self.retries:
+                    raise SummarizerError(
+                        f"LLM falhou apos {self.retries + 1} tentativas: {err}"
+                    ) from err
+                self._sleep(2**attempt)
+                continue
+
+            self.spent += _estimate_tokens(prompt) + _estimate_tokens(text)
+            if self.spent > self.max_tokens:
+                raise BudgetExceeded(
+                    f"orcamento de {self.max_tokens} tokens estourado "
+                    f"(~{self.spent} usados)"
+                )
+            return text
+
+        raise AssertionError("inalcancavel")
+
+    def _module_prompt(self, module: ModuleContext) -> str:
+        parts = [f"Modulo: {module.name}"]
+        parts.append("Arquivos:\n" + "\n".join(f"- {path}" for path in module.files))
+        if module.symbols:
+            parts.append(
+                "Simbolos:\n"
+                + "\n".join(
+                    f"- {symbol.name} ({symbol.kind}) em {symbol.file}:{symbol.line}"
+                    for symbol in module.symbols
+                )
+            )
+        if module.imports_out:
+            parts.append("Depende de: " + ", ".join(module.imports_out))
+        if module.imports_in:
+            parts.append("E usado por: " + ", ".join(module.imports_in))
+        if module.snippets:
+            parts.append("Snippets (redigidos):\n" + "\n\n".join(module.snippets))
+        parts.append(
+            "Explique o proposito deste modulo em 3 a 6 frases. "
+            "Cite arquivo:linha ao afirmar algo sobre o codigo."
+        )
+        return "\n\n".join(parts)
+
+    def summarize_module(self, module: ModuleContext) -> str:
+        return self._complete(self._module_prompt(module))
+
+    def _repo_prompt(self, ctx: RepoContext) -> str:
+        parts = [f"Repositorio: {ctx.name}"]
+        parts.append(f"Arquivos: {ctx.file_count}. Linguagens: {', '.join(ctx.languages)}.")
+        parts.append("Resumos por modulo:\n\n" + "\n\n".join(ctx.module_summaries))
+        parts.append(
+            "Com base apenas nos resumos acima, escreva uma visao geral da arquitetura "
+            "em 2 a 4 paragrafos. Nao invente fatos nem arquivos."
+        )
+        return "\n\n".join(parts)
+
+    def summarize_repo(self, ctx: RepoContext) -> str:
+        return self._complete(self._repo_prompt(ctx))

reponexia/summarize/skeleton.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+# Acima disso o arquivo não vai inteiro para o LLM: vira esqueleto.
+MAX_LINES_FOR_LLM = 1500
+
+
+# Reduz um arquivo grande às suas "costuras": imports + linhas de declaração de
+# símbolos (que o grafo já conhece), omitindo corpos.
+# Por quê: mandar 5k linhas estoura a context window e encarece a chamada.
+def skeletonize(text: str, symbols: list[dict]) -> str:
+    lines = text.splitlines()
+    if len(lines) <= MAX_LINES_FOR_LLM:
+        return text
+
+    kept: dict[int, str] = {}
+    for number, line in enumerate(lines, start=1):
+        stripped = line.lstrip()
+        # Imports dão o "de onde vem" sem custo de corpo.
+        if stripped.startswith(("import ", "from ")):
+            kept[number] = line
+
+    # Assinaturas vêm do grafo (line já é 1-based).
+    for symbol in symbols:
+        number = symbol.get("line", 0)
+        if 1 <= number <= len(lines):
+            kept[number] = lines[number - 1]
+
+    return "\n".join(kept[number] for number in sorted(kept))

reponexia-0.1.0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: reponexia
+Version: 0.1.0
+Summary: CLI que explica um repositório desconhecido
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rhyan05/reponexia
+Project-URL: Repository, https://github.com/rhyan05/reponexia
+Project-URL: Issues, https://github.com/rhyan05/reponexia/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema>=4.0
+Requires-Dist: reponexia-core==0.1.*
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Provides-Extra: llm
+Requires-Dist: litellm; extra == "llm"
+Dynamic: license-file
+
+# RepoNexia
+
+CLI que explica um repositório desconhecido: mapeia arquitetura, entry points e
+dependências críticas, e gera um onboarding doc.
+
+Motor em Rust (`reponexia-core`) faz o scan/parse e monta o grafo; o orquestrador
+em Python chama o LLM e renderiza a documentação. A fronteira é um JSON
+versionado (`src/reponexia/graph.schema.json`).
+
+## Build e instalação
+
+**Via PyPI** (após o release):
+```bash
+pip install reponexia
+pip install "reponexia[llm]"      # LLM real (litellm)
+```
+
+**A partir do código-fonte** (clone):
+```bash
+python -m venv .venv
+# .venv\Scripts\Activate.ps1  (Windows) | source .venv/bin/activate (Unix)
+
+pip install -e .                  # usa o wheel publicado do core (sem Rust)
+# ou, para compilar/testar o core local:
+pip install ./core
+pip install -e ".[llm]"
+```
+
+O Python descobre o binário nesta ordem: `REPONEXIA_CORE` → `Scripts/bin` do
+ambiente → `PATH` → `core/target/{release,debug}`.
+
+## Uso
+
+```bash
+reponexia guia                           # guia de uso no terminal
+reponexia map <path>                     # só o core; imprime o graph.json
+reponexia graph <path> --format mermaid  # exporta o grafo (json|mermaid)
+reponexia explain <path> --dry-run       # esqueleto estrutural, sem LLM
+reponexia explain <path> --model openai/gpt-4o-mini
+reponexia ask <path> "onde fica a autenticação?"
+```
+
+O mesmo guia está em [`docs/USAGE.md`](docs/USAGE.md) (gerado por
+`reponexia guia --markdown`).
+
+No modo real o modelo vem de `--model` ou `REPONEXIA_MODEL`. `--max-tokens`
+limita o orçamento; sem mudança no repo, o cache evita novas chamadas LLM.
+
+Saída padrão em `<path>/.reponexia/`: `graph.json`, `ONBOARDING.md` e
+`architecture.mmd` (`--out` sobrescreve o diretório).
+
+Exemplo de saída: [`examples/ONBOARDING.md`](examples/ONBOARDING.md).
+
+## Segurança
+
+Antes de qualquer chamada LLM, snippets passam por `redact.py` (AWS, OpenAI,
+GitHub, Slack, chave privada e connection strings). O scan ignora `.gitignore`,
+dotfiles e `.reponexia`.
+
+## Testes
+
+```bash
+cargo test --manifest-path core/Cargo.toml
+pytest
+```

reponexia-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+reponexia/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+reponexia/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+reponexia/ask.py,sha256=MmNwvOHu8IRHiCAl2pxWDFhvuUHhl-JQOVzk-E11i7M,1661
+reponexia/cache.py,sha256=3aPatv0hTMQd-Gl7R8vYgDdjR2-72bXJ4eSdicnWpaQ,1200
+reponexia/cli.py,sha256=NR277b0LW17L7N4H-YcdGEghrPgif81VDFYQAY-VpvA,6224
+reponexia/contract.py,sha256=7uZNdHGJYmQA-Kz8fNtznbvO16HV0omdOAHoXZ9H4Ag,1224
+reponexia/core_runner.py,sha256=UJ0QgrUoqQJtnM2_ZRjYSC3Ltmat8wqjHE8i23GuBJc,1788
+reponexia/graph.schema.json,sha256=f0seWkYZaML5uBrw3KVsz5fzolDe586hJjWVAYsZ_U8,3686
+reponexia/guide.py,sha256=UupeNAVSzUn7W1Rs1eSGrXSiqjDK1EMM8Tj0CsKIxOk,3545
+reponexia/modules.py,sha256=2pBDeh4mZLk7AzVDJdMEx6YLl8t99pMq3-acwvCNujo,804
+reponexia/pipeline.py,sha256=D_wCblplFWQCgwZMM-zQIPLlue3LuEJYpch1POBZo5g,3408
+reponexia/redact.py,sha256=sPeN5INPgKjXSVcYrHcjXsfSmzLJERzkaTN6zpSmSVM,1235
+reponexia/render/__init__.py,sha256=LYnbbSoB_oZMK53csmve1YuadzHLYg-vXe253T2VCTA,123
+reponexia/render/markdown.py,sha256=hetup0KN8W2IG76jzr8OIb-R9UhLrHpczx6KIoclyVQ,4906
+reponexia/render/mermaid.py,sha256=C54G1uNEMOF5U4S9iuUo0AJEcn_eeV00IUXDJ_tToy4,1818
+reponexia/summarize/__init__.py,sha256=IDsQ85V8Z0VSAUy8YEfyEjmguExsyY29HxMc-FyTD5E,139
+reponexia/summarize/base.py,sha256=eP4H2OjsVRBrG306vAJH3pnf5P4CKBY60pvXDJlYKtE,932
+reponexia/summarize/context.py,sha256=MiUHqUqFB3cCSf-T7jBcDus5YXp9kQvcGlBShGfOOJU,2057
+reponexia/summarize/litellm_impl.py,sha256=X8o3hZI1QTKaqw49Uyy7AcCamfgHewWzecPo5BLdT_8,4153
+reponexia/summarize/skeleton.py,sha256=nynCSQah8M3xcqzeidWGzpM1VHuLOX5uWikOKfMU9_o,1021
+reponexia-0.1.0.dist-info/licenses/LICENSE,sha256=FZArt7fexl-UElv3m5k5vXGZU4AdMbvLJNL82DLXTIQ,1100
+reponexia-0.1.0.dist-info/METADATA,sha256=44pHszslHckiwWCWhQu7KBFtrSAvgiWPjXTsMhNqulE,2971
+reponexia-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+reponexia-0.1.0.dist-info/entry_points.txt,sha256=gYlw4Dspp5OaIuFWnrQc9gxclHE3Dl0A9_ea-SLpJrI,49
+reponexia-0.1.0.dist-info/top_level.txt,sha256=mMigYfHgWU2gwKnE1APLF3YVVy12gqXO4hoPL5LMAHw,10
+reponexia-0.1.0.dist-info/RECORD,,