mdbind 0.1.0__py3-none-any.whl

mdbind/composer.py

@@ -0,0 +1,135 @@
+"""
+Materializacao semantica: motor de composicao documental (spec section 8.3).
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import FrozenSet, List, Optional, Set
+
+from mdbind.cycle import enter_node, would_cycle
+from mdbind.directives import _resolve_uri
+from mdbind.models import SectionGraph
+
+_PLACEHOLDER_TPL = "<!-- mdgraph:unresolved uri=\"{uri}\" -->"
+_INCLUDE_RE = re.compile(r"^\[@include(?::[^\]]*)?\]\(([^)]+)\)\s*$")
+
+
+def compose(
+    root_uri: str,
+    graph: SectionGraph,
+    *,
+    strict: bool = False,
+    deduplicate: bool = False,
+    warnings: Optional[List[str]] = None,
+    depth: Optional[int] = None,
+) -> str:
+    if warnings is None:
+        warnings = []
+
+    root_section = graph.index.get(root_uri)
+    if root_section is None:
+        raise ValueError(f"URI raiz nao encontrada: '{root_uri}'")
+
+    # O no raiz e sempre renormalizado para heading level 1
+    initial_offset = 1 - root_section.raw.heading_level
+
+    seen: Set[str] = set()
+    lines = _compose_node(
+        root_uri, graph,
+        heading_offset=initial_offset,
+        execution_path=frozenset(),
+        seen=seen,
+        strict=strict,
+        deduplicate=deduplicate,
+        warnings=warnings,
+        depth=depth,
+    )
+    return "\n".join(lines)
+
+
+def _compose_node(
+    uri: str,
+    graph: SectionGraph,
+    heading_offset: int,
+    execution_path: FrozenSet[str],
+    seen: Set[str],
+    strict: bool,
+    deduplicate: bool,
+    warnings: List[str],
+    depth: Optional[int] = None,
+) -> List[str]:
+    section = graph.index.get(uri)
+    if section is None:
+        msg = f"URI nao encontrada: '{uri}'"
+        if strict:
+            raise ValueError(msg)
+        warnings.append(msg)
+        return [_PLACEHOLDER_TPL.format(uri=uri)]
+
+    if deduplicate and uri in seen:
+        return [f"@ref({uri})"]
+
+    seen.add(uri)
+    execution_path = enter_node(uri, execution_path)
+
+    raw_lines = _raw_lines(section)
+    result: List[str] = []
+
+    for line in raw_lines:
+        adjusted = _adjust_heading(line, heading_offset)
+        m = _INCLUDE_RE.match(adjusted.strip())
+        if m:
+            # Resolver URI relativa ao arquivo de origem da secao
+            raw_target = m.group(1).strip()
+            resolved_target = _resolve_uri(raw_target, section.file_path)
+
+            if would_cycle(resolved_target, execution_path):
+                warnings.append(
+                    f"Ciclo detectado: '{resolved_target}' ja esta no caminho "
+                    f"de execucao. Aresta rompida."
+                )
+                continue  # rompe silenciosamente
+
+            # Verificar limite de profundidade
+            if depth is not None and depth <= 0:
+                continue  # nao expande, descarta a linha de @include
+
+            child_offset = heading_offset  # fallback se filho nao encontrado
+            child_section_lookup = graph.index.get(resolved_target)
+            if child_section_lookup is not None:
+                parent_new_level = section.raw.heading_level + heading_offset
+                child_offset = parent_new_level + 1 - child_section_lookup.raw.heading_level
+
+            child_lines = _compose_node(
+                resolved_target, graph,
+                heading_offset=child_offset,
+                execution_path=execution_path,
+                seen=seen,
+                strict=strict,
+                deduplicate=deduplicate,
+                warnings=warnings,
+                depth=None if depth is None else depth - 1,
+            )
+            result.extend(child_lines)
+        else:
+            result.append(adjusted)
+
+    return result
+
+
+def _raw_lines(section) -> List[str]:
+    path = Path(section.file_path)
+    all_lines = path.read_text(encoding="utf-8").splitlines()
+    start = section.raw.source_start_line - 1
+    end = section.raw.source_end_line
+    return all_lines[start:end]
+
+
+def _adjust_heading(line: str, offset: int) -> str:
+    if offset == 0 or not line.startswith("#"):
+        return line
+    original_level = len(line) - len(line.lstrip("#"))
+    new_level = max(1, original_level + offset)
+    return "#" * new_level + line[original_level:]
+

mdbind/cycle.py

@@ -0,0 +1,24 @@
+"""
+Deteccao e resolucao de ciclos durante a materializacao (spec section 5).
+
+O digrafo pode conter ciclos nativamente. Durante o compose, o motor rastreia
+o caminho de execucao atual P (stack de URIs). Se uma aresta de inclusao (x, y)
+for avaliada e y ∈ P, o ciclo e detectado e a aresta e rompida silenciosamente.
+
+O SectionGraph original NAO e modificado; apenas a materializacao e afetada.
+"""
+from __future__ import annotations
+
+from typing import FrozenSet
+
+
+def would_cycle(uri: str, execution_path: FrozenSet[str]) -> bool:
+    """
+    Retorna True se incluir `uri` no caminho atual criaria um ciclo.
+    """
+    return uri in execution_path
+
+
+def enter_node(uri: str, execution_path: FrozenSet[str]) -> FrozenSet[str]:
+    """Retorna um novo caminho com `uri` adicionado."""
+    return execution_path | {uri}

mdbind/directives.py

@@ -0,0 +1,116 @@
+"""
+Etapa 4 do pipeline: tokenizacao de diretivas.
+
+Varre os tokens de conteudo de uma ParsedSection ja delimitada e converte
+marcacoes semanticas (@ref, @include, @query) em objetos Directive tipados,
+resolvendo URIs relativas ao arquivo de origem.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import List
+
+from mdbind.models import Directive, ParsedSection
+
+# Regex que captura [@tipo: label](uri) ou [@tipo](uri)
+# Grupo 1: tipo (ref|include|query)
+# Grupo 2: label opcional (pode ser vazio ou ausente)
+# Grupo 3: uri de destino
+_DIRECTIVE_RE = re.compile(r"\[@(ref|include|query)(?::\s*([^\]]*))?\]\(([^)]+)\)")
+
+
+def _resolve_uri(target: str, source_file_path: str) -> str:
+    """
+    Resolve um target URI relativo ao diretorio do arquivo de origem.
+
+    Se o target nao tiver componente de caminho (ex: apenas "#id"), retorna
+    como esta. Se for absoluto ou ja normalizado, retorna normalizado.
+    Fragmentos (#id) sao preservados.
+    """
+    if not target:
+        return target
+
+    # Separar caminho e fragmento
+    if "#" in target:
+        path_part, fragment = target.split("#", 1)
+        fragment = "#" + fragment
+    else:
+        path_part, fragment = target, ""
+
+    if not path_part:
+        # Referencia ao proprio arquivo: "#id"
+        return source_file_path + fragment
+
+    p = Path(path_part)
+    if p.is_absolute():
+        return str(p) + fragment
+
+    # Resolver relativo ao diretorio do arquivo de origem
+    source_dir = Path(source_file_path).parent
+    resolved = (source_dir / p).resolve()
+    return str(resolved) + fragment
+
+
+# Regex para o texto do link: @tipo ou @tipo: label
+_LINK_TEXT_RE = re.compile(r"^@(ref|include|query)(?::\s*(.*))?$")
+
+
+def extract_directives(tokens: list, source_file_path: str) -> List[Directive]:
+    """
+    Varre tokens buscando diretivas na sintaxe de link Markdown:
+      [@tipo: label](uri)  ou  [@tipo](uri)
+
+    Em markdown-it-py, esse padrao e tokenizado como:
+      link_open (attrs: [["href", uri]])
+      text      (content: "@tipo: label")
+      link_close
+
+    A extracao examina cada link_open dentro de tokens `inline` e verifica
+    se o texto filho corresponde ao padrao de diretiva.
+    """
+    directives: List[Directive] = []
+
+    for tok in tokens:
+        if tok.type != "inline" or not tok.children:
+            continue
+        children = tok.children
+        i = 0
+        while i < len(children):
+            child = children[i]
+            if child.type == "link_open":
+                attrs = child.attrs or {}
+                href = attrs.get("href", "") if isinstance(attrs, dict) else ""
+                # Proximo filho deve ser o texto do link
+                if i + 1 < len(children) and children[i + 1].type == "text":
+                    link_text = children[i + 1].content.strip()
+                    m = _LINK_TEXT_RE.match(link_text)
+                    if m and href:
+                        dtype = m.group(1)
+                        raw_label = m.group(2)
+                        label = raw_label.strip() if raw_label else None
+                        resolved = _resolve_uri(href.strip(), source_file_path)
+                        directives.append(
+                            Directive(type=dtype, target_uri=resolved, label=label)  # type: ignore[arg-type]
+                        )
+            i += 1
+
+    return directives
+
+
+def bind_directives(section: ParsedSection, tokens: list) -> ParsedSection:
+    """
+    Retorna uma nova ParsedSection com o campo directives populado.
+    Varre apenas os tokens internos da secao (excluindo sub-secoes).
+    """
+    # Tokens internos: apos heading_open, inline, heading_close; para antes do proximo heading
+    all_inner = tokens[section.raw.token_start + 3: section.raw.token_end + 1]
+    inner: list = []
+    for tok in all_inner:
+        if tok.type == "heading_open":
+            break
+        inner.append(tok)
+
+    directives = extract_directives(inner, section.file_path)
+
+    return section.model_copy(update={"directives": directives})

