stepgate 0.1.0__py3-none-any.whl

stepgate/__init__.py

@@ -0,0 +1,3 @@
+"""stepgate: a step-gated micro-change protocol CLI for coding agents."""
+
+__version__ = "0.1.0"

stepgate/__main__.py

@@ -0,0 +1,4 @@
+from stepgate.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

stepgate/cli.py

@@ -0,0 +1,126 @@
+"""stepgate command-line interface.
+
+All commands are non-interactive by design (no prompts, no confirmations) so
+they behave identically in a terminal, a desktop app, or an IDE side-panel
+extension. User-facing errors are printed as clear messages, never as raw
+Python tracebacks.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from stepgate import __version__
+from stepgate.model import StepgateError
+
+
+def _add_session_flags(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--agent", help="calling agent name (e.g. claude, codex)")
+    parser.add_argument("--session", help="explicit session name to target")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="stepgate",
+        description=(
+            "Step-gated micro-change protocol for coding agents: propose, "
+            "approve, execute, verify - one small step at a time. stepgate "
+            "structures the flow; it never blocks your code, your commits, "
+            "or your git."
+        ),
+    )
+    parser.add_argument("--version", action="version", version=f"stepgate {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("init", help="create .stepgate/ and inject the agent instruction block")
+    p.add_argument("--guardrails", help="path to an existing domain guardrails doc to reference")
+
+    p = sub.add_parser("propose", help="register a micro-change plan (state: PENDING)")
+    p.add_argument("--file", required=True, help="JSON file with the six plan fields")
+    p.add_argument("--new-session", action="store_true", help="start a fresh session")
+    _add_session_flags(p)
+
+    p = sub.add_parser("show", help="show the active proposal rendered as prose")
+    _add_session_flags(p)
+
+    p = sub.add_parser("approve", help="PENDING -> APPROVED")
+    p.add_argument("--adjust", action="store_true", help="approve with an adjusted/reduced scope")
+    p.add_argument("--scope", help="comma-separated adjusted scope (files/areas)")
+    p.add_argument("--note", help="note describing the adjustment")
+    _add_session_flags(p)
+
+    p = sub.add_parser("reject", help="PENDING -> REJECTED")
+    p.add_argument("--note", required=True, help="reason for rejection")
+    _add_session_flags(p)
+
+    p = sub.add_parser("exec-log", help="APPROVED -> EXECUTED (consolidated summary)")
+    p.add_argument("--summary", required=True, help="what was done, consolidated")
+    p.add_argument("--files", help="comma-separated files that were touched")
+    _add_session_flags(p)
+
+    p = sub.add_parser("verify", help="EXECUTED -> VERIFIED")
+    p.add_argument("--evidence", required=True, help="tests/runs/evidence demonstrating the result")
+    _add_session_flags(p)
+
+    p = sub.add_parser("close", help="VERIFIED -> CLOSED")
+    _add_session_flags(p)
+
+    p = sub.add_parser("abandon", help="any non-terminal state -> ABANDONED")
+    p.add_argument("--reason", required=True, help="why the proposal is being abandoned")
+    _add_session_flags(p)
+
+    p = sub.add_parser("next", help="record a next-step suggestion (does not open a proposal)")
+    p.add_argument("--suggest", required=True, help="the suggested next step")
+    _add_session_flags(p)
+
+    p = sub.add_parser("status", help="current session state + aggregated project view")
+    _add_session_flags(p)
+
+    p = sub.add_parser("history", help="chronological, cross-session log")
+    p.add_argument("--session", help="filter by session name")
+    p.add_argument("--since", help="filter by ISO date (e.g. 2026-07-09)")
+
+    sub.add_parser("doctor", help="scan .stepgate/ and report problems (never fixes anything)")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    # Consoles with limited encodings (e.g. cp1252 on legacy Windows) must
+    # degrade output gracefully, never crash with a UnicodeEncodeError.
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            try:
+                stream.reconfigure(errors="replace")
+            except (OSError, ValueError):
+                pass
+
+    args = build_parser().parse_args(argv)
+
+    from stepgate.commands import doctor, init_cmd, lifecycle, views
+
+    handlers = {
+        "init": init_cmd.cmd_init,
+        "propose": lifecycle.cmd_propose,
+        "show": views.cmd_show,
+        "approve": lifecycle.cmd_approve,
+        "reject": lifecycle.cmd_reject,
+        "exec-log": lifecycle.cmd_exec_log,
+        "verify": lifecycle.cmd_verify,
+        "close": lifecycle.cmd_close,
+        "abandon": lifecycle.cmd_abandon,
+        "next": lifecycle.cmd_next,
+        "status": views.cmd_status,
+        "history": views.cmd_history,
+        "doctor": doctor.cmd_doctor,
+    }
+    try:
+        return handlers[args.command](args)
+    except StepgateError as exc:
+        print(f"stepgate: error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

stepgate/commands/doctor.py

@@ -0,0 +1,62 @@
+"""stepgate doctor: scan .stepgate/ and report problems without fixing
+anything. A diagnostic tool, never a repair tool — and never a gate: even
+when it finds problems, nothing else is blocked."""
+
+from __future__ import annotations
+
+import json
+
+from stepgate import render
+from stepgate.model import Session
+from stepgate.store import Store
+
+
+def cmd_doctor(args) -> int:
+    store = Store.find()
+    problems: list[str] = []
+
+    if store.config_path.exists():
+        try:
+            config = json.loads(store.config_path.read_text(encoding="utf-8"))
+            for key in ("project_name", "agents", "verify_command"):
+                if key not in config:
+                    problems.append(f"{store.config_path}: missing expected key '{key}'")
+        except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+            problems.append(f"{store.config_path}: not valid JSON ({exc})")
+    else:
+        problems.append(f"{store.config_path}: missing (run 'stepgate init' to recreate it)")
+
+    if store.sessions_dir.is_dir():
+        for path in sorted(store.sessions_dir.glob("*.json")):
+            try:
+                Session.from_dict(json.loads(path.read_text(encoding="utf-8")))
+            except (json.JSONDecodeError, UnicodeDecodeError, KeyError, TypeError) as exc:
+                problems.append(f"{path}: corrupted or invalid ({exc.__class__.__name__}: {exc})")
+    else:
+        problems.append(f"{store.sessions_dir}: missing directory")
+
+    if store.history_path.exists():
+        for i, line in enumerate(
+            store.history_path.read_text(encoding="utf-8").splitlines(), start=1
+        ):
+            if not line.strip():
+                continue
+            try:
+                json.loads(line)
+            except json.JSONDecodeError:
+                problems.append(f"{store.history_path}: invalid JSON at line {i}")
+    else:
+        problems.append(f"{store.history_path}: missing file")
+
+    if not problems:
+        render.info(f"[green]doctor: no problems found in {store.dir}[/]")
+        return 0
+    render.info(f"[yellow]doctor: found {len(problems)} problem(s) in {store.dir}:[/]")
+    for problem in problems:
+        render.info(f"  - {problem}")
+    render.info(
+        "[dim]stepgate never repairs state automatically - please inspect the "
+        "files above manually. Other sessions and normal project work are "
+        "not blocked by this.[/]"
+    )
+    return 1

stepgate/commands/init_cmd.py

@@ -0,0 +1,132 @@
+"""stepgate init: create .stepgate/ and inject the agent instruction block.
+
+Idempotent and never destructive: existing sessions/, history.jsonl and any
+hand-written content in AGENTS.md/CLAUDE.md are always preserved. Only the
+text between the stepgate markers is ever replaced.
+"""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from stepgate import render
+from stepgate.store import DEFAULT_CONFIG, Store
+
+START_MARKER = "<!-- stepgate:start -->"
+END_MARKER = "<!-- stepgate:end -->"
+
+INSTRUCTION_FILES = ("AGENTS.md", "CLAUDE.md")
+GUARDRAILS_CANDIDATES = ("GUARDRAILS.md", "docs/GUARDRAILS.md")
+
+
+def build_instruction_block(guardrails: str | None) -> str:
+    guardrails_paragraph = (
+        f"Domain knowledge for this project lives in `{guardrails}`. That document "
+        "governs *what* is correct in this domain; stepgate governs *when* you may "
+        "execute a change. Both apply, each in its own dimension — neither replaces "
+        "the other.\n\n"
+        if guardrails
+        else ""
+    )
+    return f"""{START_MARKER}
+## Micro-change protocol (stepgate)
+
+This project uses `stepgate`, a CLI that structures work into small, approved
+steps. It is your toolset for proposing and executing changes — the commands
+below are the only legitimate channel for that flow.
+
+{guardrails_paragraph}**When it applies:** any change to code or behavior — implementation, bug fixes
+that edit code, refactoring, contract/schema changes. It does NOT apply to
+read-only work: investigating, explaining, diagnosing without editing.
+
+**The cycle.** Investigate as deeply as you need first — a micro-change reduces
+the scope of *execution*, never the depth of *investigation*. Then:
+
+1. `stepgate propose --agent <your-name> --file plan.json` — a JSON object with
+   six fields (`what`, `why`, `where`, `how`, `expected_result`,
+   `verification`), each written as natural, flowing prose (where is a list of
+   files/areas). State becomes PENDING. Always pass `--agent` (e.g. `claude`,
+   `codex`) so sessions stay readable.
+2. Wait for the user to run `stepgate approve` (possibly `--adjust`) or
+   `stepgate reject`. Never execute a PENDING proposal.
+3. Execute **only** what was approved, then record it:
+   `stepgate exec-log --summary "..." --files "a,b"`.
+4. Verify with real evidence: `stepgate verify --evidence "npm test: 12 passed"`.
+5. After the user runs `stepgate close`, suggest (don't start) the next step:
+   `stepgate next --suggest "..."`.
+
+**Rules:**
+- Approval is per micro-change, never cumulative. One approval is not a blanket
+  pass for the rest of the task.
+- If your environment has an "apply change" / "accept diff" button in the IDE
+  UI, the same rule holds: only reach that point after the proposal was
+  approved via stepgate.
+- If a proposal becomes obsolete, close it out explicitly:
+  `stepgate abandon --reason "..."`.
+- Run `stepgate status`/`history` only when you actually need them (when
+  proposing, or when closing a cycle) — not as a habitual check.
+- stepgate never blocks edits, commits, or the user. It records and makes the
+  flow visible; deviating from it is visible, never silent.
+{END_MARKER}"""
+
+
+def inject_block(path: Path, block: str) -> str:
+    """Create, append, or update-in-place the stepgate block. Returns the
+    action taken. Never discards existing content."""
+    if not path.exists():
+        path.write_text(block + "\n", encoding="utf-8")
+        return "created"
+    content = path.read_text(encoding="utf-8")
+    if START_MARKER in content and END_MARKER in content:
+        start = content.index(START_MARKER)
+        end = content.index(END_MARKER) + len(END_MARKER)
+        path.write_text(content[:start] + block + content[end:], encoding="utf-8")
+        return "updated"
+    separator = "" if content.endswith("\n\n") else ("\n" if content.endswith("\n") else "\n\n")
+    path.write_text(content + separator + block + "\n", encoding="utf-8")
+    return "appended"
+
+
+def detect_guardrails(root: Path) -> str | None:
+    for candidate in GUARDRAILS_CANDIDATES:
+        if (root / candidate).exists():
+            return candidate
+    return None
+
+
+def cmd_init(args) -> int:
+    root = Path.cwd()
+    store = Store(root)
+    store.ensure_layout()
+
+    if not store.config_path.exists():
+        config = dict(DEFAULT_CONFIG)
+        config["project_name"] = root.name
+        store.write_config(config)
+        render.info(f"Created {store.config_path}")
+    else:
+        render.info(f"Kept existing {store.config_path}")
+
+    guardrails = args.guardrails or detect_guardrails(root)
+    if guardrails and not (root / guardrails).exists():
+        render.warn(f"guardrails file '{guardrails}' does not exist; referencing it anyway.")
+    block = build_instruction_block(guardrails)
+    for name in INSTRUCTION_FILES:
+        action = inject_block(root / name, block)
+        render.info(f"{action.capitalize()} stepgate instruction block in {name}")
+    if guardrails:
+        render.info(f"Instruction block references domain guardrails: {guardrails}")
+
+    if shutil.which("stepgate") is None:
+        render.warn(
+            "the 'stepgate' executable was not found on PATH from this "
+            "environment. Agents running here will not be able to call it - "
+            "check the installation (pipx install stepgate) or this "
+            "environment's PATH."
+        )
+    render.info(
+        f"[green]stepgate initialized in {store.dir}[/] "
+        "(existing sessions and history, if any, were preserved)."
+    )
+    return 0

stepgate/commands/lifecycle.py

@@ -0,0 +1,238 @@
+"""Lifecycle commands: propose, approve, reject, exec-log, verify, close,
+abandon, next. These validate the proposal state machine; they never block
+or restrict edits to the project's own code."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+from stepgate import render
+from stepgate.model import (
+    APPROVED,
+    PENDING,
+    Proposal,
+    Session,
+    StepgateError,
+    validate_plan,
+)
+from stepgate.store import Store
+
+UNKNOWN_AGENT = "unknown"
+
+
+def _agent_or_fallback(args) -> str:
+    return args.agent or UNKNOWN_AGENT
+
+
+def resolve_session(store: Store, args, *, active_only: bool = True) -> Session:
+    """Resolve which session a command targets.
+
+    Priority: explicit --session > latest session of --agent > the single
+    session with an active proposal, if there is exactly one.
+    """
+    if getattr(args, "session", None):
+        return store.load_session(args.session)
+    if args.agent:
+        session = store.latest_session_for_agent(args.agent)
+        if session is None:
+            raise StepgateError(
+                f"No session found for agent '{args.agent}'. "
+                "Start one with 'stepgate propose'."
+            )
+        return session
+    candidates = [s for s in store.iter_sessions() if not active_only or s.has_active_proposal]
+    if len(candidates) == 1:
+        return candidates[0]
+    if not candidates:
+        raise StepgateError(
+            "No session with an active proposal was found. "
+            "Start one with 'stepgate propose'."
+        )
+    names = ", ".join(s.name for s in candidates)
+    raise StepgateError(
+        f"Multiple sessions are active ({names}). "
+        "Pass --agent <name> or --session <name> to pick one."
+    )
+
+
+def _overlap_warnings(store: Store, current: Session) -> None:
+    """Warn (never block) when active proposals across sessions share files."""
+    if not current.has_active_proposal:
+        return
+    mine = set(current.proposal.plan["where"])
+    for other in store.iter_sessions():
+        if other.name == current.name or not other.has_active_proposal:
+            continue
+        if other.proposal.state not in (PENDING, APPROVED):
+            continue
+        shared = mine & set(other.proposal.plan["where"])
+        if shared:
+            render.warn(
+                f"scope overlap with session '{other.name}' "
+                f"({other.proposal.state}): {', '.join(sorted(shared))}. "
+                "This is informational only - nothing is blocked."
+            )
+
+
+def _transition(store: Store, args, action: str, data: dict) -> Session:
+    session = resolve_session(store, args)
+    if session.proposal is None:
+        raise StepgateError(
+            f"Session '{session.name}' has no proposal. "
+            "Start one with 'stepgate propose'."
+        )
+    new_state = session.proposal.apply(action, data)
+    store.save_session(session)
+    store.append_history(session.name, session.agent, action, data)
+    render.info(
+        f"[bold magenta]{session.name}[/] :: {action} -> "
+        f"[{render.STATE_STYLES.get(new_state, 'bold')}]{new_state}[/]"
+    )
+    return session
+
+
+# -- commands ---------------------------------------------------------------
+
+
+def cmd_propose(args) -> int:
+    store = Store.find()
+    plan_path = Path(args.file)
+    if not plan_path.exists():
+        raise StepgateError(f"Plan file not found: {plan_path}")
+    try:
+        raw = json.loads(plan_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+        raise StepgateError(f"Plan file is not valid JSON: {plan_path} ({exc})") from exc
+    plan = validate_plan(raw)
+
+    agent = _agent_or_fallback(args)
+    if not args.agent:
+        render.warn(
+            "no --agent flag given; using the fallback session name "
+            f"'{UNKNOWN_AGENT}-...'. Pass --agent claude|codex|... to keep "
+            "session names readable."
+        )
+
+    session = None if args.new_session else store.latest_session_for_agent(agent)
+    if session is not None and session.has_active_proposal:
+        raise StepgateError(
+            f"Session '{session.name}' already has an active proposal in state "
+            f"{session.proposal.state}. Close, reject, or abandon it first - "
+            "or pass --new-session to start a parallel session."
+        )
+    if session is None:
+        session = Session(name=store.new_session_name(agent), agent=agent)
+
+    session.proposal = Proposal(plan=plan)
+    session.pending_suggestion = None
+    store.save_session(session)
+    store.append_history(session.name, session.agent, "propose", {"plan": plan})
+
+    render.console.print(render.proposal_panel(session.name, session.proposal.to_dict()))
+    render.info(
+        f"Proposal registered as [bold yellow]PENDING[/] in session "
+        f"[bold magenta]{session.name}[/]. Waiting for approval "
+        "('stepgate approve' or 'stepgate reject')."
+    )
+    _overlap_warnings(store, session)
+    return 0
+
+
+def cmd_approve(args) -> int:
+    store = Store.find()
+    data: dict = {}
+    if args.adjust:
+        if args.scope:
+            data["scope"] = [p.strip() for p in args.scope.split(",") if p.strip()]
+        if args.note:
+            data["note"] = args.note
+        if not data:
+            raise StepgateError("--adjust requires --scope and/or --note describing the adjustment.")
+    session = _transition(store, args, "approve", data)
+    if args.adjust and data.get("scope"):
+        session.proposal.plan["where"] = data["scope"]
+        store.save_session(session)
+    render.info(
+        "Approval covers this micro-change only - it is not a blanket "
+        "approval for the rest of the task."
+    )
+    return 0
+
+
+def cmd_reject(args) -> int:
+    store = Store.find()
+    _transition(store, args, "reject", {"note": args.note})
+    return 0
+
+
+def _git_diff_stat(root: Path) -> str | None:
+    """Best-effort git diff --stat capture. Never raises, never blocks."""
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--stat", "HEAD"],
+            cwd=root, capture_output=True, text=True, timeout=15,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip()
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return None
+
+
+def cmd_exec_log(args) -> int:
+    store = Store.find()
+    data: dict = {"summary": args.summary}
+    if args.files:
+        data["files"] = [p.strip() for p in args.files.split(",") if p.strip()]
+    diff_stat = _git_diff_stat(store.root)
+    if diff_stat is not None:
+        data["git_diff_stat"] = diff_stat
+    _transition(store, args, "exec-log", data)
+    if diff_stat:
+        render.console.print(
+            "[dim]git diff --stat captured as objective evidence:[/]\n" + diff_stat
+        )
+    return 0
+
+
+def cmd_verify(args) -> int:
+    store = Store.find()
+    _transition(store, args, "verify", {"evidence": args.evidence})
+    return 0
+
+
+def cmd_close(args) -> int:
+    store = Store.find()
+    session = _transition(store, args, "close", {})
+    session.closed_proposals += 1
+    store.save_session(session)
+    render.info(
+        "Micro-change closed. Suggest the next step with 'stepgate next "
+        "--suggest \"...\"' - but do not start it without a new approved proposal."
+    )
+    return 0
+
+
+def cmd_abandon(args) -> int:
+    store = Store.find()
+    _transition(store, args, "abandon", {"reason": args.reason})
+    render.info(
+        "Session left cleanly. Nothing in the project or in other sessions "
+        "is affected."
+    )
+    return 0
+
+
+def cmd_next(args) -> int:
+    store = Store.find()
+    session = resolve_session(store, args, active_only=False)
+    session.pending_suggestion = args.suggest
+    store.save_session(session)
+    store.append_history(session.name, session.agent, "next-suggest", {"suggestion": args.suggest})
+    render.info(
+        f"Next-step suggestion recorded in session [bold magenta]{session.name}[/]. "
+        "It will stay visible in 'stepgate status' until a new proposal is opened."
+    )
+    return 0

stepgate/commands/views.py

@@ -0,0 +1,129 @@
+"""Read-only views: show, status, history."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from rich.table import Table
+from rich.text import Text
+
+from stepgate import render
+from stepgate.commands.lifecycle import resolve_session
+from stepgate.model import APPROVED, PENDING, StepgateError, TERMINAL_STATES
+from stepgate.store import Store
+
+
+def cmd_show(args) -> int:
+    store = Store.find()
+    session = resolve_session(store, args, active_only=False)
+    if session.proposal is None:
+        raise StepgateError(f"Session '{session.name}' has no proposal to show.")
+    render.console.print(render.proposal_panel(session.name, session.proposal.to_dict()))
+    return 0
+
+
+def _overlaps(sessions) -> list[str]:
+    active = [s for s in sessions if s.has_active_proposal and s.proposal.state in (PENDING, APPROVED)]
+    messages = []
+    for i, a in enumerate(active):
+        for b in active[i + 1:]:
+            shared = set(a.proposal.plan["where"]) & set(b.proposal.plan["where"])
+            if shared:
+                messages.append(
+                    f"sessions '{a.name}' and '{b.name}' both touch: "
+                    + ", ".join(sorted(shared))
+                )
+    return messages
+
+
+def cmd_status(args) -> int:
+    store = Store.find()
+    sessions = list(store.iter_sessions())
+    if not sessions:
+        render.info("No sessions yet. Start one with 'stepgate propose'.")
+        return 0
+
+    table = Table(title="stepgate :: project status", border_style="dim")
+    table.add_column("Session", style="magenta")
+    table.add_column("State")
+    table.add_column("Closed", justify="right")
+    table.add_column("Last activity", style="dim")
+    for session in sessions:
+        if session.proposal is None:
+            state = Text("no proposal", style="dim")
+            last = session.created_at
+        else:
+            state = render.state_text(session.proposal.state)
+            last = session.proposal.updated_at
+        table.add_row(session.name, state, str(session.closed_proposals), last)
+    render.console.print(table)
+
+    focus = None
+    if getattr(args, "session", None) or args.agent:
+        focus = resolve_session(store, args, active_only=False)
+    elif len(sessions) == 1:
+        focus = sessions[0]
+    if focus is not None:
+        if focus.pending_suggestion:
+            render.console.print(
+                Text.assemble(
+                    ("Suggested next step", "bold green"),
+                    (f" ({focus.name}): ", "dim"),
+                    focus.pending_suggestion,
+                )
+            )
+        if focus.proposal and focus.proposal.state not in TERMINAL_STATES:
+            render.console.print(render.proposal_panel(focus.name, focus.proposal.to_dict()))
+    else:
+        for session in sessions:
+            if session.pending_suggestion:
+                render.console.print(
+                    Text.assemble(
+                        ("Suggested next step", "bold green"),
+                        (f" ({session.name}): ", "dim"),
+                        session.pending_suggestion,
+                    )
+                )
+
+    for message in _overlaps(sessions):
+        render.warn("scope overlap - " + message + ". Informational only, nothing is blocked.")
+    return 0
+
+
+def cmd_history(args) -> int:
+    store = Store.find()
+    entries = store.read_history()
+    if args.session:
+        entries = [e for e in entries if e.get("session") == args.session]
+    if args.since:
+        try:
+            since = datetime.fromisoformat(args.since)
+        except ValueError as exc:
+            raise StepgateError(
+                f"--since must be an ISO date like 2026-07-09 (got '{args.since}')."
+            ) from exc
+        if since.tzinfo is None:
+            since = since.astimezone()
+        entries = [
+            e for e in entries
+            if datetime.fromisoformat(e["ts"]) >= since
+        ]
+    if not entries:
+        render.info("No history entries match.")
+        return 0
+    table = Table(title="stepgate :: history (append-only)", border_style="dim")
+    table.add_column("When", style="dim", no_wrap=True)
+    table.add_column("Session", style="magenta", no_wrap=True)
+    table.add_column("Event")
+    table.add_column("Detail", overflow="fold")
+    for entry in entries:
+        data = entry.get("data") or {}
+        detail = (
+            data.get("summary") or data.get("evidence") or data.get("note")
+            or data.get("reason") or data.get("suggestion")
+            or (data.get("plan", {}).get("what") if isinstance(data.get("plan"), dict) else "")
+            or ""
+        )
+        table.add_row(entry["ts"], entry["session"], entry["event"], detail)
+    render.console.print(table)
+    return 0

stepgate/model.py

@@ -0,0 +1,188 @@
+"""Data model and state machine for stepgate proposals.
+
+The state machine governs the lifecycle of a *proposal*, never the code
+itself. Editing code without an open proposal is a legitimate flow and is
+never treated as an error by stepgate.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+# Proposal states
+PENDING = "PENDING"
+APPROVED = "APPROVED"
+EXECUTED = "EXECUTED"
+VERIFIED = "VERIFIED"
+CLOSED = "CLOSED"
+REJECTED = "REJECTED"
+ABANDONED = "ABANDONED"
+
+TERMINAL_STATES = {CLOSED, REJECTED, ABANDONED}
+
+# action -> (required current state, next state)
+TRANSITIONS = {
+    "approve": (PENDING, APPROVED),
+    "reject": (PENDING, REJECTED),
+    "exec-log": (APPROVED, EXECUTED),
+    "verify": (EXECUTED, VERIFIED),
+    "close": (VERIFIED, CLOSED),
+}
+
+PLAN_FIELDS = ("what", "why", "where", "how", "expected_result", "verification")
+
+PLAN_FIELD_LABELS = {
+    "what": "What",
+    "why": "Why",
+    "where": "Where",
+    "how": "How",
+    "expected_result": "Expected result",
+    "verification": "Verification",
+}
+
+
+class StepgateError(Exception):
+    """User-facing error. The CLI prints its message without a traceback."""
+
+
+class InvalidTransitionError(StepgateError):
+    pass
+
+
+class CorruptStateError(StepgateError):
+    """Raised when a state file on disk cannot be read or parsed."""
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def validate_plan(raw: Any) -> dict[str, Any]:
+    """Validate a plan document: all six fields present and non-empty.
+
+    ``where`` may be a list of files/areas or a comma-separated string;
+    it is normalized to a list. All other fields are free-flowing prose.
+    """
+    if not isinstance(raw, dict):
+        raise StepgateError("The plan file must contain a JSON object.")
+    plan: dict[str, Any] = {}
+    missing = []
+    for name in PLAN_FIELDS:
+        value = raw.get(name)
+        if name == "where":
+            if isinstance(value, str):
+                value = [p.strip() for p in value.split(",") if p.strip()]
+            if not isinstance(value, list) or not value:
+                missing.append(name)
+                continue
+            plan[name] = [str(v) for v in value]
+        else:
+            if not isinstance(value, str) or not value.strip():
+                missing.append(name)
+                continue
+            plan[name] = value.strip()
+    if missing:
+        raise StepgateError(
+            "The plan is missing required fields: "
+            + ", ".join(missing)
+            + ". A micro-change plan must cover all six points "
+            "(what, why, where, how, expected_result, verification) "
+            "written as natural, flowing prose."
+        )
+    unknown = [k for k in raw if k not in PLAN_FIELDS]
+    if unknown:
+        raise StepgateError(
+            "The plan contains unknown fields: " + ", ".join(sorted(unknown))
+        )
+    return plan
+
+
+@dataclass
+class Proposal:
+    plan: dict[str, Any]
+    state: str = PENDING
+    created_at: str = field(default_factory=now_iso)
+    updated_at: str = field(default_factory=now_iso)
+    events: list[dict[str, Any]] = field(default_factory=list)
+
+    def apply(self, action: str, data: dict[str, Any] | None = None) -> str:
+        """Apply a lifecycle action, validating the state machine."""
+        if action == "abandon":
+            if self.state in TERMINAL_STATES:
+                raise InvalidTransitionError(
+                    f"Cannot abandon a proposal in terminal state {self.state}."
+                )
+            new_state = ABANDONED
+        else:
+            if action not in TRANSITIONS:
+                raise InvalidTransitionError(f"Unknown action: {action}")
+            required, new_state = TRANSITIONS[action]
+            if self.state != required:
+                raise InvalidTransitionError(
+                    f"'{action}' requires a proposal in state {required}, "
+                    f"but the active proposal is {self.state}."
+                )
+        self.state = new_state
+        self.updated_at = now_iso()
+        self.events.append({"ts": self.updated_at, "action": action, "data": data or {}})
+        return new_state
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "plan": self.plan,
+            "state": self.state,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "events": self.events,
+        }
+
+    @classmethod
+    def from_dict(cls, raw: dict[str, Any]) -> "Proposal":
+        return cls(
+            plan=raw["plan"],
+            state=raw["state"],
+            created_at=raw.get("created_at", now_iso()),
+            updated_at=raw.get("updated_at", now_iso()),
+            events=raw.get("events", []),
+        )
+
+
+@dataclass
+class Session:
+    name: str
+    agent: str
+    created_at: str = field(default_factory=now_iso)
+    proposal: Proposal | None = None
+    pending_suggestion: str | None = None
+    closed_proposals: int = 0
+
+    @property
+    def has_active_proposal(self) -> bool:
+        return self.proposal is not None and self.proposal.state not in TERMINAL_STATES
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "session": self.name,
+            "agent": self.agent,
+            "created_at": self.created_at,
+            "proposal": self.proposal.to_dict() if self.proposal else None,
+            "pending_suggestion": self.pending_suggestion,
+            "closed_proposals": self.closed_proposals,
+        }
+
+    @classmethod
+    def from_dict(cls, raw: dict[str, Any]) -> "Session":
+        for key in ("session", "agent"):
+            if not isinstance(raw.get(key), str):
+                raise KeyError(key)
+        proposal = raw.get("proposal")
+        return cls(
+            name=raw["session"],
+            agent=raw["agent"],
+            created_at=raw.get("created_at", now_iso()),
+            proposal=Proposal.from_dict(proposal) if proposal else None,
+            pending_suggestion=raw.get("pending_suggestion"),
+            closed_proposals=raw.get("closed_proposals", 0),
+        )

