teddy-cli 0.1.17.dev1416__tar.gz → 0.1.17.dev1419__tar.gz

{teddy_cli-0.1.17.dev1416 → teddy_cli-0.1.17.dev1419}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: teddy-cli
-Version: 0.1.17.dev1416
+Version: 0.1.17.dev1419
 Summary: The local-first, test-driven agentic engineering harness. Because you should own the means of development.
 Author: Raphael Atteritano
 License: AGPL-3.0-only

{teddy_cli-0.1.17.dev1416 → teddy_cli-0.1.17.dev1419}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "teddy-cli"
-version = "0.1.17.dev1416"
+version = "0.1.17.dev1419"
 description = "The local-first, test-driven agentic engineering harness. Because you should own the means of development."
 readme = "README.md"
 keywords = [

{teddy_cli-0.1.17.dev1416 → teddy_cli-0.1.17.dev1419}/src/teddy_executor/adapters/inbound/session_cli_handlers.py

@@ -286,6 +286,7 @@ _GIT_PULL_TIMEOUT_SECONDS = 15
 _PULL_SKIPPED_WARNING = "⚠ Workspace pull skipped; continuing with the current branch."
 _PULL_TIMEOUT_WARNING = "⚠ Workspace pull timed out; continuing without it."
 _PULL_GIT_UNAVAILABLE_WARNING = "⚠ Workspace pull skipped; git is unavailable."
+_PULL_UP_TO_DATE_NOTICE = "✓ Workspace up-to-date with remote"
 _IN_PROGRESS_GIT_MARKERS = (
     "rebase-merge",
     "rebase-apply",
@@ -295,13 +296,12 @@ _IN_PROGRESS_GIT_MARKERS = (
 
 
 def _warn_pull(message: str) -> None:
-    """Print one yellow pull warning followed by a blank line.
+    """Print one yellow pull warning.
 
-    The trailing blank line keeps every pull block, success or warning, the
-    same height before the ``Checking configurations...`` line.
+    The shared preamble owns the separator blank line before
+    ``Checking configurations...``, so this line carries no trailing blank.
     """
     typer.secho(message, fg=typer.colors.YELLOW, err=True)
-    typer.echo("", err=True)
 
 
 def _pull_workspace_on_start(
@@ -411,20 +411,22 @@ def _read_head(git_run: Callable[..., Any]) -> str:
 
 
 def _report_fast_forward(git_run: Callable[..., Any], before: str, after: str) -> None:
-    """Report how many commits the fast-forward moved, or stay silent.
+    """Report the pull outcome so the user always sees a result.
 
-    A pull that moves no commit has nothing to report, so it prints nothing.
+    A fast-forward names the number of moved commits. A pull that moves no
+    commit confirms the workspace is already up to date.
     """
-    if after == before:
-        return
-    count_output = git_run(
-        ["git", "rev-list", "--count", f"{before}..{after}"],
-        capture_output=True,
-        text=True,
-        timeout=_GIT_PULL_TIMEOUT_SECONDS,
-    ).stdout.strip()
-    commits = int(count_output) if count_output else 0
+    commits = 0
+    if after != before:
+        count_output = git_run(
+            ["git", "rev-list", "--count", f"{before}..{after}"],
+            capture_output=True,
+            text=True,
+            timeout=_GIT_PULL_TIMEOUT_SECONDS,
+        ).stdout.strip()
+        commits = int(count_output) if count_output else 0
     if commits <= 0:
+        typer.secho(_PULL_UP_TO_DATE_NOTICE, fg=typer.colors.GREEN, err=True)
         return
     noun = "commit" if commits == 1 else "commits"
     typer.secho(
@@ -432,9 +434,6 @@ def _report_fast_forward(git_run: Callable[..., Any], before: str, after: str) -
         fg=typer.colors.GREEN,
         err=True,
     )
-    # A trailing blank line separates the fast-forward block from the
-    # ``Checking configurations...`` line that follows it.
-    typer.echo("", err=True)
 
 
 def _start_background_update_check(container: Container) -> list[str]:
@@ -468,16 +467,19 @@ def _run_startup_preamble(  # noqa: PLR0913  # Each parameter is an explicit sta
     """Run the shared startup preamble for both session entry points.
 
     The order is fixed so the banner layout cannot drift: health checks, the
-    start-only workspace fast-forward line, the ``Checking configurations...``
-    line, the preflight check (whose returned keys extend ``fired``), then the
-    shared disable-footer. ``start`` forwards its ``agent`` so the preflight
-    validates the agent prompt and enables ``pull_workspace``; ``resume``
-    leaves the agent ``None`` and keeps the pull off.
+    start-only workspace fast-forward line, one separator blank line, the
+    ``Checking configurations...`` line, the preflight check (whose returned
+    keys extend ``fired``), then the shared disable-footer. ``start`` forwards
+    its ``agent`` so the preflight validates the agent prompt and enables
+    ``pull_workspace``; ``resume`` leaves the agent ``None`` and keeps the pull
+    off.
     """
     config_service = container.resolve(IConfigService)
     _run_health_checks(config_service)
     if pull_workspace:
         _pull_workspace_on_start(config_service)
+    # One separator groups the checkmark block above with the notices below.
+    typer.echo("", err=True)
     typer.echo("Checking configurations...", err=True)
     fired.extend(
         _run_cli_preflight_check(
@@ -772,11 +774,10 @@ def _display_drift_notification(container: Container) -> list[str]:
         fired.append("checks.templates")
 
     if drift_lines:
-        # A single leading blank separates this block from the
-        # ``Checking configurations...`` line above it. The lines carry no
-        # trailing newline, so the shared disable-footer (emitted next) abuts
-        # the final drift line.
-        typer.echo("\n" + "\n".join(drift_lines))
+        # The notices sit directly under ``Checking configurations...``. The
+        # lines carry no trailing newline, so the shared disable-footer
+        # (emitted next) abuts the final drift line.
+        typer.echo("\n".join(drift_lines))
 
     return fired
 

{teddy_cli-0.1.17.dev1416 → teddy_cli-0.1.17.dev1419}/src/teddy_executor/resources/MRP.md

@@ -56,7 +56,7 @@ Every EXECUTE action runs in a fresh subshell rooted at the project root (CWD).
 
 ### Information Gathering Workflow
 
-If you are missing information critical to your immediate goal, gather it efficiently without getting sidetracked. You can chain multiple discovery actions in one turn. Discover locally via `EXECUTE` (`git grep`) and externally via `RESEARCH`. Never rely on search snippets; always `READ` target URLs. For opaque sources (JavaScript-rendered pages, PDFs, binary formats) where `READ` fails or yields unusable content, `CREATE` and `EXECUTE` a minimal extraction script to inspect the raw data or API. If static reading leaves behavioral ambiguity, validate assumptions via a minimal spike in `spikes/`. Check flags with `[tool] --help` before running complex CLI commands.
+If you are missing information critical to your immediate goal, gather it efficiently without getting sidetracked. You can chain multiple discovery actions in one turn. Discover locally via `EXECUTE` (`git grep`) and externally via `RESEARCH`. Never rely on search snippets; always `READ` target URLs. For opaque sources (JavaScript-rendered pages, PDFs, binary formats) where `READ` fails or yields unusable content, `CREATE` and `EXECUTE` a minimal extraction script to inspect the raw data or API. If static reading leaves behavioral ambiguity, validate assumptions via a minimal spike in `spikes/`. Check flags with `[tool] --help` before running complex CLI commands. To read CI logs, use `make logs RUN=<run-id>` for all failed steps, or `make logs RUN=<run-id> STEP="<step-name>"` for one step.
 
 ### Version Control
 
@@ -67,7 +67,7 @@ The entire commit cycle (test, stage, commit) MUST occur in a dedicated Version
 3. Execution: Run `make commit MSG="<type>(<scope>): <description>"`. This stages all local changes (`git add .`) and runs Git's local hooks before committing.
 4. Post-conditions: All tests MUST pass: the post-commit hook reverts automatically on failure and cannot be bypassed.
 5. Push at Conclusion: In the Conclusion phase, if a remote is configured, run `make push`.
-6. CI Monitoring: If remote CI is configured and a push occurred, run `make ci-watch` to monitor workflow runs and to inspect results: use `make logs RUN=<run-id>` (or `make logs RUN=<run-id> STEP="<step-name>"`) for full logs.
+6. CI Monitoring: If remote CI is configured and a push occurred, run `make ci-watch` to monitor workflow runs. If needed inspect details using `make logs`.
 
 ### Standardized Plan Types
 

{teddy_cli-0.1.17.dev1416 → teddy_cli-0.1.17.dev1419}/src/teddy_executor/resources/config/prompts/debugger.md

@@ -14,7 +14,7 @@ Follow these phases and steps in order. Keep track of your progress in your Stat
 1. **Case File Check:**
    If a Case File was not provided in the initial context, CREATE one following the case file template and path conventions.
 2. **Context and History Gathering:**
-   Use EXECUTE `git grep`, EXECUTE `git log`, READ, and RESEARCH to understand the codebase, recent changes, and identify the last known green CI run or commit. For historical CI failures, do not try to read the entire log: extract failed step logs by executing `make logs RUN=[ID]` (for all failed steps) or `make logs RUN=[ID] STEP="[STEP_NAME]"` (for a specific step).
+   Use EXECUTE `git grep`, EXECUTE `git log`, READ, and RESEARCH to understand the codebase, recent changes, and identify the last known green CI run or commit. For historical CI failures pull the failed step logs.
 3. **Diagnostic MRE and Platform Check:**
    Trigger the symptom: if an existing command, test, or CI failure exists, execute it to observe the failure live. If the bug is reported verbally or without an existing test, write a targeted probe script in `spikes/debug/{scope-slug}/` to trigger the symptom.
 

{teddy_cli-0.1.17.dev1416 → teddy_cli-0.1.17.dev1419}/src/teddy_executor/resources/templates/makefile.md

@@ -13,7 +13,7 @@ make commit MSG="feat(templates): add PROJECT.md template"
 ```
 
 **What is `.PHONY`?**
-`.PHONY` is a Makefile directive that declares `commit`, `push`, `ci-watch`, `probe`, `test`, `logs`, `help`, and the internal `_preflight` gate as phony targets — they do not correspond to actual files. Without `.PHONY`, if a file named `commit` or `probe` existed in the directory (e.g., a script called `commit`), Make would see it as up-to-date and skip the target entirely. By declaring them phony, Make always runs the recipe when you call `make commit`, `make push`, `make ci-watch`, `make probe`, or `make test`.
+`.PHONY` declares `commit`, `push`, `ci-watch`, `probe`, `test`, `logs`, `help`, and the internal `_preflight` gate as targets that name no file. Without it, a file named `commit` in the project root makes Make treat that target as up to date and skip the recipe.
 
 ### Help
 ```shell
@@ -91,17 +91,40 @@ EOF
 
 Always use GNU Make native features for cross-platform compatibility instead of shell-specific constructs:
 
-- **Native argument validation:** Use `$(if $(strip $(VAR)),,$(error Usage: ...))` instead of POSIX `[ -n "$$VAR" ]`. GNU Make validates parameters before spawning any shell process.
+- **Required input validation:** Reject a missing required input in a parse-time block, not in the recipe. Make runs the check while it reads the file, so it aborts before any prerequisite and before any shell process starts. See [Parse-Time Input Validation](#parse-time-input-validation).
 - **Named inputs instead of positional goals:** Pass values as `NAME="value"`, as in `make commit MSG="feat(scope): add thing"`. GNU Make treats a command-line assignment as a variable, so no word of the value can become a goal. Positional capture through `$(MAKECMDGOALS)` is forbidden, because a word that names a real target executes that target.
 - **Parse-time goal validation:** Compare `$(MAKECMDGOALS)` against a `_KNOWN_GOALS` list and abort with `$(error ...)` when a goal is unknown or when more than one goal is present. The check runs while Make reads the file, so no recipe line can run first.
-- **POSIX shell preflight:** Every POSIX recipe target (`ci-watch`, `probe`, `logs`) depends on the internal `_preflight` target, which verifies `git`, `gh`, `awk`, and `sed` before any network call. It aborts with one actionable message instead of a generic `make: *** Error 1`.
+- **POSIX shell preflight:** Every POSIX recipe target (`ci-watch`, `probe`, `logs`) depends on the internal `_preflight` target, which verifies `git`, `gh`, `awk`, and `sed` before any network call. It aborts with one actionable message instead of a generic `make: *** Error 1`. A missing required input aborts at parse time, before the tool gate runs.
+- **One shell process per command group:** Make spawns one process per recipe line that carries a shell metacharacter, and Windows process creation costs far more than on POSIX. Join a target's independent commands into one backslash-continued block separated by `;`, so the target pays one process instead of one per line.
 - **Shell routing for Bash-only commands:** Make spawns a recipe line directly when the line carries no shell metacharacter. That direct spawn bypasses `SHELL`. On Windows it fails for Git Bash-only programs such as `sleep` and for shell builtins such as `echo`. Keep these commands inside a shell block that carries `;`, `&&`, or a variable expansion.
-- **Windows shell selection:** Set `SHELL := bash.exe` when `OS` is `Windows_NT` so multi-line shell pipelines (`ci-watch`, `probe`, `logs`) execute through Git Bash. `_preflight` also confirms that the shell is Git Bash rather than the WSL `bash.exe` shim, and it names the `SHELL=` override when it is not.
+- **Windows shell selection:** Set `SHELL := bash.exe` when `OS` is `Windows_NT`. The assignment covers every target, not only the pipelines, and `_preflight` confirms that the shell is Git Bash rather than the WSL `bash.exe` shim and names the `SHELL=` override when it is not.
 - **Portable quoting:** Pass values with double quotes, as in `--field reason="..."`, because Windows `cmd.exe` keeps single quotes literally.
 - **ASCII-only output:** Recipe output stays ASCII, because a Windows console turns a non-ASCII dash into mojibake in captured logs.
 - **Explicit advisory fallback:** The advisory pre-commit pass consumes its own exit code with `|| echo "<sentence>"`, so a failing run prints one plain sentence. Make's `-` prefix is forbidden here, because it prints a bare `Error 1 (ignored)` line that reads as an unexplained defect.
 - **Error transparency:** The first pre-commit pass is advisory, so its non-zero exit is ignored and auto-fixed files are re-staged. Git then runs the same hooks again during `git commit`, and that second run is the blocking local gate. A hook failure there aborts the commit. The post-commit test gate is the final safety net. `make push` runs `git pull --rebase` and `git push` without suppression, so a rebase conflict or push rejection surfaces as a non-zero exit.
 
+### Parse-Time Input Validation
+
+A required input is rejected while Make reads the file, so the check runs before any prerequisite and before any shell process starts. A recipe-level check is forbidden, because it runs after the `_preflight` prerequisite.
+
+```makefile
+ifneq ($(filter commit,$(MAKECMDGOALS)),)
+ifeq ($(strip $(MSG)),)
+$(error Usage: make commit MSG="<type>(<scope>): <description>")
+endif
+endif
+ifneq ($(filter probe,$(MAKECMDGOALS)),)
+ifeq ($(strip $(REASON)),)
+$(error Usage: make probe REASON="<reason>")
+endif
+endif
+ifneq ($(filter logs,$(MAKECMDGOALS)),)
+ifeq ($(strip $(RUN)),)
+$(error Usage: make logs RUN=<run-id> [STEP="<step-name>"])
+endif
+endif
+```
+
 ## Test Workflow
 
 ### Example
@@ -127,7 +150,6 @@ test:
 
 ```makefile
 commit:
-	$(if $(strip $(MSG)),,$(error Usage: make commit MSG="<type>(<scope>): <description>"))
 	git add .
 	@uv run pre-commit run || echo "Advisory pre-commit reported issues. Auto-fixed files were re-staged and the commit continues."
 	git add .
@@ -300,9 +322,6 @@ ci-watch: _preflight
 
 ```makefile
 probe: _preflight
-
-probe:
-	$(if $(strip $(REASON)),,$(error Usage: make probe REASON="<reason>"))
 	git add -f spikes/debug/probe.sh
 	git commit -m "debug: probe" --no-verify --allow-empty
 	git push
@@ -336,8 +355,7 @@ The Debugger's Reproduction phase needs to read CI logs without drowning in the
 ### Example
 
 ```makefile
-logs:
-	$(if $(strip $(RUN)),,$(error Usage: make logs RUN=<run-id> [STEP="<step-name>"]))
+logs: _preflight
 	@if [ -z "$(STEP)" ]; then \
 	  gh run view "$(RUN)" --log-failed 2>/dev/null | awk -F'\t' '{ if(j!=$$1||s!=$$2){j=$$1;s=$$2;print "\n["j" > "s"]"} l=$$3; p=index(l,"Z "); if(p>0)l=substr(l,p+2); gsub(/\x1B\[[0-9;]*[a-zA-Z]/,"",l); gsub(/\^\[\[[0-9;]*[a-zA-Z]/,"",l); if(l ~ /^##\[group\]Run /){k=1;next} if(k && l ~ /^##\[endgroup\]/){k=0;next} if(k)next; if(l ~ /^##\[group\]/ || l ~ /^##\[endgroup\]/)next; gsub(/^##\[error\]/,"Error: ",l); print l }'; \
 	else \