codeforerunner 0.3.0__py3-none-any.whl

codeforerunner/mcp_server.py

@@ -0,0 +1,177 @@
+"""Minimal stdio MCP server exposing prompt bundles as tools. See SPEC.md §D.mcp.
+
+Hand-rolled JSON-RPC 2.0 over line-delimited stdio. Stdlib only.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, Iterable
+
+PROTOCOL_VERSION = "2024-11-05"
+SERVER_NAME = "codeforerunner"
+SERVER_VERSION = "0.2.0"
+
+
+def _repo_root(start: Path | None = None) -> Path:
+    here = (start or Path.cwd()).resolve()
+    for candidate in [here, *here.parents]:
+        if (candidate / "prompts" / "tasks").is_dir():
+            return candidate
+    raise FileNotFoundError(
+        "could not locate codeforerunner repo root (no prompts/tasks/ found upward)"
+    )
+
+
+def _read(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def resolve_bundle(repo: Path, task: str) -> str:
+    """Concatenate system/base.md + sorted partials/*.md + tasks/<task>.md with marker comments."""
+    task_path = repo / "prompts" / "tasks" / f"{task}.md"
+    if not task_path.is_file():
+        raise FileNotFoundError(f"unknown task '{task}' (no {task_path})")
+
+    parts: list[str] = []
+    base = repo / "prompts" / "system" / "base.md"
+    if base.is_file():
+        parts.append(f"<!-- system: base.md -->\n{_read(base).rstrip()}")
+
+    partials_dir = repo / "prompts" / "partials"
+    if partials_dir.is_dir():
+        for p in sorted(partials_dir.glob("*.md")):
+            parts.append(f"<!-- partial: {p.name} -->\n{_read(p).rstrip()}")
+
+    parts.append(f"<!-- task: {task_path.name} -->\n{_read(task_path).rstrip()}")
+    return "\n\n".join(parts) + "\n"
+
+
+def _list_tasks(repo: Path) -> list[Path]:
+    tasks_dir = repo / "prompts" / "tasks"
+    if not tasks_dir.is_dir():
+        return []
+    return sorted(tasks_dir.glob("*.md"))
+
+
+def _description_for(task_path: Path) -> str:
+    """First non-empty markdown line, stripped of leading '#' chars and whitespace."""
+    for raw in task_path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line:
+            continue
+        return line.lstrip("#").strip()
+    return task_path.stem
+
+
+def _tools(repo: Path) -> list[dict[str, Any]]:
+    return [
+        {
+            "name": p.stem,
+            "description": _description_for(p),
+            "inputSchema": {"type": "object", "properties": {}, "required": []},
+        }
+        for p in _list_tasks(repo)
+    ]
+
+
+def _ok(req_id: Any, result: Any) -> dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": req_id, "result": result}
+
+
+def _err(req_id: Any, code: int, message: str) -> dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": req_id, "error": {"code": code, "message": message}}
+
+
+SCAN_EXEMPT_TOOLS = frozenset({"init-agent-onboarding", "scan"})
+
+
+def _handle(repo: Path, msg: dict[str, Any], state: dict[str, Any]) -> dict[str, Any] | None:
+    method = msg.get("method")
+    req_id = msg.get("id")
+    params = msg.get("params") or {}
+
+    # Notifications: no id, no response.
+    if method == "notifications/initialized":
+        return None
+    if req_id is None and isinstance(method, str) and method.startswith("notifications/"):
+        return None
+
+    if method == "initialize":
+        return _ok(
+            req_id,
+            {
+                "protocolVersion": PROTOCOL_VERSION,
+                "capabilities": {"tools": {}},
+                "serverInfo": {"name": SERVER_NAME, "version": SERVER_VERSION},
+            },
+        )
+
+    if method == "tools/list":
+        return _ok(req_id, {"tools": _tools(repo)})
+
+    if method == "tools/call":
+        name = params.get("name")
+        task_path = repo / "prompts" / "tasks" / f"{name}.md"
+        if not isinstance(name, str) or not task_path.is_file():
+            return _err(req_id, -32602, f"unknown tool: {name!r}")
+        if name not in SCAN_EXEMPT_TOOLS and not state.get("scan_called"):
+            return _err(
+                req_id,
+                -32000,
+                "scan-first required: call tools/call name=scan before this task (SPEC V2)",
+            )
+        if name == "scan":
+            state["scan_called"] = True
+        try:
+            text = resolve_bundle(repo, name)
+        except Exception as e:  # pragma: no cover - defensive
+            return _err(req_id, -32603, f"internal error: {e}")
+        return _ok(
+            req_id,
+            {"content": [{"type": "text", "text": text}], "isError": False},
+        )
+
+    return _err(req_id, -32601, f"method not found: {method!r}")
+
+
+def serve(repo: Path, stdin: Iterable[str] = sys.stdin, stdout=sys.stdout, stderr=sys.stderr) -> int:
+    state: dict[str, Any] = {"scan_called": False}
+    for raw in stdin:
+        line = raw.strip()
+        if not line:
+            continue
+        try:
+            msg = json.loads(line)
+        except json.JSONDecodeError as e:
+            print(f"mcp_server: invalid JSON: {e}", file=stderr)
+            resp = {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "parse error"}}
+            stdout.write(json.dumps(resp) + "\n")
+            stdout.flush()
+            continue
+
+        try:
+            resp = _handle(repo, msg, state)
+        except Exception as e:  # pragma: no cover - defensive
+            print(f"mcp_server: handler error: {e}", file=stderr)
+            resp = _err(msg.get("id"), -32603, f"internal error: {e}")
+
+        if resp is not None:
+            stdout.write(json.dumps(resp) + "\n")
+            stdout.flush()
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    try:
+        repo = _repo_root()
+    except FileNotFoundError as e:
+        print(f"mcp_server: {e}", file=sys.stderr)
+        return 2
+    return serve(repo)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codeforerunner/providers/__init__.py

@@ -0,0 +1,36 @@
+"""Provider registry. See SPEC.md §T38."""
+
+from __future__ import annotations
+
+from codeforerunner.providers.anthropic import AnthropicProvider
+from codeforerunner.providers.base import CompletionResult, Provider, ProviderError
+from codeforerunner.providers.google import GoogleProvider
+from codeforerunner.providers.ollama import OllamaProvider
+from codeforerunner.providers.openai import OpenAIProvider
+
+__all__ = [
+    "AnthropicProvider",
+    "CompletionResult",
+    "GoogleProvider",
+    "OllamaProvider",
+    "OpenAIProvider",
+    "Provider",
+    "ProviderError",
+    "REGISTRY",
+    "get",
+]
+
+REGISTRY: dict[str, type] = {
+    "anthropic": AnthropicProvider,
+    "openai": OpenAIProvider,
+    "google": GoogleProvider,
+    "ollama": OllamaProvider,
+}
+
+
+def get(name: str) -> type:
+    if name not in REGISTRY:
+        raise ProviderError(
+            f"unknown provider '{name}' (expected one of {sorted(REGISTRY)})"
+        )
+    return REGISTRY[name]

codeforerunner/providers/anthropic.py

@@ -0,0 +1,61 @@
+"""Anthropic Messages API provider. Stdlib HTTP only."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+
+from codeforerunner.providers.base import CompletionResult, ProviderError
+
+
+class AnthropicProvider:
+    name = "anthropic"
+    default_env_var = "ANTHROPIC_API_KEY"
+    default_model = "claude-opus-4-5"
+
+    endpoint = "https://api.anthropic.com/v1/messages"
+
+    def complete(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> CompletionResult:
+        if not api_key:
+            raise ProviderError(f"missing API key (set ${self.default_env_var})")
+        model = model or self.default_model
+        body = json.dumps(
+            {
+                "model": model,
+                "max_tokens": 4096,
+                "messages": [{"role": "user", "content": prompt}],
+            }
+        ).encode("utf-8")
+        req = urllib.request.Request(
+            self.endpoint,
+            data=body,
+            method="POST",
+            headers={
+                "x-api-key": api_key,
+                "anthropic-version": "2023-06-01",
+                "content-type": "application/json",
+            },
+        )
+        try:
+            with urllib.request.urlopen(req) as resp:
+                raw = resp.read()
+        except urllib.error.HTTPError as e:
+            snippet = (e.read() or b"")[:500].decode("utf-8", errors="replace")
+            raise ProviderError(f"HTTP {e.code}: {snippet}") from e
+        except urllib.error.URLError as e:
+            raise ProviderError(f"network error: {e.reason}") from e
+        try:
+            data = json.loads(raw.decode("utf-8"))
+            text = data["content"][0]["text"]
+        except (json.JSONDecodeError, KeyError, IndexError, TypeError) as e:
+            raise ProviderError(f"malformed response: {e}") from e
+        return CompletionResult(
+            text=text, model=data.get("model", model), usage=data.get("usage")
+        )

codeforerunner/providers/base.py

@@ -0,0 +1,31 @@
+"""Provider protocol + shared types. See SPEC.md §T38."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass(frozen=True)
+class CompletionResult:
+    text: str
+    model: str
+    usage: dict | None = None  # provider-reported token counts; None if unknown
+
+
+class Provider(Protocol):
+    name: str
+    default_env_var: str  # e.g. "ANTHROPIC_API_KEY"
+    default_model: str  # provider's recommended default
+
+    def complete(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> CompletionResult: ...
+
+
+class ProviderError(Exception):
+    """Raised on provider HTTP failures, missing keys, or malformed responses."""

codeforerunner/providers/google.py

@@ -0,0 +1,62 @@
+"""Google Gemini generateContent provider. Stdlib HTTP only."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from codeforerunner.providers.base import CompletionResult, ProviderError
+
+
+class GoogleProvider:
+    name = "google"
+    default_env_var = "GOOGLE_API_KEY"
+    default_model = "gemini-2.5-pro"
+
+    endpoint_template = (
+        "https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key}"
+    )
+
+    def complete(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> CompletionResult:
+        if not api_key:
+            raise ProviderError(f"missing API key (set ${self.default_env_var})")
+        model = model or self.default_model
+        url = self.endpoint_template.format(
+            model=urllib.parse.quote(model, safe=""),
+            key=urllib.parse.quote(api_key, safe=""),
+        )
+        body = json.dumps(
+            {"contents": [{"parts": [{"text": prompt}]}]}
+        ).encode("utf-8")
+        req = urllib.request.Request(
+            url,
+            data=body,
+            method="POST",
+            headers={"content-type": "application/json"},
+        )
+        try:
+            with urllib.request.urlopen(req) as resp:
+                raw = resp.read()
+        except urllib.error.HTTPError as e:
+            snippet = (e.read() or b"")[:500].decode("utf-8", errors="replace")
+            raise ProviderError(f"HTTP {e.code}: {snippet}") from e
+        except urllib.error.URLError as e:
+            raise ProviderError(f"network error: {e.reason}") from e
+        try:
+            data = json.loads(raw.decode("utf-8"))
+            text = data["candidates"][0]["content"]["parts"][0]["text"]
+        except (json.JSONDecodeError, KeyError, IndexError, TypeError) as e:
+            raise ProviderError(f"malformed response: {e}") from e
+        return CompletionResult(
+            text=text,
+            model=data.get("modelVersion", model),
+            usage=data.get("usageMetadata"),
+        )

codeforerunner/providers/ollama.py

@@ -0,0 +1,56 @@
+"""Ollama local provider. Stdlib HTTP only."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+from codeforerunner.providers.base import CompletionResult, ProviderError
+
+DEFAULT_HOST = "http://localhost:11434"
+
+
+class OllamaProvider:
+    name = "ollama"
+    default_env_var = "OLLAMA_HOST"
+    default_model = "llama3"
+
+    def complete(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> CompletionResult:
+        # api_key is interpreted as a base URL override; fall back to env then default.
+        base = api_key or os.environ.get(self.default_env_var) or DEFAULT_HOST
+        base = base.rstrip("/")
+        model = model or self.default_model
+        url = f"{base}/api/generate"
+        body = json.dumps(
+            {"model": model, "prompt": prompt, "stream": False}
+        ).encode("utf-8")
+        req = urllib.request.Request(
+            url,
+            data=body,
+            method="POST",
+            headers={"content-type": "application/json"},
+        )
+        try:
+            with urllib.request.urlopen(req) as resp:
+                raw = resp.read()
+        except urllib.error.HTTPError as e:
+            snippet = (e.read() or b"")[:500].decode("utf-8", errors="replace")
+            raise ProviderError(f"HTTP {e.code}: {snippet}") from e
+        except urllib.error.URLError as e:
+            raise ProviderError(f"network error: {e.reason}") from e
+        try:
+            data = json.loads(raw.decode("utf-8"))
+            text = data["response"]
+        except (json.JSONDecodeError, KeyError, TypeError) as e:
+            raise ProviderError(f"malformed response: {e}") from e
+        usage_keys = ("prompt_eval_count", "eval_count", "total_duration")
+        usage = {k: data[k] for k in usage_keys if k in data} or None
+        return CompletionResult(text=text, model=data.get("model", model), usage=usage)

codeforerunner/providers/openai.py

@@ -0,0 +1,59 @@
+"""OpenAI chat completions provider. Stdlib HTTP only."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+
+from codeforerunner.providers.base import CompletionResult, ProviderError
+
+
+class OpenAIProvider:
+    name = "openai"
+    default_env_var = "OPENAI_API_KEY"
+    default_model = "gpt-4o"
+
+    endpoint = "https://api.openai.com/v1/chat/completions"
+
+    def complete(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> CompletionResult:
+        if not api_key:
+            raise ProviderError(f"missing API key (set ${self.default_env_var})")
+        model = model or self.default_model
+        body = json.dumps(
+            {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+            }
+        ).encode("utf-8")
+        req = urllib.request.Request(
+            self.endpoint,
+            data=body,
+            method="POST",
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "content-type": "application/json",
+            },
+        )
+        try:
+            with urllib.request.urlopen(req) as resp:
+                raw = resp.read()
+        except urllib.error.HTTPError as e:
+            snippet = (e.read() or b"")[:500].decode("utf-8", errors="replace")
+            raise ProviderError(f"HTTP {e.code}: {snippet}") from e
+        except urllib.error.URLError as e:
+            raise ProviderError(f"network error: {e.reason}") from e
+        try:
+            data = json.loads(raw.decode("utf-8"))
+            text = data["choices"][0]["message"]["content"]
+        except (json.JSONDecodeError, KeyError, IndexError, TypeError) as e:
+            raise ProviderError(f"malformed response: {e}") from e
+        return CompletionResult(
+            text=text, model=data.get("model", model), usage=data.get("usage")
+        )

codeforerunner-0.3.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: codeforerunner
+Version: 0.3.0
+Summary: Model-agnostic repository documentation tooling (prompt-first; thin CLI).
+Author: Derek Palmer
+License-Expression: LicenseRef-Codeforerunner-SAL-0.1
+Project-URL: Repository, https://github.com/derek-palmer/codeforerunner
+Project-URL: Issues, https://github.com/derek-palmer/codeforerunner/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: PyYAML>=6.0
+Dynamic: license-file
+
+![codeForerunner — your codebase gets a Forerunner; your docs finally see the light](images/readme_banner.png)
+
+# codeForerunner
+
+CodeForerunner is a model-agnostic documentation agent that acts as overwatch for your repository, automatically analyzing code and maintaining docs, diagrams, and architecture knowledge as your codebase evolves over time.
+
+The current repo is the prompt-first foundation for that agent: it ships prompt assets for understanding a codebase and generating developer docs. A thin Python CLI (including `forerunner mcp-server` and a scoped `forerunner init --full / --agents-only`), an idempotent skill installer, pre-commit + CI hooks, and a PyPI publish workflow now wrap those prompts; the first published PyPI release remains pending.
+
+## Current State
+
+- Core product: Markdown prompts in `prompts/`.
+- Agent package artifacts: Codex plugin files under `plugins/codeforerunner/` and Claude Code plugin files under `.claude-plugin/` plus `skills/codeforerunner/`.
+- Python package: `pyproject.toml` + `src/codeforerunner/` expose a `forerunner` console script. `forerunner doc <task>` resolves the prompt bundle (base + partials + task) to stdout; `forerunner install <agent>` idempotently writes the canonical skill into agent-specific directories; `forerunner init` resolves the agent-onboarding bundle (with `--full` to prepend a scan or `--agents-only` for the default scope); `forerunner scan` resolves the scan bundle; `forerunner mcp-server` serves prompt bundles as MCP tools over stdio.
+- Hooks: `.pre-commit-hooks.yaml` exposes a `forerunner-check` hook; `.github/workflows/forerunner-check.yml` mirrors it in CI. Both no-op when `forerunner.config.yaml` is absent.
+- Current config: `forerunner.config.yaml.example` documents the schema now parsed by `src/codeforerunner/config.py`; see "Configuration" below.
+- Not currently present: Docker image, Makefile, published PyPI release.
+
+## Install
+
+After the first PyPI release:
+
+```bash
+pipx install codeforerunner   # recommended; isolated environment
+pip install codeforerunner    # alternative
+```
+
+From source:
+
+```bash
+git clone https://github.com/derek-palmer/codeForerunner
+cd codeForerunner
+python -m pip install -e .
+```
+
+Then `forerunner --help` should print the subcommand list.
+
+## Prompt Layout
+
+```text
+prompts/
+├── system/
+│   └── base.md
+├── partials/
+│   ├── context-format.md
+│   ├── output-rules.md
+│   └── stack-hints.md
+└── tasks/
+    ├── scan.md
+    ├── init-agent-onboarding.md
+    ├── readme.md
+    ├── api-docs.md
+    ├── stack-docs.md
+    ├── diagrams.md
+    ├── flows.md
+    ├── version-audit.md
+    ├── check.md
+    └── review.md
+```
+
+## Quick Start
+
+1. Open `prompts/system/base.md` and use it as the agent system or project instruction.
+2. Assemble repo context using the shape in `prompts/partials/context-format.md`.
+3. For documentation generation, run `prompts/tasks/scan.md` first.
+4. For agent onboarding only, run `prompts/tasks/init-agent-onboarding.md` directly.
+5. Pass the scan result into one downstream documentation prompt, such as `prompts/tasks/readme.md` or `prompts/tasks/stack-docs.md`.
+6. Apply generated docs only after checking that every claim is grounded in provided files.
+
+## What The Prompts Do
+
+| Prompt | Purpose |
+| --- | --- |
+| `prompts/system/base.md` | Defines the codeforerunner role, quality bar, Markdown rules, and accuracy constraints. |
+| `prompts/tasks/scan.md` | Produces the first structured repo scan used by downstream tasks. |
+| `prompts/tasks/init-agent-onboarding.md` | Generates or updates `AGENTS.md` from repo evidence plus files such as `CLAUDE.md`, `.cursor/rules/*`, `.cursorrules`, `.github/copilot-instructions.md`, and `opencode.json`. |
+| `prompts/tasks/readme.md` | Generates or rewrites a top-level README from scan output and selected files. |
+| `prompts/tasks/api-docs.md` | Documents public APIs when endpoints/interfaces are evident. |
+| `prompts/tasks/stack-docs.md` | Documents stack-specific areas of a repo. |
+| `prompts/tasks/diagrams.md` | Generates Mermaid architecture or flow diagrams. |
+| `prompts/tasks/flows.md` | Documents user, request, job, or data flows. |
+| `prompts/tasks/version-audit.md` | Audits pinned versions from manifests, lockfiles, Dockerfiles, workflows, or IaC. |
+| `prompts/tasks/check.md` | Checks existing docs for staleness against a fresh scan. |
+| `prompts/tasks/review.md` | Summarizes documentation impact for review. |
+
+## Docs And Spec
+
+- `SPEC.md` tracks phases, invariants, and tasks so future PRs can make small status updates instead of broad rewrites.
+- `docs/getting-started.md` explains manual prompt use.
+- `docs/prompt-guide.md` explains how system, partial, and task prompts compose.
+- `docs/editor-agent-setup.md` explains how to adapt prompts to local agents.
+- `docs/roadmap.md` mirrors the `SPEC.md` phase status in human-readable form.
+- `docs/agent-distribution-design.md` records the design that backs the Codex/Claude packages and `forerunner install`.
+
+## Configuration
+
+`forerunner.config.yaml.example` documents the loaded schema. Copy it to `forerunner.config.yaml` to opt in; without that file, `forerunner check` is a silent no-op. The schema has top-level provider/model fields (`provider`, `model`, `api_key_env`, `output_dir`, `context_max_files`, `context_max_lines_per_file`, `approaching_eol_threshold_months`), `ignore_patterns`, `tasks.version_audit`, and `tasks.check`. `forerunner check` honors `tasks.check.enabled_rules` (allowlist of rule IDs, default all) and `tasks.check.ignore_paths` (fnmatch globs applied to scanned docs). Invalid YAML, unknown providers, unknown `api_key_env` providers, or unknown severities surface as a `ConfigError` and exit non-zero.
+
+### MCP Server
+
+`forerunner mcp-server` speaks JSON-RPC 2.0 over stdio and exposes one tool per `prompts/tasks/*.md` (tool name = filename stem). Each `tools/call` returns the resolved `base + partials + task` bundle as text. A scan-first gate enforces SPEC V2: any tool other than `scan` or `init-agent-onboarding` returns an error until `scan` has been called in the same session. Point any MCP-compatible client at `forerunner mcp-server` as a stdio server (running from the target repo so `prompts/tasks/` resolves).
+
+See `examples/mcp/` for Claude Desktop and mcp-cli wiring examples.
+
+## Roadmap
+
+See `SPEC.md` for the canonical phase/task tracker and `docs/roadmap.md` for the human-readable roadmap.

codeforerunner-0.3.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+codeforerunner/__init__.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+codeforerunner/check.py,sha256=kSrVoTVb9ALEBHvUerR2nZfroXco_yz6gMgXzdz45Ac,4905
+codeforerunner/cli.py,sha256=anRbSooRqb5cS4EtgGJHVIOTK1ZgdACWb4WcD5Y0hqM,8478
+codeforerunner/config.py,sha256=REs4FgmSSn7R2tLIwLJPL8VmSCGkTvw8J2SqBOggzho,6206
+codeforerunner/doctor.py,sha256=AFHY8YbqTp726JcxLAYvrdeOLwr6WLPiNUUF2QYOwL8,10076
+codeforerunner/installer.py,sha256=WJkWbZjP7x_CWQDs3cfx8zBr97riMgzmGFRNtruPlgI,10301
+codeforerunner/mcp_server.py,sha256=d8eiBPGTLmf_k78tbH1hCfdyokXQajAgcM40loVXNHI,5737
+codeforerunner/providers/__init__.py,sha256=ttMAbHWJIO8s-8H6Kb_EWf3LN5oMzlmX1D12RyGSmIg,962
+codeforerunner/providers/anthropic.py,sha256=zaJDyzH1vPr7nSqUOv6avlTk3covpkWXLHae2-bS9io,2021
+codeforerunner/providers/base.py,sha256=Jk9vBeRNxH9naUC6stN5jY1KHmhrqg2k2kMGOhbQTYk,752
+codeforerunner/providers/google.py,sha256=wBpbte8hdX_Jnr_JBHvQarogT6T1hWR4aGF5O2exBCU,2109
+codeforerunner/providers/ollama.py,sha256=bKhigdjHs3aw73iB5uQka9_n-XCjv1sh_zZfe1TrWTQ,1975
+codeforerunner/providers/openai.py,sha256=OHWeZ11OuHPgQBMwqJnJWxNHyGIP5KL7B06w2ttgxlY,1952
+codeforerunner-0.3.0.dist-info/licenses/LICENSE.md,sha256=iIhmJHib6GbdjcwiDMM-npiNRf3XgASom1WsOJivEdc,2915
+codeforerunner-0.3.0.dist-info/METADATA,sha256=MsbTrzGM5GeGz_JtKhSONLHtwxbGwIz7A_EyK3vSd_c,7047
+codeforerunner-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codeforerunner-0.3.0.dist-info/entry_points.txt,sha256=3p8BbPlq-wfcXk42tsweKePRaGlZ1WXho1gOkuZGyIQ,55
+codeforerunner-0.3.0.dist-info/top_level.txt,sha256=pV1rt0-NIpNEotKXpL_sF2060DHr-_0F86LWhUlvXis,15
+codeforerunner-0.3.0.dist-info/RECORD,,

codeforerunner-0.3.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
+

codeforerunner-0.3.0.dist-info/entry_points.txt

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