codingest 0.2.34__cp312-abi3-win_amd64.whl

codingest/__init__.py

@@ -0,0 +1,46 @@
+"""codingest — parse polyglot codebases into kglite knowledge graphs.
+
+    import codingest
+
+    g = codingest.build(".")          # -> kglite.KnowledgeGraph
+    g.cypher("MATCH (f:Function) RETURN f.name LIMIT 10")
+
+`build()` parses the tree with codingest's native tree-sitter builder (grammars
+bundled — nothing else to install), serializes the result to a `.kgl`, and hands
+off to the separately installed `kglite` wheel: the returned object is a real
+`kglite.KnowledgeGraph`, so every downstream kglite API works unchanged. This
+restores the builder surface that kglite 0.14 removed (`kglite.code_tree`).
+
+Entry points:
+    build            - parse a directory (with optional git `rev`/`revs`).
+    repo_tree        - clone a GitHub repo and build.
+    read_manifest    - extract project metadata from a manifest file.
+    language_for_path- map a path to its parser language, or None.
+"""
+
+from __future__ import annotations
+
+from importlib import metadata as _metadata
+
+# The native extension registers `build` / `repo_tree` / `read_manifest` /
+# `language_for_path`. Renamed to `codingest.codingest` by maturin's
+# `module-name`; this pulls its public functions up to the package root.
+from .codingest import (  # noqa: F401
+    build,
+    language_for_path,
+    read_manifest,
+    repo_tree,
+)
+
+try:
+    __version__ = _metadata.version("codingest")
+except _metadata.PackageNotFoundError:  # pragma: no cover - source checkout
+    from .codingest import __version__ as __version__
+
+__all__ = [
+    "build",
+    "repo_tree",
+    "read_manifest",
+    "language_for_path",
+    "__version__",
+]

codingest/__init__.pyi

