oh-my-opencode 5.1.48 → 5.1.54

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/tests/test_surrogate.py

@@ -1,252 +0,0 @@
-"""Surrogate registry/fetch/ordering tests; registry entries and responses are faked, never live network."""
-from __future__ import annotations
-
-import json
-import os
-import sys
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
-
-from engine.result_schema import Attempt  # noqa: E402
-from engine.validators import Verdict  # noqa: E402
-
-FIXTURES = Path(__file__).resolve().parent / "fixtures"
-TARGET = "https://en.wikipedia.org/wiki/Web_archiving"  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-
-
-def _fixture(name: str) -> str:
-    return (FIXTURES / name).read_text(encoding="utf-8", errors="replace")
-
-
-class _Resp:
-    def __init__(self, text: str = "", status: int = 200, url: str = "", payload: dict | None = None):
-        self.text = text
-        self.status_code = status
-        self.url = url
-        self.cookies = {}
-        self.headers = {}
-        self._payload = payload
-
-    def json(self):
-        if self._payload is None:
-            raise ValueError("no json payload")
-        return self._payload
-
-
-def _fail_attempt(phase: str) -> Attempt:
-    return Attempt(
-        phase=phase,
-        executor="curl_cffi",
-        url=TARGET,
-        url_transform="original",
-        impersonate="safari",
-        referer="self_root",
-        verdict=Verdict.CHALLENGE.value,
-    )
-
-
-class SurrogateRegistry(unittest.TestCase):
-    def test_default_registry_contains_wayback(self) -> None:
-        from engine import surrogate
-
-        reg = surrogate.load_surrogates()
-        self.assertIn("wayback", reg)
-        self.assertEqual(reg["wayback"]["kind"], "archive")
-        self.assertEqual(reg["wayback"]["trust"], "archive")
-
-    def test_stale_entries_detected(self) -> None:
-        from engine import surrogate
-
-        self.assertTrue(surrogate.is_stale({"last_verified": "2025-01-01"}, max_age_days=90))
-        self.assertFalse(surrogate.is_stale({"last_verified": "2999-01-01"}, max_age_days=90))
-
-
-class SurrogateFetch(unittest.TestCase):
-    def test_wayback_success_sets_snapshot_provenance(self) -> None:
-        from engine import surrogate
-
-        discovery = json.loads(_fixture("wayback_available.json"))
-
-        def fake_http(u: str, **kw):
-            if "wayback/available" in u:
-                return _Resp(json.dumps(discovery), 200, u, payload=discovery)
-            return _Resp(_fixture("wayback_snapshot.html"), 200, u)
-
-        with patch.object(surrogate, "_http_get", side_effect=fake_http):
-            atts, meta, content = surrogate.run_surrogate(TARGET, registry=surrogate.load_surrogates(), timeout=5)
-
-        att = atts[-1]
-        self.assertEqual(att.phase, "surrogate")
-        self.assertEqual(att.executor, "surrogate_wayback")
-        self.assertEqual(att.verdict, Verdict.WEAK_OK.value)
-        self.assertEqual(meta["provenance"], "snapshot")
-        self.assertTrue(meta["snapshot_timestamp"])
-        self.assertEqual(meta["trust"], "archive")
-        self.assertGreater(len(content), 3000)
-
-    def test_stub_snapshot_is_not_accepted(self) -> None:
-        from engine import surrogate
-
-        disc = {"archived_snapshots": {"closest": {"available": True, "url": "https://web.archive.org/web/2024/x", "timestamp": "20240101000000"}}}  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-
-        def fake_http(u: str, **kw):
-            if "wayback/available" in u:
-                return _Resp(json.dumps(disc), 200, u, payload=disc)
-            return _Resp(_fixture("amp_redirect_stub.html"), 200, u)
-
-        with patch.object(surrogate, "_http_get", side_effect=fake_http):
-            atts, _, _ = surrogate.run_surrogate(TARGET, registry={"wayback": surrogate.DEFAULT_SURROGATES["wayback"]}, timeout=5)
-        att = atts[-1]
-        self.assertNotIn(att.verdict, (Verdict.STRONG_OK.value, Verdict.WEAK_OK.value))
-
-    def test_proxy_skips_without_allow_flag(self) -> None:
-        from engine import surrogate
-
-        reg = {"anon_relay": {"kind": "proxy", "trust": "untrusted", "enabled": False,
-                              "last_verified": "2999-01-01", "fetch": "https://relay.invalid/{target}"}}  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-        called: list[str] = []
-
-        with patch.object(surrogate, "_http_get", side_effect=lambda u, **kw: (called.append(u), _Resp("<html>" + "y" * 4000 + "</html>", 200, u))[1]):
-            atts, _, _ = surrogate.run_surrogate(TARGET, registry=reg, allow_proxy=False, timeout=5)
-        self.assertEqual(len(called), 0)
-
-        with patch.object(surrogate, "_http_get", side_effect=lambda u, **kw: (called.append(u), _Resp("<html>" + "y" * 4000 + "</html>", 200, u))[1]):
-            atts, meta, _ = surrogate.run_surrogate(TARGET, registry=reg, allow_proxy=True, timeout=5)
-        self.assertEqual(len(called), 1)
-        att = atts[-1]
-        self.assertEqual(att.executor, "surrogate_anon_relay")
-        self.assertEqual(meta["trust"], "untrusted")
-
-    def test_proxy_never_carries_credentials(self) -> None:
-        from engine import surrogate
-
-        seen: list[dict] = []
-
-        def fake_http(u: str, **kw):
-            seen.append(kw.get("headers", {}))
-            return _Resp("<html>" + "z" * 4000 + "</html>", 200, u)
-
-        reg = {"anon_relay": {"kind": "proxy", "trust": "untrusted", "enabled": False,
-                              "last_verified": "2999-01-01", "fetch": "https://relay.invalid/{target}"}}  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-        os.environ["OMOB_TEST_TOKEN"] = "secret"
-        try:
-            with patch.object(surrogate, "_http_get", side_effect=fake_http):
-                surrogate.run_surrogate(TARGET, registry=reg, allow_proxy=True, timeout=5)
-        finally:
-            os.environ.pop("OMOB_TEST_TOKEN", None)
-
-        self.assertEqual(len(seen), 1)
-        joined = json.dumps(seen[0]).lower()
-        self.assertNotIn("secret", joined)
-        self.assertNotIn("authorization", joined)
-        self.assertNotIn("cookie", joined)
-
-
-class ChainOrdering(unittest.TestCase):
-    def _profile(self) -> dict:
-        return {
-            "tls_impersonate_candidates": [[]],
-            "referer_strategies": [],
-            "url_transform_order": ["original"],
-            "fallback_when_challenge": ["surrogate_wayback", "playwright_real_chrome"],
-        }
-
-    def test_surrogate_success_short_circuits_playwright(self) -> None:
-        from engine.fetch_chain import fetch
-        from engine import surrogate
-        from engine import executor as ex
-
-        def fake_surrogate(*a, **kw):
-            att = Attempt(
-                phase="surrogate",
-                executor="surrogate_wayback",
-                url=TARGET,
-                url_transform="original",
-                impersonate=None,
-                referer="",
-                verdict=Verdict.WEAK_OK.value,
-                body_size=5000,
-            )
-            return [att], {"provenance": "snapshot", "snapshot_timestamp": "20240101000000", "trust": "archive"}, "<html>content</html>"
-
-        def fail_playwright(*a, **kw):
-            raise AssertionError("playwright must not run after surrogate success")
-
-        with patch("engine.fetch_chain._load_profiles", return_value={}), \
-                patch("engine.fetch_chain.last_load_error", return_value=None), \
-                patch("engine.fetch_chain.run_attempt", side_effect=lambda *a, **kw: (_fail_attempt(str(kw.get("phase", "grid"))), None)), \
-                patch("engine.fetch_chain.detect", return_value=[]), \
-                patch("engine.fetch_chain.load_profile", side_effect=lambda *a, **kw: self._profile()), \
-                patch.object(surrogate, "run_surrogate", side_effect=fake_surrogate), \
-                patch.object(ex, "run_playwright_fallback", side_effect=fail_playwright):
-            result = fetch(TARGET, enable_playwright=True, max_attempts=1)
-
-        self.assertTrue(result.ok)
-        self.assertEqual(result.provenance, "snapshot")
-        self.assertEqual(result.snapshot_timestamp, "20240101000000")
-
-    def test_surrogate_still_runs_when_playwright_disabled(self) -> None:
-        from engine.fetch_chain import fetch
-        from engine import surrogate
-
-        calls: list[str] = []
-
-        def fake_surrogate(*a, **kw):
-            calls.append("surrogate")
-            att = Attempt(phase="surrogate", executor="surrogate_wayback", url=TARGET,
-                          url_transform="original", impersonate=None, referer="",
-                          verdict=Verdict.WEAK_OK.value, body_size=5000)
-            return [att], {"provenance": "snapshot", "snapshot_timestamp": "20240101000000", "trust": "archive"}, "<html>snap</html>"
-
-        with patch("engine.fetch_chain._load_profiles", return_value={}), \
-                patch("engine.fetch_chain.last_load_error", return_value=None), \
-                patch("engine.fetch_chain.run_attempt", side_effect=lambda *a, **kw: (_fail_attempt(str(kw.get("phase", "grid"))), None)), \
-                patch("engine.fetch_chain.detect", return_value=[]), \
-                patch("engine.fetch_chain.load_profile", side_effect=lambda *a, **kw: self._profile()), \
-                patch.object(surrogate, "run_surrogate", side_effect=fake_surrogate):
-            result = fetch(TARGET, enable_playwright=False, max_attempts=1)
-
-        self.assertEqual(calls, ["surrogate"])
-        self.assertTrue(result.ok)
-        self.assertEqual(result.provenance, "snapshot")
-
-    def test_playwright_runs_when_surrogate_fails(self) -> None:
-        from engine.fetch_chain import fetch
-        from engine import surrogate
-        from engine import executor as ex
-
-        calls: list[str] = []
-
-        def fake_surrogate(*a, **kw):
-            calls.append("surrogate")
-            att = Attempt(phase="surrogate", executor="surrogate_wayback", url=TARGET,
-                          url_transform="original", impersonate=None, referer="",
-                          verdict=Verdict.UNKNOWN.value)
-            return [att], {"provenance": "live", "snapshot_timestamp": None, "trust": "origin"}, ""
-
-        def fake_playwright(*a, **kw):
-            calls.append("playwright")
-            att = Attempt(phase="fallback", executor="playwright_real_chrome", url=TARGET,
-                          url_transform="original", impersonate=None, referer="",
-                          verdict=Verdict.WEAK_OK.value, body_size=5000)
-            return att, "<html>chrome content</html>"
-
-        with patch("engine.fetch_chain._load_profiles", return_value={}), \
-                patch("engine.fetch_chain.last_load_error", return_value=None), \
-                patch("engine.fetch_chain.run_attempt", side_effect=lambda *a, **kw: (_fail_attempt(str(kw.get("phase", "grid"))), None)), \
-                patch("engine.fetch_chain.detect", return_value=[]), \
-                patch("engine.fetch_chain.load_profile", side_effect=lambda *a, **kw: self._profile()), \
-                patch.object(surrogate, "run_surrogate", side_effect=fake_surrogate), \
-                patch.object(ex, "run_playwright_fallback", side_effect=fake_playwright):
-            result = fetch(TARGET, enable_playwright=True, max_attempts=1)
-
-        self.assertTrue(result.ok)
-        self.assertEqual(result.provenance, "live")
-        self.assertEqual(calls, ["surrogate", "playwright"])
-
-
-if __name__ == "__main__":
-    unittest.main()