mdbind/index.py

@@ -0,0 +1,57 @@
+"""
+Etapa 5 do pipeline: indexacao do repositorio e construcao do SectionGraph.
+
+index_repository(root_path) -> SectionGraph
+  - Descobre recursivamente todos os .md no diretorio raiz
+  - Executa o pipeline parser.parse_file em cada arquivo (com cache incremental)
+  - Registra secoes no SectionIndex
+  - Constroi arestas bidirecionais no SectionGraph
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from mdbind.cache import build_index_with_cache, save_cache, serialize_section
+from mdbind.models import SectionGraph, SectionIndex
+from mdbind.parser import ParseError
+
+
+def index_repository(
+    root_path: str | Path,
+    *,
+    no_cache: bool = False,
+    persist_cache: bool = False,
+) -> SectionGraph:
+    """
+    Varre recursivamente root_path buscando arquivos .md,
+    parseia cada um e monta o SectionGraph completo em memoria.
+
+    Parametros:
+      no_cache: ignorar cache existente e reprocessar tudo
+      persist_cache: gravar cache em .mdgraph/index.json apos indexar
+
+    Raises ParseError se houver URIs duplicadas.
+    """
+    root = Path(root_path).resolve()
+    md_files = sorted(root.rglob("*.md"))
+
+    sections, file_hashes = build_index_with_cache(root, md_files, no_cache=no_cache)
+
+    index = SectionIndex()
+    graph = SectionGraph(index=index)
+
+    for section in sections:
+        try:
+            index.add(section)
+        except ValueError as exc:
+            raise ParseError(str(exc)) from exc
+
+        for directive in section.directives:
+            if directive.type in ("ref", "include"):
+                graph.add_edge(section.uri, directive.target_uri)
+
+    if persist_cache:
+        sections_data = [serialize_section(s) for s in index.sections.values()]
+        save_cache(root, file_hashes, sections_data)
+
+    return graph

mdbind/models.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Dict, List, Literal, Set
+
+from pydantic import BaseModel, Field, model_validator
+
+
+# ---------------------------------------------------------------------------
+# Fase 2: Delimitacao Fisica
+# ---------------------------------------------------------------------------
+
+class RawSection(BaseModel):
+    """Resolve apenas o escopo espacial da secao na AST e no arquivo fonte."""
+
+    heading_level: int
+    heading_text: str
+    token_start: int
+    token_end: int
+    source_start_line: int
+    source_end_line: int
+
+
+# ---------------------------------------------------------------------------
+# Fase 4: Semantica e Diretivas
+# ---------------------------------------------------------------------------
+
+class Directive(BaseModel):
+    """Diretivas deixam de ser texto e se tornam nos logicos."""
+
+    type: Literal["ref", "include", "query"]
+    target_uri: str
+    label: str | None = None
+
+
+class ParsedSection(BaseModel):
+    """Resolve o significado. Amarra o espaco fisico aos metadados e referencias."""
+
+    raw: RawSection
+    uri: str
+    file_path: str
+    # metadata deve conter obrigatoriamente a chave 'id'
+    metadata: Dict[str, Any]
+    directives: List[Directive] = Field(default_factory=list)
+
+    @model_validator(mode="after")
+    def _require_id_in_metadata(self) -> "ParsedSection":
+        if "id" not in self.metadata:
+            raise ValueError("secao sem payload obrigatorio: campo 'id' ausente em metadata")
+        return self
+
+
+# ---------------------------------------------------------------------------
+# Fase 5: Indexacao e Grafo
+# ---------------------------------------------------------------------------
+
+class SectionIndex(BaseModel):
+    """Repositorio de acesso em O(1) de secoes ja parseadas."""
+
+    sections: Dict[str, ParsedSection] = Field(default_factory=dict)
+
+    def add(self, section: ParsedSection) -> None:
+        if section.uri in self.sections:
+            raise ValueError(f"URI duplicada no indice: '{section.uri}'")
+        self.sections[section.uri] = section
+
+    def get(self, uri: str) -> ParsedSection | None:
+        return self.sections.get(uri)
+
+
+class SectionGraph(BaseModel):
+    """Gestao topologica de dependencias (Backlinks suportados)."""
+
+    index: SectionIndex = Field(default_factory=SectionIndex)
+    outgoing_edges: Dict[str, Set[str]] = Field(
+        default_factory=lambda: defaultdict(set)
+    )
+    incoming_edges: Dict[str, Set[str]] = Field(
+        default_factory=lambda: defaultdict(set)
+    )
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    def add_edge(self, source_uri: str, target_uri: str) -> None:
+        self.outgoing_edges[source_uri].add(target_uri)
+        self.incoming_edges[target_uri].add(source_uri)

mdbind/parser.py

@@ -0,0 +1,241 @@
+"""
+Parser Markdown: pipeline Markdown -> AST -> RawSection -> ParsedSection.
+
+Etapas cobertas (spec section 2):
+  1. Geracao de AST via markdown-it-py
+  2. Section Discovery -> RawSection
+  3. Metadata Binding -> ParsedSection
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+import yaml
+from markdown_it import MarkdownIt
+
+from mdbind.directives import bind_directives
+from mdbind.models import Directive, ParsedSection, RawSection
+
+
+# ---------------------------------------------------------------------------
+# Erros de parsing
+# ---------------------------------------------------------------------------
+
+class ParseError(Exception):
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Etapa 1: Geracao de AST
+# ---------------------------------------------------------------------------
+
+def _tokenize(text: str) -> list:
+    md = MarkdownIt()
+    return md.parse(text)
+
+
+# ---------------------------------------------------------------------------
+# Etapa 2: Section Discovery -> List[RawSection]
+# ---------------------------------------------------------------------------
+
+def _discover_sections(tokens: list) -> List[RawSection]:
+    """
+    Varre a lista plana de tokens e delimita secoes por heading_open.
+    Uma secao vai do seu heading_open ate o proximo heading_open de nivel <= ao seu,
+    ou ate o fim do documento.
+    """
+    # Coletar posicoes dos headings
+    heading_positions = []
+    for i, tok in enumerate(tokens):
+        if tok.type == "heading_open":
+            level = int(tok.tag[1])  # "h1" -> 1, "h2" -> 2, etc.
+            # source_start_line: markdown-it usa base-0, convertemos para base-1
+            source_line = (tok.map[0] + 1) if tok.map else 0
+            heading_positions.append((i, level, source_line))
+
+    raws: List[RawSection] = []
+    for idx, (token_start, level, source_start_line) in enumerate(heading_positions):
+        # Texto do heading: token seguinte e heading_content, proximo e heading_close
+        heading_text_tok = tokens[token_start + 1]
+        heading_text = heading_text_tok.children[0].content if heading_text_tok.children else ""
+
+        # Determinar token_end e source_end_line
+        token_end = len(tokens) - 1
+        source_end_line = _last_source_line(tokens)
+
+        for future_start, future_level, future_source in heading_positions[idx + 1:]:
+            if future_level <= level:
+                # A proxima secao de mesmo nivel ou superior encerra esta
+                token_end = future_start - 1
+                source_end_line = future_source - 1
+                break
+
+        raws.append(RawSection(
+            heading_level=level,
+            heading_text=heading_text,
+            token_start=token_start,
+            token_end=token_end,
+            source_start_line=source_start_line,
+            source_end_line=source_end_line,
+        ))
+
+    return raws
+
+
+def _last_source_line(tokens: list) -> int:
+    """Retorna a ultima linha fonte referenciada nos tokens (base-1)."""
+    last = 1
+    for tok in reversed(tokens):
+        if tok.map:
+            last = tok.map[1]  # map[1] ja e o indice exclusivo (base-0), vira base-1
+            break
+    return last
+
+
+# ---------------------------------------------------------------------------
+# Etapa 3: Metadata Binding -> ParsedSection
+# ---------------------------------------------------------------------------
+
+def _bind_metadata(
+    raw: RawSection,
+    tokens: list,
+    file_path: str,
+) -> ParsedSection:
+    """
+    Analisa os tokens internos da RawSection buscando o bloco 'section' (YAML).
+    Aplica as validacoes da spec section 3.
+    """
+    # +3 pula: heading_open, inline (texto), heading_close
+    # O scan termina no primeiro heading interno (qualquer nivel), pois o bloco
+    # section so pode estar no conteudo direto da secao, nao em sub-secoes.
+    all_inner = tokens[raw.token_start + 3: raw.token_end + 1]
+    inner_tokens: list = []
+    for tok in all_inner:
+        if tok.type == "heading_open":
+            break
+        inner_tokens.append(tok)
+
+    section_blocks: list[str] = []
+    first_text_seen = False
+    section_block_index = -1  # posicao do primeiro bloco section nos inner_tokens
+
+    i = 0
+    while i < len(inner_tokens):
+        tok = inner_tokens[i]
+
+        if tok.type == "fence" and tok.info.strip() == "yaml":
+            parsed_yaml = None
+            try:
+                parsed_yaml = yaml.safe_load(tok.content) or {}
+            except yaml.YAMLError:
+                parsed_yaml = {}
+            if not isinstance(parsed_yaml, dict) or "section" not in parsed_yaml:
+                # Bloco yaml sem campo 'section' e ignorado (yaml generico)
+                first_text_seen = True
+                i += 1
+                continue
+            if first_text_seen and section_block_index == -1:
+                raise ParseError(
+                    f"payload nao e o primeiro bloco na secao '{raw.heading_text}' "
+                    f"(linha {raw.source_start_line})"
+                )
+            section_blocks.append(tok.content)
+            if section_block_index == -1:
+                section_block_index = i
+        elif tok.type in ("paragraph_open", "fence", "bullet_list_open",
+                          "ordered_list_open", "blockquote_open", "html_block",
+                          "table_open", "hr"):
+            # Qualquer bloco textual que nao seja o bloco section
+            if tok.type != "fence":  # fence ja tratado acima
+                first_text_seen = True
+        elif tok.type == "inline" and tok.content.strip():
+            first_text_seen = True
+
+        i += 1
+
+    if len(section_blocks) > 1:
+        raise ParseError(
+            f"bloco section duplicado na secao '{raw.heading_text}' "
+            f"(linha {raw.source_start_line})"
+        )
+
+    if not section_blocks:
+        # Secao sem bloco section: metadata vazio, sem erro
+        # Nao podemos construir ParsedSection pois falta 'id' — retornamos None
+        # para que o chamador decida se ignora ou errou
+        return None  # type: ignore[return-value]
+
+    raw_yaml = section_blocks[0]
+    try:
+        metadata = yaml.safe_load(raw_yaml) or {}
+    except yaml.YAMLError as exc:
+        raise ParseError(
+            f"YAML invalido no bloco section da secao '{raw.heading_text}': {exc}"
+        ) from exc
+
+    if not isinstance(metadata, dict):
+        raise ParseError(
+            f"bloco section da secao '{raw.heading_text}' nao e um mapeamento YAML valido"
+        )
+
+    if not metadata.get("section"):
+        raise ParseError(
+            f"secao sem payload obrigatorio: campo 'section' ausente na secao "
+            f"'{raw.heading_text}' (linha {raw.source_start_line})"
+        )
+
+    section_id = str(metadata.pop("section"))
+    metadata["id"] = section_id
+    uri = f"{file_path}#{section_id}"
+
+    return ParsedSection(
+        raw=raw,
+        uri=uri,
+        file_path=file_path,
+        metadata=metadata,
+        directives=[],  # populado em B-003
+    )
+
+
+# ---------------------------------------------------------------------------
+# API publica
+# ---------------------------------------------------------------------------
+
+def parse_file(file_path: str | Path) -> List[ParsedSection]:
+    """
+    Executa o pipeline completo para um arquivo .md.
+    Retorna apenas as ParsedSections que possuem bloco section (com id).
+    Secoes sem bloco section sao silenciosamente ignoradas.
+    """
+    path = Path(file_path)
+    text = path.read_text(encoding="utf-8")
+    return parse_text(text, file_path=str(path))
+
+
+def parse_text(text: str, file_path: str = "<string>") -> List[ParsedSection]:
+    """
+    Executa o pipeline completo sobre texto Markdown bruto.
+    """
+    tokens = _tokenize(text)
+    raws = _discover_sections(tokens)
+
+    seen_ids: set[str] = set()
+    sections: List[ParsedSection] = []
+
+    for raw in raws:
+        parsed = _bind_metadata(raw, tokens, file_path)
+        if parsed is None:
+            continue
+
+        section_id = str(parsed.metadata["id"])
+        if section_id in seen_ids:
+            raise ParseError(
+                f"id duplicado '{section_id}' no arquivo '{file_path}'"
+            )
+        seen_ids.add(section_id)
+        # Etapa 4: tokenizar diretivas
+        parsed = bind_directives(parsed, tokens)
+        sections.append(parsed)
+
+    return sections

