smallsteps 0.1.1__py3-none-any.whl

smallsteps/__init__.py

@@ -0,0 +1,12 @@
+from smallsteps.cli import app
+from smallsteps.command_runner import CommandRunner
+from smallsteps.prober import Prober
+from smallsteps.ratchet import Ratchet, evaluate
+
+__all__ = [
+    "app",
+    "Ratchet",
+    "evaluate",
+    "CommandRunner",
+    "Prober",
+]

smallsteps/ci_adapter.py

@@ -0,0 +1,69 @@
+import re
+from pathlib import Path
+from typing import List
+
+from smallsteps.ratchet import Ratchet
+
+
+def ratchet_to_slug(ratchet: Ratchet) -> str:
+    """Generates a standardized environment variable key for a given ratchet name."""
+    return f"SMALLSTEPS_{re.sub(r'[^a-zA-Z0-9]', '_', ratchet.name).upper()}"
+
+
+class GitHubCIAdapter:
+    """Generates a custom local GitHub Composite Action matched to the project metrics."""
+
+    def generate_action(self, ratchets: List[Ratchet]) -> str:
+        """Generates an action.yml manifest string with dynamic inputs, setup stubs, and mapping."""
+        yaml_lines = [
+            "name: 'Smallsteps Ratchet Evaluation'",
+            "description: 'Evaluates your quality goals'",
+        ]
+
+        # 1. Append inputs only if there are active ratchets to list
+        if ratchets:
+            yaml_lines.append("inputs:")
+            for r in ratchets:
+                slug = ratchet_to_slug(r)
+                yaml_lines.extend(
+                    [
+                        f"  {slug}:",
+                        f"    description: \"Current live performance value for '{r.name}'\"",
+                        "    required: true",
+                    ]
+                )
+
+        # 2. Append core composite block infrastructure and the installation placeholder
+        yaml_lines.extend(
+            [
+                "",
+                "runs:",
+                "  using: 'composite'",
+                "  steps:",
+                "    - name: Install uv",
+                "      uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0",
+                "      with:",
+                "        enable-cache: true",
+                "",
+                "    - name: Run Smallsteps Guardrail Validation",
+                "      shell: bash",
+                "      run: uvx smallsteps-ratchet check",
+            ]
+        )
+
+        # 3. Append step context environment maps sequentially via loop execution
+        if ratchets:
+            yaml_lines.append("      env:")
+            for r in ratchets:
+                slug = ratchet_to_slug(r)
+                yaml_lines.append(f"        {slug}: ${{{{ inputs.{slug} }}}}")
+
+        return "\n".join(yaml_lines) + "\n"
+
+    def save(self, path: Path, content: str) -> None:
+        """Writes the custom composite action metadata safely out to file."""
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+        except Exception as e:
+            raise IOError(f"Failed to write local custom action configuration: {e}")

smallsteps/cli.py

