codeforerunner 0.3.1__tar.gz → 0.3.2__tar.gz

{codeforerunner-0.3.1/src/codeforerunner.egg-info → codeforerunner-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeforerunner
-Version: 0.3.1
+Version: 0.3.2
 Summary: Model-agnostic repository documentation tooling (prompt-first; thin CLI).
 Author: Derek Palmer
 License-Expression: LicenseRef-Codeforerunner-SAL-0.1

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codeforerunner"
-version = "0.3.1"
+version = "0.3.2"
 description = "Model-agnostic repository documentation tooling (prompt-first; thin CLI)."
 readme = "README.md"
 requires-python = ">=3.11"

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/src/codeforerunner/check.py

@@ -1,9 +1,9 @@
-"""Drift detection for docs that claim files don't exist when they do."""
+"""Drift detection for docs vs repo state."""
 from __future__ import annotations
 
 import fnmatch
 import re
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 from codeforerunner.config import CheckConfig
@@ -17,8 +17,18 @@ class Violation:
     message: str
 
 
-_RULES = [
-    (
+@dataclass(frozen=True)
+class _Rule:
+    id: str
+    pattern: re.Pattern
+    triggers: tuple[str, ...]
+    message: str
+    invert: bool = False  # True = fire when triggers ABSENT (doc claims feature exists but file gone)
+
+
+_RULES: list[_Rule] = [
+    # Normal rules: fire when trigger EXISTS and phrase matches (doc denies a thing that's present)
+    _Rule(
         "R1-no-cli",
         re.compile(
             r"(?i)no\s+CLI\s+exists"
@@ -29,56 +39,87 @@ _RULES = [
         ("src/codeforerunner/cli.py",),
         "doc claims no CLI exists, but src/codeforerunner/cli.py is present",
     ),
-    (
+    _Rule(
         "R2-no-pre-commit",
         re.compile(r"(?i)no\s+pre[- ]commit(\s+hook)?"),
         (".pre-commit-hooks.yaml",),
         "doc claims no pre-commit hook, but .pre-commit-hooks.yaml is present",
     ),
-    (
+    _Rule(
         "R3-no-ci",
         re.compile(r"(?i)no\s+CI(\s+workflow)?"),
         (".github/workflows/*.yml",),
         "doc claims no CI workflow, but .github/workflows/*.yml is present",
     ),
-    (
+    _Rule(
         "R4-no-installer",
         re.compile(r"(?i)no\s+installer"),
         ("src/codeforerunner/installer.py",),
         "doc claims no installer, but src/codeforerunner/installer.py is present",
     ),
-    (
+    _Rule(
         "R5-no-python-package",
         re.compile(r"(?i)no\s+Python\s+package"),
         ("pyproject.toml",),
         "doc claims no Python package, but pyproject.toml is present",
     ),
-    (
+    _Rule(
         "R6-no-docker",
         re.compile(r"(?i)no\s+Docker(\s+image)?|no\s+Dockerfile"),
         ("Dockerfile", "compose.yml", "docker-compose.yml"),
         "doc claims no Docker, but Dockerfile/compose file is present",
     ),
-    (
+    _Rule(
         "R6b-no-makefile",
         re.compile(r"(?i)no\s+Makefile"),
         ("Makefile",),
         "doc claims no Makefile, but Makefile is present",
     ),
-    (
+    _Rule(
         "R7-no-mcp",
         re.compile(r"(?i)no\s+MCP(\s+server)?"),
         ("src/codeforerunner/mcp_server.py",),
         "doc claims no MCP server, but src/codeforerunner/mcp_server.py is present",
     ),
-    (
+    _Rule(
         "R8-no-marketplace",
         re.compile(r"(?i)no\s+marketplace(\s+manifest)?"),
         ("plugins/codex/marketplace.json",),
         "doc claims no marketplace, but plugins/codex/marketplace.json is present",
     ),
+    # Inverse rules: fire when trigger ABSENT and phrase matches (doc claims thing exists but file gone)
+    _Rule(
+        "RI1-missing-cli",
+        re.compile(
+            r"(?i)\bforerunner\s+(?:init|scan|doc|check|generate|doctor)\b"
+        ),
+        ("src/codeforerunner/cli.py",),
+        "doc references forerunner CLI commands, but src/codeforerunner/cli.py is absent",
+        invert=True,
+    ),
+    _Rule(
+        "RI5-missing-python-package",
+        re.compile(r"(?i)\bpipx?\s+install\s+codeforerunner\b"),
+        ("pyproject.toml",),
+        "doc claims package is installable via pip/pipx, but pyproject.toml is absent",
+        invert=True,
+    ),
+    _Rule(
+        "RI7-missing-mcp",
+        re.compile(r"(?i)\bforerunner\s+mcp-server\b"),
+        ("src/codeforerunner/mcp_server.py",),
+        "doc references forerunner mcp-server, but src/codeforerunner/mcp_server.py is absent",
+        invert=True,
+    ),
 ]
 
+_VERSION_PIN_RE = re.compile(
+    r"(?:codeforerunner==|codeforerunner@v)"
+    r"(\d+\.\d+\.\d+)"
+)
+_PYPROJECT_VERSION_RE = re.compile(r'^version\s*=\s*"(\d+\.\d+\.\d+)"', re.MULTILINE)
+_CHANGELOG_FILENAME = "CHANGELOG.md"
+
 
 def _trigger_exists(repo: Path, patterns: tuple[str, ...]) -> bool:
     for pat in patterns:
@@ -114,6 +155,54 @@ def _path_ignored(repo: Path, doc: Path, ignore_patterns: tuple[str, ...]) -> bo
     return any(fnmatch.fnmatch(rel, pat) for pat in ignore_patterns)
 
 
+def _current_version(repo: Path) -> str | None:
+    pyproject = repo / "pyproject.toml"
+    if not pyproject.is_file():
+        return None
+    try:
+        text = pyproject.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    m = _PYPROJECT_VERSION_RE.search(text)
+    return m.group(1) if m else None
+
+
+def _check_version_drift(
+    repo: Path,
+    docs: list[Path],
+    ignore_patterns: tuple[str, ...],
+    enabled: set[str] | None,
+) -> list[Violation]:
+    if enabled is not None and "RV1-version-drift" not in enabled:
+        return []
+    current = _current_version(repo)
+    if current is None:
+        return []
+    violations: list[Violation] = []
+    for doc in docs:
+        if doc.name == _CHANGELOG_FILENAME:
+            continue
+        if _path_ignored(repo, doc, ignore_patterns):
+            continue
+        try:
+            text = doc.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        for lineno, line in enumerate(text.splitlines(), start=1):
+            for m in _VERSION_PIN_RE.finditer(line):
+                pinned = m.group(1)
+                if pinned != current:
+                    violations.append(
+                        Violation(
+                            path=doc,
+                            line=lineno,
+                            rule_id="RV1-version-drift",
+                            message=f"version pin {pinned!r} does not match current {current!r}",
+                        )
+                    )
+    return violations
+
+
 def run(repo: Path, config: CheckConfig | None = None) -> list[Violation]:
     """Scan repo docs for drift; return list of violations.
 
@@ -124,16 +213,18 @@ def run(repo: Path, config: CheckConfig | None = None) -> list[Violation]:
     enabled = set(config.enabled_rules) if (config and config.enabled_rules is not None) else None
     ignore_patterns = config.ignore_paths if config else ()
 
-    active_rules = [
-        (rid, rx, msg)
-        for rid, rx, triggers, msg in _RULES
-        if _trigger_exists(repo, triggers) and (enabled is None or rid in enabled)
-    ]
-    if not active_rules:
-        return []
+    docs = _scanned_docs(repo)
+
+    active_rules: list[_Rule] = []
+    for rule in _RULES:
+        if enabled is not None and rule.id not in enabled:
+            continue
+        trigger_found = _trigger_exists(repo, rule.triggers)
+        if (not rule.invert and trigger_found) or (rule.invert and not trigger_found):
+            active_rules.append(rule)
 
     violations: list[Violation] = []
-    for doc in _scanned_docs(repo):
+    for doc in docs:
         if _path_ignored(repo, doc, ignore_patterns):
             continue
         try:
@@ -141,11 +232,13 @@ def run(repo: Path, config: CheckConfig | None = None) -> list[Violation]:
         except (OSError, UnicodeDecodeError):
             continue
         for lineno, line in enumerate(text.splitlines(), start=1):
-            for rid, rx, msg in active_rules:
-                if rx.search(line):
+            for rule in active_rules:
+                if rule.pattern.search(line):
                     violations.append(
-                        Violation(path=doc, line=lineno, rule_id=rid, message=msg)
+                        Violation(path=doc, line=lineno, rule_id=rule.id, message=rule.message)
                     )
+
+    violations.extend(_check_version_drift(repo, docs, ignore_patterns, enabled))
     return violations
 
 

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/src/codeforerunner/cli.py

@@ -135,6 +135,17 @@ def cmd_generate(args: argparse.Namespace) -> int:
         print(f"error: missing API key; set ${env_var}", file=sys.stderr)
         return 3
 
+    if getattr(args, "stream", False):
+        try:
+            for chunk in provider.stream(prompt=buf.getvalue(), model=model, api_key=api_key):
+                sys.stdout.write(chunk)
+                sys.stdout.flush()
+        except _providers.ProviderError as e:
+            print(f"error: {provider_name} provider failed: {e}", file=sys.stderr)
+            return 4
+        sys.stdout.write("\n")
+        return 0
+
     try:
         result = provider.complete(prompt=buf.getvalue(), model=model, api_key=api_key)
     except _providers.ProviderError as e:
@@ -151,7 +162,15 @@ def cmd_generate(args: argparse.Namespace) -> int:
 
 def cmd_doctor(args: argparse.Namespace) -> int:
     from codeforerunner import doctor
+    from codeforerunner.config import CONFIG_FILENAME
     root = Path(args.repo).resolve() if args.repo else Path.cwd()
+    if getattr(args, "fix", False):
+        cfg_path = root / CONFIG_FILENAME
+        if not cfg_path.is_file():
+            cfg_path.write_text(doctor.starter_config(), encoding="utf-8")
+            print(f"wrote {cfg_path}", file=sys.stderr)
+        else:
+            print(f"{cfg_path} already exists; skipping --fix", file=sys.stderr)
     findings = doctor.run(root)
     sys.stdout.write(doctor.format_report(findings) + "\n")
     return 1 if any(f.severity == "error" for f in findings) else 0
@@ -200,12 +219,18 @@ def build_parser() -> argparse.ArgumentParser:
     s_mcp.set_defaults(func=cmd_mcp_server)
 
     s_doctor = sub.add_parser("doctor", help="health report: skill parity + marketplace + installed dests")
+    s_doctor.add_argument(
+        "--fix",
+        action="store_true",
+        help="write a starter forerunner.config.yaml if absent",
+    )
     s_doctor.set_defaults(func=cmd_doctor)
 
     s_gen = sub.add_parser("generate", help="resolve bundle for <task> and call the configured provider")
     s_gen.add_argument("task", help="task basename under prompts/tasks/")
     s_gen.add_argument("--provider", help="override config provider")
     s_gen.add_argument("--model", help="override config model")
+    s_gen.add_argument("--stream", action="store_true", help="stream output token-by-token")
     s_gen.set_defaults(func=cmd_generate)
 
     from codeforerunner import installer

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/src/codeforerunner/doctor.py

@@ -274,6 +274,26 @@ def _check_provider_api_key(repo: Path) -> list[Finding]:
     ]
 
 
+_STARTER_CONFIG = """\
+# forerunner.config.yaml — generated by `forerunner doctor --fix`
+# See https://github.com/derek-palmer/codeforerunner for docs.
+
+enabled_rules:
+  - R1-no-cli
+  - R2-no-pre-commit
+  - R3-no-ci
+  - R4-no-installer
+  - R5-no-python-package
+  - R7-no-mcp
+  - R8-no-marketplace
+ignore_paths: []
+"""
+
+
+def starter_config() -> str:
+    return _STARTER_CONFIG
+
+
 def run(repo: Path) -> list[Finding]:
     repo = repo.resolve()
     findings: list[Finding] = []

codeforerunner-0.3.2/src/codeforerunner/providers/anthropic.py

@@ -0,0 +1,118 @@
+"""Anthropic Messages API provider. Stdlib HTTP only."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from typing import Iterator
+
+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")
+        )
+
+    def stream(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> Iterator[str]:
+        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,
+                "stream": True,
+                "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:
+            resp = urllib.request.urlopen(req)
+        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:
+            for raw_line in resp:
+                line = raw_line.decode("utf-8").rstrip("\n")
+                if not line.startswith("data: "):
+                    continue
+                payload = line[6:]
+                if payload.strip() == "[DONE]":
+                    break
+                try:
+                    event = json.loads(payload)
+                except json.JSONDecodeError:
+                    continue
+                if event.get("type") == "content_block_delta":
+                    delta = event.get("delta", {})
+                    if delta.get("type") == "text_delta":
+                        text = delta.get("text", "")
+                        if text:
+                            yield text
+        finally:
+            resp.close()

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/src/codeforerunner/providers/base.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Protocol
+from typing import Iterator, Protocol
 
 
 @dataclass(frozen=True)
@@ -26,6 +26,14 @@ class Provider(Protocol):
         api_key: str | None = None,
     ) -> CompletionResult: ...
 
+    def stream(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> Iterator[str]: ...
+
 
 class ProviderError(Exception):
     """Raised on provider HTTP failures, missing keys, or malformed responses."""

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/src/codeforerunner/providers/google.py

@@ -6,6 +6,7 @@ import json
 import urllib.error
 import urllib.parse
 import urllib.request
+from typing import Iterator
 
 from codeforerunner.providers.base import CompletionResult, ProviderError
 
@@ -18,6 +19,10 @@ class GoogleProvider:
     endpoint_template = (
         "https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key}"
     )
+    stream_endpoint_template = (
+        "https://generativelanguage.googleapis.com/v1beta/models/{model}:streamGenerateContent"
+        "?key={key}&alt=sse"
+    )
 
     def complete(
         self,
@@ -60,3 +65,48 @@ class GoogleProvider:
             model=data.get("modelVersion", model),
             usage=data.get("usageMetadata"),
         )
+
+    def stream(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> Iterator[str]:
+        if not api_key:
+            raise ProviderError(f"missing API key (set ${self.default_env_var})")
+        model = model or self.default_model
+        url = self.stream_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:
+            resp = urllib.request.urlopen(req)
+        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:
+            for raw_line in resp:
+                line = raw_line.decode("utf-8").rstrip("\n")
+                if not line.startswith("data: "):
+                    continue
+                try:
+                    event = json.loads(line[6:])
+                    text = event["candidates"][0]["content"]["parts"][0]["text"]
+                    if text:
+                        yield text
+                except (json.JSONDecodeError, KeyError, IndexError, TypeError):
+                    continue
+        finally:
+            resp.close()

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/src/codeforerunner/providers/ollama.py

@@ -6,6 +6,7 @@ import json
 import os
 import urllib.error
 import urllib.request
+from typing import Iterator
 
 from codeforerunner.providers.base import CompletionResult, ProviderError
 
@@ -54,3 +55,47 @@ class OllamaProvider:
         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)
+
+    def stream(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> Iterator[str]:
+        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": True}
+        ).encode("utf-8")
+        req = urllib.request.Request(
+            url,
+            data=body,
+            method="POST",
+            headers={"content-type": "application/json"},
+        )
+        try:
+            resp = urllib.request.urlopen(req)
+        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:
+            for raw_line in resp:
+                line = raw_line.decode("utf-8").strip()
+                if not line:
+                    continue
+                try:
+                    event = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                text = event.get("response", "")
+                if text:
+                    yield text
+                if event.get("done", False):
+                    break
+        finally:
+            resp.close()

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/src/codeforerunner/providers/openai.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import urllib.error
 import urllib.request
+from typing import Iterator
 
 from codeforerunner.providers.base import CompletionResult, ProviderError
 
@@ -57,3 +58,56 @@ class OpenAIProvider:
         return CompletionResult(
             text=text, model=data.get("model", model), usage=data.get("usage")
         )
+
+    def stream(
+        self,
+        *,
+        prompt: str,
+        model: str | None = None,
+        api_key: str | None = None,
+    ) -> Iterator[str]:
+        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,
+                "stream": True,
+                "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:
+            resp = urllib.request.urlopen(req)
+        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:
+            for raw_line in resp:
+                line = raw_line.decode("utf-8").rstrip("\n")
+                if not line.startswith("data: "):
+                    continue
+                payload = line[6:]
+                if payload.strip() == "[DONE]":
+                    break
+                try:
+                    event = json.loads(payload)
+                except json.JSONDecodeError:
+                    continue
+                choices = event.get("choices", [])
+                if choices:
+                    text = choices[0].get("delta", {}).get("content")
+                    if text:
+                        yield text
+        finally:
+            resp.close()

{codeforerunner-0.3.1 → codeforerunner-0.3.2/src/codeforerunner.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeforerunner
-Version: 0.3.1
+Version: 0.3.2
 Summary: Model-agnostic repository documentation tooling (prompt-first; thin CLI).
 Author: Derek Palmer
 License-Expression: LicenseRef-Codeforerunner-SAL-0.1

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/tests/test_check.py

@@ -271,6 +271,120 @@ def test_violation_line_number_correct(tmp_path):
     assert vs[0].line == 3
 
 
+# ── Inverse rules (RI*) ────────────────────────────────────────────────────
+
+
+def test_ri1_fires_when_cli_absent(tmp_path):
+    _seed(tmp_path, {"README.md": "Run `forerunner init` to get started.\n"})
+    vs = run(tmp_path)
+    assert any(v.rule_id == "RI1-missing-cli" for v in vs)
+
+
+def test_ri1_silent_when_cli_present(tmp_path):
+    _seed(
+        tmp_path,
+        {
+            "README.md": "Run `forerunner init` to get started.\n",
+            "src/codeforerunner/cli.py": "# cli\n",
+        },
+    )
+    assert not any(v.rule_id == "RI1-missing-cli" for v in run(tmp_path))
+
+
+def test_ri5_fires_when_pyproject_absent(tmp_path):
+    _seed(tmp_path, {"README.md": "Install with `pip install codeforerunner`.\n"})
+    vs = run(tmp_path)
+    assert any(v.rule_id == "RI5-missing-python-package" for v in vs)
+
+
+def test_ri5_silent_when_pyproject_present(tmp_path):
+    _seed(
+        tmp_path,
+        {
+            "README.md": "Install with `pip install codeforerunner`.\n",
+            "pyproject.toml": '[project]\nname = "codeforerunner"\n',
+        },
+    )
+    assert not any(v.rule_id == "RI5-missing-python-package" for v in run(tmp_path))
+
+
+def test_ri7_fires_when_mcp_server_absent(tmp_path):
+    _seed(tmp_path, {"README.md": "Start with `forerunner mcp-server`.\n"})
+    vs = run(tmp_path)
+    assert any(v.rule_id == "RI7-missing-mcp" for v in vs)
+
+
+def test_ri7_silent_when_mcp_server_present(tmp_path):
+    _seed(
+        tmp_path,
+        {
+            "README.md": "Start with `forerunner mcp-server`.\n",
+            "src/codeforerunner/mcp_server.py": "# mcp\n",
+        },
+    )
+    assert not any(v.rule_id == "RI7-missing-mcp" for v in run(tmp_path))
+
+
+# ── Version drift (RV1) ────────────────────────────────────────────────────
+
+
+def test_rv1_fires_when_pin_mismatches(tmp_path):
+    _seed(
+        tmp_path,
+        {
+            "README.md": "Install `pip install codeforerunner==0.1.0`.\n",
+            "pyproject.toml": '[project]\nname = "codeforerunner"\nversion = "0.3.1"\n',
+        },
+    )
+    vs = run(tmp_path)
+    rv = [v for v in vs if v.rule_id == "RV1-version-drift"]
+    assert len(rv) == 1
+    assert "0.1.0" in rv[0].message
+    assert "0.3.1" in rv[0].message
+
+
+def test_rv1_silent_when_pin_matches(tmp_path):
+    _seed(
+        tmp_path,
+        {
+            "README.md": "Install `pip install codeforerunner==0.3.1`.\n",
+            "pyproject.toml": '[project]\nname = "codeforerunner"\nversion = "0.3.1"\n',
+        },
+    )
+    assert not any(v.rule_id == "RV1-version-drift" for v in run(tmp_path))
+
+
+def test_rv1_skips_changelog_md(tmp_path):
+    # CHANGELOG.md not in _scanned_docs; old pins there should not fire
+    _seed(
+        tmp_path,
+        {
+            "CHANGELOG.md": "## 0.1.0\n- `pip install codeforerunner==0.1.0`\n",
+            "pyproject.toml": '[project]\nname = "codeforerunner"\nversion = "0.3.1"\n',
+        },
+    )
+    assert not any(v.rule_id == "RV1-version-drift" for v in run(tmp_path))
+
+
+def test_rv1_silent_when_no_pyproject(tmp_path):
+    _seed(tmp_path, {"README.md": "See `pip install codeforerunner==0.1.0`.\n"})
+    assert not any(v.rule_id == "RV1-version-drift" for v in run(tmp_path))
+
+
+def test_rv1_not_run_when_excluded_from_enabled_rules(tmp_path):
+    from codeforerunner.config import CheckConfig
+
+    _seed(
+        tmp_path,
+        {
+            "README.md": "Install `pip install codeforerunner==0.1.0`.\n",
+            "pyproject.toml": '[project]\nname = "codeforerunner"\nversion = "0.3.1"\n',
+        },
+    )
+    cfg = CheckConfig(enabled_rules=("R1-no-cli",))
+    assert not any(v.rule_id == "RV1-version-drift" for v in run(tmp_path, cfg))
+
+
 def test_workflows_lint_when_actionlint_available():
     import shutil
     import subprocess

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/tests/test_doctor.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 import pytest
 
-from codeforerunner.doctor import Finding, format_report, main, run
+from codeforerunner.doctor import Finding, format_report, main, run, starter_config
 
 REPO = Path(__file__).resolve().parent.parent
 
@@ -135,3 +135,42 @@ def test_main_exits_one_when_error_present(tmp_path: Path, capsys):
     rc = main(["--repo", str(repo)])
     capsys.readouterr()
     assert rc == 1
+
+
+# ── starter_config / --fix ─────────────────────────────────────────────────
+
+
+def test_starter_config_contains_expected_rules():
+    cfg = starter_config()
+    assert "R1-no-cli" in cfg
+    assert "R7-no-mcp" in cfg
+    assert "R8-no-marketplace" in cfg
+    assert "ignore_paths" in cfg
+
+
+def test_doctor_fix_writes_config_when_absent(tmp_path: Path, capsys):
+    from codeforerunner.cli import main as cli_main
+
+    repo = _copy_repo_layout(tmp_path)
+    cfg_path = repo / "forerunner.config.yaml"
+    assert not cfg_path.exists()
+
+    cli_main(["--repo", str(repo), "doctor", "--fix"])
+    capsys.readouterr()
+
+    assert cfg_path.is_file()
+    content = cfg_path.read_text(encoding="utf-8")
+    assert "R1-no-cli" in content
+
+
+def test_doctor_fix_does_not_overwrite_existing_config(tmp_path: Path, capsys):
+    from codeforerunner.cli import main as cli_main
+
+    repo = _copy_repo_layout(tmp_path)
+    cfg_path = repo / "forerunner.config.yaml"
+    cfg_path.write_text("# my custom config\n", encoding="utf-8")
+
+    cli_main(["--repo", str(repo), "doctor", "--fix"])
+    capsys.readouterr()
+
+    assert cfg_path.read_text(encoding="utf-8") == "# my custom config\n"

{codeforerunner-0.3.1 → codeforerunner-0.3.2}/tests/test_providers.py

@@ -302,3 +302,180 @@ def test_ollama_api_key_used_as_base_url(monkeypatch):
     with patch("urllib.request.urlopen", side_effect=_fake_urlopen(fake, captured)):
         OllamaProvider().complete(prompt="hi", api_key="http://custom:8888")
     assert captured["url"] == "http://custom:8888/api/generate"
+
+
+# ── Streaming helpers ─────────────────────────────────────────────────────
+
+
+def _fake_stream_urlopen(lines: list[bytes]):
+    """Return urlopen side_effect that yields byte-lines and has .close()."""
+
+    def _opener(req, *args, **kwargs):
+        mock = MagicMock()
+        mock.__iter__ = MagicMock(return_value=iter(lines))
+        mock.close = MagicMock()
+        return mock
+
+    return _opener
+
+
+def _stream_http_error(code: int):
+    import urllib.error
+
+    def _opener(req, *args, **kwargs):
+        raise urllib.error.HTTPError(
+            url=req.full_url, code=code, msg="err", hdrs=None, fp=io.BytesIO(b"err")
+        )
+
+    return _opener
+
+
+# ── Anthropic stream ──────────────────────────────────────────────────────
+
+
+def test_anthropic_stream_yields_text():
+    lines = [
+        b'event: content_block_delta\n',
+        b'data: {"type": "content_block_delta", "delta": {"type": "text_delta", "text": "hello "}}\n',
+        b'\n',
+        b'data: {"type": "content_block_delta", "delta": {"type": "text_delta", "text": "world"}}\n',
+        b'data: {"type": "message_stop"}\n',
+    ]
+    with patch("urllib.request.urlopen", side_effect=_fake_stream_urlopen(lines)):
+        chunks = list(AnthropicProvider().stream(prompt="hi", api_key="sk"))
+    assert chunks == ["hello ", "world"]
+
+
+def test_anthropic_stream_sends_stream_true():
+    lines = [b'data: {"type": "message_stop"}\n']
+    captured: dict = {}
+
+    def _opener(req, *args, **kwargs):
+        captured["body"] = json.loads(req.data.decode("utf-8"))
+        mock = MagicMock()
+        mock.__iter__ = MagicMock(return_value=iter(lines))
+        mock.close = MagicMock()
+        return mock
+
+    with patch("urllib.request.urlopen", side_effect=_opener):
+        list(AnthropicProvider().stream(prompt="hi", api_key="sk"))
+    assert captured["body"]["stream"] is True
+
+
+def test_anthropic_stream_missing_key_raises():
+    with pytest.raises(ProviderError):
+        list(AnthropicProvider().stream(prompt="hi", api_key=None))
+
+
+def test_anthropic_stream_http_error_raises():
+    with patch("urllib.request.urlopen", side_effect=_stream_http_error(401)):
+        with pytest.raises(ProviderError, match="HTTP 401"):
+            list(AnthropicProvider().stream(prompt="hi", api_key="sk"))
+
+
+# ── OpenAI stream ─────────────────────────────────────────────────────────
+
+
+def test_openai_stream_yields_text():
+    lines = [
+        b'data: {"choices": [{"delta": {"content": "foo"}}]}\n',
+        b'data: {"choices": [{"delta": {"content": " bar"}}]}\n',
+        b'data: [DONE]\n',
+    ]
+    with patch("urllib.request.urlopen", side_effect=_fake_stream_urlopen(lines)):
+        chunks = list(OpenAIProvider().stream(prompt="hi", api_key="sk"))
+    assert chunks == ["foo", " bar"]
+
+
+def test_openai_stream_missing_key_raises():
+    with pytest.raises(ProviderError):
+        list(OpenAIProvider().stream(prompt="hi", api_key=None))
+
+
+def test_openai_stream_http_error_raises():
+    with patch("urllib.request.urlopen", side_effect=_stream_http_error(429)):
+        with pytest.raises(ProviderError, match="HTTP 429"):
+            list(OpenAIProvider().stream(prompt="hi", api_key="sk"))
+
+
+def test_openai_stream_ignores_done_sentinel():
+    lines = [
+        b'data: {"choices": [{"delta": {"content": "x"}}]}\n',
+        b'data: [DONE]\n',
+        b'data: {"choices": [{"delta": {"content": "should not appear"}}]}\n',
+    ]
+    with patch("urllib.request.urlopen", side_effect=_fake_stream_urlopen(lines)):
+        chunks = list(OpenAIProvider().stream(prompt="hi", api_key="sk"))
+    assert chunks == ["x"]
+
+
+# ── Google stream ─────────────────────────────────────────────────────────
+
+
+def test_google_stream_yields_text():
+    lines = [
+        b'data: {"candidates": [{"content": {"parts": [{"text": "hi "}]}}]}\n',
+        b'data: {"candidates": [{"content": {"parts": [{"text": "there"}]}}]}\n',
+    ]
+    with patch("urllib.request.urlopen", side_effect=_fake_stream_urlopen(lines)):
+        chunks = list(GoogleProvider().stream(prompt="q", api_key="g-key"))
+    assert chunks == ["hi ", "there"]
+
+
+def test_google_stream_uses_stream_endpoint():
+    lines = [b'data: {"candidates": [{"content": {"parts": [{"text": "x"}]}}]}\n']
+    captured: dict = {}
+
+    def _opener(req, *args, **kwargs):
+        captured["url"] = req.full_url
+        mock = MagicMock()
+        mock.__iter__ = MagicMock(return_value=iter(lines))
+        mock.close = MagicMock()
+        return mock
+
+    with patch("urllib.request.urlopen", side_effect=_opener):
+        list(GoogleProvider().stream(prompt="q", api_key="g-key"))
+    assert "streamGenerateContent" in captured["url"]
+    assert "alt=sse" in captured["url"]
+
+
+def test_google_stream_missing_key_raises():
+    with pytest.raises(ProviderError):
+        list(GoogleProvider().stream(prompt="hi", api_key=None))
+
+
+def test_google_stream_http_error_raises():
+    with patch("urllib.request.urlopen", side_effect=_stream_http_error(403)):
+        with pytest.raises(ProviderError, match="HTTP 403"):
+            list(GoogleProvider().stream(prompt="hi", api_key="g-key"))
+
+
+# ── Ollama stream ─────────────────────────────────────────────────────────
+
+
+def test_ollama_stream_yields_text():
+    lines = [
+        b'{"response": "foo ", "done": false}\n',
+        b'{"response": "bar", "done": true}\n',
+    ]
+    with patch("urllib.request.urlopen", side_effect=_fake_stream_urlopen(lines)):
+        chunks = list(OllamaProvider().stream(prompt="hi"))
+    assert chunks == ["foo ", "bar"]
+
+
+def test_ollama_stream_stops_at_done(monkeypatch):
+    monkeypatch.delenv("OLLAMA_HOST", raising=False)
+    lines = [
+        b'{"response": "a", "done": false}\n',
+        b'{"response": "b", "done": true}\n',
+        b'{"response": "c", "done": false}\n',
+    ]
+    with patch("urllib.request.urlopen", side_effect=_fake_stream_urlopen(lines)):
+        chunks = list(OllamaProvider().stream(prompt="hi"))
+    assert chunks == ["a", "b"]
+
+
+def test_ollama_stream_http_error_raises():
+    with patch("urllib.request.urlopen", side_effect=_stream_http_error(500)):
+        with pytest.raises(ProviderError, match="HTTP 500"):
+            list(OllamaProvider().stream(prompt="hi"))

codeforerunner-0.3.1/src/codeforerunner/providers/anthropic.py

@@ -1,61 +0,0 @@
-"""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")
-        )