uncoded 0.5.0__py3-none-any.whl

uncoded/stubs.py

@@ -0,0 +1,389 @@
+"""Generate .pyi stub files for agent navigation."""
+
+import ast
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from uncoded.extract import _property_kind, iter_source_files
+from uncoded.sync import remove_file, sync_file
+
+# Width cap for inlining the right-hand side of an assignment. If the unparsed
+# RHS exceeds this, it is elided to "..." so stubs stay compact and stable.
+VALUE_WIDTH_CAP = 80
+
+
+@dataclass
+class StubParam:
+    """A function parameter with name and optional type annotation."""
+
+    name: str
+    annotation: str | None = None
+
+
+@dataclass
+class StubFunction:
+    """A function or method with its signature."""
+
+    name: str
+    params: list[StubParam] = field(default_factory=list)
+    return_annotation: str | None = None
+    docstring_excerpt: str | None = None
+    is_async: bool = False
+
+
+@dataclass
+class StubAssignment:
+    """A module-level or class-level assignment.
+
+    ``value_source`` is the rendered RHS if it fits within ``VALUE_WIDTH_CAP``,
+    or the literal string ``"..."`` if the RHS was elided. ``None`` means there
+    is no RHS at all (e.g. a bare annotation ``X: int``).
+    """
+
+    name: str
+    annotation: str | None = None
+    value_source: str | None = None
+    is_type_alias: bool = False
+
+
+@dataclass
+class StubClass:
+    """A class with its members."""
+
+    name: str
+    bases: list[str] = field(default_factory=list)
+    docstring_excerpt: str | None = None
+    attributes: list[StubAssignment] = field(default_factory=list)
+    methods: list[StubFunction] = field(default_factory=list)
+
+
+@dataclass
+class StubModule:
+    """All symbols extracted from a single Python module."""
+
+    rel_path: str
+    imports: list[str] = field(default_factory=list)
+    constants: list[StubAssignment] = field(default_factory=list)
+    classes: list[StubClass] = field(default_factory=list)
+    functions: list[StubFunction] = field(default_factory=list)
+
+
+def _first_sentence(
+    node: ast.AsyncFunctionDef | ast.FunctionDef | ast.ClassDef | ast.Module,
+) -> str | None:
+    """Return the first sentence of a node's docstring, or None."""
+    docstring = ast.get_docstring(node)
+    if not docstring:
+        return None
+    text = docstring.strip()
+    match = re.match(r"(.+?\.)\s", text + " ")
+    if match:
+        return match.group(1)
+    return text.split("\n")[0].strip()
+
+
+def _extract_params(args: ast.arguments) -> list[StubParam]:
+    """Extract parameters from a function argument node, without defaults."""
+    params: list[StubParam] = []
+
+    for arg in args.posonlyargs:
+        annotation = ast.unparse(arg.annotation) if arg.annotation else None
+        params.append(StubParam(name=arg.arg, annotation=annotation))
+    if args.posonlyargs:
+        params.append(StubParam(name="/"))
+
+    for arg in args.args:
+        annotation = ast.unparse(arg.annotation) if arg.annotation else None
+        params.append(StubParam(name=arg.arg, annotation=annotation))
+
+    if args.vararg:
+        annotation = (
+            ast.unparse(args.vararg.annotation) if args.vararg.annotation else None
+        )
+        params.append(StubParam(name=f"*{args.vararg.arg}", annotation=annotation))
+    elif args.kwonlyargs:
+        params.append(StubParam(name="*"))
+
+    for arg in args.kwonlyargs:
+        annotation = ast.unparse(arg.annotation) if arg.annotation else None
+        params.append(StubParam(name=arg.arg, annotation=annotation))
+
+    if args.kwarg:
+        annotation = (
+            ast.unparse(args.kwarg.annotation) if args.kwarg.annotation else None
+        )
+        params.append(StubParam(name=f"**{args.kwarg.arg}", annotation=annotation))
+
+    return params
+
+
+def _render_value(value: ast.expr) -> str:
+    """Render an expression as source, eliding to '...' if too long or multi-line."""
+    source = ast.unparse(value)
+    if len(source) > VALUE_WIDTH_CAP or "\n" in source:
+        return "..."
+    return source
+
+
+def _extract_assignment(
+    node: ast.Assign | ast.AnnAssign | ast.TypeAlias,
+) -> StubAssignment | None:
+    """Build a StubAssignment from an assignment-style AST node.
+
+    Returns None if the node's target is not a single simple name (e.g. tuple
+    unpacking or attribute assignment), which we can't represent cleanly.
+    """
+    if isinstance(node, ast.TypeAlias):
+        if not isinstance(node.name, ast.Name):
+            return None
+        return StubAssignment(
+            name=node.name.id,
+            value_source=_render_value(node.value),
+            is_type_alias=True,
+        )
+
+    if isinstance(node, ast.AnnAssign):
+        if not isinstance(node.target, ast.Name):
+            return None
+        annotation = ast.unparse(node.annotation)
+        value_source = _render_value(node.value) if node.value is not None else None
+        return StubAssignment(
+            name=node.target.id,
+            annotation=annotation,
+            value_source=value_source,
+        )
+
+    # ast.Assign
+    if len(node.targets) != 1 or not isinstance(node.targets[0], ast.Name):
+        return None
+    return StubAssignment(
+        name=node.targets[0].id,
+        value_source=_render_value(node.value),
+    )
+
+
+def _extract_function(
+    node: ast.FunctionDef | ast.AsyncFunctionDef,
+) -> StubFunction:
+    """Build a StubFunction from a function or method AST node."""
+    return StubFunction(
+        name=node.name,
+        params=_extract_params(node.args),
+        return_annotation=ast.unparse(node.returns) if node.returns else None,
+        docstring_excerpt=_first_sentence(node),
+        is_async=isinstance(node, ast.AsyncFunctionDef),
+    )
+
+
+def _property_attribute(
+    node: ast.FunctionDef | ast.AsyncFunctionDef,
+) -> StubAssignment:
+    """Build a StubAssignment representing a @property as a class attribute."""
+    return StubAssignment(
+        name=node.name,
+        annotation=ast.unparse(node.returns) if node.returns else None,
+        value_source=None,
+        is_type_alias=False,
+    )
+
+
+def _extract_class(node: ast.ClassDef) -> StubClass:
+    """Build a StubClass from a class AST node."""
+    bases = [ast.unparse(b) for b in node.bases]
+
+    attributes: list[StubAssignment] = []
+    methods: list[StubFunction] = []
+
+    for child in ast.iter_child_nodes(node):
+        if isinstance(child, (ast.AnnAssign, ast.Assign)):
+            assignment = _extract_assignment(child)
+            if assignment is not None:
+                attributes.append(assignment)
+        elif isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            kind = _property_kind(child)
+            if kind == "setter" or kind == "deleter":
+                continue
+            if kind == "property":
+                attributes.append(_property_attribute(child))
+            else:
+                methods.append(_extract_function(child))
+
+    return StubClass(
+        name=node.name,
+        bases=bases,
+        docstring_excerpt=_first_sentence(node),
+        attributes=attributes,
+        methods=methods,
+    )
+
+
+def extract_stub(source: str, rel_path: str) -> StubModule:
+    """Parse Python source and extract imports, constants, classes, and functions."""
+    tree = ast.parse(source)
+    imports: list[str] = []
+    constants: list[StubAssignment] = []
+    classes: list[StubClass] = []
+    functions: list[StubFunction] = []
+
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, (ast.Import, ast.ImportFrom)):
+            imports.append(ast.unparse(node))
+        elif isinstance(node, ast.ClassDef):
+            classes.append(_extract_class(node))
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            functions.append(_extract_function(node))
+        elif isinstance(node, (ast.Assign, ast.AnnAssign, ast.TypeAlias)):
+            assignment = _extract_assignment(node)
+            if assignment is not None:
+                constants.append(assignment)
+
+    return StubModule(
+        rel_path=rel_path,
+        imports=imports,
+        constants=constants,
+        classes=classes,
+        functions=functions,
+    )
+
+
+def _render_param(p: StubParam) -> str:
+    """Render a single parameter as a string for a function signature."""
+    if p.name in ("/", "*"):
+        return p.name
+    if p.annotation:
+        return f"{p.name}: {p.annotation}"
+    return p.name
+
+
+def _render_function(func: StubFunction, indent: str = "") -> list[str]:
+    """Render a function or method as stub lines, indented for methods."""
+    params_str = ", ".join(_render_param(p) for p in func.params)
+    ret = f" -> {func.return_annotation}" if func.return_annotation else ""
+    prefix = "async def" if func.is_async else "def"
+    lines = [f"{indent}{prefix} {func.name}({params_str}){ret}:"]
+    if func.docstring_excerpt:
+        lines.append(f'{indent}    """{func.docstring_excerpt}"""')
+    lines.append(f"{indent}    ...")
+    return lines
+
+
+def _format_assignment_body(a: StubAssignment) -> str:
+    """Render the 'name [: type] [= value]' portion of an assignment."""
+    if a.is_type_alias:
+        return f"type {a.name} = {a.value_source}"
+    head = f"{a.name}: {a.annotation}" if a.annotation else a.name
+    if a.value_source is None:
+        return head
+    return f"{head} = {a.value_source}"
+
+
+def _render_assignment(a: StubAssignment, indent: str = "") -> str:
+    """Render a module-level assignment as a stub line."""
+    body = _format_assignment_body(a)
+    return f"{indent}{body}"
+
+
+def render_stub(module: StubModule) -> str:
+    """Render a StubModule as a .pyi file string."""
+    lines: list[str] = [f"# {module.rel_path}", ""]
+
+    if module.imports:
+        lines.extend(module.imports)
+        lines.append("")
+
+    for const in module.constants:
+        lines.append(_render_assignment(const))
+    if module.constants:
+        lines.append("")
+
+    for func in module.functions:
+        lines.extend(_render_function(func))
+        lines.append("")
+
+    for cls in module.classes:
+        bases_str = f"({', '.join(cls.bases)})" if cls.bases else ""
+        lines.append(f"class {cls.name}{bases_str}:")
+        if cls.docstring_excerpt:
+            lines.append(f'    """{cls.docstring_excerpt}"""')
+        lines.append("")
+
+        for attr in cls.attributes:
+            lines.append(_render_assignment(attr, indent="    "))
+        if cls.attributes:
+            lines.append("")
+
+        for method in cls.methods:
+            lines.extend(_render_function(method, indent="    "))
+            lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _generate_stubs(source_root: Path) -> dict[Path, str]:
+    """Return a mapping from stub relative paths to rendered stub content."""
+    result: dict[Path, str] = {}
+    for source, rel_path in iter_source_files(source_root):
+        try:
+            module = extract_stub(source, rel_path)
+        except SyntaxError:
+            continue
+        if not module.classes and not module.functions and not module.constants:
+            continue
+        result[Path(rel_path).with_suffix(".pyi")] = render_stub(module)
+    return result
+
+
+DEFAULT_STUBS_OUTPUT = Path(".uncoded/stubs")
+
+
+def build_stubs(
+    source_root: Path,
+    output_dir: Path = DEFAULT_STUBS_OUTPUT,
+    *,
+    check: bool = False,
+) -> int:
+    """Sync stub files for all symbols under source_root, removing any orphans.
+
+    Writes only files whose content has changed. After reconciling the current
+    set of stubs, any pre-existing ``.pyi`` files in the corresponding subtree
+    of ``output_dir`` whose source has been removed or renamed are deleted,
+    and any directories left empty by the deletion are pruned. Only the
+    subtree corresponding to ``source_root`` is touched, so other source
+    roots' stubs are not affected.
+
+    When ``check=True``, the on-disk tree is not mutated; instead, prospective
+    writes and removals are reported and counted. Returns the number of
+    changes (or prospective changes).
+    """
+    changes = 0
+    expected: set[Path] = set()
+    for rel_stub_path, content in _generate_stubs(source_root).items():
+        stub_path = output_dir / rel_stub_path
+        if sync_file(stub_path, content, check=check):
+            changes += 1
+        expected.add(stub_path.resolve())
+
+    base = Path.cwd().resolve()
+    try:
+        source_rel = source_root.resolve().relative_to(base)
+    except ValueError:
+        # source_root is outside cwd; we have no safe subtree to clean.
+        return changes
+    stubs_root = output_dir / source_rel
+    if not stubs_root.exists():
+        return changes
+
+    for existing in stubs_root.rglob("*.pyi"):
+        if existing.resolve() not in expected and remove_file(existing, check=check):
+            changes += 1
+
+    if check:
+        return changes
+
+    # Prune now-empty directories, deepest-first, but keep stubs_root itself.
+    for d in sorted(stubs_root.rglob("*"), key=lambda p: len(p.parts), reverse=True):
+        if d.is_dir() and not any(d.iterdir()):
+            d.rmdir()
+
+    return changes