package/packages/omo-codex/plugin/skills/ultimate-browsing/engine/tests/test_surrogate_validators.py

@@ -1,78 +0,0 @@
-"""Surrogate-tier validation tests; fixtures only, never live network, so the suite cannot flake."""
-from __future__ import annotations
-
-import sys
-import unittest
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
-
-from engine.result_schema import FetchResult  # noqa: E402
-from engine.validators import Verdict, validate  # noqa: E402
-
-FIXTURES = Path(__file__).resolve().parent / "fixtures"
-
-
-def _fixture(name: str) -> str:
-    return (FIXTURES / name).read_text(encoding="utf-8", errors="replace")
-
-
-class _Resp:
-    def __init__(self, text: str = "", status: int = 200, url: str = ""):
-        self.text = text
-        self.status_code = status
-        self.url = url
-        self.cookies = {}
-        self.headers = {}
-
-
-class RedirectStubRejection(unittest.TestCase):
-    def test_amp_redirect_stub_is_not_ok(self) -> None:
-        body = _fixture("amp_redirect_stub.html")
-        self.assertLess(len(body), 1000)
-        resp = _Resp(body, 200, "https://en-wikipedia-org.cdn.ampproject.org/c/s/x")  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-        vr = validate(resp, target_url="https://en.wikipedia.org/wiki/Web_archiving")  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-        self.assertIn(vr.verdict, (Verdict.CHALLENGE, Verdict.UNKNOWN))
-        self.assertFalse(vr.ok)
-
-    def test_real_snapshot_still_passes(self) -> None:
-        resp = _Resp(_fixture("wayback_snapshot.html"), 200, "https://web.archive.org/web/2024/x")  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-        vr = validate(resp, target_url="https://en.wikipedia.org/wiki/Web_archiving")  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-        self.assertTrue(vr.ok)
-
-    def test_plain_page_still_weak_ok(self) -> None:
-        resp = _Resp("<html><body>" + ("x" * 4000) + "</body></html>", 200, "https://example.com/")
-        vr = validate(resp, target_url="https://example.com/")
-        self.assertTrue(vr.ok)
-
-
-class InterstitialRejection(unittest.TestCase):
-    def test_search_engine_interstitial_is_not_ok(self) -> None:
-        body = _fixture("search_interstitial.html")
-        resp = _Resp(body, 200, "https://webcache.googleusercontent.com/search?q=cache:x")  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-        vr = validate(resp, target_url="https://en.wikipedia.org/wiki/Web_archiving")  # NOTE-BIAS-OK — fixture URL from a third-party surrogate service, not a target site
-        self.assertIn(vr.verdict, (Verdict.CHALLENGE, Verdict.UNKNOWN))
-        self.assertFalse(vr.ok)
-
-
-class ResultSchemaProvenance(unittest.TestCase):
-    def test_defaults_are_live_origin(self) -> None:
-        r = FetchResult(ok=True)
-        self.assertEqual(r.provenance, "live")
-        self.assertEqual(r.trust, "origin")
-        self.assertIsNone(r.snapshot_timestamp)
-        d = r.to_dict()
-        self.assertEqual(d["provenance"], "live")
-        self.assertEqual(d["trust"], "origin")
-        self.assertIn("snapshot_timestamp", d)
-
-    def test_snapshot_fields_roundtrip(self) -> None:
-        r = FetchResult(ok=True, provenance="snapshot", snapshot_timestamp="20241227132135", trust="archive")
-        d = r.to_dict()
-        self.assertEqual(d["provenance"], "snapshot")
-        self.assertEqual(d["snapshot_timestamp"], "20241227132135")
-        self.assertEqual(d["trust"], "archive")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/packages/shared-skills/skills/programming/scripts/go/new-project.py