@@ -0,0 +1,275 @@
+from datetime import date, datetime, timedelta
+from pathlib import Path
+
+import typer
+
+from smallsteps.ci_adapter import GitHubCIAdapter
+from smallsteps.cli_helpers import find_git_root
+from smallsteps.command_runner import (
+    CommandRunnerWithEnvLookUp,
+    OSCommandRunner,
+    OSEnvAdapter,
+)
+from smallsteps.config_adapter import TOMLConfigAdapter
+from smallsteps.parsing import parse_numeric_input
+from smallsteps.prober import Prober, StaticDateProvider, local_system_date_provider
+from smallsteps.ratchet import (
+    Ratchet,
+    RatchetEvaluationFailure,
+    RatchetEvaluationSuccess,
+)
+
+app = typer.Typer(
+    help="Smallsteps: Monotonic progress tracking and enforcement.",
+    no_args_is_help=True,
+)
+
+DEFAULT_CONFIG_FILE = Path("smallsteps.toml")
+
+
+def resolve_config_path(explicit_path: Path | None) -> Path:
+    if explicit_path is not None:
+        return explicit_path
+    return find_git_root() / DEFAULT_CONFIG_FILE
+
+
+@app.command(name="add")
+def add(
+    name: str = typer.Option(
+        None, "--name", "-n", help="Unique name for your ratchet."
+    ),
+    goal_val: str = typer.Option(
+        None, "--goal", "-g", help="Goal value (e.g. .9 or 250)."
+    ),
+    command_str: str = typer.Option(
+        None, "--command", "-cmd", help="Shell command to compute the value."
+    ),
+    end_date: datetime | None = typer.Option(
+        None, "--end", "-e", help="Ratchet goal end date (YYYY-MM-DD)."
+    ),
+    config: Path | None = typer.Option(
+        None, "--config", "-c", help="Custom path to config file."
+    ),
+):
+    """Adds a ratchet to your configuration (Auto-creates smallsteps.toml if missing)."""
+    config_path = resolve_config_path(config)
+    config_adapter = TOMLConfigAdapter()
+
+    # 1. Collect or prompt for the name first
+    final_name = name or typer.prompt("Ratchet name (e.g., Test Coverage)")
+
+    existing_ratchets = config_adapter.load(config_path)
+    if any(r.name == final_name for r in existing_ratchets):
+        typer.secho(
+            f"❌ A ratchet named '{final_name}' already exists.",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    # 2. Ask for command and use it for baseline
+    final_cmd = command_str or typer.prompt(
+        "Shell command to compute the ratchet value"
+    )
+    typer.echo("Running command to establish live baseline value...")
+    runner = OSCommandRunner()
+    try:
+        # Create a temporary Ratchet instance to satisfy our runner protocol
+        temp_ratchet = Ratchet(
+            name=final_name,
+            start=date.today(),
+            end=date.today(),
+            initial_value=0,
+            goal_value=100,
+            command=final_cmd,
+        )
+        discovered_baseline = runner(temp_ratchet)
+
+    except Exception as e:
+        typer.secho(
+            f"❌ Failed to calculate baseline using that command.\nError: {e}",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Live baseline discovered: {discovered_baseline:.2f}")
+    # 3. Ask for the Goal
+    raw_goal = goal_val or typer.prompt(
+        f"What is your goal value? (Current: {discovered_baseline})"
+    )
+
+    try:
+        final_goal = parse_numeric_input(raw_goal)
+    except ValueError as e:
+        typer.secho(f"❌ Invalid goal value: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+
+    # 4. Handle Target Goal Date
+    if end_date:
+        final_end_date = end_date.date()
+    else:
+        goal_date_str = typer.prompt(
+            f"What is the end date by which the goal must be met? (YYYY-MM-DD, e.g. in 30 days its {(date.today() + timedelta(days=30)).isoformat()} ) ",
+        )
+        try:
+            final_end_date = date.fromisoformat(goal_date_str)
+        except ValueError:
+            typer.secho(
+                f"❌ Invalid date format '{goal_date_str}'. Please use YYYY-MM-DD.",
+                fg=typer.colors.RED,
+                err=True,
+            )
+            raise typer.Exit(code=1)
+
+    # 5. Construct Ratchet
+    try:
+        validated_ratchet = Ratchet(
+            name=final_name,
+            start=date.today(),
+            end=final_end_date,
+            initial_value=discovered_baseline,
+            goal_value=final_goal,
+            command=final_cmd,
+        )
+    except Exception as e:
+        typer.secho(
+            f"❌ Ratchet validation failed:\n{e}", fg=typer.colors.RED, err=True
+        )
+        raise typer.Exit(code=1)
+
+    # 6. Write
+    config_adapter.append(config_path, validated_ratchet)
+    typer.secho(
+        f"✨ Successfully added '{validated_ratchet.name}' to {config_path.name}!",
+        fg=typer.colors.GREEN,
+    )
+
+
+@app.command(name="check")
+def check(
+    date: datetime | None = typer.Option(
+        None,
+        "--date",
+        "-d",
+        help="Timetravel to a specific date to check your ratchets at.",
+    ),
+    config: Path | None = typer.Option(None, "--config", "-c"),
+):
+    """Evaluates all ratchets and enforces progress."""
+    config_path = resolve_config_path(config)
+    config_adapter = TOMLConfigAdapter()
+
+    try:
+        ratchets = config_adapter.load(config_path)
+    except RuntimeError as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+
+    if not ratchets:
+        typer.secho(
+            f"No active ratchets found in {config_path.name}.",
+            fg=typer.colors.YELLOW,
+        )
+        return
+
+    # Wire up runner & prober pipeline
+    runner_with_lookup = CommandRunnerWithEnvLookUp(
+        env_adapter=OSEnvAdapter(), command_runner=OSCommandRunner()
+    )
+    date_provider = (
+        StaticDateProvider(date.date()) if date else local_system_date_provider
+    )
+    prober = Prober(command_runner=runner_with_lookup, date_provider=date_provider)
+
+    any_failed = False
+    typer.echo(f"Evaluating {len(ratchets)} ratchet(s)...\n")
+
+    for ratchet in ratchets:
+        eval_result = prober.probe(ratchet)
+
+        match eval_result:
+            # TRACK 1: Metric is completely healthy and on track
+            case RatchetEvaluationSuccess(is_healthy=True) as success:
+                typer.secho(
+                    f"{ratchet.name}: ON TRACK "
+                    f"(Current: {success.current_value:.2f}, Expected Min: {success.expected_value:.2f})",
+                    fg=typer.colors.GREEN,
+                )
+
+            # TRACK 2: Command executed fine, but progress dropped below expected target bounds
+            case RatchetEvaluationSuccess(is_healthy=False) as below:
+                any_failed = True
+                typer.secho(
+                    f"{ratchet.name}: BEHIND "
+                    f"(Current: {below.current_value:.2f}, Expected Min: {below.expected_value:.2f})",
+                    fg=typer.colors.RED,
+                )
+
+            # TRACK 3: Underlying shell execution exploded completely (command error, timeout, missing binary)
+            case RatchetEvaluationFailure() as failure:
+                any_failed = True
+
+                typer.secho(
+                    f"{ratchet.name} EVALUATION FAILED! \n"
+                    f"Details: {failure.error_message}",
+                    fg=typer.colors.RED,
+                    err=True,
+                )
+
+    if any_failed:
+        typer.echo("\nProgress check failed.")
+        raise typer.Exit(code=1)
+
+    typer.echo("All monitored project metrics are completely healthy.")
+
+
+@app.command(name="ci")
+def ci(
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        "-o",
+        help="Force overwrite the action.yml file if it already exists.",
+    ),
+    config: Path | None = typer.Option(
+        None, "--config", "-c", help="Custom path to the smallsteps configuration file."
+    ),
+):
+    """Generates a scaffoling for a github action"""
+    config_path = resolve_config_path(config)
+    config_adapter = TOMLConfigAdapter()
+    ci_adapter = GitHubCIAdapter()
+
+    # 1. Check if the target file destination already exists
+    action_path = Path(".github/actions/smallsteps/action.yml")
+    if action_path.exists() and not overwrite:
+        typer.secho(
+            f"Action manifest already exists at:\n   {action_path.resolve()}\n\n"
+            f"To overwrite this file, re-run this command with the overwrite flag:\n"
+            f"uv run smallsteps ci --overwrite",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    # 2. Extract configuration records
+    try:
+        ratchets = config_adapter.load(config_path)
+    except RuntimeError as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+
+    # 3. Process layout formatting maps
+    yaml_content = ci_adapter.generate_action(ratchets)
+
+    # 4. Save out structural changes
+    try:
+        ci_adapter.save(action_path, yaml_content)
+        typer.secho(
+            f"🚀 Custom GitHub Composite Action successfully written to:\n   {action_path}",
+            fg=typer.colors.GREEN,
+        )
+    except Exception as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)

smallsteps/cli_helpers.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+
+def find_git_root() -> Path:
+    """
+    Traverses upwards from the current working directory to find the Git root.
+    Falls back to the current working directory if no Git repository is detected.
+    """
+    # Start at the absolute current working directory
+    current_dir = Path.cwd().resolve()
+
+    # Check the current directory, then walk up through all parent directories
+    for path in [current_dir] + list(current_dir.parents):
+        if (path / ".git").exists():
+            return path
+
+    # Fallback if we hit the filesystem root without finding a .git marker
+    return Path.cwd()

smallsteps/command_runner.py

@@ -0,0 +1,86 @@
+import os
+import re
+import subprocess
+from typing import Optional, Protocol
+
+from smallsteps.parsing import parse_numeric_input
+from smallsteps.ratchet import Ratchet
+
+
+def ratchet_to_slug(ratchet: Ratchet) -> str:
+    clean_name = re.sub(r"[^a-zA-Z0-9]", "_", ratchet.name).upper()
+    return f"SMALLSTEPS_{clean_name}"
+
+
+class EnvAdapter(Protocol):
+    def __call__(self, key: str) -> int | float | None: ...
+
+
+class CommandRunner(Protocol):
+    def __call__(self, ratchet: Ratchet) -> int | float: ...
+
+
+class OSCommandRunner(CommandRunner):
+    def __init__(self, timeout_seconds: int = 30) -> None:
+        self.timeout_seconds = timeout_seconds
+
+    def __call__(self, ratchet: Ratchet) -> int | float:
+        # Guard against empty commands
+        if not ratchet.command or not ratchet.command.strip():
+            raise ValueError(
+                f"Ratchet '{ratchet.name}' has an empty or missing command string."
+            )
+
+        try:
+            # Execute the shell command
+            result = subprocess.run(
+                ratchet.command,
+                shell=True,
+                capture_output=True,  # Captures stdout and stderr
+                text=True,  # Returns strings instead of bytes
+                timeout=self.timeout_seconds,  # Prevents hanging infinitely in CI
+                check=True,  # Raises CalledProcessError if exit code != 0
+            )
+
+            # Extract, clean, and parse the output
+            raw_output = result.stdout.strip()
+            return parse_numeric_input(raw_output)
+
+        except subprocess.TimeoutExpired as e:
+            # Enrich the timeout error with explicit context
+            raise RuntimeError(
+                f"Command timed out after {self.timeout_seconds}s: '{ratchet.command}'"
+            ) from e
+
+        except subprocess.CalledProcessError as e:
+            error_details = e.stderr.strip() or e.stdout.strip() or "No output logged."
+            raise RuntimeError(
+                f"Command failed with exit code {e.returncode}.\n"
+                f"Command: '{ratchet.command}'\n"
+                f"Error Details: {error_details}"
+            ) from e
+
+
+class OSEnvAdapter(EnvAdapter):
+    def __call__(self, key: str) -> Optional[int | float]:
+
+        val = os.environ.get(key)
+        if val is None:
+            return None
+
+        return parse_numeric_input(val)
+
+
+class CommandRunnerWithEnvLookUp(CommandRunner):
+    def __init__(self, env_adapter: EnvAdapter, command_runner: CommandRunner) -> None:
+        self.env_adapter = env_adapter
+        self.command_runner = command_runner
+
+    def __call__(self, ratchet: Ratchet) -> int | float:
+        slug = ratchet_to_slug(ratchet)
+        env_res = self.env_adapter(slug)
+
+        if env_res is not None:
+            return env_res
+
+        return self.command_runner(ratchet)

smallsteps/config_adapter.py

@@ -0,0 +1,54 @@
+import tomllib
+from datetime import date
+from pathlib import Path
+from typing import List
+
+from pydantic import TypeAdapter
+
+from smallsteps.ratchet import Ratchet
+
+
+class TOMLConfigAdapter:
+    """Manages reading, validating, and mutating the smallsteps TOML file structure."""
+
+    def load(self, path: Path) -> List[Ratchet]:
+        """Reads and parses the entire configuration file into a list of valid Ratchets."""
+        if not path.exists():
+            return []
+
+        try:
+            with open(path, "rb") as f:
+                toml_data = tomllib.load(f)
+
+            return TypeAdapter(List[Ratchet]).validate_python(
+                toml_data.get("ratchets", [])
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Malformed or invalid configuration at {path.name}:\n{e}"
+            )
+
+    def append(self, path: Path, ratchet: Ratchet) -> None:
+        """Serializes a single valid Ratchet and appends it structurally to the file."""
+        # Auto-initialize the file if it doesn't exist yet
+        #
+        if not path.exists():
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text("# Smallsteps Configuration\n", encoding="utf-8")
+
+        toml_lines = ["", "[[ratchets]]"]
+        for key, value in ratchet.model_dump().items():
+            if isinstance(value, date):
+                toml_lines.append(f"{key} = {value.isoformat()}")
+            elif isinstance(value, str):
+                toml_lines.append(f'{key} = "{value}"')
+            else:
+                toml_lines.append(f"{key} = {value}")
+
+        toml_block = "\n".join(toml_lines) + "\n"
+
+        try:
+            with open(path, "a", encoding="utf-8") as f:
+                f.write(toml_block)
+        except Exception as e:
+            raise IOError(f"Failed to write ratchet data to filesystem: {e}")

smallsteps/parsing.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+
+def parse_numeric_input(value: Any) -> int | float:
+    if isinstance(value, (int, float)):
+        return value
+
+    if not isinstance(value, str):
+        raise TypeError(f"Expected string or number, got {type(value).__name__}")
+
+    cleaned = value.strip()
+
+    # Elegant trick: Change "99.5%" to "99.5e-2" (scientific notation for /100)
+    if cleaned.endswith("%"):
+        return float(cleaned.rstrip("%").strip() + "e-2")
+
+    # Standard fallback path (int takes priority to preserve type fidelity)
+    try:
+        return int(cleaned)
+    except ValueError:
+        try:
+            return float(cleaned)
+        except ValueError:
+            raise ValueError(f"Could not parse string '{value}' into a number.")

smallsteps/prober.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from datetime import date
+from typing import Protocol
+
+from smallsteps.command_runner import CommandRunner
+from smallsteps.ratchet import (
+    Ratchet,
+    RatchetEvaluation,
+    RatchetEvaluationFailure,
+    evaluate,
+)
+
+
+class DateProvider(Protocol):
+    def __call__(self) -> date: ...
+
+
+def local_system_date_provider() -> date:
+    return date.today()
+
+
+class StaticDateProvider(DateProvider):
+    def __init__(self, date: date) -> None:
+        self.date = date
+
+    def __call__(self) -> date:
+        return self.date
+
+
+@dataclass(frozen=True)
+class Prober:
+    command_runner: CommandRunner
+    date_provider: DateProvider
+
+    def probe(self, ratchet: Ratchet) -> RatchetEvaluation:
+
+        try:
+            current_value = self.command_runner(ratchet)
+            current_date = self.date_provider()
+
+        except Exception as e:
+            return RatchetEvaluationFailure(error_message=str(e))
+        return evaluate(
+            ratchet=ratchet, current_value=current_value, current_date=current_date
+        )

smallsteps/ratchet.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+from datetime import date
+
+from pydantic import BaseModel, ConfigDict, model_validator
+from typing_extensions import Self
+
+
+class Ratchet(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    name: str
+    start: date
+    end: date
+    initial_value: int | float
+    goal_value: int | float
+    command: str
+
+    @model_validator(mode="after")
+    def validate_end(self) -> Self:
+        if self.end < self.start:
+            raise ValueError("End date must be >= start date of ratchet")
+        return self
+
+    @model_validator(mode="after")
+    def validate_value(self) -> Self:
+        if self.initial_value == self.goal_value:
+            raise ValueError("Initial value must be different from goal")
+        return self
+
+
+@dataclass(frozen=True)
+class RatchetEvaluationSuccess:
+    current_date: date
+    current_value: int | float
+    expected_value: float
+    is_healthy: bool
+
+
+@dataclass(frozen=True)
+class RatchetEvaluationFailure:
+    error_message: str
+    is_healthy: bool = False
+
+
+RatchetEvaluation = RatchetEvaluationSuccess | RatchetEvaluationFailure
+
+
+def evaluate(
+    ratchet: Ratchet, current_value: int | float, current_date: date
+) -> RatchetEvaluation:
+    if current_date <= ratchet.start:
+        time_ratio = 0.0
+    elif current_date >= ratchet.end:
+        time_ratio = 1.0
+    else:
+        time_ratio = (current_date - ratchet.start).days / (
+            ratchet.end - ratchet.start
+        ).days
+
+    expected_progress = time_ratio  # linear progress assumed
+    expected_value = ratchet.initial_value + (
+        expected_progress * (ratchet.goal_value - ratchet.initial_value)
+    )
+    actual_progress = (current_value - ratchet.initial_value) / (
+        ratchet.goal_value - ratchet.initial_value
+    )
+    return RatchetEvaluationSuccess(
+        current_date=current_date,
+        current_value=current_value,
+        expected_value=expected_value,
+        is_healthy=actual_progress >= expected_progress,
+    )

smallsteps-0.1.1.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: smallsteps
+Version: 0.1.1
+Summary: Add your description here
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: typer>=0.26.7
+Description-Content-Type: text/markdown
+
+# Smallsteps - improve your codebase in small steps
+
+Smallsteps allows you to declare ratchets – metrics that must increase over time – and to enforce them via testing or CI pipelines.
+
+A typical situation: you want to add test coverage as a health check.
+Initially your coverage is at 42% so you create a CI gate that fails if it falls under 40%. Now you have your baseline secured – so far so good. You make a resolution to yourself that you will increase your coverage to bump up the percentage in your CI action frequently.
+**Somehow that never happens and your coverage stays at 42%.**
+
+With smallsteps you declare your goal of 80% coverage and that you want to reach it in 100 days. Smallsteps computes the necessary percentage that must be met for each day (e.g. after 50 days you need 60% coverage) and fails if the goal is not met.
+
+## Example
+
+We are using this repository itself as an example. We want to enforce our test coverage to go up.
+So we create a ratchet:
+
+```
+uvx smallsteps add \
+  --name="Pytest Coverage" \
+  --command="uv run pytest --cov --cov-report=json > /dev/null && jq -r '.totals.percent_covered' coverage.json" \
+  --goal=80 \
+  --end="2026-10-01"
+```
+
+This created a new file – `smallsteps.toml` – which holds the configuration of our ratchet:
+
+```toml
+# Smallsteps Configuration
+
+[[ratchets]]
+name = "Pytest Coverage"
+start = 2026-06-25
+end = 2026-10-01
+initial_value = 57.142857142857146
+goal_value = 80
+command = "uv run pytest --cov --cov-report=json > /dev/null && jq -r '.totals.percent_covered' coverage.json"
+
+```
+
+**Note**
+
+- You don't need to memorize the command parameters, `smallsteps add` walks you through them interactively.
+- Ratchets can be increasing or decreasing. Percentages (56%) are parsed as floats (.56). So make sure that your goal matches the format of the command output.
+
+You can inspect, add or modify the ratchets using the the toml file.
+
+### Checking your Ratchets
+
+Run `uvx smallsteps check` to check the status of your ratchets. To simulate the future you can run with `--date`, e.g.:
+
+```
+uv smallsteps check --date 2026-10-31
+Evaluating 1 ratchet(s)...
+
+Pytest Coverage: BEHIND (Current: 57.14, Expected Min: 80.00)
+
+Progress check failed.
+
+```
+
+shows that on the goal date the check will fail if we do not achieve 80% test coverage.
+
+### CI and reading values from env
+
+When running `smallsteps check` all commands to gather your metrics are run by smallsteps. This may be not the desired behaviour in CI because you want to run the checks in different workflows / actions and do not want to use smallsteps as a central orchestrator.
+
+By default smallsteps looks for environment variables matching the ratchets before running the command. E.g. if `SMALLSTEPS_PYTEST_COVERAGE` is present, the coverage is not re-computed. You can use this in CI to pass outputs from test workflow into the smallsteps action. To get a scaffolding github action with the required input vars for your ratchets run `uvx smallsteps ci`.
+
+Have a look at [the action](.github/actions/smallsteps/action.yml) and the whole workflow (not provided by a command because too specific for your setup) to see how the plumbing can work.
+
+## Installation
+
+This documentaion assumes you are using `uv`, hence you don't need to do anything despite using the uv tool command (`ux`) to install and run smallsteps.
+
+# License
+
+MIT

smallsteps-0.1.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+smallsteps/__init__.py,sha256=7AyPBtevDUNnsu-5qvjDg4u9cu9QXMWRy8x_0JHdcyA,261
+smallsteps/ci_adapter.py,sha256=17qXL0wHMjzLGQjsvxwqIVZEobMln3-C-QW3dY7s-Wo,2609
+smallsteps/cli.py,sha256=lMUAT9xx4P5hVVEPqmzAMlOqcNrL-l9DbWeAZmCIvxc,9196
+smallsteps/cli_helpers.py,sha256=kLcLJitmjhGRqnQDTMU5NJ8560qOFr3PHkndrB1Ay8M,624
+smallsteps/command_runner.py,sha256=WL1WrXTnUFc54AmSQMyrMRSbbpHqO59W9lcJbKkcEd0,2837
+smallsteps/config_adapter.py,sha256=8_t8tUzQgo03XHGpw65-4FZddeaPupVtttO2Q_gyySk,1874
+smallsteps/parsing.py,sha256=XE-E_b5RV2rdcF01km81gn-aoNDABWPu7DvXyOrq_ik,746
+smallsteps/prober.py,sha256=azpOGapz514HHwzymNVYaazEpFMR8rJIINfPfa0SFYU,1064
+smallsteps/ratchet.py,sha256=sFlJf3diMd6xsZbZGOWOjWDDgN-bBPILiP4dmv4tnzw,1993
+smallsteps-0.1.1.dist-info/METADATA,sha256=8mAcHcX3qcgFpZQa3hSqyGzFFLKG3_kPMDmEPEA0Oo8,3589
+smallsteps-0.1.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+smallsteps-0.1.1.dist-info/entry_points.txt,sha256=L7SjUfIYSJvCxaoEdege14YzNrMYGwcyk9rfFYIiToM,50
+smallsteps-0.1.1.dist-info/RECORD,,

smallsteps-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

smallsteps-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+smallsteps = smallsteps.cli:app