uncoded/sync.py

@@ -0,0 +1,50 @@
+"""Content-aware file writes with an optional check-only mode.
+
+Every place that writes an artifact (namespace map, stubs, instruction-file
+sections) routes through :func:`sync_file` / :func:`remove_file` so that two
+concerns live in one place: only write when content actually changes, and
+when ``check=True`` report the prospective action without touching disk.
+
+``check=True`` is what powers ``uncoded --check`` — the same pipeline runs,
+but the writers never mutate the tree, and the CLI exits non-zero if any
+helper reports a change. That gives CI a zero-mutation freshness gate.
+"""
+
+from pathlib import Path
+
+
+def sync_file(path: Path, content: str, *, check: bool = False) -> bool:
+    """Write ``content`` to ``path`` if it differs from what's on disk.
+
+    Prints ``Wrote``/``Updated`` in apply mode, ``Would write``/``Would
+    update`` in check mode. Returns ``True`` if a write was (or would be)
+    performed, ``False`` if the file was already up to date. Parent
+    directories are created as needed.
+    """
+    if not path.exists():
+        if not check:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content)
+        print(f"{'Would write' if check else 'Wrote'} {path}")
+        return True
+    if path.read_text() == content:
+        return False
+    if not check:
+        path.write_text(content)
+    print(f"{'Would update' if check else 'Updated'} {path}")
+    return True
+
+
+def remove_file(path: Path, *, check: bool = False) -> bool:
+    """Remove ``path`` if it exists.
+
+    Prints ``Removed`` in apply mode, ``Would remove`` in check mode.
+    Returns ``True`` if a removal was (or would be) performed, ``False``
+    if the file was already absent.
+    """
+    if not path.exists():
+        return False
+    if not check:
+        path.unlink()
+    print(f"{'Would remove' if check else 'Removed'} {path}")
+    return True