@@ -1,138 +0,0 @@
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "typer",
-#     "rich",
-# ]
-# ///
-
-# ─── How to run ───
-# 1. Install uv (if not installed):
-#      curl -LsSf https://astral.sh/uv/install.sh | sh
-# 2. Run:
-#      uv run new-project.py myservice
-#      uv run new-project.py myservice --module github.com/your-org/myservice
-# ──────────────────
-#
-# Creates a new Go project with the canonical strict layout:
-#   - go.mod with go 1.23
-#   - .golangci.yml (v2, strict bundle)
-#   - Taskfile.yml (fmt + lint + test + build)
-#   - cmd/server/main.go entrypoint
-#   - internal/{cmd,config,api,domain,obs} skeletons
-#   - .github/workflows/ci.yml
-#
-# Templates live in ./templates/ — keep this script under 250 pure LOC.
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-from string import Template
-
-import typer
-from rich.console import Console
-
-console = Console(stderr=True)
-
-TEMPLATES_DIR = Path(__file__).parent / "templates"
-
-
-def _render(template_file: str, **subs: str) -> str:
-    """Read a template file and apply $placeholder substitutions.
-
-    Uses string.Template ($name) so Go/YAML curly braces stay literal.
-    """
-    raw = (TEMPLATES_DIR / template_file).read_text()
-    if not subs:
-        return raw
-    return Template(raw).substitute(**subs)
-
-
-# (template-file → relative output path; is_format = .format() is run)
-FILES: list[tuple[str, str, bool]] = [
-    (".golangci.yml",   ".golangci.yml",                   False),
-    ("Taskfile.yml",    "Taskfile.yml",                    False),
-    (".editorconfig",   ".editorconfig",                   False),
-    ("gitignore",       ".gitignore",                      False),
-    ("ci.yml",          ".github/workflows/ci.yml",        False),
-    ("run.go",          "internal/cmd/run.go",             False),
-    ("config.go",       "internal/config/config.go",       False),
-    ("main.go.tmpl",    "cmd/server/main.go",              True),
-    ("AGENTS.md.tmpl",  "AGENTS.md",                       True),
-    ("README.md.tmpl",  "README.md",                       True),
-]
-
-
-def _init_go_module(project_dir: Path, module: str) -> None:
-    try:
-        subprocess.run(
-            ["go", "mod", "init", module],
-            cwd=project_dir,
-            check=True,
-            capture_output=True,
-        )
-        console.print(f"  [dim]ran[/] go mod init {module}")
-    except (subprocess.CalledProcessError, FileNotFoundError) as e:
-        console.print(f"  [yellow]warn[/] go mod init failed ({e}); writing fallback go.mod")
-        (project_dir / "go.mod").write_text(f"module {module}\n\ngo 1.23\n")
-
-
-def _create_layout(project_dir: Path) -> None:
-    """Create the canonical internal/ tree."""
-    subdirs = [
-        "cmd/server",
-        "internal/cmd",
-        "internal/config",
-        "internal/api",
-        "internal/domain",
-        "internal/obs",
-        ".github/workflows",
-    ]
-    for sd in subdirs:
-        (project_dir / sd).mkdir(parents=True)
-
-
-def _write_files(project_dir: Path, name: str, module: str, purpose: str) -> None:
-    """Render every template into the project tree."""
-    for tmpl_name, out_rel, is_format in FILES:
-        subs = (
-            {"name": name, "module": module, "short_purpose": purpose}
-            if is_format
-            else {}
-        )
-        content = _render(tmpl_name, **subs)
-        out_path = project_dir / out_rel
-        out_path.parent.mkdir(parents=True, exist_ok=True)
-        out_path.write_text(content)
-        console.print(f"  [dim]wrote[/] {out_rel}")
-
-
-def main(
-    name: str,
-    path: str = typer.Option(".", help="Parent dir"),
-    module: str = typer.Option("", help="Go module path; default: <name>"),
-    purpose: str = typer.Option("HTTP", help="Short purpose for AGENTS.md"),
-) -> None:
-    """Scaffold a new Go project with the strict toolchain."""
-    project_dir = Path(path) / name
-    if project_dir.exists():
-        console.print(f"[red]✗[/red] {project_dir} already exists")
-        sys.exit(1)
-
-    module_path = module or name
-
-    project_dir.mkdir(parents=True)
-    _create_layout(project_dir)
-    _init_go_module(project_dir, module_path)
-    _write_files(project_dir, name, module_path, purpose)
-
-    console.print(f"\n[bold green]Done![/] cd {project_dir}")
-    console.print("  go get github.com/caarlos0/env/v11")
-    console.print("  task        # fmt + lint + test")
-
-
-if __name__ == "__main__":
-    typer.run(main)

