oh-my-opencode 5.1.51 → 5.1.55

package/packages/omo-codex/plugin/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/omo-codex/plugin/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)

package/packages/omo-codex/plugin/skills/programming/scripts/python/new-script.py

@@ -1,116 +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-script.py my_tool
-#      uv run new-script.py my_tool --output ./scripts/my_tool.py
-#      uv run new-script.py my_tool --deps 'httpx2[http2,brotli,zstd]' --deps rich --deps polars
-#      uv run new-script.py my_tool --py 3.13
-# ──────────────────
-
-"""Generate a PEP 723 Python script with all boilerplate pre-filled.
-
-Creates a new .py file with:
-  - uv shebang
-  - PEP 723 inline metadata (requires-python + dependencies)
-  - Mandatory "How to run" comment block
-  - from __future__ import annotations
-  - main() + if __name__ guard
-
-By default writes to a temp directory and prints the path.
-"""
-
-from __future__ import annotations
-
-import os
-import stat
-import sys
-import tempfile
-from pathlib import Path
-
-import typer
-from rich import print as rprint
-
-
-TEMPLATE = '''\
-#!/usr/bin/env -S uv run --script
-# /// script
-# requires-python = ">={python_version}"
-# dependencies = [
-{deps_block}# ]
-# ///
-
-# ─── How to run ───
-# 1. Install uv (if not installed):
-#      curl -LsSf https://astral.sh/uv/install.sh | sh
-# 2. Run directly (no venv, no pip install needed):
-#      uv run {filename} {args_hint}
-# 3. Or make executable and run:
-#      chmod +x {filename} && ./{filename}
-# ──────────────────
-
-from __future__ import annotations
-
-
-def main() -> None:
-    """TODO: implement."""
-
-
-if __name__ == "__main__":
-    main()
-'''
-
-
-def main(
-    name: str = typer.Argument(help="Script name (without .py extension)"),
-    output: Path | None = typer.Option(None, "--output", "-o", help="Output path. Default: OS temp directory."),
-    deps: list[str] = typer.Option([], "--deps", "-d", help="Dependencies to include (repeat --deps for each)."),
-    py: str = typer.Option("3.13", "--py", help="Minimum Python version."),
-) -> None:
-    """Generate a new PEP 723 script with all boilerplate pre-filled."""
-    filename = f"{name}.py" if not name.endswith(".py") else name
-    stem = filename.removesuffix(".py")
-
-    if output is not None:
-        dest = Path(output)
-    else:
-        tmp_dir = Path(tempfile.gettempdir()) / "uv-scripts"
-        tmp_dir.mkdir(exist_ok=True)
-        dest = tmp_dir / filename
-
-    dep_list = deps or []
-    if dep_list:
-        deps_block = "".join(f'#     "{d}",\n' for d in dep_list)
-    else:
-        deps_block = '#     # add deps here, e.g.: "httpx2[http2,brotli,zstd]"\n'
-
-    content = TEMPLATE.format(
-        python_version=py,
-        deps_block=deps_block,
-        filename=filename,
-        args_hint="",
-    )
-
-    dest.parent.mkdir(parents=True, exist_ok=True)
-    dest.write_text(content)
-
-    # Make executable on Unix
-    if sys.platform != "win32":
-        st = dest.stat()
-        dest.chmod(st.st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
-
-    rprint(f"[green]✓[/green] Created: [bold]{dest}[/bold]")
-    rprint(f"  Run: [cyan]uv run {dest}[/cyan]")
-
-
-if __name__ == "__main__":
-    typer.run(main)

package/packages/omo-codex/plugin/skills/programming/scripts/rust/new-project.py

@@ -1,178 +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
-# ──────────────────
-#
-# Creates a new Rust project with strict lints, deny.toml, rustfmt.toml, and
-# rust-toolchain.toml pre-configured. The generated project passes its own
-# fmt + clippy gate before any code is written.
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-import typer
-from rich.console import Console
-
-console = Console(stderr=True)
-
-# ── Embedded config contents ─────────────────────────────────────────────
-
-RUST_TOOLCHAIN_TOML = """\
-[toolchain]
-channel = "stable"
-components = ["rustfmt", "clippy", "rust-src"]
-profile = "default"
-"""
-
-CARGO_TOML_LINTS = """
-[lints.rust]
-unsafe_op_in_unsafe_fn = "deny"
-missing_docs = "warn"
-missing_debug_implementations = "warn"
-unreachable_pub = "warn"
-unused_must_use = "deny"
-elided_lifetimes_in_paths = "warn"
-non_ascii_idents = "deny"
-trivial_numeric_casts = "warn"
-unused_lifetimes = "warn"
-single_use_lifetimes = "warn"
-unexpected_cfgs = { level = "deny", check-cfg = ["cfg(loom)"] }
-
-[lints.clippy]
-all = { level = "deny", priority = -1 }
-pedantic = { level = "warn", priority = -1 }
-nursery = { level = "warn", priority = -1 }
-cargo = { level = "warn", priority = -1 }
-undocumented_unsafe_blocks = "deny"
-multiple_unsafe_ops_per_block = "deny"
-unwrap_used = "deny"
-expect_used = "deny"
-panic = "deny"
-todo = "deny"
-unimplemented = "deny"
-dbg_macro = "deny"
-print_stdout = "warn"
-print_stderr = "warn"
-allow_attributes = "deny"
-allow_attributes_without_reason = "deny"
-let_underscore_must_use = "deny"
-indexing_slicing = "deny"
-mem_forget = "deny"
-clone_on_ref_ptr = "warn"
-module_name_repetitions = { level = "allow" }
-must_use_candidate = { level = "allow" }
-"""
-
-DENY_TOML = """\
-[advisories]
-yanked = "deny"
-
-[licenses]
-private = { ignore = true }  # publish = false crates carry no license field
-allow = ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "Unicode-3.0", "Zlib"]
-
-[bans]
-multiple-versions = "warn"
-wildcards = "deny"
-
-[sources]
-unknown-registry = "deny"
-unknown-git = "deny"
-"""
-
-MAIN_RS = """\
-//! Command-line entry point.
-
-use std::io::Write as _;
-
-fn main() -> std::io::Result<()> {
-    writeln!(std::io::stdout().lock(), "Hello, world!")
-}
-"""
-
-RUSTFMT_TOML = """\
-edition = "2024"
-max_width = 100
-use_field_init_shorthand = true
-use_try_shorthand = true
-"""
-
-# ── Main ─────────────────────────────────────────────────────────────────
-
-app = typer.Typer(add_completion=False)
-
-
-@app.command()
-def main(
-    name: str = typer.Argument(help="Name of the new Rust project"),
-    path: Path = typer.Option(
-        Path.cwd(),
-        "--path",
-        "-p",
-        help="Parent directory where the project folder is created",
-    ),
-) -> None:
-    """Scaffold a new Rust project with strict lints and tooling configs."""
-    project_dir = path / name
-
-    # ── cargo init ───────────────────────────────────────────────────
-    console.print(f"[bold green]Creating[/] project [cyan]{name}[/] at [dim]{project_dir}[/]")
-    try:
-        subprocess.run(
-            ["cargo", "init", str(project_dir), "--name", name],
-            check=True,
-            capture_output=True,
-            text=True,
-        )
-    except FileNotFoundError:
-        console.print("[bold red]Error:[/] cargo not found. Install Rust via https://rustup.rs")
-        sys.exit(1)
-    except subprocess.CalledProcessError as exc:
-        console.print(f"[bold red]cargo init failed:[/]\n{exc.stderr}")
-        sys.exit(1)
-
-    # ── rust-toolchain.toml ──────────────────────────────────────────
-    (project_dir / "rust-toolchain.toml").write_text(RUST_TOOLCHAIN_TOML)
-    console.print("  [dim]wrote[/] rust-toolchain.toml")
-
-    # ── Declare the MSRV and append [lints] to Cargo.toml ────────────
-    cargo_toml = project_dir / "Cargo.toml"
-    manifest = cargo_toml.read_text()
-    if 'edition = "2024"\n' not in manifest:
-        console.print("[bold red]Error:[/] cargo did not create an edition 2024 package; install Rust >= 1.85")
-        sys.exit(1)
-    manifest = manifest.replace(
-        'edition = "2024"\n', 'edition = "2024"\nrust-version = "1.85"\npublish = false\n', 1
-    )
-    cargo_toml.write_text(manifest + CARGO_TOML_LINTS)
-    (project_dir / "src" / "main.rs").write_text(MAIN_RS)
-    console.print("  [dim]appended[/] [lints] to Cargo.toml")
-
-    # ── deny.toml ────────────────────────────────────────────────────
-    (project_dir / "deny.toml").write_text(DENY_TOML)
-    console.print("  [dim]wrote[/] deny.toml")
-
-    # ── rustfmt.toml ─────────────────────────────────────────────────
-    (project_dir / "rustfmt.toml").write_text(RUSTFMT_TOML)
-    console.print("  [dim]wrote[/] rustfmt.toml")
-
-    console.print(f"\n[bold green]Done![/] cd {project_dir} && cargo check")
-
-
-if __name__ == "__main__":
-    app()