ralph-code 0.5.0__tar.gz → 0.6.2__tar.gz

{ralph_code-0.5.0/ralph_code.egg-info → ralph_code-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ralph-code
-Version: 0.5.0
+Version: 0.6.2
 Summary: Automated task implementation with Claude Code and Codex
 Author: Ralph Coding
 License: MIT
@@ -37,7 +37,7 @@ Dynamic: requires-python
 
 # ralph-code
 
-Automated task implementation with Claude Code and Codex for "Ralph Coding". What is [Ralph Coding](https://ghuntley.com/ralph/)? It's a method of coding where context rot is avoided by controlling the retention of information. This method involves re-invoking claude or codex for each task, and passing information about the requirements, acceptance testing, and any progress that's made (or roadblocks/challenges faced) through files, rather than retaining all prompts + thinking + response tokens. It tends to result in more requests, some duplicated token work, but fairly consistent performance, and best of all it can largely be done unattended. Recommend Claude Max account or codex equivalent, but be aware that GPT-5 - GPT5.2's slow reasoning and response makes this ponderous, it's fine overnight.
+Automated task implementation with Claude Code and Codex for "Ralph Coding". What is [Ralph Coding](https://ghuntley.com/ralph/)? It's a method of coding where context rot is avoided by controlling the retention of information. This method involves re-invoking claude or codex for each task, and passing information about the requirements, acceptance testing, and any progress that's made (or roadblocks/challenges faced) through files, rather than retaining all prompts + thinking + response tokens. It tends to result in more requests, some duplicated token work, but fairly consistent performance, and best of all it can largely be done unattended. Ralph now defaults to continuing past PRD-to-task conversion instead of pausing there, and non-interactive harness calls are bounded by timeouts and turn caps so stuck agent runs fail fast instead of hanging forever. Recommend Claude Max account or codex equivalent, but be aware that GPT-5 - GPT5.2's slow reasoning and response makes this ponderous, it's fine overnight.
 
 Because LLMs are carrying out the work, we can specify a job of "Find all the python files in the project that directly or indirectly access sqlalchemy objects, and upgrade the code to work with sqlalchemy 2.* This will result in probably a single-task project, but that one task might add 50 other tasks (on per file) to the backlog, which are then processed sequentially."
 
@@ -59,6 +59,15 @@ pip install ralph-code
 ralph [OPTIONS] [DIRECTORY]
 ```
 
+## Recent changes
+
+Version `0.6.2` includes:
+- Bounded non-interactive harness execution with timeout and turn limits
+- Structured `tasks.json` generation for more reliable PRD conversion
+- Automatic continuation after task generation by default
+- `PRDs/` as the standard task directory, with legacy `PRD/` compatibility
+- Refreshed model catalogs and current defaults
+
 ### Options
 
 - `--debug`: Enable debug logging, logs are saved into the .ralph subdirectory of the project
@@ -66,8 +75,8 @@ ralph [OPTIONS] [DIRECTORY]
 
 ## Usage
 
-First create a task, give a short name for the task (used for the branch commits will be added to), and then give a description. 
-Then you run the ralph-coder, it will produce a .md file of the specifications, which will be broken into small tasks put into a tasks.json file. Each task will be worked on independently. 
+First create a task in `PRDs/`, give a short name for the task (used for the branch commits will be added to), and then give a description.
+Then you run `ralph`, it will produce a `.md` file of the specifications, which will be broken into small tasks put into a `tasks.json` file. Each task will be worked on independently.
 
 ## Requirements
 

{ralph_code-0.5.0 → ralph_code-0.6.2}/README.md

@@ -1,6 +1,6 @@
 # ralph-code
 
-Automated task implementation with Claude Code and Codex for "Ralph Coding". What is [Ralph Coding](https://ghuntley.com/ralph/)? It's a method of coding where context rot is avoided by controlling the retention of information. This method involves re-invoking claude or codex for each task, and passing information about the requirements, acceptance testing, and any progress that's made (or roadblocks/challenges faced) through files, rather than retaining all prompts + thinking + response tokens. It tends to result in more requests, some duplicated token work, but fairly consistent performance, and best of all it can largely be done unattended. Recommend Claude Max account or codex equivalent, but be aware that GPT-5 - GPT5.2's slow reasoning and response makes this ponderous, it's fine overnight.
+Automated task implementation with Claude Code and Codex for "Ralph Coding". What is [Ralph Coding](https://ghuntley.com/ralph/)? It's a method of coding where context rot is avoided by controlling the retention of information. This method involves re-invoking claude or codex for each task, and passing information about the requirements, acceptance testing, and any progress that's made (or roadblocks/challenges faced) through files, rather than retaining all prompts + thinking + response tokens. It tends to result in more requests, some duplicated token work, but fairly consistent performance, and best of all it can largely be done unattended. Ralph now defaults to continuing past PRD-to-task conversion instead of pausing there, and non-interactive harness calls are bounded by timeouts and turn caps so stuck agent runs fail fast instead of hanging forever. Recommend Claude Max account or codex equivalent, but be aware that GPT-5 - GPT5.2's slow reasoning and response makes this ponderous, it's fine overnight.
 
 Because LLMs are carrying out the work, we can specify a job of "Find all the python files in the project that directly or indirectly access sqlalchemy objects, and upgrade the code to work with sqlalchemy 2.* This will result in probably a single-task project, but that one task might add 50 other tasks (on per file) to the backlog, which are then processed sequentially."
 
@@ -22,6 +22,15 @@ pip install ralph-code
 ralph [OPTIONS] [DIRECTORY]
 ```
 
+## Recent changes
+
+Version `0.6.2` includes:
+- Bounded non-interactive harness execution with timeout and turn limits
+- Structured `tasks.json` generation for more reliable PRD conversion
+- Automatic continuation after task generation by default
+- `PRDs/` as the standard task directory, with legacy `PRD/` compatibility
+- Refreshed model catalogs and current defaults
+
 ### Options
 
 - `--debug`: Enable debug logging, logs are saved into the .ralph subdirectory of the project
@@ -29,8 +38,8 @@ ralph [OPTIONS] [DIRECTORY]
 
 ## Usage
 
-First create a task, give a short name for the task (used for the branch commits will be added to), and then give a description. 
-Then you run the ralph-coder, it will produce a .md file of the specifications, which will be broken into small tasks put into a tasks.json file. Each task will be worked on independently. 
+First create a task in `PRDs/`, give a short name for the task (used for the branch commits will be added to), and then give a description.
+Then you run `ralph`, it will produce a `.md` file of the specifications, which will be broken into small tasks put into a `tasks.json` file. Each task will be worked on independently.
 
 ## Requirements
 

{ralph_code-0.5.0 → ralph_code-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ralph-code"
-version = "0.5.0"
+version = "0.6.2"
 description = "Automated task implementation with Claude Code and Codex"
 readme = "README.md"
 license = {text = "MIT"}
@@ -57,6 +57,15 @@ include = ["ralph*"]
 [tool.setuptools.package-data]
 ralph = ["schemas/*.json"]
 
+[tool.pytest.ini_options]
+markers = [
+    "integration: marks tests as integration tests (may be slower)",
+    "e2e: marks tests as end-to-end tests (requires terminal)",
+    "slow: marks tests as slow (> 1 second)",
+]
+testpaths = ["tests"]
+addopts = "-v"
+
 [tool.mypy]
 strict = true
 python_version = "3.12"

{ralph_code-0.5.0 → ralph_code-0.6.2}/ralph/__init__.py

@@ -1,6 +1,6 @@
 """ralph-code: Automated task implementation with Claude Code and Codex."""
 
-__version__ = "0.1.0"
+__version__ = "0.6.2"
 __author__ = "Ralph Coding"
 
 from .app import RalphApp, main

{ralph_code-0.5.0 → ralph_code-0.6.2}/ralph/__main__.py

@@ -7,8 +7,16 @@ import click
 
 from .app import main
 
+# Version is imported from pyproject.toml at build time
+try:
+    from importlib.metadata import version
+    __version__ = version("ralph-code")
+except Exception:
+    __version__ = "unknown"
+
 
 @click.command()
+@click.version_option(version=__version__, prog_name="ralph")
 @click.option(
     "--debug",
     is_flag=True,

{ralph_code-0.5.0 → ralph_code-0.6.2}/ralph/app.py

@@ -353,9 +353,19 @@ class RalphApp:
         elif workflow.is_paused:
             choices = [
                 {"name": "Resume workflow", "value": "resume"},
+            ]
+            # If there's an error, offer retry option
+            if workflow.error_message:
+                choices.append({"name": "Retry", "value": "retry"})
+            # If paused after spec/tasks, offer review options
+            if workflow.current_task:
+                choices.append({"name": "Review PRD (open in editor)", "value": "review_prd"})
+            if has_stories:
+                choices.append({"name": "Review tasks.json (open in editor)", "value": "review_tasks"})
+            choices.extend([
                 {"name": "Add PRD", "value": "add"},
                 {"name": "List PRDs", "value": "list"},
-            ]
+            ])
             if has_stories:
                 choices.append({"name": "Manage stories", "value": "stories"})
             choices.extend([
@@ -440,6 +450,8 @@ class RalphApp:
                     {"name": f"Branch prefix: {self._config.branch_prefix}", "value": "branch_prefix"},
                     {"name": f"On error: {self._config.on_error}", "value": "on_error"},
                     {"name": f"Auto spec: {self._config.auto_spec_without_oversight}", "value": "auto_spec"},
+                    {"name": f"Pause after PRD spec: {self._config.pause_after_spec}", "value": "pause_after_spec"},
+                    {"name": f"Pause after tasks: {self._config.pause_after_tasks}", "value": "pause_after_tasks"},
                     {"name": f"Wait on rate limit: {self._config.wait_on_rate_limit}", "value": "rate_limit"},
                     {"name": f"Pause on completion: {self._config.pause_on_completion}", "value": "pause_completion"},
                     {"name": f"Always build tests: {self._config.always_build_tests}", "value": "tests"},
@@ -493,6 +505,12 @@ class RalphApp:
             elif setting == "auto_spec":
                 self._config.auto_spec_without_oversight = not self._config.auto_spec_without_oversight
                 self.console.print(f"[cyan]Auto spec: {self._config.auto_spec_without_oversight}[/cyan]")
+            elif setting == "pause_after_spec":
+                self._config.pause_after_spec = not self._config.pause_after_spec
+                self.console.print(f"[cyan]Pause after PRD spec: {self._config.pause_after_spec}[/cyan]")
+            elif setting == "pause_after_tasks":
+                self._config.pause_after_tasks = not self._config.pause_after_tasks
+                self.console.print(f"[cyan]Pause after tasks: {self._config.pause_after_tasks}[/cyan]")
             elif setting == "rate_limit":
                 self._config.wait_on_rate_limit = not self._config.wait_on_rate_limit
                 self.console.print(f"[cyan]Wait on rate limit: {self._config.wait_on_rate_limit}[/cyan]")
@@ -541,7 +559,7 @@ class RalphApp:
         choices: list[Choice] = []
 
         for model_name, label in supported_models:
-            choices.append(Choice(title=model_name, value=model_name))
+            choices.append(Choice(title=f"{model_name} ({label})", value=model_name))
 
         # No models available - show alert and return
         if not choices:
@@ -1057,6 +1075,60 @@ class RalphApp:
         workflow.story_manager.update_story(story)
         self.console.print(f"[{NORD14}]Removed: {removed}[/{NORD14}]")
 
+    def _review_prd(self, workflow: WorkflowEngine) -> None:
+        """Open the current PRD in the default editor."""
+        if not workflow.current_task:
+            self.console.print("[dim]No PRD currently selected.[/dim]")
+            return
+
+        prd_file = workflow.current_task.file_path
+        self.console.print(f"Opening {prd_file} in default editor...")
+
+        import subprocess
+        import platform
+
+        try:
+            if platform.system() == "Darwin":  # macOS
+                subprocess.run(["open", str(prd_file)])
+            elif platform.system() == "Windows":
+                subprocess.run(["start", str(prd_file)], shell=True)
+            else:  # Linux
+                subprocess.run(["xdg-open", str(prd_file)])
+
+            self.console.print("[green]✓ Opened in editor. Resume workflow when ready.[/green]")
+            # Reload PRD after editing
+            workflow.prd_manager.reload()
+        except Exception as e:
+            self.console.print(f"[red]Failed to open editor: {e}[/red]")
+            self.console.print(f"[dim]File location: {prd_file}[/dim]")
+
+    def _review_tasks(self, workflow: WorkflowEngine) -> None:
+        """Open tasks.json in the default editor."""
+        tasks_file = self.project_dir / "tasks.json"
+        if not tasks_file.exists():
+            self.console.print("[dim]No tasks.json file found.[/dim]")
+            return
+
+        self.console.print(f"Opening {tasks_file} in default editor...")
+
+        import subprocess
+        import platform
+
+        try:
+            if platform.system() == "Darwin":  # macOS
+                subprocess.run(["open", str(tasks_file)])
+            elif platform.system() == "Windows":
+                subprocess.run(["start", str(tasks_file)], shell=True)
+            else:  # Linux
+                subprocess.run(["xdg-open", str(tasks_file)])
+
+            self.console.print("[green]✓ Opened in editor. Resume workflow when ready.[/green]")
+            # Reload tasks after editing
+            workflow.story_manager.reload()
+        except Exception as e:
+            self.console.print(f"[red]Failed to open editor: {e}[/red]")
+            self.console.print(f"[dim]File location: {tasks_file}[/dim]")
+
     def _show_answer_questions(self) -> None:
         """Show UI to answer PRD questions."""
         workflow = self._get_workflow()
@@ -1167,6 +1239,17 @@ class RalphApp:
                     self._show_settings_menu()
                 elif choice == "run" or choice == "resume":
                     self._run_workflow()
+                elif choice == "retry":
+                    # Reset iteration counter and run workflow again
+                    # resume() resets iteration to 0, giving full max_iterations again
+                    current_max = workflow._config.max_iterations
+                    self.console.print(f"[green]Retrying with {current_max} attempts...[/green]")
+                    workflow.resume()
+                    self._run_workflow()
+                elif choice == "review_prd":
+                    self._review_prd(workflow)
+                elif choice == "review_tasks":
+                    self._review_tasks(workflow)
                 elif choice == "pause":
                     workflow.pause()
                     self.console.print("[yellow]Paused[/yellow]")
@@ -1295,20 +1378,39 @@ class RalphApp:
         self.console.print()
         self._last_status_key = None  # Reset change detection
 
+        live = None
         try:
-            # Higher refresh rate for spinner animation
-            with Live(self._build_live_status(), refresh_per_second=10, console=self.console) as live:
-                self._live = live
-                self._spinner.reset()
-                while workflow.step():
-                    # Always update to animate spinner during active states
-                    live.update(self._build_live_status())
-                self._live = None
+            # Moderate refresh rate for spinner animation (4 fps for better responsiveness)
+            live = Live(
+                self._build_live_status(),
+                refresh_per_second=4,
+                console=self.console,
+                transient=False
+            )
+            live.start()
+            self._live = live
+            self._spinner.reset()
+
+            while workflow.step():
+                # Update display for spinner animation
+                live.update(self._build_live_status())
+
+                # Safety check: if workflow is paused or in error state, stop
+                if workflow.is_paused or workflow.state == WorkflowState.ERROR:
+                    break
 
         except KeyboardInterrupt:
-            self._live = None
             workflow.pause()
+            if live:
+                live.stop()
+            self._live = None
             self.console.print("\n[yellow]Paused by user[/yellow]")
+            return
+
+        finally:
+            if live:
+                live.stop()
+            self._live = None
 
         # Show final status
         if workflow.state == WorkflowState.IDLE:

{ralph_code-0.5.0 → ralph_code-0.6.2}/ralph/config.py

@@ -14,9 +14,13 @@ DEFAULT_CONFIG = {
     "harness": "claude",
     "worker_model": "opus",
     "summary_model": "haiku",
+    "harness_timeout_seconds": 1800,
+    "non_interactive_max_turns": 12,
     "max_iterations": 10,
     "max_story_attempts": 3,
     "auto_spec_without_oversight": True,
+    "pause_after_spec": False,
+    "pause_after_tasks": False,
     "wait_on_rate_limit": True,
     "pause_on_completion": True,
     "always_build_tests": False,
@@ -61,7 +65,7 @@ class Config:
         if "worker_model" not in self._config:
             harness = self._config.get("harness", DEFAULT_CONFIG["harness"])
             if harness == "codex":
-                self._config["worker_model"] = "gpt-5.2-codex"
+                self._config["worker_model"] = "gpt-5.3-codex"
             else:
                 self._config["worker_model"] = "opus"
             needs_save = True
@@ -70,7 +74,7 @@ class Config:
         if "summary_model" not in self._config:
             harness = self._config.get("harness", DEFAULT_CONFIG["harness"])
             if harness == "codex":
-                self._config["summary_model"] = "gpt-5.2"
+                self._config["summary_model"] = "gpt-5.1-codex-mini"
             else:
                 self._config["summary_model"] = "haiku"
             needs_save = True
@@ -122,6 +126,26 @@ class Config:
         self._config["summary_model"] = value
         self._save()
 
+    @property
+    def harness_timeout_seconds(self) -> int:
+        """Maximum seconds to wait for a harness subprocess before aborting."""
+        return int(self._config.get("harness_timeout_seconds", 1800))
+
+    @harness_timeout_seconds.setter
+    def harness_timeout_seconds(self, value: int) -> None:
+        self._config["harness_timeout_seconds"] = max(1, value)
+        self._save()
+
+    @property
+    def non_interactive_max_turns(self) -> int:
+        """Maximum agent turns for non-interactive harness runs."""
+        return int(self._config.get("non_interactive_max_turns", 12))
+
+    @non_interactive_max_turns.setter
+    def non_interactive_max_turns(self, value: int) -> None:
+        self._config["non_interactive_max_turns"] = max(1, value)
+        self._save()
+
     @property
     def max_iterations(self) -> int:
         """Maximum iterations for implementation loop."""
@@ -142,6 +166,26 @@ class Config:
         self._config["auto_spec_without_oversight"] = value
         self._save()
 
+    @property
+    def pause_after_spec(self) -> bool:
+        """Whether to pause after creating PRD specs for review."""
+        return bool(self._config["pause_after_spec"])
+
+    @pause_after_spec.setter
+    def pause_after_spec(self, value: bool) -> None:
+        self._config["pause_after_spec"] = value
+        self._save()
+
+    @property
+    def pause_after_tasks(self) -> bool:
+        """Whether to pause after converting PRD to tasks for review."""
+        return bool(self._config["pause_after_tasks"])
+
+    @pause_after_tasks.setter
+    def pause_after_tasks(self, value: bool) -> None:
+        self._config["pause_after_tasks"] = value
+        self._save()
+
     @property
     def wait_on_rate_limit(self) -> bool:
         """Whether to wait and retry on rate limit."""

{ralph_code-0.5.0 → ralph_code-0.6.2}/ralph/git_manager.py

@@ -170,8 +170,9 @@ class GitManager:
         """Get list of changed files that should be staged (excluding ralph files)."""
         result = self._run_git("status", "--porcelain")
         files = []
-        for line in result.stdout.strip().split("\n"):
-            if not line:
+        # Use rstrip() to preserve leading spaces which are significant in porcelain format
+        for line in result.stdout.rstrip().split("\n"):
+            if not line.strip():
                 continue
             # Status is first 2 chars, filename starts at position 3
             filepath = line[3:].strip()
@@ -229,6 +230,11 @@ class GitManager:
 
         return self.commit(message)
 
+    def get_staged_files(self) -> list[str]:
+        """Get list of files currently staged for commit."""
+        result = self._run_git("diff", "--cached", "--name-only")
+        return [f for f in result.stdout.strip().split("\n") if f]
+
     def get_unstaged_files(self) -> list[str]:
         """Get list of files with unstaged changes (modified + untracked).
 

{ralph_code-0.5.0 → ralph_code-0.6.2}/ralph/harness.py

@@ -46,13 +46,19 @@ HarnessType = Literal["claude", "codex", "custom"]
 # These defaults are used when CLI model querying fails or isn't supported.
 DEFAULT_MODELS: dict[HarnessType, list[tuple[str, str]]] = {
     "claude": [
+        ("default", "Standard"),
         ("haiku", "Light"),
         ("sonnet", "Standard"),
         ("opus", "Standard"),
+        ("sonnet[1m]", "Extended"),
+        ("opusplan", "Planning"),
     ],
     "codex": [
         ("gpt-5.1-codex-mini", "Light"),
+        ("gpt-5.3-codex-spark", "Preview"),
+        ("gpt-5.3-codex", "Standard"),
         ("gpt-5.2-codex", "Standard"),
+        ("gpt-5.1-codex", "Standard"),
         ("gpt-5.1-codex-max", "Standard"),
         ("gpt-5.2", "Standard"),
     ],
@@ -61,13 +67,13 @@ DEFAULT_MODELS: dict[HarnessType, list[tuple[str, str]]] = {
 
 DEFAULT_WORKER_MODEL: dict[HarnessType, str] = {
     "claude": "opus",
-    "codex": "gpt-5.2-codex",
+    "codex": "gpt-5.3-codex",
     "custom": "",
 }
 
 DEFAULT_SUMMARY_MODEL: dict[HarnessType, str] = {
     "claude": "haiku",
-    "codex": "gpt-5.2",
+    "codex": "gpt-5.1-codex-mini",
     "custom": "",
 }