package/packages/shared-skills/skills/programming/scripts/python/new-project.py

@@ -1,172 +0,0 @@
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "typer",
-#     "rich",
-# ]
-# ///
-
-# ─── How to run ───
-# 1. Install uv (if not installed):
-#      curl -LsSf https://astral.sh/uv/install.sh | sh
-# 2. Run:
-#      uv run new-project.py myproject
-#      uv run new-project.py myproject --path ./workspace
-#      uv run new-project.py myproject --lib   # library (publishable)
-# ──────────────────
-
-"""Scaffold a new Python project with ultra-strict config from pyproject-strict.md.
-
-Creates via `uv init`, then injects basedpyright + ruff ALL + pytest config.
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-import typer
-from rich import print as rprint
-
-# ── Strict tool config (from pyproject-strict.md) ──
-
-TOOL_CONFIG = '''
-[dependency-groups]
-dev = [
-    "basedpyright>=1.21",
-    "ruff>=0.8",
-    "pytest>=8",
-    "pytest-cov>=5",
-]
-
-[tool.basedpyright]
-typeCheckingMode = "all"
-pythonVersion = "3.13"
-reportMissingTypeStubs = false
-reportUnknownMemberType = false
-reportUnknownArgumentType = false
-reportUnknownVariableType = false
-reportUnknownLambdaType = false
-reportUnknownParameterType = false
-reportMissingParameterType = false
-reportUnnecessaryIsInstance = false
-reportUnusedCallResult = false
-reportImplicitOverride = false
-
-[tool.ruff]
-target-version = "py313"
-line-length = 120
-
-[tool.ruff.lint]
-select = ["ALL"]
-ignore = [
-    "COM812",   # trailing comma (conflicts with formatter)
-    "ISC001",   # single-line string concat (conflicts with formatter)
-    "D1",       # undocumented-public-* (too noisy early on)
-    "ANN101",   # deprecated: self annotation
-    "ANN102",   # deprecated: cls annotation
-    "S101",     # assert used (pytest needs it)
-    "PLR2004",  # magic-value-comparison (test data)
-    "FBT",      # boolean-trap (too strict for CLIs)
-    "TD",       # flake8-todos (noisy)
-    "FIX",      # fixme (noisy)
-]
-
-[tool.ruff.lint.per-file-ignores]
-"tests/**/*.py" = ["S101", "PLR2004", "SLF001", "D", "ARG", "ANN"]
-
-[tool.ruff.lint.pydocstyle]
-convention = "google"
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-addopts = "-ra --strict-markers --strict-config"
-'''
-
-GITIGNORE = """\
-__pycache__/
-*.py[cod]
-*.so
-.venv/
-dist/
-*.egg-info/
-.coverage
-htmlcov/
-.basedpyright/
-.ruff_cache/
-"""
-
-
-def main(
-    name: str = typer.Argument(help="Project name"),
-    path: Path = typer.Option(Path("."), "--path", "-p", help="Parent directory"),
-    lib: bool = typer.Option(False, "--lib", help="Create as publishable library (uv init --lib)"),
-) -> None:
-    """Create a new Python project with ultra-strict config."""
-    project_dir = path / name
-
-    if project_dir.exists():
-        rprint(f"[red]Error:[/red] {project_dir} already exists")
-        raise SystemExit(1)
-
-    # Run uv init
-    cmd = ["uv", "init", "--lib" if lib else "--app", str(project_dir)]
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    if result.returncode != 0:
-        rprint(f"[red]uv init failed:[/red] {result.stderr}")
-        raise SystemExit(1)
-
-    # Read existing pyproject.toml
-    pyproject_path = project_dir / "pyproject.toml"
-    content = pyproject_path.read_text()
-
-    # Remove the default [dependency-groups] if uv init created one
-    # (we'll replace it with our strict version)
-    lines = content.splitlines(keepends=True)
-    filtered: list[str] = []
-    skip = False
-    for line in lines:
-        if line.strip().startswith("[dependency-groups]"):
-            skip = True
-            continue
-        if skip and line.strip().startswith("["):
-            skip = False
-        if not skip:
-            filtered.append(line)
-
-    content = "".join(filtered).rstrip("\n") + "\n"
-
-    # Append strict tool config
-    content += TOOL_CONFIG
-
-    pyproject_path.write_text(content)
-
-    # Add dev dependencies
-    subprocess.run(
-        ["uv", "add", "--dev", "basedpyright", "ruff", "pytest", "pytest-cov"],
-        cwd=project_dir,
-        capture_output=True,
-    )
-
-    # Create tests directory
-    tests_dir = project_dir / "tests"
-    tests_dir.mkdir(exist_ok=True)
-    (tests_dir / "__init__.py").touch()
-
-    # Overwrite .gitignore
-    (project_dir / ".gitignore").write_text(GITIGNORE)
-
-    # Create py.typed marker for libraries
-    if lib:
-        src_dir = project_dir / "src" / name.replace("-", "_")
-        if src_dir.exists():
-            (src_dir / "py.typed").touch()
-
-    rprint(f"[green]✓[/green] Created: [bold]{project_dir}[/bold]")
-    rprint(f"  cd {name} && uv sync && uv run basedpyright . && uv run ruff check .")
-
-
-if __name__ == "__main__":
-    typer.run(main)