foothold 0.1.1__py3-none-any.whl

foothold/issues.py

@@ -0,0 +1,71 @@
+"""Good-first-issue candidates, derived deterministically.
+
+Three sources, all offline: TODO/FIXME markers, public functions without a
+docstring in low-centrality modules, and source files with no matching test.
+Low centrality matters - a first issue should not sit on the critical path.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from foothold.models import RepoMap
+
+
+@dataclass
+class IssueCandidate:
+    title: str
+    body: str
+    labels: list[str]
+    difficulty: str
+
+
+def propose(repo: RepoMap, limit: int = 10) -> list[IssueCandidate]:
+    out: list[IssueCandidate] = []
+    rank_of = {s.path: i for i, s in enumerate(repo.scores)}
+    peripheral = len(repo.scores) // 2
+
+    for marker in repo.markers:
+        if rank_of.get(marker.path, 0) < peripheral // 2:
+            continue  # too central for a newcomer
+        out.append(
+            IssueCandidate(
+                title=f"{marker.kind.title()}: {marker.text or marker.path}"[:80],
+                body=(
+                    f"`{marker.path}:{marker.lineno}` carries a {marker.kind} marker:\n\n"
+                    f"> {marker.text}\n\n"
+                    "Self-contained and off the critical path — a good first change."
+                ),
+                labels=["good first issue"],
+                difficulty="small",
+            )
+        )
+
+    for path in repo.untested[:limit]:
+        out.append(
+            IssueCandidate(
+                title=f"Add tests for {path}",
+                body=(
+                    f"`{path}` has no test file referencing it. Adding coverage is a "
+                    "low-risk way to learn the module."
+                ),
+                labels=["good first issue", "tests"],
+                difficulty="small",
+            )
+        )
+
+    for score in repo.scores[peripheral:]:
+        module = repo.modules[score.module]
+        if module.docstring is None and module.defines:
+            out.append(
+                IssueCandidate(
+                    title=f"Document the public API of {score.path}",
+                    body=(
+                        f"`{score.path}` exports {', '.join(module.defines[:5])} with no "
+                        "module docstring."
+                    ),
+                    labels=["good first issue", "documentation"],
+                    difficulty="small",
+                )
+            )
+    return out[:limit]

foothold/models.py

@@ -0,0 +1,70 @@
+"""Core data structures shared across collectors, graph and renderers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class Module:
+    """A single source file resolved to a dotted module path."""
+
+    path: str
+    module: str
+    loc: int
+    is_test: bool
+    is_package_init: bool
+    defines: tuple[str, ...] = ()
+    docstring: str | None = None
+
+
+@dataclass
+class Edge:
+    """A directed import edge between two in-project modules."""
+
+    src: str
+    dst: str
+    lineno: int
+
+
+@dataclass
+class Marker:
+    """A TODO/FIXME/HACK comment left in the source."""
+
+    path: str
+    lineno: int
+    kind: str
+    text: str
+
+
+@dataclass
+class Score:
+    """Ranking output for one module."""
+
+    module: str
+    path: str
+    total: float
+    centrality: float
+    churn: float
+    fan_in: int
+    fan_out: int
+    loc: int
+    reasons: list[str] = field(default_factory=list)
+
+
+@dataclass
+class RepoMap:
+    """Everything Foothold knows about a repository after the offline pass."""
+
+    root: str
+    modules: dict[str, Module]
+    edges: list[Edge]
+    scores: list[Score]
+    entrypoints: list[str]
+    markers: list[Marker]
+    untested: list[str]
+    cycles: list[list[str]]
+
+    @property
+    def loc_total(self) -> int:
+        return sum(m.loc for m in self.modules.values())

foothold/narrator/__init__.py

@@ -0,0 +1,3 @@
+from foothold.narrator.client import NarratorError, narrate
+
+__all__ = ["NarratorError", "narrate"]

foothold/narrator/client.py

