plain.code 0.17.0__tar.gz → 0.18.0__tar.gz

plain_code-0.18.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: plain.code
+Version: 0.18.0
+Summary: Preconfigured code formatting and linting.
+Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: plain<1.0.0
+Requires-Dist: requests>=2.0.0
+Requires-Dist: ruff>=0.1.0
+Requires-Dist: tomlkit>=0.11.0
+Requires-Dist: ty>=0.0.11
+Description-Content-Type: text/markdown
+
+# plain.code
+
+**Preconfigured code formatting and linting.**
+
+- [Overview](#overview)
+- [Commands](#commands)
+    - [`plain fix`](#plain-fix)
+    - [`plain code check`](#plain-code-check)
+    - [`plain code annotations`](#plain-code-annotations)
+- [Configuration](#configuration)
+- [FAQs](#faqs)
+- [Installation](#installation)
+
+## Overview
+
+Plain.code provides comprehensive code quality tools with sensible defaults:
+
+- **[Ruff](https://astral.sh/ruff)** - Python linting and formatting
+- **[ty](https://astral.sh/ty)** - Python type checking
+- **[Biome](https://biomejs.dev/)** - JavaScript, JSON, and CSS formatting
+
+Ruff and ty are installed as Python dependencies. Biome is managed automatically as a standalone binary (npm is not required).
+
+## Commands
+
+### `plain fix`
+
+The most used command is [`plain fix`](./cli.py#fix), which automatically fixes linting issues and formats your code:
+
+```bash
+plain fix
+```
+
+![](https://assets.plainframework.com/docs/plain-fix.png)
+
+You can also apply unsafe fixes or add noqa comments to suppress errors:
+
+```bash
+# Apply Ruff's unsafe fixes
+plain fix --unsafe-fixes
+
+# Add noqa comments instead of fixing
+plain fix --add-noqa
+```
+
+### `plain code check`
+
+To check your code without making changes (including type checking):
+
+```bash
+plain code check
+```
+
+You can skip specific tools if needed:
+
+```bash
+# Skip type checking during rapid development
+plain code check --skip-ty
+
+# Only run type checks
+plain code check --skip-ruff --skip-biome
+
+# Skip Biome checks
+plain code check --skip-biome
+
+# Skip annotation coverage checks
+plain code check --skip-annotations
+```
+
+If [`plain.dev`](/plain-dev/README.md) is installed, `plain code check` will be run automatically as a part of `plain pre-commit` to help catch issues before they are committed.
+
+### `plain code annotations`
+
+Check the type annotation coverage of your codebase:
+
+```bash
+plain code annotations
+```
+
+This outputs a summary like `85.2% typed (23/27 functions)`.
+
+To see which functions are missing annotations:
+
+```bash
+plain code annotations --details
+```
+
+You can also output the results as JSON for use in CI or other tools:
+
+```bash
+plain code annotations --json
+```
+
+## Configuration
+
+Default configuration is provided by [`ruff_defaults.toml`](./ruff_defaults.toml) and [`biome_defaults.json`](./biome_defaults.json).
+
+You can customize the behavior in your `pyproject.toml`:
+
+```toml
+[tool.plain.code]
+exclude = ["path/to/exclude"]
+
+[tool.plain.code.ty]
+enabled = true  # Set to false to disable ty
+
+[tool.plain.code.biome]
+enabled = true  # Set to false to disable Biome
+version = "1.5.3"  # Pin to a specific version
+
+[tool.plain.code.annotations]
+enabled = true  # Set to false to disable annotation checks
+exclude = ["migrations"]  # Exclude specific patterns
+```
+
+For more advanced configuration options, see [`get_code_config`](./cli.py#get_code_config).
+
+Generally you won't need to change the configuration. The defaults are designed to "just work" for most projects. If you find yourself needing extensive customization, consider using the underlying tools (Ruff, ty, Biome) directly instead.
+
+## FAQs
+
+#### How do I install or update Biome manually?
+
+Biome is installed automatically when you run `plain fix` or `plain code check`. If you need to manage it manually:
+
+```bash
+# Install Biome (or reinstall if corrupted)
+plain code install
+
+# Force reinstall even if up to date
+plain code install --force
+
+# Update to the latest version
+plain code update
+```
+
+#### Why are test files excluded from annotation coverage?
+
+Test files (`test_*.py`, `*_test.py`, and files in `tests/` or `test/` directories) are excluded by default because they typically contain many small helper functions where type annotations add noise without providing significant value. You can customize this behavior via the `exclude` option in the annotations configuration.
+
+#### How do I check a specific directory?
+
+All commands accept a path argument:
+
+```bash
+plain fix path/to/directory
+plain code check path/to/directory
+plain code annotations path/to/directory
+```
+
+## Installation
+
+Install the `plain.code` package from [PyPI](https://pypi.org/project/plain.code/):
+
+```bash
+uv add plain.code
+```

{plain_code-0.17.0 → plain_code-0.18.0}/plain/code/CHANGELOG.md

@@ -1,5 +1,18 @@
 # plain-code changelog
 
+## [0.18.0](https://github.com/dropseed/plain/releases/plain-code@0.18.0) (2026-01-13)
+
+### What's changed
+
+- Added `plain code annotations` command for checking type annotation coverage in Python files ([df353b8](https://github.com/dropseed/plain/commit/df353b8))
+    - Use `--details` to list untyped functions
+    - Use `--json` for machine-readable output
+- Renamed the `plain-check` skill to `plain-lint`, then to `plain-fix` to better match the primary command ([d51294a](https://github.com/dropseed/plain/commit/d51294a), [519c5af](https://github.com/dropseed/plain/commit/519c5af))
+
+### Upgrade instructions
+
+- If you were using the `plain-check` or `plain-lint` AI skill, it has been renamed to `plain-fix`
+
 ## [0.17.0](https://github.com/dropseed/plain/releases/plain-code@0.17.0) (2026-01-13)
 
 ### What's changed

plain_code-0.18.0/plain/code/README.md

@@ -0,0 +1,157 @@
+# plain.code
+
+**Preconfigured code formatting and linting.**
+
+- [Overview](#overview)
+- [Commands](#commands)
+    - [`plain fix`](#plain-fix)
+    - [`plain code check`](#plain-code-check)
+    - [`plain code annotations`](#plain-code-annotations)
+- [Configuration](#configuration)
+- [FAQs](#faqs)
+- [Installation](#installation)
+
+## Overview
+
+Plain.code provides comprehensive code quality tools with sensible defaults:
+
+- **[Ruff](https://astral.sh/ruff)** - Python linting and formatting
+- **[ty](https://astral.sh/ty)** - Python type checking
+- **[Biome](https://biomejs.dev/)** - JavaScript, JSON, and CSS formatting
+
+Ruff and ty are installed as Python dependencies. Biome is managed automatically as a standalone binary (npm is not required).
+
+## Commands
+
+### `plain fix`
+
+The most used command is [`plain fix`](./cli.py#fix), which automatically fixes linting issues and formats your code:
+
+```bash
+plain fix
+```
+
+![](https://assets.plainframework.com/docs/plain-fix.png)
+
+You can also apply unsafe fixes or add noqa comments to suppress errors:
+
+```bash
+# Apply Ruff's unsafe fixes
+plain fix --unsafe-fixes
+
+# Add noqa comments instead of fixing
+plain fix --add-noqa
+```
+
+### `plain code check`
+
+To check your code without making changes (including type checking):
+
+```bash
+plain code check
+```
+
+You can skip specific tools if needed:
+
+```bash
+# Skip type checking during rapid development
+plain code check --skip-ty
+
+# Only run type checks
+plain code check --skip-ruff --skip-biome
+
+# Skip Biome checks
+plain code check --skip-biome
+
+# Skip annotation coverage checks
+plain code check --skip-annotations
+```
+
+If [`plain.dev`](/plain-dev/README.md) is installed, `plain code check` will be run automatically as a part of `plain pre-commit` to help catch issues before they are committed.
+
+### `plain code annotations`
+
+Check the type annotation coverage of your codebase:
+
+```bash
+plain code annotations
+```
+
+This outputs a summary like `85.2% typed (23/27 functions)`.
+
+To see which functions are missing annotations:
+
+```bash
+plain code annotations --details
+```
+
+You can also output the results as JSON for use in CI or other tools:
+
+```bash
+plain code annotations --json
+```
+
+## Configuration
+
+Default configuration is provided by [`ruff_defaults.toml`](./ruff_defaults.toml) and [`biome_defaults.json`](./biome_defaults.json).
+
+You can customize the behavior in your `pyproject.toml`:
+
+```toml
+[tool.plain.code]
+exclude = ["path/to/exclude"]
+
+[tool.plain.code.ty]
+enabled = true  # Set to false to disable ty
+
+[tool.plain.code.biome]
+enabled = true  # Set to false to disable Biome
+version = "1.5.3"  # Pin to a specific version
+
+[tool.plain.code.annotations]
+enabled = true  # Set to false to disable annotation checks
+exclude = ["migrations"]  # Exclude specific patterns
+```
+
+For more advanced configuration options, see [`get_code_config`](./cli.py#get_code_config).
+
+Generally you won't need to change the configuration. The defaults are designed to "just work" for most projects. If you find yourself needing extensive customization, consider using the underlying tools (Ruff, ty, Biome) directly instead.
+
+## FAQs
+
+#### How do I install or update Biome manually?
+
+Biome is installed automatically when you run `plain fix` or `plain code check`. If you need to manage it manually:
+
+```bash
+# Install Biome (or reinstall if corrupted)
+plain code install
+
+# Force reinstall even if up to date
+plain code install --force
+
+# Update to the latest version
+plain code update
+```
+
+#### Why are test files excluded from annotation coverage?
+
+Test files (`test_*.py`, `*_test.py`, and files in `tests/` or `test/` directories) are excluded by default because they typically contain many small helper functions where type annotations add noise without providing significant value. You can customize this behavior via the `exclude` option in the annotations configuration.
+
+#### How do I check a specific directory?
+
+All commands accept a path argument:
+
+```bash
+plain fix path/to/directory
+plain code check path/to/directory
+plain code annotations path/to/directory
+```
+
+## Installation
+
+Install the `plain.code` package from [PyPI](https://pypi.org/project/plain.code/):
+
+```bash
+uv add plain.code
+```

plain_code-0.18.0/plain/code/annotations.py

@@ -0,0 +1,345 @@
+"""
+Type annotation analyzer for Python codebases.
+
+Analyzes Python files to determine the percentage of functions/methods
+that have complete type annotations (parameters and return types).
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import re
+from dataclasses import dataclass, field
+from fnmatch import fnmatch
+from pathlib import Path
+
+
+@dataclass
+class FunctionInfo:
+    """Information about a function/method for type checking."""
+
+    name: str
+    file: str
+    line: int
+    is_method: bool = False
+    has_return_type: bool = False
+    total_params: int = 0
+    typed_params: int = 0
+    is_property: bool = False
+
+    @property
+    def is_fully_typed(self) -> bool:
+        """Check if function has all type annotations."""
+        return self.has_return_type and (self.typed_params == self.total_params)
+
+
+@dataclass
+class FileStats:
+    """Statistics for a single Python file."""
+
+    path: str
+    functions: list[FunctionInfo] = field(default_factory=list)
+    ignore_comments: int = 0
+    cast_calls: int = 0
+    assert_statements: int = 0
+
+    @property
+    def total_functions(self) -> int:
+        return len(self.functions)
+
+    @property
+    def fully_typed_functions(self) -> int:
+        return sum(1 for f in self.functions if f.is_fully_typed)
+
+    @property
+    def missing_functions(self) -> int:
+        return self.total_functions - self.fully_typed_functions
+
+
+class TypeAnnotationAnalyzer(ast.NodeVisitor):
+    """AST visitor to analyze type annotations in Python code."""
+
+    def __init__(self, file_path: str) -> None:
+        self.file_path = file_path
+        self.functions: list[FunctionInfo] = []
+        self.class_stack: list[str] = []
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        """Track when we enter/exit a class."""
+        self.class_stack.append(node.name)
+        self.generic_visit(node)
+        self.class_stack.pop()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """Analyze function definitions."""
+        self._analyze_function(node)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """Analyze async function definitions."""
+        self._analyze_function(node)
+        self.generic_visit(node)
+
+    def _analyze_function(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
+        """Analyze a function/method for type annotations."""
+        # Skip __init__ return type check (it's always None implicitly)
+        is_init = node.name == "__init__"
+
+        # Check if it's a method (inside a class)
+        is_method = bool(self.class_stack)
+
+        # Check decorators
+        is_property = any(
+            (isinstance(d, ast.Name) and d.id == "property")
+            or (isinstance(d, ast.Attribute) and d.attr == "property")
+            for d in node.decorator_list
+        )
+
+        # Create function info
+        func_info = FunctionInfo(
+            name=node.name,
+            file=self.file_path,
+            line=node.lineno,
+            is_method=is_method,
+            is_property=is_property,
+        )
+
+        # Check return type (not needed for __init__)
+        if not is_init:
+            func_info.has_return_type = node.returns is not None
+        else:
+            func_info.has_return_type = True
+
+        def handle_param(arg: ast.arg) -> None:
+            if is_method and arg.arg in {"self", "cls"}:
+                return
+
+            func_info.total_params += 1
+            if arg.annotation is not None:
+                func_info.typed_params += 1
+
+        # Analyze parameters
+        for arg in node.args.posonlyargs:
+            handle_param(arg)
+
+        for arg in node.args.args:
+            handle_param(arg)
+
+        for arg in node.args.kwonlyargs:
+            handle_param(arg)
+
+        # Check *args and **kwargs
+        if node.args.vararg:
+            func_info.total_params += 1
+            if node.args.vararg.annotation is not None:
+                func_info.typed_params += 1
+
+        if node.args.kwarg:
+            func_info.total_params += 1
+            if node.args.kwarg.annotation is not None:
+                func_info.typed_params += 1
+
+        self.functions.append(func_info)
+
+
+def count_ignore_comments(content: str) -> int:
+    """Count type: ignore comments in the file."""
+    count = 0
+    pattern = r"#\s*type:\s*ignore"
+
+    for line in content.split("\n"):
+        if re.search(pattern, line, re.IGNORECASE):
+            count += 1
+
+    return count
+
+
+def count_cast_calls(content: str) -> int:
+    """Count cast() function calls in the file."""
+    # Match both 'cast(' and 'typing.cast('
+    patterns = [
+        r"\bcast\s*\(",
+        r"\btyping\.cast\s*\(",
+    ]
+
+    count = 0
+    for line in content.split("\n"):
+        for pattern in patterns:
+            count += len(re.findall(pattern, line))
+
+    return count
+
+
+class AssertCounter(ast.NodeVisitor):
+    """AST visitor to count assert statements."""
+
+    def __init__(self) -> None:
+        self.count = 0
+
+    def visit_Assert(self, node: ast.Assert) -> None:
+        self.count += 1
+        self.generic_visit(node)
+
+
+def count_assert_statements(tree: ast.AST) -> int:
+    """Count assert statements in the AST."""
+    counter = AssertCounter()
+    counter.visit(tree)
+    return counter.count
+
+
+def analyze_file(file_path: Path) -> FileStats | None:
+    """Analyze a single Python file for type annotations."""
+    try:
+        with open(file_path, encoding="utf-8") as f:
+            content = f.read()
+
+        tree = ast.parse(content, filename=str(file_path))
+        analyzer = TypeAnnotationAnalyzer(str(file_path))
+        analyzer.visit(tree)
+
+        ignore_count = count_ignore_comments(content)
+        cast_count = count_cast_calls(content)
+        assert_count = count_assert_statements(tree)
+
+        stats = FileStats(
+            path=str(file_path),
+            functions=analyzer.functions,
+            ignore_comments=ignore_count,
+            cast_calls=cast_count,
+            assert_statements=assert_count,
+        )
+        return stats
+
+    except (SyntaxError, UnicodeDecodeError):
+        return None
+
+
+def find_python_files(
+    directory: Path, exclude_patterns: list[str] | None = None
+) -> list[Path]:
+    """Find all Python files in a directory, excluding certain patterns."""
+    default_patterns = [
+        "__pycache__",
+        ".git",
+        ".venv",
+        "venv",
+        "env",
+        ".tox",
+        "build",
+        "dist",
+        "*.egg-info",
+        ".mypy_cache",
+        ".pytest_cache",
+        # Exclude test files from annotation metrics
+        "test_*.py",
+        "*_test.py",
+        "tests",
+        "test",
+    ]
+
+    patterns = list(default_patterns)
+    if exclude_patterns:
+        patterns.extend(exclude_patterns)
+
+    def should_exclude(path: Path) -> bool:
+        try:
+            relative = path.relative_to(directory).as_posix()
+        except ValueError:
+            relative = path.as_posix()
+
+        candidates = {relative, path.as_posix(), path.name}
+        for pattern in patterns:
+            if any(fnmatch(candidate, pattern) for candidate in candidates):
+                return True
+        return False
+
+    python_files = []
+
+    for root, dirs, files in os.walk(directory):
+        # Filter out excluded directories
+        root_path = Path(root)
+        dirs[:] = [d for d in dirs if not should_exclude(root_path / d)]
+
+        for file in files:
+            if file.endswith(".py"):
+                file_path = root_path / file
+                # Check if file path matches excluded patterns
+                if not should_exclude(file_path):
+                    python_files.append(file_path)
+
+    return python_files
+
+
+@dataclass
+class AnnotationResult:
+    """Result of annotation analysis."""
+
+    total_functions: int
+    fully_typed_functions: int
+    missing_count: int
+    total_ignores: int
+    total_casts: int
+    total_asserts: int
+    file_stats: list[FileStats]
+
+    @property
+    def coverage_percentage(self) -> float:
+        if self.total_functions == 0:
+            return 100.0
+        return (self.fully_typed_functions / self.total_functions) * 100
+
+
+def check_annotations(
+    path: str, exclude_patterns: list[str] | None = None
+) -> AnnotationResult:
+    """Check type annotations in the given path."""
+    target = Path(path)
+
+    if target.is_file():
+        if not target.suffix == ".py":
+            return AnnotationResult(
+                total_functions=0,
+                fully_typed_functions=0,
+                missing_count=0,
+                total_ignores=0,
+                total_casts=0,
+                total_asserts=0,
+                file_stats=[],
+            )
+        python_files = [target]
+    elif target.is_dir():
+        python_files = find_python_files(target, exclude_patterns)
+    else:
+        return AnnotationResult(
+            total_functions=0,
+            fully_typed_functions=0,
+            missing_count=0,
+            total_ignores=0,
+            total_casts=0,
+            total_asserts=0,
+            file_stats=[],
+        )
+
+    all_stats = []
+    for file_path in python_files:
+        stats = analyze_file(file_path)
+        if stats:
+            all_stats.append(stats)
+
+    total_functions = sum(s.total_functions for s in all_stats)
+    fully_typed_functions = sum(s.fully_typed_functions for s in all_stats)
+    total_ignores = sum(s.ignore_comments for s in all_stats)
+    total_casts = sum(s.cast_calls for s in all_stats)
+    total_asserts = sum(s.assert_statements for s in all_stats)
+
+    return AnnotationResult(
+        total_functions=total_functions,
+        fully_typed_functions=fully_typed_functions,
+        missing_count=total_functions - fully_typed_functions,
+        total_ignores=total_ignores,
+        total_casts=total_casts,
+        total_asserts=total_asserts,
+        file_stats=all_stats,
+    )

{plain_code-0.17.0 → plain_code-0.18.0}/plain/code/cli.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import subprocess
 import sys
 import tomllib
@@ -12,6 +13,7 @@ from plain.cli import register_cli
 from plain.cli.print import print_event
 from plain.cli.runtime import common_command, without_runtime_setup
 
+from .annotations import AnnotationResult, check_annotations
 from .biome import Biome
 
 DEFAULT_RUFF_CONFIG = Path(__file__).parent / "ruff_defaults.toml"
@@ -78,12 +80,14 @@ def update() -> None:
 @click.option("--skip-ruff", is_flag=True, help="Skip Ruff checks")
 @click.option("--skip-ty", is_flag=True, help="Skip ty type checks")
 @click.option("--skip-biome", is_flag=True, help="Skip Biome checks")
+@click.option("--skip-annotations", is_flag=True, help="Skip type annotation checks")
 def check(
     ctx: click.Context,
     path: str,
     skip_ruff: bool,
     skip_ty: bool,
     skip_biome: bool,
+    skip_annotations: bool,
 ) -> None:
     """Check for formatting and linting issues"""
     ruff_args = ["--config", str(DEFAULT_RUFF_CONFIG)]
@@ -125,6 +129,106 @@ def check(
         result = biome.invoke("check", path)
         maybe_exit(result.returncode)
 
+    if not skip_annotations and config.get("annotations", {}).get("enabled", True):
+        print_event("annotations...", newline=False)
+        exclude_patterns = config.get("annotations", {}).get("exclude", [])
+        ann_result = check_annotations(path, exclude_patterns or None)
+        if ann_result.missing_count > 0:
+            click.secho(
+                f"{ann_result.missing_count} functions are untyped",
+                fg="red",
+            )
+            click.secho("Run 'plain code annotations --details' for details")
+            maybe_exit(1)
+        else:
+            click.secho("All functions typed!", fg="green")
+
+
+@without_runtime_setup
+@cli.command()
+@click.argument("path", default=".")
+@click.option("--details", is_flag=True, help="List untyped functions")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def annotations(path: str, details: bool, as_json: bool) -> None:
+    """Check type annotation status"""
+    config = get_code_config()
+    exclude_patterns = config.get("annotations", {}).get("exclude", [])
+    result = check_annotations(path, exclude_patterns or None)
+    if as_json:
+        _print_annotations_json(result)
+    else:
+        _print_annotations_report(result, show_details=details)
+
+
+def _print_annotations_report(
+    result: AnnotationResult,
+    show_details: bool = False,
+) -> None:
+    """Print the annotation report with colors."""
+    if result.total_functions == 0:
+        click.echo("No functions found")
+        return
+
+    # Detailed output first (if enabled and there are untyped functions)
+    if show_details and result.missing_count > 0:
+        # Collect all untyped functions with full paths
+        untyped_items: list[tuple[str, str, int, list[str]]] = []
+
+        for stats in result.file_stats:
+            for func in stats.functions:
+                if not func.is_fully_typed:
+                    issues = []
+                    if not func.has_return_type:
+                        issues.append("return type")
+                    missing_params = func.total_params - func.typed_params
+                    if missing_params > 0:
+                        param_word = "param" if missing_params == 1 else "params"
+                        issues.append(f"{missing_params} {param_word}")
+                    untyped_items.append((stats.path, func.name, func.line, issues))
+
+        # Sort by file path, then line number
+        untyped_items.sort(key=lambda x: (x[0], x[2]))
+
+        # Print each untyped function
+        for file_path, func_name, line, issues in untyped_items:
+            location = click.style(f"{file_path}:{line}", fg="cyan")
+            issue_str = click.style(f"({', '.join(issues)})", dim=True)
+            click.echo(f"{location}  {func_name}  {issue_str}")
+
+        click.echo()
+
+    # Summary line
+    pct = result.coverage_percentage
+    color = "green" if result.missing_count == 0 else "red"
+    click.secho(
+        f"{pct:.1f}% typed ({result.fully_typed_functions}/{result.total_functions} functions)",
+        fg=color,
+    )
+
+    # Code smell indicators (only if present)
+    smells = []
+    if result.total_ignores > 0:
+        smells.append(f"{result.total_ignores} ignore")
+    if result.total_casts > 0:
+        smells.append(f"{result.total_casts} cast")
+    if result.total_asserts > 0:
+        smells.append(f"{result.total_asserts} assert")
+    if smells:
+        click.secho(f"{', '.join(smells)}", fg="yellow")
+
+
+def _print_annotations_json(result: AnnotationResult) -> None:
+    """Print the annotation report as JSON."""
+    output = {
+        "overall_coverage": result.coverage_percentage,
+        "total_functions": result.total_functions,
+        "fully_typed_functions": result.fully_typed_functions,
+        "total_ignores": result.total_ignores,
+        "total_casts": result.total_casts,
+        "total_asserts": result.total_asserts,
+    }
+    click.echo(json.dumps(output))
+
 
 @common_command
 @without_runtime_setup

plain_code-0.18.0/plain/code/skills/plain-fix/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: plain-fix
+description: Fixes code formatting and linting issues. Use during development to clean up code as you work.
+---
+
+# Fix Code Issues
+
+```
+uv run plain fix [path]
+```
+
+Automatically fixes formatting and linting issues using ruff and biome.
+
+Options:
+
+- `--unsafe-fixes` - Apply ruff unsafe fixes
+- `--add-noqa` - Add noqa comments to suppress errors
+
+## Check Without Fixing
+
+```
+uv run plain code check [path]
+```
+
+Runs ruff, ty (type checking), biome, and annotation coverage checks without auto-fixing.

{plain_code-0.17.0 → plain_code-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.code"
-version = "0.17.0"
+version = "0.18.0"
 description = "Preconfigured code formatting and linting."
 authors = [{name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev"}]
 readme = "README.md"

plain_code-0.17.0/PKG-INFO

@@ -1,93 +0,0 @@
-Metadata-Version: 2.4
-Name: plain.code
-Version: 0.17.0
-Summary: Preconfigured code formatting and linting.
-Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
-License-Expression: BSD-3-Clause
-License-File: LICENSE
-Requires-Python: >=3.13
-Requires-Dist: plain<1.0.0
-Requires-Dist: requests>=2.0.0
-Requires-Dist: ruff>=0.1.0
-Requires-Dist: tomlkit>=0.11.0
-Requires-Dist: ty>=0.0.11
-Description-Content-Type: text/markdown
-
-# plain.code
-
-**Preconfigured code formatting and linting.**
-
-- [Overview](#overview)
-- [Configuration](#configuration)
-- [Installation](#installation)
-
-## Overview
-
-The `plain code` command provides comprehensive code quality tools:
-
-- **[Ruff](https://astral.sh/ruff)** - Python linting and formatting
-- **[ty](https://astral.sh/ty)** - Python type checking
-- **[Biome](https://biomejs.dev/)** - JavaScript, JSON, and CSS formatting
-
-Ruff and ty are installed as Python dependencies. Biome is managed automatically as a standalone binary (npm is not required).
-
-The most used command is `plain code fix`, which can be run using the alias `plain fix`:
-
-```bash
-plain fix
-```
-
-This will automatically fix linting issues and format your code according to the configured rules.
-
-![](https://assets.plainframework.com/docs/plain-fix.png)
-
-To check your code without making changes (including type checking):
-
-```bash
-plain code check
-```
-
-You can skip specific tools if needed:
-
-```bash
-# Skip type checking during rapid development
-plain code check --skip-ty
-
-# Only run type checks
-plain code check --skip-ruff --skip-biome
-
-# Skip Biome checks
-plain code check --skip-biome
-```
-
-If [`plain.dev`](/plain-dev/README.md) is installed then `plain code check` will be run automatically as a part of `plain precommit` to help catch issues before they are committed.
-
-## Configuration
-
-Default configuration is provided by [`ruff_defaults.toml`](./ruff_defaults.toml) and [`biome_defaults.json`](./biome_defaults.json).
-
-You can customize the behavior in your `pyproject.toml`:
-
-```toml
-[tool.plain.code]
-exclude = ["path/to/exclude"]
-
-[tool.plain.code.ty]
-enabled = true  # Set to false to disable ty
-
-[tool.plain.code.biome]
-enabled = true  # Set to false to disable Biome
-version = "1.5.3"  # Pin to a specific version
-```
-
-For more advanced configuration options, see [`get_code_config`](./cli.py#get_code_config).
-
-Generally it's expected that you won't change the configuration! We've tried to pick defaults that "just work" for most projects. If you find yourself needing to customize things, you should probably just move to using the tools themselves directly instead of the `plain.code` package.
-
-## Installation
-
-Install the `plain.code` package from [PyPI](https://pypi.org/project/plain.code/):
-
-```bash
-uv add plain.code
-```

plain_code-0.17.0/plain/code/README.md

@@ -1,78 +0,0 @@
-# plain.code
-
-**Preconfigured code formatting and linting.**
-
-- [Overview](#overview)
-- [Configuration](#configuration)
-- [Installation](#installation)
-
-## Overview
-
-The `plain code` command provides comprehensive code quality tools:
-
-- **[Ruff](https://astral.sh/ruff)** - Python linting and formatting
-- **[ty](https://astral.sh/ty)** - Python type checking
-- **[Biome](https://biomejs.dev/)** - JavaScript, JSON, and CSS formatting
-
-Ruff and ty are installed as Python dependencies. Biome is managed automatically as a standalone binary (npm is not required).
-
-The most used command is `plain code fix`, which can be run using the alias `plain fix`:
-
-```bash
-plain fix
-```
-
-This will automatically fix linting issues and format your code according to the configured rules.
-
-![](https://assets.plainframework.com/docs/plain-fix.png)
-
-To check your code without making changes (including type checking):
-
-```bash
-plain code check
-```
-
-You can skip specific tools if needed:
-
-```bash
-# Skip type checking during rapid development
-plain code check --skip-ty
-
-# Only run type checks
-plain code check --skip-ruff --skip-biome
-
-# Skip Biome checks
-plain code check --skip-biome
-```
-
-If [`plain.dev`](/plain-dev/README.md) is installed then `plain code check` will be run automatically as a part of `plain precommit` to help catch issues before they are committed.
-
-## Configuration
-
-Default configuration is provided by [`ruff_defaults.toml`](./ruff_defaults.toml) and [`biome_defaults.json`](./biome_defaults.json).
-
-You can customize the behavior in your `pyproject.toml`:
-
-```toml
-[tool.plain.code]
-exclude = ["path/to/exclude"]
-
-[tool.plain.code.ty]
-enabled = true  # Set to false to disable ty
-
-[tool.plain.code.biome]
-enabled = true  # Set to false to disable Biome
-version = "1.5.3"  # Pin to a specific version
-```
-
-For more advanced configuration options, see [`get_code_config`](./cli.py#get_code_config).
-
-Generally it's expected that you won't change the configuration! We've tried to pick defaults that "just work" for most projects. If you find yourself needing to customize things, you should probably just move to using the tools themselves directly instead of the `plain.code` package.
-
-## Installation
-
-Install the `plain.code` package from [PyPI](https://pypi.org/project/plain.code/):
-
-```bash
-uv add plain.code
-```

plain_code-0.17.0/plain/code/skills/plain-check/SKILL.md

@@ -1,35 +0,0 @@
----
-name: plain-check
-description: Runs code quality checks including ruff, type checking, and biome. Use for linting, formatting, or preflight validation.
----
-
-# Code Quality
-
-## Check for Issues
-
-```
-uv run plain code check [path]
-```
-
-Runs ruff, ty (type checking), and biome checks.
-
-## Fix Issues
-
-```
-uv run plain fix [path]
-```
-
-Automatically fixes formatting and linting issues.
-
-Options:
-
-- `--unsafe-fixes` - Apply ruff unsafe fixes
-- `--add-noqa` - Add noqa comments to suppress errors
-
-## Preflight Checks
-
-```
-uv run plain preflight
-```
-
-Validates Plain configuration.