stepgate/render.py

@@ -0,0 +1,83 @@
+"""Terminal rendering helpers.
+
+Proposals are rendered as flowing, readable prose — the same natural
+language the agent wrote them in — never as a rigid telegraphic form.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+err_console = Console(stderr=True, style="yellow")
+
+STATE_STYLES = {
+    "PENDING": "bold yellow",
+    "APPROVED": "bold cyan",
+    "EXECUTED": "bold blue",
+    "VERIFIED": "bold green",
+    "CLOSED": "bold dim green",
+    "REJECTED": "bold red",
+    "ABANDONED": "bold dim",
+}
+
+
+def state_text(state: str) -> Text:
+    return Text(state, style=STATE_STYLES.get(state, "bold"))
+
+
+def plan_as_prose(plan: dict[str, Any]) -> Group:
+    """Render the six plan fields as connected paragraphs of prose."""
+    where = ", ".join(plan["where"])
+    paragraphs = [
+        Text(plan["what"]),
+        Text(plan["why"], style="dim"),
+        Text.assemble(("Touches: ", "italic"), where),
+        Text(plan["how"]),
+        Text.assemble(("Expected result: ", "italic"), plan["expected_result"]),
+        Text.assemble(("Verification: ", "italic"), plan["verification"]),
+    ]
+    spaced: list[Any] = []
+    for para in paragraphs:
+        spaced.append(para)
+        spaced.append(Text(""))
+    return Group(*spaced[:-1])
+
+
+def proposal_panel(session_name: str, proposal: dict[str, Any]) -> Panel:
+    title = Text.assemble(
+        ("Proposal :: ", "bold"), (session_name, "bold magenta"), (" :: ", "bold"),
+        state_text(proposal["state"]),
+    )
+    body: list[Any] = [plan_as_prose(proposal["plan"])]
+    notes = []
+    for event in proposal.get("events", []):
+        data = event.get("data") or {}
+        if event["action"] == "approve" and (data.get("note") or data.get("scope")):
+            note = data.get("note", "")
+            scope = data.get("scope")
+            detail = f"Approved with adjustment: {note}" if note else "Approved with adjusted scope"
+            if scope:
+                detail += f" (scope: {', '.join(scope)})"
+            notes.append(detail)
+        elif event["action"] == "reject":
+            notes.append(f"Rejected: {data.get('note', '')}")
+        elif event["action"] == "abandon":
+            notes.append(f"Abandoned: {data.get('reason', '')}")
+    if notes:
+        body.append(Text(""))
+        for note in notes:
+            body.append(Text(f"- {note}", style="yellow"))
+    return Panel(Group(*body), title=title, title_align="left", border_style="dim")
+
+
+def warn(message: str) -> None:
+    err_console.print(f"warning: {message}")
+
+
+def info(message: str) -> None:
+    console.print(message)

stepgate/store.py

@@ -0,0 +1,166 @@
+"""On-disk state for stepgate: .stepgate/ directory, sessions, history.
+
+The file lock protects only stepgate's own internal state under .stepgate/.
+It never touches, locks, or otherwise restricts the project's source code,
+the user's editor, or git.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import date
+from pathlib import Path
+from typing import Any, Iterator
+
+from filelock import FileLock
+
+from stepgate.model import CorruptStateError, Session, StepgateError, now_iso
+
+STEPGATE_DIR = ".stepgate"
+SESSION_NAME_RE = re.compile(r"^(?P<agent>.+)-(?P<date>\d{4}-\d{2}-\d{2})-(?P<seq>\d+)$")
+
+DEFAULT_CONFIG = {
+    "project_name": "",
+    "agents": ["claude", "codex"],
+    "verify_command": "",
+}
+
+
+class Store:
+    def __init__(self, root: Path):
+        self.root = root
+        self.dir = root / STEPGATE_DIR
+        self.sessions_dir = self.dir / "sessions"
+        self.history_path = self.dir / "history.jsonl"
+        self.config_path = self.dir / "config.json"
+        self.lock = FileLock(str(self.dir / ".lock"), timeout=10)
+
+    # -- discovery ---------------------------------------------------------
+
+    @classmethod
+    def find(cls, start: Path | None = None) -> "Store":
+        """Locate .stepgate/ in the current directory or any parent."""
+        current = (start or Path.cwd()).resolve()
+        for candidate in [current, *current.parents]:
+            if (candidate / STEPGATE_DIR).is_dir():
+                return cls(candidate)
+        raise StepgateError(
+            "No .stepgate/ directory found in this directory or any parent. "
+            "Run 'stepgate init' at the root of the project first."
+        )
+
+    def ensure_layout(self) -> None:
+        self.dir.mkdir(exist_ok=True)
+        self.sessions_dir.mkdir(exist_ok=True)
+        if not self.history_path.exists():
+            self.history_path.touch()
+
+    # -- config ------------------------------------------------------------
+
+    def load_config(self) -> dict[str, Any]:
+        if not self.config_path.exists():
+            return dict(DEFAULT_CONFIG)
+        try:
+            return json.loads(self.config_path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+            raise CorruptStateError(
+                f"Config file is not valid JSON: {self.config_path}\n"
+                f"  ({exc})\n"
+                "Please inspect and fix it manually; stepgate never rewrites "
+                "state on its own."
+            ) from exc
+
+    def write_config(self, config: dict[str, Any]) -> None:
+        with self.lock:
+            self.config_path.write_text(
+                json.dumps(config, indent=2, ensure_ascii=False) + "\n",
+                encoding="utf-8",
+            )
+
+    # -- sessions ----------------------------------------------------------
+
+    def session_path(self, name: str) -> Path:
+        return self.sessions_dir / f"{name}.json"
+
+    def load_session(self, name: str) -> Session:
+        path = self.session_path(name)
+        if not path.exists():
+            raise StepgateError(f"Session '{name}' does not exist under {self.sessions_dir}.")
+        return self._read_session_file(path)
+
+    def _read_session_file(self, path: Path) -> Session:
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+            return Session.from_dict(raw)
+        except (json.JSONDecodeError, UnicodeDecodeError, KeyError, TypeError) as exc:
+            raise CorruptStateError(
+                f"Session file is corrupted or invalid: {path}\n"
+                f"  ({exc.__class__.__name__}: {exc})\n"
+                "Please inspect it manually; stepgate never repairs or "
+                "rewrites state on its own. Other sessions are unaffected."
+            ) from exc
+
+    def iter_sessions(self) -> Iterator[Session]:
+        """Yield all sessions, sorted by name. Corrupt files raise."""
+        for path in sorted(self.sessions_dir.glob("*.json")):
+            yield self._read_session_file(path)
+
+    def save_session(self, session: Session) -> None:
+        with self.lock:
+            self.session_path(session.name).write_text(
+                json.dumps(session.to_dict(), indent=2, ensure_ascii=False) + "\n",
+                encoding="utf-8",
+            )
+
+    def new_session_name(self, agent: str) -> str:
+        """Allocate the next human-readable session name for today."""
+        today = date.today().isoformat()
+        prefix = f"{agent}-{today}-"
+        seqs = [
+            int(m.group("seq"))
+            for p in self.sessions_dir.glob(f"{agent}-{today}-*.json")
+            if (m := SESSION_NAME_RE.match(p.stem)) and m.group("agent") == agent
+        ]
+        return f"{prefix}{max(seqs, default=0) + 1}"
+
+    def latest_session_for_agent(self, agent: str) -> Session | None:
+        paths = sorted(
+            (p for p in self.sessions_dir.glob(f"{agent}-*.json")
+             if (m := SESSION_NAME_RE.match(p.stem)) and m.group("agent") == agent),
+            key=lambda p: p.stat().st_mtime,
+        )
+        if not paths:
+            return None
+        return self._read_session_file(paths[-1])
+
+    # -- history (append-only) ----------------------------------------------
+
+    def append_history(self, session: str, agent: str, event: str, data: dict[str, Any]) -> None:
+        """Append one event line. history.jsonl is never rewritten or edited."""
+        line = json.dumps(
+            {"ts": now_iso(), "session": session, "agent": agent, "event": event, "data": data},
+            ensure_ascii=False,
+        )
+        with self.lock:
+            with self.history_path.open("a", encoding="utf-8") as fh:
+                fh.write(line + "\n")
+
+    def read_history(self) -> list[dict[str, Any]]:
+        if not self.history_path.exists():
+            return []
+        entries = []
+        for i, line in enumerate(
+            self.history_path.read_text(encoding="utf-8").splitlines(), start=1
+        ):
+            if not line.strip():
+                continue
+            try:
+                entries.append(json.loads(line))
+            except json.JSONDecodeError as exc:
+                raise CorruptStateError(
+                    f"History file has an invalid entry at line {i}: {self.history_path}\n"
+                    f"  ({exc})\n"
+                    "Please inspect it manually; stepgate never rewrites history."
+                ) from exc
+        return entries

stepgate-0.1.0.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: stepgate
+Version: 0.1.0
+Summary: A step-gated micro-change protocol CLI for coding agents: propose, approve, execute, verify — one small step at a time.
+Project-URL: Homepage, https://github.com/LeoCostta/stepgate
+Project-URL: Repository, https://github.com/LeoCostta/stepgate
+Project-URL: Issues, https://github.com/LeoCostta/stepgate/issues
+Author: Leo Costta
+License-Expression: MIT
+License-File: LICENSE
+Keywords: claude-code,cli,codex,coding-agents,guardrails,workflow
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: filelock>=3.12
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# stepgate
+
+[![PyPI version](https://img.shields.io/pypi/v/stepgate)](https://pypi.org/project/stepgate/)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue)](https://pypi.org/project/stepgate/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+**A step-gated micro-change protocol for coding agents.**
+
+Coding agents (Claude Code, Codex, …) working on large or loosely-scoped tasks
+tend to mix contexts, silently expand scope, touch files unrelated to the
+original request, or declare success without real evidence. `stepgate` makes
+the correct workflow — investigate, propose, wait for approval, execute only
+what was approved, verify, suggest the next step — **the single natural path
+of action**, so that deviating from it is visible and recorded, never silent.
+
+`stepgate` is *not* an enforcement tool. It never blocks your code, your
+editor, your commits, or git. You can always edit anything, commit anything,
+and cancel any agent session at any time. What it gives you is structure and
+an honest, append-only trail of what was proposed, approved, executed, and
+verified — across every agent working on the repo, even concurrently.
+
+## Install
+
+```bash
+pipx install stepgate   # recommended: one global install per machine
+# or: pip install stepgate
+```
+
+Then, at the root of any project:
+
+```bash
+stepgate init
+```
+
+This creates `.stepgate/` (state + append-only history) and injects an
+instruction block into `AGENTS.md`/`CLAUDE.md` telling agents to use the
+protocol. It is idempotent and never overwrites anything you wrote in those
+files — only the text between its own markers is ever touched. If your
+project already has a domain guardrails document, point to it with
+`--guardrails GUARDRAILS.md` and the generated block will reference it.
+
+## The protocol
+
+Every micro-change is a proposal moving through a state machine, validated by
+the CLI itself:
+
+```
+PENDING ──approve──► APPROVED ──exec-log──► EXECUTED ──verify──► VERIFIED ──close──► CLOSED
+   │
+   └─reject──► REJECTED          (any non-terminal state) ──abandon──► ABANDONED
+```
+
+A proposal covers six points, each written as natural flowing prose (not a
+telegraphic form): **what** will change now, **why** this step comes first,
+**where** (files/contracts/flows touched), **how** it will be implemented,
+the **expected result**, and the **verification** that will demonstrate it.
+
+Key rule: *a micro-change reduces the scope of execution, never the depth of
+investigation* — the agent still investigates everything it needs to
+understand before proposing, even if it will only implement a small piece.
+
+## A real cycle
+
+You ask your agent to fix a race condition. It investigates, then proposes:
+
+```bash
+stepgate propose --agent claude --file plan.json
+```
+
+You read it rendered as prose, and approve with a tweak:
+
+```bash
+stepgate show
+stepgate approve --adjust --note "rename the function to apply_sanity_loss_atomic"
+```
+
+The agent implements **only** what was approved, logs it (a `git diff --stat`
+is captured automatically as objective evidence), and verifies:
+
+```bash
+stepgate exec-log --summary "atomic decrement migration + typing" --files "migrations/013.sql,types.ts"
+stepgate verify --evidence "type-check ok, simulated concurrency test passed"
+```
+
+You close the cycle; the agent suggests — but does not start — the next step:
+
+```bash
+stepgate close
+stepgate next --suggest "wire SalaJogo.tsx to the new function via supabase.rpc(...)"
+```
+
+The suggestion stays visible in `stepgate status` until a new proposal is
+opened. The full trail lives in `stepgate history` — chronological, across
+all sessions and agents, append-only.
+
+## Commands
+
+| Command | Purpose |
+| --- | --- |
+| `stepgate init` | Create `.stepgate/`, inject the agent instruction block |
+| `stepgate propose --agent X --file plan.json` | Register a micro-change plan (PENDING) |
+| `stepgate show` | Render the active proposal as readable prose |
+| `stepgate approve [--adjust --scope ... --note ...]` | Approve (optionally with reduced scope) |
+| `stepgate reject --note "..."` | Reject a pending proposal |
+| `stepgate exec-log --summary "..." --files "..."` | Record execution (+ automatic `git diff --stat`) |
+| `stepgate verify --evidence "..."` | Record verification evidence |
+| `stepgate close` | Close a verified micro-change |
+| `stepgate abandon --reason "..."` | Cleanly abandon from any non-terminal state |
+| `stepgate next --suggest "..."` | Record a next-step suggestion (opens nothing) |
+| `stepgate status` | Current session + aggregated project view |
+| `stepgate history [--session X] [--since DATE]` | Append-only, cross-session log |
+| `stepgate doctor` | Report corrupted/invalid state files (fixes nothing) |
+
+Multiple agents can work concurrently: each session has its own state file
+(`.stepgate/sessions/claude-2026-07-09-1.json` — human-readable names, not
+hashes), writes are file-locked, and `propose`/`status` warn — informationally,
+never blockingly — when two active proposals touch the same files.
+
+## Design principles
+
+- **Never block.** No git hooks, no file locks on your code, no commit gates.
+  The file lock in `.stepgate/` protects only stepgate's own state files.
+- **Never act silently.** No auto-repair, no auto-expiry of stale sessions,
+  no rewriting of history. `doctor` diagnoses; a human decides.
+- **Non-interactive by design.** No prompts or confirmations, so it behaves
+  identically in a terminal, a desktop app, or an IDE side-panel extension.
+- **Structure when you opt in.** Editing code without a proposal is a
+  legitimate flow, not an error. The state machine gives shape to the agent
+  workflow — it is never a requirement for the code to change.
+
+## License
+
+[MIT](LICENSE) © Leo Costta

stepgate-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+stepgate/__init__.py,sha256=IZxXfQ2n8pnmLgv6dj1Be9njsxplcENXp806poUTp8I,97
+stepgate/__main__.py,sha256=Xyfrw2Y79AkRDE3dKx8uIVu4s-u2gzrfbzwkcBOFkTg,87
+stepgate/cli.py,sha256=BzEWRXwl9grVouYrQW-zTsNlhAL6fU93Jl4MWynXITA,5102
+stepgate/model.py,sha256=tJ7alq87B9fU6HIFeCCovUKu31syCMVvp5wCjqqCuMw,6153
+stepgate/render.py,sha256=IGmyZ3maUy43NK3tDkvFOS0y1BQjc5-ZWAvg7PLLQRA,2702
+stepgate/store.py,sha256=AIgdN7JoHYPHgvgVwJgmfaSkdVjPZqut-yxStq9FpyY,6451
+stepgate/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stepgate/commands/doctor.py,sha256=k4HdpoCO7VI8W2QeCKaxFzHuqkOlySY_XkJ51ffS_pc,2429
+stepgate/commands/init_cmd.py,sha256=qbf2b-MXf3tYatAqLvXNuW33xWLNnrrMMEfsj_kQ-kE,5564
+stepgate/commands/lifecycle.py,sha256=7kQehaK8BSa7CIatAyNnaxp-dkHKlUE1f9ziOuf0CHk,8119
+stepgate/commands/views.py,sha256=M8BNp4HtmF3y9vZCq0kR3YiOzKpz-xRVkg3Ol5Kx2qM,4749
+stepgate-0.1.0.dist-info/METADATA,sha256=pZO6YqvK1Wr0iBQWnKH3YK5hi6igi7eMdcGK8OCuJhc,7055
+stepgate-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+stepgate-0.1.0.dist-info/entry_points.txt,sha256=s0w8mFOv3Zp6rDu3_xwZll-RP7QeklkzYuvl88_fKEc,47
+stepgate-0.1.0.dist-info/licenses/LICENSE,sha256=VlYH_evnP_W3jmP7TtpaTmQQC0_cGvVK8F4AC9kd7ZI,1067
+stepgate-0.1.0.dist-info/RECORD,,

stepgate-0.1.0.dist-info/WHEEL

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

stepgate-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stepgate = stepgate.cli:main

stepgate-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leo Costta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.