uncoded-0.5.0.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: uncoded
+Version: 0.5.0
+Summary: Static symbol indexes for AI-assisted code navigation
+Project-URL: Homepage, https://github.com/alimanfoo/uncoded
+Project-URL: Repository, https://github.com/alimanfoo/uncoded
+Author-email: Alistair Miles <alimanfoo@googlemail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pre-commit>=3.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# uncoded
+
+AI coding agents navigate codebases poorly. They grep for guessed keywords,
+skim the first few lines of files, and fill gaps from pretraining rather than
+reading the actual code. The result is plausible-looking output built on a
+hallucinated understanding of code that's sitting right there, unread.
+
+**uncoded** builds a static navigation index so agents can orient themselves
+at the start of a task and navigate deterministically to what they need —
+no guessing, no grep.
+
+Additionally, **uncoded** provides some convenience for setting up your coding agent with a language server, so they can reliably find symbol usages and rename, edit, or delete symbols safely.
+
+## What it generates
+
+Running `uncoded sync` produces:
+
+**`.uncoded/namespace.yaml`** — a hierarchical YAML file listing every symbol:
+directories, files, classes (with attributes and methods), functions. Covers
+all configured source roots. An agent can load this at the start of a task
+and immediately know the full vocabulary of the codebase.
+
+**`.uncoded/stubs/`** — one `.pyi` stub per source file, with imports, full
+signatures (parameter names, types, return types), first-sentence docstrings,
+module constants, and class attributes.
+
+**`.claude/skills/coherence-review/SKILL.md`** and
+**`.agents/skills/coherence-review/SKILL.md`** — a coherence review skill,
+written to both Claude Code and Codex skill directories (see
+[Coherence review](#coherence-review) below).
+
+`uncoded` also injects a navigation protocol into `CLAUDE.md`/`AGENTS.md`, so agents
+working in the repo pick up the instructions automatically.
+
+## Install
+
+```
+pip install uncoded
+```
+
+Or with uv:
+
+```
+uv add uncoded
+```
+
+## Configure
+
+Add a `[tool.uncoded]` section to your `pyproject.toml`:
+
+```toml
+[tool.uncoded]
+source-roots = ["src", "tests"]
+```
+
+## Use
+
+```
+uncoded sync
+```
+
+Run it from the repo root. It reads `pyproject.toml` to find your source
+roots, builds the index, and updates `CLAUDE.md`/`AGENTS.md`.
+
+Commit the generated `.uncoded/` directory so agents working
+in the repo always have a current index.
+
+## Keep it current with pre-commit
+
+Add `uncoded sync` as a pre-commit hook so the index stays in sync
+automatically:
+
+```yaml
+- repo: local
+  hooks:
+    - id: uncoded
+      name: uncoded
+      entry: uncoded sync
+      language: system
+      pass_filenames: false
+```
+
+Like `ruff format`: if `uncoded sync` modifies any files, the commit
+fails and you stage the updated index before committing again.
+
+You can also set up your CI to run `pre-commit run --all-files` to verify the index is up to date.
+
+## Verify the index is fresh
+
+For CI or scripted checks that must not modify the working tree, use
+the `check` subcommand:
+
+```
+uncoded check
+```
+
+It runs the same pipeline but writes nothing. Exits 0 if every generated
+file is byte-identical to what a rebuild would produce, and 1 otherwise
+— printing which files would change. A stale index is a silent failure
+mode (agents read misleading names and signatures), so gating on this in
+CI is worthwhile even alongside a pre-commit hook.
+
+## How agents use it
+
+When `uncoded` is set up, a navigation section is automatically maintained in
+the configured instruction files (by default, `CLAUDE.md` and `AGENTS.md`).
+Agents following that protocol:
+
+1. Read `.uncoded/namespace.yaml` to orient — every symbol, at a glance.
+2. Read the relevant `.pyi` stubs to understand imports, signatures, constants, class members, and docstring summaries.
+3. Use Serena's `find_symbol(..., include_body=True)` when they need implementation detail for a specific symbol.
+
+The split is deliberate: `uncoded` provides a stable map and semantic summary;
+Serena resolves the current source body. No grep, no stale line-number
+coordinates, no offset arithmetic.
+
+## Coherence review
+
+AI coding agents tend to leave codebases in an incoherent state: names that
+no longer match behaviour, docstrings that describe stale signatures, dead
+symbols, pattern changes applied in some places but not others. `uncoded sync`
+installs a `/coherence-review` skill that runs a structured diagnostic sweep to
+find these problems.
+
+Invoke it in Claude Code:
+
+```
+/coherence-review
+```
+
+The review works in four sweeps:
+
+1. **Orient** — loads `namespace.yaml` and forms a vocabulary map.
+2. **Lexical** — scans the namespace for naming inconsistency: concept
+   duplication, qualifier accretion (`_v2`, `_legacy`, `_final`), vocabulary
+   islands, name collision with drift.
+3. **Promissory** — reads stubs, checking each symbol's name / signature /
+   docstring triple for internal disagreement.
+4. **Structural** — checks for boundary violations (private symbols imported
+   across modules), overgrown public surfaces, cross-domain imports, and
+   zero-caller public symbols.
+
+Output is a timestamped Markdown report saved to `.uncoded/reviews/`, with
+verbatim evidence and a confidence level (high / medium / low) for each
+finding. The review only reports — it proposes no fixes. The human decides
+what to follow up.
+
+## Using uncoded with a language server
+
+Symbol-level operations — finding callers, reading or editing a single
+symbol, renaming, safe deletion — are better served by a language server
+than by grep and freeform text edits. Uncoded's map supplies the
+`name_path` and `relative_path` these tools take as input.
+
+The recommended setup is [oraios/serena][serena] as the MCP bridge with
+[astral-sh/ty][ty] as the Python language-server backend. Serena launches
+via `uvx`, so there's nothing to install globally; ty is downloaded by
+Serena on first use.
+
+### Setup
+
+```
+uv run uncoded setup-serena
+```
+
+Generates three files, tailored for Claude Code:
+
+- **`.mcp.json`** — registers Serena as an MCP server, launched via `uvx`.
+- **`.serena/project.yml`** — picks ty as the backend, ignores `.uncoded/`,
+  drops the redundant `execute_shell_command`.
+- **`.claude/settings.json`** — enables the Serena server and allowlists
+  its navigation, edit, and memory tools.
+
+Safe to re-run: JSON files merge into existing content (so pre-existing
+MCP servers and permissions are preserved), and the Serena project YAML
+is left alone once present. Restart your agent afterwards so the new
+MCP server is picked up.
+
+If you're not using Claude Code, the generated `.serena/project.yml` is
+MCP-client-agnostic, and `.mcp.json` can serve as a starting point —
+replace `claude-code` with your client's context name.
+
+[serena]: https://github.com/oraios/serena
+[ty]: https://github.com/astral-sh/ty
+
+## Dev setup
+
+Clone, install dependencies, and wire up the pre-commit hooks:
+
+```
+git clone https://github.com/alimanfoo/uncoded
+cd uncoded
+uv sync --extra dev
+uv run pre-commit install
+```
+
+Run the tests:
+
+```
+uv run pytest
+```
+
+Run all checks (the same suite CI runs):
+
+```
+uv run pre-commit run --all-files
+```

uncoded-0.5.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+uncoded/__init__.py,sha256=MjXnTazgjAK1flha1TC6c-Mz42ovqHnwtMt1fwXif2g,89
+uncoded/cli.py,sha256=TflX5JSgfv9W4RekYmYEhXou1-_D3z-1CjGo7drcNzc,3310
+uncoded/config.py,sha256=7GBz4IQ_i-o4cXpKjTfQHTC7HDOH4tFN_M5jUppaNj8,1832
+uncoded/extract.py,sha256=9FwDgSawQd6IthL3Qy4q1kGpY19dnRK0OTU8zF1mZg8,4562
+uncoded/instruction_files.py,sha256=scKbl3Y2c_80i5PCWfX_-7JIX7noveE10Bi-k9o8kzc,5955
+uncoded/namespace_map.py,sha256=s_gsKxDd18UtFxu4RtIRbrGDQl1pq2Pu3urI4l1kMaA,2523
+uncoded/serena_setup.py,sha256=DowjJOje2bg29lkVVqnSxtCf2yMBnnX3pflxsYUQdgE,6719
+uncoded/skill.py,sha256=4SZ0zCCrLBcO5d84D7_X5b8IHO0HH-AaZNSEPIXHx08,16641
+uncoded/stubs.py,sha256=ns9e7lSz3FqHOuXitLHCrGzJi_tmuYDxgI4y8LFGoLs,12967
+uncoded/sync.py,sha256=CkAcliTeoFTJeCmcdZGxlcFq0YR4gHYzH-dxCD609R8,1892
+uncoded-0.5.0.dist-info/METADATA,sha256=mJUY5SWEoD9V3xiRs3Xd9vzovZpY8dd3QWgfxOyDsLk,7525
+uncoded-0.5.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+uncoded-0.5.0.dist-info/entry_points.txt,sha256=C6dE7We5ZSE3z2KTWBzPceaRCS8XbgZ1WG8DV4S06H0,45
+uncoded-0.5.0.dist-info/licenses/LICENSE,sha256=gDwBEl-d7vujEM9osJvZhkrb3GTU8VwDfYC4ekNcT1s,1071
+uncoded-0.5.0.dist-info/RECORD,,

uncoded-0.5.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

uncoded-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uncoded = uncoded.cli:main