@@ -0,0 +1,138 @@
+"""Type stubs for the codingest wheel.
+
+`build()` / `repo_tree()` return a `kglite.KnowledgeGraph` — the object the
+installed `kglite` wheel produces, reached through the `.kgl`-bytes handoff
+(build native → serialize → `kglite.load`). Every downstream kglite API
+(`.cypher()`, `.describe()`, …) is available on the returned value.
+"""
+
+from typing import Any, Optional
+
+from kglite import KnowledgeGraph
+
+__version__: str
+
+def build(
+    src_dir: str,
+    *,
+    save_to: Optional[str] = None,
+    verbose: bool = False,
+    include_tests: bool = True,
+    max_loc_per_file: Optional[int] = None,
+    include_docs: bool = False,
+    rev: Optional[str] = None,
+    revs: Optional[list[str]] = None,
+    repo_root: Optional[str] = None,
+    embed_skills: bool = False,
+) -> KnowledgeGraph:
+    """Parse a codebase at ``src_dir`` into a :class:`kglite.KnowledgeGraph`.
+
+    The stable, public entry point for code-graph building (tree-sitter grammars
+    are bundled in the native extension — nothing else to install). codingest
+    builds the graph with its own native builder, serializes it to a ``.kgl``,
+    and loads it back through the installed ``kglite`` wheel, so the returned
+    object is a real ``kglite.KnowledgeGraph``.
+
+    Pass ``include_docs=True`` to also ingest the repo's markdown as ``:Doc``
+    nodes linked to the code they mention
+    (``(:Doc)-[:MENTIONS]->(:Function|:Class|…)`` and
+    ``(:Doc)-[:DOCUMENTS]->(:Doc|:File)``). Off by default (code-only graph).
+
+    Pass ``rev=<tag|branch|sha>`` to build the codebase as it existed at that git
+    revision instead of the working tree. The revision's tracked files are
+    materialized into a tempdir via ``git archive`` — ``HEAD`` and the working
+    tree are never touched, and uncommitted changes are excluded. The git root
+    is auto-resolved from ``src_dir`` (override with ``repo_root``); a bad rev or
+    non-git directory raises a clear error. The built graph's ``describe()``
+    records the revision it represents.
+
+    Pass ``revs=[<rev>, ...]`` (oldest → newest, mutually exclusive with
+    ``rev``) to merge N revisions into ONE multi-rev graph: one node per entity
+    across revs, each node carrying native list props ``revs: [str]`` (revisions
+    it appears in) + ``rev_fp: [int]`` (a per-rev shape fingerprint), and each
+    edge carrying ``revs: [str]``. Unchanged entities are stored once, so the
+    graph is ≈ base + deltas. Ordinary properties (``signature``,
+    ``value_preview``, …) report the NEWEST rev an entity appears in
+    (newest-wins). Because one graph holds every rev, an **unscoped**
+    ``MATCH (n:Function) RETURN count(n)`` over-counts across revs — scope a
+    query to one rev with membership::
+
+        MATCH (n:Function) WHERE 'v2' IN n.revs RETURN n.name
+
+    and use ``CALL rev_diff({from: 'v1', to: 'v2'})`` for added / removed /
+    changed deltas between two revs. ``describe()`` lists the loaded revs and
+    teaches this scoping idiom.
+
+    Args:
+        src_dir: Path to the directory (or manifest-rooted project) to parse.
+        save_to: If given, also write the built graph to this ``.kgl`` path
+            (the loaded graph is still returned).
+        verbose: Emit build progress to stderr.
+        include_tests: Include test files/dirs in the graph (default True).
+        max_loc_per_file: Skip files longer than this many lines (None = no cap).
+        include_docs: Ingest markdown as ``:Doc`` nodes (see above).
+        embed_skills: Also write codingest's ``code_review`` skill and its
+            recipe catalogue into the graph as graph-carried records
+            (``KgliteSkill`` / ``KgliteRecipe``), for a ``.kgl`` served by a
+            plain ``kglite-mcp-server --graph``. Off by default: the default
+            graph is byte-identical to earlier releases, and ``codingest-mcp``
+            serves the methodology by itself. ``repo_tree`` never embeds.
+        rev: A single git revspec to build (mutually exclusive with ``revs``).
+        revs: A list of git revspecs to merge into a multi-rev graph.
+        repo_root: Override the auto-resolved git root for ``rev``/``revs``.
+
+    Returns:
+        A :class:`kglite.KnowledgeGraph` of the parsed codebase.
+    """
+    ...
+
+def repo_tree(
+    repo: str,
+    *,
+    save_to: Optional[str] = None,
+    clone_to: Optional[str] = None,
+    branch: Optional[str] = None,
+    token: Optional[str] = None,
+    verbose: bool = False,
+    include_tests: bool = True,
+    max_loc_per_file: Optional[int] = None,
+    include_docs: bool = False,
+) -> KnowledgeGraph:
+    """Clone a GitHub repository and build its code knowledge graph.
+
+    Shallow-clones ``repo`` (shelling out to ``git``) into a tempdir (or
+    ``clone_to``) and builds it, returning a :class:`kglite.KnowledgeGraph`.
+    Set ``include_docs=True`` to also ingest the repo's markdown as ``:Doc``
+    nodes linked to the code they mention (see :func:`build`).
+
+    Args:
+        repo: ``owner/name`` or a full clone URL.
+        save_to: If given, also write the built graph to this ``.kgl`` path.
+        clone_to: Directory to clone into (default: a tempdir, removed after).
+        branch: Branch / tag / ref to check out (default: the repo default).
+        token: Auth token for private repos.
+        verbose: Emit build progress to stderr.
+        include_tests: Include test files/dirs in the graph (default True).
+        max_loc_per_file: Skip files longer than this many lines.
+        include_docs: Ingest markdown as ``:Doc`` nodes (see :func:`build`).
+
+    Returns:
+        A :class:`kglite.KnowledgeGraph` of the cloned repository.
+    """
+    ...
+
+def read_manifest(path: str) -> Optional[dict[str, Any]]:
+    """Read a project manifest and return a dict of project metadata.
+
+    Recognises ``pyproject.toml`` / ``Cargo.toml`` (and more). Returns ``None``
+    when no manifest is found at ``path``. The dict carries ``name``,
+    ``version``, ``description``, ``languages``, ``authors``, ``license``,
+    ``repository_url``, ``manifest_path``, ``build_system``, ``source_roots``,
+    and ``test_roots`` (the last two as lists of directory paths).
+    """
+    ...
+
+def language_for_path(path: str) -> Optional[str]:
+    """Map a file path to its codingest parser language, or ``None`` if no
+    parser handles the file (e.g. ``"src/app.py"`` → ``"python"``)."""
+    ...