@@ -0,0 +1,85 @@
+"""The only component that talks to a model.
+
+Design constraints, in order of importance:
+
+1. The model receives a *pruned* context - the ranked file list and selected
+   docstrings - never the repository. Cost scales with the summary, not the code.
+2. Every call reports its estimated spend before it happens; non-interactive
+   runs must pass ``--yes``.
+3. The dependency is optional. Without ``pip install foothold[narrate]``
+   every other command still works.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+from foothold.models import RepoMap
+
+SYSTEM = (
+    "You are documenting an unfamiliar codebase for a new contributor. You are given a "
+    "ranked file list produced by static analysis, not the source. Describe what the "
+    "system does and in what order to read it. State only what the data supports; if a "
+    "module's purpose is unclear from its name and docstring, say so."
+)
+
+
+class NarratorError(RuntimeError):
+    """Raised when narration is requested but unavailable."""
+
+
+@dataclass
+class Usage:
+    prompt_tokens: int
+    completion_tokens: int
+
+    def cost_usd(self, per_m_in: float = 0.15, per_m_out: float = 0.60) -> float:
+        return (self.prompt_tokens * per_m_in + self.completion_tokens * per_m_out) / 1e6
+
+
+def build_context(repo: RepoMap, top: int = 25) -> str:
+    """Assemble the pruned context. Kept pure so it can be snapshot-tested."""
+    lines = [f"Repository: {repo.root}", f"{len(repo.modules)} modules, {repo.loc_total} lines", ""]
+    lines.append("Entry points:")
+    lines += [f"- {repo.modules[n].path}" for n in repo.entrypoints[:6]]
+    lines.append("")
+    lines.append("Ranked core modules (score, imported-by, lines, docstring first line):")
+    for score in repo.scores[:top]:
+        doc = (repo.modules[score.module].docstring or "").strip().splitlines()
+        lines.append(
+            f"- {score.path} | {score.total:.3f} | in={score.fan_in} | loc={score.loc} | "
+            f"{doc[0] if doc else ''}"
+        )
+    if repo.cycles:
+        lines += ["", "Import cycles:"] + [f"- {' -> '.join(c)}" for c in repo.cycles[:5]]
+    return "\n".join(lines)
+
+
+def estimate_tokens(context: str) -> int:
+    """Deliberately crude: 4 chars/token. Over-estimates, which is the safe direction."""
+    return len(context) // 4 + 400
+
+
+def narrate(repo: RepoMap, model: str, top: int = 25) -> tuple[str, Usage]:
+    try:
+        from openai import OpenAI
+    except ModuleNotFoundError as exc:  # pragma: no cover
+        raise NarratorError(
+            "Narration needs the optional dependency: pip install 'foothold[narrate]'"
+        ) from exc
+    if not os.getenv("OPENAI_API_KEY"):
+        raise NarratorError("OPENAI_API_KEY is not set.")
+
+    context = build_context(repo, top=top)
+    client = OpenAI()
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "system", "content": SYSTEM}, {"role": "user", "content": context}],
+        temperature=0.2,
+    )
+    usage = Usage(
+        prompt_tokens=getattr(response.usage, "prompt_tokens", 0),
+        completion_tokens=getattr(response.usage, "completion_tokens", 0),
+    )
+    return response.choices[0].message.content or "", usage

foothold/render/__init__.py

@@ -0,0 +1,5 @@
+from foothold.render.markdown import render_architecture
+from foothold.render.mermaid import render_mermaid
+from foothold.render.terminal import render_map
+
+__all__ = ["render_architecture", "render_map", "render_mermaid"]

foothold/render/markdown.py

@@ -0,0 +1,57 @@
+"""Deterministic ARCHITECTURE.md.
+
+This renderer never calls a model. ``foothold docs --narrate`` adds prose on
+top of exactly this structure, so the document remains useful, and correct,
+without an API key.
+"""
+
+from __future__ import annotations
+
+from foothold.models import RepoMap
+from foothold.render.mermaid import render_mermaid
+
+
+def render_architecture(repo: RepoMap, top: int = 20, narrative: str | None = None) -> str:
+    sources = [m for m in repo.modules.values() if not m.is_test]
+    parts = [
+        "# Architecture",
+        "",
+        "<!-- Generated by foothold. Re-run `foothold docs` to refresh. -->",
+        "",
+        f"{len(repo.modules)} modules ({len(sources)} source), {repo.loc_total:,} lines, "
+        f"{len(repo.edges)} import statements.",
+        "",
+    ]
+    if narrative:
+        parts += ["## Overview", "", narrative, ""]
+    parts += ["## Where to start", ""]
+    for name in repo.entrypoints[:6]:
+        module = repo.modules[name]
+        summary = (module.docstring or "").strip().splitlines()
+        parts.append(f"- `{module.path}` — {summary[0] if summary else 'no docstring'}")
+    parts += [
+        "",
+        "## Core modules",
+        "",
+        "| File | Score | Imported by | Lines | Signals |",
+        "|---|---:|---:|---:|---|",
+    ]
+    for score in repo.scores[:top]:
+        parts.append(
+            f"| `{score.path}` | {score.total:.3f} | {score.fan_in} | {score.loc} | "
+            f"{', '.join(score.reasons) or '—'} |"
+        )
+    parts += ["", "## Dependency graph", "", render_mermaid(repo), ""]
+    if repo.cycles:
+        parts += ["## Import cycles", ""]
+        parts += [f"- {' → '.join(c)}" for c in repo.cycles[:5]]
+        parts.append("")
+    parts += [
+        "## How this file is scored",
+        "",
+        "`score = 0.45·pagerank + 0.30·churn + 0.15·fan-in + 0.10·log(loc)`, each term "
+        "min-max normalised across the repository. Weights are configurable in "
+        "`.foothold.toml`.",
+        "",
+    ]
+    return "\n".join(parts)

foothold/render/mermaid.py

@@ -0,0 +1,24 @@
+"""Mermaid diagram of the top-N subgraph - GitHub renders it natively."""
+
+from __future__ import annotations
+
+from foothold.models import RepoMap
+
+
+def _slug(name: str) -> str:
+    return name.replace(".", "_").replace("-", "_")
+
+
+def render_mermaid(repo: RepoMap, top: int = 12) -> str:
+    keep = {s.module for s in repo.scores[:top]}
+    lines = ["```mermaid", "graph LR"]
+    for score in repo.scores[:top]:
+        lines.append(f'    {_slug(score.module)}["{score.path}"]')
+    seen: set[tuple[str, str]] = set()
+    for edge in repo.edges:
+        src, dst = edge.src, edge.dst
+        if src in keep and dst in keep and (src, dst) not in seen and src != dst:
+            seen.add((src, dst))
+            lines.append(f"    {_slug(src)} --> {_slug(dst)}")
+    lines.append("```")
+    return "\n".join(lines)

foothold/render/terminal.py

@@ -0,0 +1,47 @@
+"""Rich terminal output."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.table import Table
+
+from foothold.models import RepoMap
+
+
+def render_map(repo: RepoMap, top: int, console: Console | None = None) -> None:
+    console = console or Console()
+    sources = [m for m in repo.modules.values() if not m.is_test]
+    tests = len(repo.modules) - len(sources)
+    console.print(
+        f"[bold]{len(repo.modules)}[/bold] modules "
+        f"([bold]{len(sources)}[/bold] source, [bold]{tests}[/bold] test) · "
+        f"[bold]{repo.loc_total:,}[/bold] lines · "
+        f"[bold]{len(repo.edges)}[/bold] import statements"
+    )
+
+    table = Table(title=f"Top {top} files by structural weight", title_justify="left")
+    table.add_column("#", justify="right", style="dim")
+    table.add_column("file")
+    table.add_column("score", justify="right")
+    table.add_column("in", justify="right")
+    table.add_column("loc", justify="right")
+    table.add_column("why", style="dim")
+    for i, score in enumerate(repo.scores[:top], start=1):
+        table.add_row(
+            str(i),
+            score.path,
+            f"{score.total:.3f}",
+            str(score.fan_in),
+            str(score.loc),
+            ", ".join(score.reasons) or "—",
+        )
+    console.print(table)
+
+    if repo.entrypoints:
+        console.print("\n[bold]Entry points[/bold] (imported by nothing in-project)")
+        for name in repo.entrypoints[:8]:
+            console.print(f"  · {repo.modules[name].path}")
+    if repo.cycles:
+        console.print(f"\n[bold yellow]{len(repo.cycles)} import cycle(s)[/bold yellow]")
+        for cycle in repo.cycles[:3]:
+            console.print(f"  · {' → '.join(cycle)}")