mdbind-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: mdbind
+Version: 0.1.0
+Summary: MdBind — Structured memory in plain Markdown
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.0
+Requires-Dist: markdown-it-py>=3.0
+Requires-Dist: typer>=0.12
+Requires-Dist: pyyaml>=6.0

mdbind-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+mdbind/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdbind/cache.py,sha256=KrdOyrR1pmkyQ6C-FjNlvGDvVGHs7RBaw1mMBF3EPok,5570
+mdbind/cli.py,sha256=SQoHZV1jHvyQ7U_Ejjfjj8iVkjE37cfu0h30GDBGW3k,40992
+mdbind/composer.py,sha256=mtLCeNdXblAVHf5cEY0-U7s_03c4h_1is52BDOLC5Kw,4175
+mdbind/cycle.py,sha256=nnqWZKrfI0TpFqhpXQYfm4g0FJgaWTXyaJIhuG3V_-s,821
+mdbind/directives.py,sha256=Vj_wRxoCsg2vt6hIwv_hc2R0yyHQtZmCPU6oSI-DQdg,4047
+mdbind/index.py,sha256=M25hkb5QHT0cGsX2ujgdN5qUi5JiKbrqYWvEV8Xadl0,1786
+mdbind/models.py,sha256=W79gzwYi5trhLMmdUhVx48J_FZn8hcVYrpI6gIpPPl0,2817
+mdbind/parser.py,sha256=MsNPgORBq7MpNxXY07Lbactorn6ij8trG9M-v_Kyh_Q,8422
+mdbind-0.1.0.dist-info/METADATA,sha256=SFy2YjelbOKXLTAKHDIORN-J9_586WXjEG82bC6uvko,248
+mdbind-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mdbind-0.1.0.dist-info/entry_points.txt,sha256=dAbUX6TuxiskOOMPGEtnMkyEeD3ab6NTpBQmwVxADYw,39
+mdbind-0.1.0.dist-info/top_level.txt,sha256=rmhkm853CHFBfq831bRqCJcDDCUETMCUYBb2ytOutjA,7
+mdbind-0.1.0.dist-info/RECORD,,

mdbind-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mdbind-0.1.0.dist-info/entry_points.txt

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