codingest/cli.py

@@ -0,0 +1,31 @@
+"""Console-script shim for the Rust ``codingest`` CLI bundled in the wheel.
+
+The CLI implementation lives in the ``codingest-cli`` Rust library and is linked
+into this wheel's existing extension alongside the code-graph builder. This
+module only forwards argv and formats a top-level error; command parsing and
+behavior are shared with the standalone ``codingest-cli`` binary distribution
+(``cargo install codingest-cli``).
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the bundled Rust CLI with ``argv`` or ``sys.argv[1:]``."""
+    from codingest.codingest import _run_cli
+
+    args = list(sys.argv[1:] if argv is None else argv)
+    try:
+        _run_cli(args)
+    except KeyboardInterrupt:
+        return 130
+    except RuntimeError as exc:
+        print(f"codingest: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codingest/codingest.pyd

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: codingest/codingest.pyd
+size: 66061824 bytes
+sha256: 0b74887915ebd605f5c8b9d35fc2856465ddc16d31ee040546681c49ab383d96

codingest/mcp_server.py

@@ -0,0 +1,38 @@
+"""Console-script shim for the Rust ``codingest-mcp`` server in the wheel.
+
+Codingest supplies the source-builder hooks; KGlite supplies graph/Cypher
+serving and pulls the generic MCP lifecycle from ``mcp-methods``. All three are
+linked into the wheel's existing native extension, so users need only
+``pip install codingest``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the bundled MCP server with ``argv`` or ``sys.argv[1:]``."""
+    from codingest.codingest import _run_mcp_server
+
+    args = list(sys.argv[1:] if argv is None else argv)
+    # In a wheel console script, current_exe() is Python rather than the Rust
+    # server. Give KGlite's selftest the exact command needed to re-enter this
+    # module with the same interpreter and environment.
+    os.environ["KGLITE_MCP_RESPAWN"] = json.dumps(
+        [sys.executable, "-m", "codingest.mcp_server"]
+    )
+    try:
+        _run_mcp_server(args)
+    except KeyboardInterrupt:
+        return 130
+    except RuntimeError as exc:
+        print(f"codingest-mcp: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codingest-0.2.34.dist-info/METADATA

@@ -0,0 +1,301 @@
+Metadata-Version: 2.4
+Name: codingest
+Version: 0.2.34
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: kglite>=0.21.4,<0.22
+License-File: LICENSE
+Summary: Build fast, queryable code graphs for AI agents, MCP code review, and local or GitHub repository analysis.
+Keywords: ai-agents,mcp,code-review,knowledge-graph,code-analysis,github,tree-sitter,cypher
+Author-email: Kristian dF Kollsgård <kkollsg@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://codingest.readthedocs.io
+Project-URL: Homepage, https://github.com/kkollsga/codingest
+Project-URL: Issues, https://github.com/kkollsga/codingest/issues
+Project-URL: Repository, https://github.com/kkollsga/codingest
+
+# codingest
+
+[![CI](https://github.com/kkollsga/codingest/actions/workflows/ci.yml/badge.svg)](https://github.com/kkollsga/codingest/actions/workflows/ci.yml)
+[![crates.io](https://img.shields.io/crates/v/codingest.svg)](https://crates.io/crates/codingest)
+[![PyPI](https://img.shields.io/pypi/v/codingest.svg)](https://pypi.org/project/codingest/)
+[![Docs](https://readthedocs.org/projects/codingest/badge/?version=latest)](https://codingest.readthedocs.io)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Give AI agents a live, queryable map of any codebase — locally, privately, and
+without running the code you are analysing.
+
+codingest turns polyglot source into a
+[KGLite](https://github.com/kkollsga/kglite) knowledge graph of functions,
+types, calls, imports, inheritance, routes, documentation, and git revisions.
+Use it from Python, the command line, or as an MCP server for coding agents.
+
+```bash
+pip install codingest
+```
+
+```python
+import codingest
+
+graph = codingest.build(".")
+graph.cypher("MATCH (f:Function) RETURN f.name LIMIT 10")
+```
+
+No language servers, databases, or repository-specific build steps are
+required. The native Rust builder bundles parsers for 17 languages and returns
+a real `kglite.KnowledgeGraph`, ready for Cypher queries.
+
+## Built for agents and code analysis
+
+- **Agent-ready MCP:** give an MCP client `graph_overview`, `cypher_query`,
+  `read_code_source`, repository switching, automatic graph refresh, and the
+  code-review methodology itself — a `code_review` skill and a catalogue of
+  parameter-checked review recipes (`run_recipe_query`) served for every graph.
+  [opencode is set up and verified end to end](https://codingest.readthedocs.io/en/latest/mcp.html#using-codingest-mcp-with-opencode)
+  — including a config that needs no absolute paths — and `codingest skill
+  install` packages the review skill for Claude Code and Codex, which opencode
+  also discovers with no extra step.
+- **Fast local review:** map definitions, callers, dependencies, routes,
+  inheritance, and affected tests without uploading or executing the project.
+- **Open-source intelligence:** clone and analyse a GitHub repository with one
+  Python call, or let an agent manage cached public repositories through MCP.
+- **Polyglot by default:** one graph across Python, Rust, TypeScript,
+  JavaScript, Java, Go, C/C++, C#, Swift, PHP, HTML, CSS, Dart, Julia, R,
+  and AGC assembly — capabilities per language in
+  [docs/languages.md](docs/languages.md).
+- **Revision-aware:** analyse a tag, branch, commit, or multiple revisions in
+  one graph and query what changed.
+
+AGC assembly receives architecture-aware control and data relationships rather
+than a generic text-level call graph; see the [AGC graph model](https://codingest.readthedocs.io/en/latest/agc-assembly.html).
+
+## Give your agent a code-review MCP server
+
+```bash
+pip install codingest
+codingest-mcp --watch /absolute/path/to/repo
+```
+
+Point an MCP client at the same command:
+
+```json
+{
+  "mcpServers": {
+    "code-review": {
+      "command": "codingest-mcp",
+      "args": ["--watch", "/absolute/path/to/repo"]
+    }
+  }
+}
+```
+
+The server builds the graph at startup, refreshes it when source files change,
+and gives the agent schema discovery, Cypher, and source-reading tools over
+stdio. For a multi-repository agent sandbox with runtime `set_root_dir`, use
+the local-workspace manifest described in the [MCP guide](https://codingest.readthedocs.io/en/latest/mcp.html).
+
+For a zero-configuration CLI workflow, install the packaged code-review Agent
+Skill instead:
+
+```bash
+pip install codingest
+codingest skill install
+```
+
+The skill teaches compatible agents to build a fresh graph, discover its
+schema before querying, combine Cypher with the git diff, and verify findings
+against source lines. See the [MCP guide](https://codingest.readthedocs.io/en/latest/mcp.html)
+and [CLI guide](https://codingest.readthedocs.io/en/latest/cli.html).
+
+## Analyse a local codebase
+
+```python
+import codingest
+
+graph = codingest.build(
+    ".",
+    include_docs=True,
+)
+
+rows = graph.cypher("""
+MATCH (caller:Function)-[:CALLS]->(target:Function)
+RETURN target.qualified_name, count(caller) AS callers
+ORDER BY callers DESC
+LIMIT 10
+""")
+
+codingest.build(".", save_to="code-review.kgl")
+```
+
+The bundled terminal command offers the same workflow:
+
+```bash
+codingest build /path/to/repo
+codingest status --output /path/to/repo/.kglite/code-review.kgl
+codingest query -g /path/to/repo/.kglite/code-review.kgl \
+  "MATCH (f:Function)-[:CALLS]->(g:Function) RETURN f.name, g.name LIMIT 20"
+kglite describe /path/to/repo/.kglite/code-review.kgl --connections
+```
+
+`codingest query` prints unbounded TSV to stdout (use `--format csv|json`, or
+Cypher `LIMIT` to bound rows), warns on stderr when the graph has gone stale,
+and with `--require-fresh` refuses a stale graph with exit code 3 — see
+[docs/cli.md](docs/cli.md).
+
+## Analyse an open-source repository
+
+```python
+import codingest
+
+graph = codingest.repo_tree("pallets/flask")
+graph.cypher("""
+MATCH (route:Function)-[:CALLS]->(dependency:Function)
+RETURN route.qualified_name, dependency.qualified_name
+LIMIT 25
+""")
+```
+
+`repo_tree()` shallow-clones the requested repository into a temporary
+directory, builds the graph, and cleans up afterward. Pass `branch=`,
+`clone_to=`, or `token=` for a specific revision, a reusable cache, or a
+private repository.
+
+## Compare revisions
+
+```python
+graph = codingest.build(".", revs=["v1.0", "v2.0"])
+graph.cypher("""
+MATCH (f:Function)
+WHERE 'v2.0' IN f.revs AND NOT 'v1.0' IN f.revs
+RETURN f.qualified_name
+""")
+```
+
+Revision builds use tracked git content without changing the working tree.
+Multi-revision graphs store shared entities once and expose revision membership
+for direct Cypher analysis.
+
+## Install options
+
+```bash
+pip install codingest          # Python API + CLI + MCP server + KGLite runtime
+codingest skill install        # code-review Agent Skill
+```
+
+The wheel bundles every grammar plus the `codingest` and `codingest-mcp`
+commands. KGLite ≥0.21.4 is installed automatically as the query/storage
+engine; its MCP server and the transitive `mcp-methods` framework power the
+builder-aware Codingest server. Nothing else needs to be installed.
+
+Rust-only environments can instead use `cargo install codingest-cli
+codingest-mcp`; these are alternative distributions of the same commands, not
+Python prerequisites.
+
+### Rust crate
+
+```toml
+[dependencies]
+codingest = "0.2"
+kglite = "0.21.4"
+```
+
+```rust
+use codingest::build_code_tree;
+
+let graph = build_code_tree(
+    dir,
+    false, // verbose
+    true,  // include tests
+    None,  // save path
+    None,  // max lines per file
+    false, // include docs
+)?;
+```
+
+## How it fits together
+
+codingest owns code-graph construction, the Python/CLI interfaces, the
+builder-backed MCP executable, and the code-review Agent Skill. KGLite provides
+the graph engine, Cypher, persistence, and reusable query/read tools. Keeping
+that boundary explicit lets codingest focus on accurate code understanding
+while reusing a dedicated graph engine.
+
+Documentation: **[codingest.readthedocs.io](https://codingest.readthedocs.io)**
+
+## Workspace layout
+
+| Crate | What it is |
+|---|---|
+| `crates/codingest` | The component library (`codingest`): builder, parsers, manifest reader, docs pass, multi-rev merge, cross-language edges. Extracted from the former `KGLite/crates/kglite/src/code_tree/` (removed upstream 2026-07-16) and re-targeted at the public `kglite::api` facade. Ships the `codingest_stats` + `codingest_bench` binaries. |
+| `crates/codingest-cli` | `codingest` binary — `build` a checkout or git revision(s) into a `.kgl` graph, `status` to check staleness, and `skill` to install Codingest's code-review Agent Skill. |
+| `crates/codingest-mcp` | `codingest-mcp` binary — the full MCP tool surface imported from the `kglite-mcp-server` library, with the codingest builder injected and codingest's `code_review` skill + recipe catalogue registered as the producer's methodology. |
+| `crates/codingest-py` | PyO3 wrapper built by maturin into the `codingest` wheel (`pip install codingest`). Python package source is `codingest/`; `pyproject.toml` drives the maturin build. Not published to crates.io (`publish = false`). |
+
+## CI-equivalent local gate
+
+```bash
+cargo build --workspace
+cargo clippy --workspace --all-targets -- -D warnings
+cargo test --workspace
+cargo test --workspace --test parity
+```
+
+### The golden-digest oracle (also the determinism gate)
+
+KGLite deleted its in-tree `code_tree` builder on 2026-07-16, so the old
+two-builder parity sweep is gone. The authority it enforced was **frozen** while
+the builders were still verified identical, into per-corpus SHA-256 digests
+under `crates/codingest/tests/goldens/` (committed fixtures — no network). The
+`golden_parity` test builds each corpus **three times** with only the codingest
+builder, digests a canonical exhaustive graph rendering, and requires every
+build to match every other build *and* the frozen golden. Repeating the build is
+what makes this the determinism gate: hash iteration order is randomized per
+`HashMap`, so an order-dependent builder fails it (the
+`tests/corpus/dup_minified_assets` fixture reproduces the original DEFINES-edge
+nondeterminism bug). Disagreement between builds is reported as NONDETERMINISM;
+agreement between builds but not with the golden is reported as a behaviour
+change. The multi-rev fixture is guarded instead by `rev_self_consistency`.
+Regenerate goldens only for deliberate builder-behavior changes:
+`cargo test --workspace --test parity -- --ignored capture_goldens` (details in
+`crates/codingest/tests/goldens/README.md`).
+
+Everything the gate needs is committed to this repository, so it is hermetic and
+runs in CI. It replaced a local-only `make` step that asserted an exact edge
+count against a *sibling* checkout — a verdict this project did not control.
+`make determinism-soak REPO=…` keeps the large-repo reproducer available as a
+diagnostic.
+
+## Dependency policy
+
+`kglite` and `kglite-mcp-server` use matching crates.io requirements with a
+0.21.4 minimum and a shared lockfile. This keeps the builder, persistence
+handoff, and embedded MCP server on one compatible engine patch line.
+
+## Parity with the (now-removed) in-tree component
+
+codingest was extracted to be feature- and performance-identical to kglite's
+in-tree `code_tree`. KGLite removed that module on 2026-07-16, so parity is now
+enforced against a **frozen record** of its last-known-good output rather than
+live cross-comparison. See `PARITY.md` (stats-diff + timing), `BENCHMARKS.md`
+(build-time + Cypher benchmarks), `crates/codingest/tests/parity.rs` (the golden
+oracle), and `docs/mcp-parity.md` (the MCP↔builder coupling and the hook).
+
+`tests/python-legacy/` preserves KGLite's full 47-file `kglite.code_tree`
+behavioral suite verbatim as the dormant behavioral spec — the source of truth
+for what the Python builder guaranteed (see its README).
+
+## License
+
+MIT © Kristian dF Kollsgård. codingest is an independent project; it depends on
+`kglite` at runtime but is not otherwise affiliated with it.
+

codingest-0.2.34.dist-info/RECORD

@@ -0,0 +1,11 @@
+codingest/__init__.py,sha256=ZWRR1wNYROPOD6Wlyne23irAB20SsapFUY5eJB3Lc9U,1649
+codingest/__init__.pyi,sha256=sr2tovS7XJIKnj03AmFFPK9_vUCdCCtUlLufOImi8lg,6505
+codingest/cli.py,sha256=bACzbAfoRCtUJtp-3Txxdhf8zlee5EKt-2Z3sk0PXLY,982
+codingest/codingest.pyd,sha256=C3SIeRXr1gX1yLnTX8KFZGXdwW0x7gQFRmgcSas4PZY,66061824
+codingest/mcp_server.py,sha256=Lp72lAEvLj87f5BcxyNRn9JmALNw-qLr-jO2vNgG8Y8,1259
+codingest-0.2.34.dist-info/METADATA,sha256=CVVnCxcrNKqxYsH9C3XbPz9-mT88F1L95tyQCDnpHEw,12701
+codingest-0.2.34.dist-info/WHEEL,sha256=rjikdQI6uHLAgYXPVkr7bTnnX2G_U4MjYuRag5dSWZs,96
+codingest-0.2.34.dist-info/entry_points.txt,sha256=GhjPNm4tJElg6cuggI4OoHJLx48nV9EP8PYZF5QqIcs,87
+codingest-0.2.34.dist-info/licenses/LICENSE,sha256=q0gXpC0K7UDWntzOORLPFJ1qRsJneOljj9IE_TBHX0I,1100
+codingest-0.2.34.dist-info/sboms/codingest-py.cyclonedx.json,sha256=RtnTdwNHV4iC1APVVpqyLLBPy2oCS97aQ2KOgjBB1K0,376938
+codingest-0.2.34.dist-info/RECORD,,

codingest-0.2.34.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.15.0)
+Root-Is-Purelib: false
+Tag: cp312-abi3-win_amd64

codingest-0.2.34.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+codingest=codingest.cli:main
+codingest-mcp=codingest.mcp_server:main

codingest-0.2.34.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kristian dF Kollsgård
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.