foothold-0.1.1.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: foothold
+Version: 0.1.1
+Summary: Turn an unfamiliar repository into a reading path
+Project-URL: Homepage, https://github.com/serdairy/foothold
+Project-URL: Issues, https://github.com/serdairy/foothold/issues
+Project-URL: Changelog, https://github.com/serdairy/foothold/blob/main/CHANGELOG.md
+Author-email: Sergei Petrov <pserg@me.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: cli,developer-tools,documentation,onboarding,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.10
+Requires-Dist: networkx>=3.1
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: narrate
+Requires-Dist: openai>=1.40; extra == 'narrate'
+Description-Content-Type: text/markdown
+
+# Foothold
+
+[![CI](https://github.com/serdairy/foothold/actions/workflows/ci.yml/badge.svg)](https://github.com/serdairy/foothold/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/foothold.svg)](https://pypi.org/project/foothold/)
+[![Python](https://img.shields.io/pypi/pyversions/foothold.svg)](https://pypi.org/project/foothold/)
+[![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![Checked with mypy](https://img.shields.io/badge/mypy-strict-blue.svg)](https://mypy-lang.org/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+**Which 20 files should I read first?** Foothold answers that for a Python repository in
+under a second, without an API key — the foothold you need before you can start climbing
+an unfamiliar codebase.
+
+```console
+$ foothold map ~/src/rich
+99 modules (99 source, 0 test) · 38,437 lines · 1,884 import statements
+Top 6 files by structural weight
+┏━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━┳━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ # ┃ file                      ┃ score ┃ in ┃  loc ┃ why                      ┃
+┡━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━╇━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ 1 │ console.py                │ 0.695 │ 49 │ 2699 │ imported by 49 modules   │
+│ 2 │ cells.py                  │ 0.542 │ 31 │  353 │ imported by 31 modules   │
+│ 3 │ _unicode_data/__init__.py │ 0.380 │  1 │   94 │ high transitive reach    │
+│ 4 │ text.py                   │ 0.353 │ 31 │ 1364 │ imported by 31 modules   │
+│ 5 │ style.py                  │ 0.299 │ 30 │  797 │ imported by 30 modules   │
+│ 6 │ segment.py                │ 0.220 │ 21 │  781 │ 781 lines                │
+└───┴───────────────────────────┴───────┴────┴──────┴──────────────────────────┘
+```
+
+That ordering is not a guess. It falls out of the import graph, weighted by how often each
+file has been edited.
+
+## The problem
+
+Contributor onboarding is the most expensive unpaid work in open source, and it is paid
+twice — once by the newcomer who spends a weekend deciding which of 400 files matter, and
+once by the maintainer answering the same orientation question in every issue thread.
+
+The usual mitigations do not hold. `ARCHITECTURE.md` is written once at project inception
+and drifts within two releases. Generated API references list every symbol and rank none
+of them. Pasting a repository into a chat window costs ~46,000 tokens for a project the
+size of networkx, and produces fluent prose with no grounding in the actual import graph.
+
+Foothold splits the problem in two. **Ranking is deterministic** — a graph, a churn
+count, a formula you can read. **Prose is optional** and sits on top of an already-correct,
+already-pruned selection. The expensive part is the part that does not need a model.
+
+## Install
+
+```bash
+uv tool install foothold      # or: pipx install foothold
+```
+
+Three runtime dependencies: `typer`, `rich`, `networkx`. PageRank is implemented in pure
+Python specifically to avoid pulling ~100 MB of scipy and numpy into a CLI.
+
+## Commands
+
+| Command | What it does | Network |
+|---|---|---|
+| `foothold map .` | Rank the files that hold the repo together | none |
+| `foothold docs . -o ARCHITECTURE.md` | Write a deterministic architecture document with a Mermaid graph | none |
+| `foothold issues . --max 10` | Propose good-first-issue candidates, off the critical path | none |
+| `foothold explain . --dry-run` | Print the exact payload a model would receive | none |
+| `foothold explain .` | Prose walkthrough grounded in the ranked map | OpenAI API |
+| `foothold docs . --narrate` | The same document, with an overview section | OpenAI API |
+
+The two commands that cost money print an estimate and require confirmation; `--yes` is
+mandatory for non-interactive use.
+
+## How the ranking works
+
+```
+score = 0.45·pagerank + 0.30·churn + 0.15·fan-in + 0.10·log(loc)
+```
+
+Each term is min-max normalised across the repository, so scores compare within a repo but
+not across repos. The weights live in `.foothold.toml` and are printed in every generated
+document — a ranking you cannot interrogate is a ranking you cannot trust.
+
+- **PageRank** over the in-project import graph. Edges point *importer → imported*, so a
+  module everything depends on scores high. External and stdlib imports are dropped: they
+  add nodes without adding signal. (`test_pagerank_ranks_dependencies_above_dependents`
+  guards the direction — reversing it silently inverts the whole tool.)
+- **Churn** from `git log --since=18.months`. A file edited in every release is a file a
+  newcomer will have to touch. Repositories without git history degrade to a zero churn
+  signal rather than failing.
+- **Fan-in** as a plain, legible count, so the top of the list is explainable without
+  understanding PageRank.
+- **Size**, log-scaled, as a weak tiebreaker.
+
+Tests are excluded from the ranking and used instead to detect untested modules.
+
+## What it sends, and what it does not
+
+`foothold explain . --dry-run` prints the complete payload. It contains file paths,
+scores, entry points, import cycles and the first line of each module docstring. **It does
+not contain source code** — there is a test asserting exactly that.
+
+The consequence is that context size tracks `--top`, not repository size:
+
+| Repository | Modules | Lines of code | Context sent | Budgeted tokens |
+|---|---:|---:|---:|---:|
+| foothold | 31 | 1,284 | 1,999 chars | 899 |
+| rich | 99 | 38,437 | 2,314 chars | 978 |
+| networkx | 565 | 183,241 | 2,837 chars | 1,109 |
+
+A 183,000-line codebase is described in under 3 KB. Full numbers and method in
+[docs/cost-model.md](docs/cost-model.md).
+
+Foothold also never executes the code it reads — parsing is stdlib `ast`, which does not
+evaluate. See [SECURITY.md](SECURITY.md).
+
+## Architecture
+
+```
+src/foothold/
+├── cli.py              # Typer entry point
+├── analyze.py          # orchestration: collect → graph → rank → RepoMap
+├── models.py           # the shared vocabulary; imported by 10 modules
+├── config.py           # .foothold.toml, ranking weights
+├── collectors/         # python_ast · git_history · markers    (offline)
+├── graph/              # build (import graph) · rank (pagerank + weights)
+├── issues.py           # good-first-issue heuristics           (offline)
+├── render/             # terminal · markdown · mermaid         (offline)
+└── narrator/           # the only module that talks to a model
+```
+
+[ARCHITECTURE.md](ARCHITECTURE.md) is generated by `foothold docs` and refreshed at each
+release. It is deliberately not pinned by a CI equality check: churn is an input, so the
+ranking moves as history accumulates, and a byte-for-byte assertion would fail on every
+commit. What CI does assert is that the generator runs against this repository on all
+twelve OS and Python combinations.
+
+## Limitations
+
+Stated plainly, because the alternative wastes your time:
+
+- **Python only.** Other languages are parsed as nothing. tree-sitter support is v0.3.
+- Dynamic imports (`importlib`, plugin registries, `__getattr__` re-exports) are invisible
+  to static analysis and will under-rank plugin-heavy architectures.
+- Churn needs real git history. CI must use `fetch-depth: 0`; shallow clones silently lose
+  that signal.
+- Monorepos with several independent packages are ranked as one graph. v0.5.
+- Scores are comparable within a repository, never across repositories.
+- Scores also move over time within one repository: churn is measured over a rolling
+  18-month window, so the same commit ranked today and in six months can differ. The
+  ranking describes a repository's present, not a fixed property of its files.
+
+## Roadmap
+
+| Version | Scope | Status |
+|---|---|---|
+| **v0.1** | `map`, `docs`, `issues`, `explain`; Python; 85% coverage | **shipped** |
+| v0.2 | Content-hash cache; incremental re-analysis on diff; `--since` | next |
+| v0.3 | tree-sitter parsers: TypeScript, JavaScript, Go | planned |
+| v0.4 | `tour` with personas; GitHub Action for CI-regenerated docs | planned |
+| v0.5 | Monorepo support; call-graph edges, not just imports | planned |
+| v1.0 | Stable JSON schema; benchmark suite against hand-written docs | planned |
+
+Non-goals: replacing hand-written design documents, reviewing code, running as a hosted
+service. Foothold is a local tool that produces files you own and commit.
+
+## Contributing
+
+Foothold exists because onboarding is hard, so its own onboarding has to be good:
+
+```bash
+git clone https://github.com/serdairy/foothold && cd foothold
+uv sync --all-extras
+uv run foothold map .        # start here
+uv run pytest                # 23 tests, ~0.2s, no network
+```
+
+If `map` gives you a confusing reading order on your project, open a **bad ranking** issue
+— that is the most useful report this project can receive. See
+[CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+Apache-2.0 — chosen over MIT for the explicit patent grant, which matters for a tool that
+parses other people's code. See [LICENSE](LICENSE).

foothold-0.1.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+foothold/__init__.py,sha256=bdoIUJJotvwJJVIol1KyhDd1R49_2a--WKJ5KM_OQDE,90
+foothold/analyze.py,sha256=m6LMevjjlCsRkV0xxCOwSRpLoJryuygvgOEa4FdNhmI,1452
+foothold/cli.py,sha256=VWoY_oulKWibYbG_sUhrgwpVS34HwXSXWlu0aUrF6oY,5357
+foothold/config.py,sha256=SdK8Mgx9974Zu7OBAIPdMl27shzQNmAsXQzO-ufMjrI,1731
+foothold/issues.py,sha256=VyNcYnpDzlY_vSqpIuGTCEgcBQuFoShgeKAwZD1vhZk,2404
+foothold/models.py,sha256=NGsTnvjAWf1OmC9PzGD4hnx3QV41ZZkVb9OJOVxaNHs,1348
+foothold/collectors/__init__.py,sha256=egbW0cc6lKrfDH1EXjx5hfET-HUN2Q85e35fv0HBjdg,240
+foothold/collectors/git_history.py,sha256=tuJS55gWsmJW2l_B3dyJ3AVrwV_PtN9TdtcwpMl6BSU,1209
+foothold/collectors/markers.py,sha256=GCrYf_t3cYnMnfPHziH2XeD81ovRHAI24z8XJAdhoFo,958
+foothold/collectors/python_ast.py,sha256=dy-SNVOsZ8gGqx88114aB0CvBti-3uJwkvFQXNaaT_0,3799
+foothold/graph/__init__.py,sha256=f-NiKBD-t1RwzNXtOZpSQvqQFnXEjTMlifJH7ZyOLGk,183
+foothold/graph/build.py,sha256=6XT4GdD5NKRrmJfcZG9tc0e_Ah52eWX_jFNd0D4cIso,2884
+foothold/graph/rank.py,sha256=Lyd9nicmu8lpwVVFqxHr8xi9eqCZ0W6YsMcPYKYgNTE,4249
+foothold/narrator/__init__.py,sha256=gdBGBl4c5IazvJD9o9Chy2Gvpzr7nsZw657I0xP93QQ,100
+foothold/narrator/client.py,sha256=2Jna2xt6PpO1QuG_DrO24lfUro67LagZyAsXddM-u4U,3229
+foothold/render/__init__.py,sha256=cfD8TslJvzinR-czFbUdH-MMWWLU2AtlOS1_gXmgjtQ,223
+foothold/render/markdown.py,sha256=OBPhBALtCYL0GbuDIH_SOrkkTSh4g_MShbF0AKaM38k,2048
+foothold/render/mermaid.py,sha256=irYTouXP9_1XcSN7NV_dfmSVmXHCWRPxdOxTX3hbVhY,815
+foothold/render/terminal.py,sha256=T7DRSx135Vi5WhUgCFxoeSpfIiJyXFApJazAXCXhfS0,1734
+foothold-0.1.1.dist-info/METADATA,sha256=PWBH9vffoAEragtptB4pc5Q47wCb_fEsd6Yrozcy_Ns,11012
+foothold-0.1.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+foothold-0.1.1.dist-info/entry_points.txt,sha256=1drN3lESuKX_JcU3707la3PnJ4vB_lI5WxsNppNA320,46
+foothold-0.1.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+foothold-0.1.1.dist-info/RECORD,,

foothold-0.1.1.dist-info/WHEEL

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

foothold-0.1.1.dist-info/entry_points.txt

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