tloop-cli 0.5.0__tar.gz → 0.6.0__tar.gz

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tloop-cli
-Version: 0.5.0
+Version: 0.6.0
 Summary: Automated Claude Code task runner
 License-Expression: MIT
 Requires-Python: >=3.9
@@ -60,6 +60,8 @@ tasks:
 | `prompt_file` | prompt 文件路径（解析顺序：绝对路径 → `~/.tloop/` 相对 → 任务目录相对） |
 | `model` | 覆盖该任务的模型 |
 | `branch` | `true`（自动 `feature-YYYYMMDD-NNN`）、`"custom/name"`、或 `false`（跳过分支） |
+| `use` | 任务执行器：`cybervisor`（默认，多阶段复杂任务）或 `claude`（定向任务，支持循环） |
+| `max_rounds` | `use: claude` 时生效，最大迭代次数（默认 5）；到达上限前未收到 `<promise>COMPLETE</promise>` 信号则任务失败 |
 
 ## 用法
 
@@ -76,6 +78,37 @@ tloop archive --latest     # 显示最近一次归档详情
 tloop migrate              # 迁移旧的项目本地数据到 ~/.tloop/
 ```
 
+## 执行器
+
+t-loop 支持两种任务执行器，通过 `use` 字段选择：
+
+| 执行器 | 说明 | 适用场景 |
+|--------|------|----------|
+| `cybervisor` | 默认，执行 `cybervisor run`，适合复杂多阶段任务 | 大型重构、多步骤分析 |
+| `claude` | 执行 `claude -p --dangerously-skip-permissions`，支持循环迭代 | 定向 bug 修复、明确目标的任务 |
+
+### ClaudeRunner 循环机制
+
+`use: claude` 时，任务以多轮迭代方式执行：
+
+1. 每轮启动一次 `claude -p --dangerously-skip-permissions`，传入 prompt
+2. 如果输出包含 `<promise>COMPLETE</promise>`，立即结束并标记成功
+3. 否则等待 2 秒，继续下一轮，直到达到 `max_rounds`（默认 5）
+4. `max_rounds` 用尽仍未检测到完成信号，任务标记失败
+
+使用示例：
+
+```yaml
+tasks:
+  - name: 修复空指针 bug
+    dir: ~/proj
+    use: claude
+    max_rounds: 3
+    prompt_file: bugfix.md
+```
+
+在 prompt 文件中加入 `<promise>COMPLETE</promise>` 即可让 Claude 主动退出循环。
+
 ## 工作原理
 
 每个任务的执行流程：

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/README.md

@@ -49,6 +49,8 @@ tasks:
 | `prompt_file` | prompt 文件路径（解析顺序：绝对路径 → `~/.tloop/` 相对 → 任务目录相对） |
 | `model` | 覆盖该任务的模型 |
 | `branch` | `true`（自动 `feature-YYYYMMDD-NNN`）、`"custom/name"`、或 `false`（跳过分支） |
+| `use` | 任务执行器：`cybervisor`（默认，多阶段复杂任务）或 `claude`（定向任务，支持循环） |
+| `max_rounds` | `use: claude` 时生效，最大迭代次数（默认 5）；到达上限前未收到 `<promise>COMPLETE</promise>` 信号则任务失败 |
 
 ## 用法
 
@@ -65,6 +67,37 @@ tloop archive --latest     # 显示最近一次归档详情
 tloop migrate              # 迁移旧的项目本地数据到 ~/.tloop/
 ```
 
+## 执行器
+
+t-loop 支持两种任务执行器，通过 `use` 字段选择：
+
+| 执行器 | 说明 | 适用场景 |
+|--------|------|----------|
+| `cybervisor` | 默认，执行 `cybervisor run`，适合复杂多阶段任务 | 大型重构、多步骤分析 |
+| `claude` | 执行 `claude -p --dangerously-skip-permissions`，支持循环迭代 | 定向 bug 修复、明确目标的任务 |
+
+### ClaudeRunner 循环机制
+
+`use: claude` 时，任务以多轮迭代方式执行：
+
+1. 每轮启动一次 `claude -p --dangerously-skip-permissions`，传入 prompt
+2. 如果输出包含 `<promise>COMPLETE</promise>`，立即结束并标记成功
+3. 否则等待 2 秒，继续下一轮，直到达到 `max_rounds`（默认 5）
+4. `max_rounds` 用尽仍未检测到完成信号，任务标记失败
+
+使用示例：
+
+```yaml
+tasks:
+  - name: 修复空指针 bug
+    dir: ~/proj
+    use: claude
+    max_rounds: 3
+    prompt_file: bugfix.md
+```
+
+在 prompt 文件中加入 `<promise>COMPLETE</promise>` 即可让 Claude 主动退出循环。
+
 ## 工作原理
 
 每个任务的执行流程：

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tloop-cli"
-version = "0.5.0"
+version = "0.6.0"
 description = "Automated Claude Code task runner"
 readme = "README.md"
 requires-python = ">=3.9"

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/src/claude_runner.py

@@ -45,12 +45,21 @@ def run_claude(prompt, cwd, max_retries=DEFAULT_MAX_RETRIES, verify_fn=None, log
         else:
             attempt_cmd = cmd
 
-        result = subprocess.run(
-            attempt_cmd,
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-        )
+        print(f"  Running claude (attempt {attempt}/{max_retries})...")
+        try:
+            result = subprocess.run(
+                attempt_cmd,
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                timeout=300,
+            )
+        except subprocess.TimeoutExpired:
+            print(f"{YELLOW}  Claude timed out after 300s (attempt {attempt}/{max_retries}){RESET}")
+            if attempt >= max_retries:
+                print(f"{RED}  Max retries reached. Giving up.{RESET}")
+                return False
+            continue
 
         if log_file:
             with open(log_file, "a") as log:

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/src/cmd_edit.py

@@ -31,6 +31,8 @@ Task file format (~/.tloop/tasks.yaml):
       # OR:
       prompt_file: ./prompts/my-task.md
       branch: true           # true=auto, "custom/name", false=skip
+      use: cybervisor        # cybervisor (default) or claude
+      max_rounds: 5          # only for use: claude
 
   Each task runs in the specified directory. Completed tasks are
   archived to ~/.tloop/archive/ after each run cycle.

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/src/config.py

@@ -39,5 +39,16 @@ def load_config():
         print(f"{RED}Error: {TASKS_FILE} not found{RESET}")
         print(f"Run tloop run to initialize, then edit tasks.yaml.")
         sys.exit(1)
-    with open(TASKS_FILE) as f:
-        return yaml.safe_load(f) or {}
+    try:
+        with open(TASKS_FILE) as f:
+            return yaml.safe_load(f) or {}
+    except yaml.YAMLError as e:
+        location = ""
+        if hasattr(e, "problem_mark") and e.problem_mark:
+            mark = e.problem_mark
+            location = f" (line {mark.line + 1}, column {mark.column + 1})"
+        print(f"{RED}Error: {TASKS_FILE} 解析失败{location}{RESET}")
+        if hasattr(e, "problem") and e.problem:
+            print(f"  {e.problem}")
+        print("请检查 YAML 格式，常见问题：含冒号/特殊字符的值需要用引号包裹。")
+        sys.exit(1)

tloop_cli-0.6.0/src/runner/claude.py

@@ -0,0 +1,89 @@
+"""Claude Code runner backend with round-loop execution."""
+
+import subprocess
+import time
+
+from runner import Runner
+
+COMPLETION_SUFFIX = (
+
+    "\n\nWhen you have fully completed all the requested work, "
+    "output the following on its own line to signal completion:\n"
+    "<promise>COMPLETE</promise>\n"
+    "Do NOT output this unless you have finished everything. "
+    "If there is still work to do, end your response normally — "
+    "another iteration will pick up where you left off."
+)
+
+
+class ClaudeRunner(Runner):
+    def run(self, prompt, cwd, log_file=None, max_rounds=5, prompt_file=None):
+        """
+        Run Claude Code in a loop with configurable round limit.
+
+        Args:
+            prompt: The prompt to send to Claude Code
+            cwd: Working directory for the task
+            log_file: Optional path to log file
+            max_rounds: Maximum number of loop iterations (default 5)
+            prompt_file: Optional path to prompt file (used as stdin like CybervisorRunner)
+
+        Returns:
+            0 on success (completion signal detected), non-zero on failure
+        """
+        enriched_prompt = prompt + COMPLETION_SUFFIX
+
+        log = open(log_file, "a") if log_file else open("/dev/null", "a")
+        try:
+            for round_num in range(1, max_rounds + 1):
+                log.write(f"\n{'='*60}\n")
+                log.write(f"Round {round_num}/{max_rounds}\n")
+                log.write(f"{'='*60}\n\n")
+                log.flush()
+
+                print(f"\n{'='*60}")
+                print(f" Round {round_num}/{max_rounds} ")
+                print(f"{'='*60}")
+
+                process = subprocess.Popen(
+                    ["claude", "-p", "--dangerously-skip-permissions"],
+                    cwd=cwd,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                )
+
+                output_parts = []
+                if prompt_file:
+                    with open(prompt_file, "r") as f:
+                        process.stdin.write(f.read())
+                    process.stdin.write(COMPLETION_SUFFIX)
+                else:
+                    process.stdin.write(enriched_prompt)
+                process.stdin.close()
+
+                for line in process.stdout:
+                    print(line, end="")
+                    log.write(line)
+                    output_parts.append(line)
+
+                process.wait()
+                log.flush()
+
+                accumulated = "".join(output_parts)
+                if "<promise>COMPLETE</promise>" in accumulated:
+                    log.write("\n[Completion signal detected - exiting loop]\n")
+                    log.flush()
+                    return 0
+
+                if round_num < max_rounds:
+                    log.write(f"\n[Round {round_num} complete, sleeping 2s before next round]\n")
+                    log.flush()
+                    time.sleep(2)
+
+            log.write(f"\n[All {max_rounds} rounds exhausted without completion signal]\n")
+            log.flush()
+            return 1
+        finally:
+            log.close()

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/src/task.py

@@ -7,6 +7,7 @@ from pathlib import Path
 import config
 from git_ops import ensure_clean_git, create_task_branch
 from runner.cybervisor import CybervisorRunner
+from runner.claude import ClaudeRunner
 from state import save_state
 
 
@@ -100,12 +101,24 @@ def run_task(task, index, state):
     try:
         with open(log_file, "a") as log:
             log.write(f"Started: {started}\n")
-            log.write(f"Command: cybervisor run < {'<prompt_file>' if resolved_pf else '<prompt>'}\n")
-            log.write("-" * 60 + "\n\n")
             log.flush()
 
-        runner = CybervisorRunner()
-        returncode = runner.run(prompt, dir_path, log_file=log_file, prompt_file=resolved_pf)
+            runner_name = task.get("use", "cybervisor")
+            if runner_name == "claude":
+                runner = ClaudeRunner()
+                max_rounds = task.get("max_rounds", 5)
+                log.write(f"Runner: ClaudeRunner (max_rounds={max_rounds})\n")
+                log.write(f"Command: claude -p --dangerously-skip-permissions\n")
+                log.write("-" * 60 + "\n\n")
+                log.flush()
+                returncode = runner.run(prompt, dir_path, log_file=log_file, max_rounds=max_rounds, prompt_file=resolved_pf)
+            else:
+                runner = CybervisorRunner()
+                log.write(f"Runner: CybervisorRunner\n")
+                log.write(f"Command: cybervisor run < {'<prompt_file>' if resolved_pf else '<prompt>'}\n")
+                log.write("-" * 60 + "\n\n")
+                log.flush()
+                returncode = runner.run(prompt, dir_path, log_file=log_file, prompt_file=resolved_pf)
 
         if returncode == 0:
             state["tasks"][str(index)] = {
@@ -139,4 +152,4 @@ def run_task(task, index, state):
         print(f"\n{config.RED}❌ Task [{index + 1}] error: {e}{config.RESET}")
         return False
 
-    return True
+    return True

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/src/tloop_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tloop-cli
-Version: 0.5.0
+Version: 0.6.0
 Summary: Automated Claude Code task runner
 License-Expression: MIT
 Requires-Python: >=3.9
@@ -60,6 +60,8 @@ tasks:
 | `prompt_file` | prompt 文件路径（解析顺序：绝对路径 → `~/.tloop/` 相对 → 任务目录相对） |
 | `model` | 覆盖该任务的模型 |
 | `branch` | `true`（自动 `feature-YYYYMMDD-NNN`）、`"custom/name"`、或 `false`（跳过分支） |
+| `use` | 任务执行器：`cybervisor`（默认，多阶段复杂任务）或 `claude`（定向任务，支持循环） |
+| `max_rounds` | `use: claude` 时生效，最大迭代次数（默认 5）；到达上限前未收到 `<promise>COMPLETE</promise>` 信号则任务失败 |
 
 ## 用法
 
@@ -76,6 +78,37 @@ tloop archive --latest     # 显示最近一次归档详情
 tloop migrate              # 迁移旧的项目本地数据到 ~/.tloop/
 ```
 
+## 执行器
+
+t-loop 支持两种任务执行器，通过 `use` 字段选择：
+
+| 执行器 | 说明 | 适用场景 |
+|--------|------|----------|
+| `cybervisor` | 默认，执行 `cybervisor run`，适合复杂多阶段任务 | 大型重构、多步骤分析 |
+| `claude` | 执行 `claude -p --dangerously-skip-permissions`，支持循环迭代 | 定向 bug 修复、明确目标的任务 |
+
+### ClaudeRunner 循环机制
+
+`use: claude` 时，任务以多轮迭代方式执行：
+
+1. 每轮启动一次 `claude -p --dangerously-skip-permissions`，传入 prompt
+2. 如果输出包含 `<promise>COMPLETE</promise>`，立即结束并标记成功
+3. 否则等待 2 秒，继续下一轮，直到达到 `max_rounds`（默认 5）
+4. `max_rounds` 用尽仍未检测到完成信号，任务标记失败
+
+使用示例：
+
+```yaml
+tasks:
+  - name: 修复空指针 bug
+    dir: ~/proj
+    use: claude
+    max_rounds: 3
+    prompt_file: bugfix.md
+```
+
+在 prompt 文件中加入 `<promise>COMPLETE</promise>` 即可让 Claude 主动退出循环。
+
 ## 工作原理
 
 每个任务的执行流程：

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/src/tloop_cli.egg-info/SOURCES.txt

@@ -20,5 +20,6 @@ src/tloop_cli.egg-info/dependency_links.txt
 src/tloop_cli.egg-info/entry_points.txt
 src/tloop_cli.egg-info/requires.txt
 src/tloop_cli.egg-info/top_level.txt
+test/test_claude_runner.py
 test/test_cli.py
 test/test_git_ops.py

tloop_cli-0.6.0/test/test_claude_runner.py

@@ -0,0 +1,89 @@
+"""Tests for ClaudeRunner."""
+
+import subprocess
+import unittest
+from unittest.mock import patch, MagicMock
+
+from runner.claude import ClaudeRunner
+
+
+class MockProcess:
+    def __init__(self, stdout_lines, returncode=0):
+        self._stdout_lines = stdout_lines
+        self.returncode = returncode
+        self.stdin = MagicMock()
+
+    @property
+    def stdout(self):
+        return iter(self._stdout_lines)
+
+    def wait(self):
+        pass
+
+
+class ClaudeRunnerTests(unittest.TestCase):
+
+    def test_completion_signal_exits_early(self):
+        runner = ClaudeRunner()
+        mock_process = MockProcess(["Some output\n", "<promise>COMPLETE</promise>\n", "More output\n"])
+        with patch("subprocess.Popen", return_value=mock_process):
+            with patch("time.sleep"):
+                returncode = runner.run("test prompt", "/tmp", max_rounds=5)
+        self.assertEqual(returncode, 0)
+
+    def test_no_signal_exhausts_rounds(self):
+        runner = ClaudeRunner()
+        mock_process = MockProcess(["Some output\n", "No completion here\n"])
+        with patch("subprocess.Popen", return_value=mock_process):
+            with patch("time.sleep"):
+                returncode = runner.run("test prompt", "/tmp", max_rounds=3)
+        self.assertEqual(returncode, 1)
+
+    def test_default_max_rounds_is_5(self):
+        runner = ClaudeRunner()
+        calls = []
+        mock_process = MockProcess(["No signal\n"])
+
+        def track_popen(*args, **kwargs):
+            calls.append(args)
+            return mock_process
+
+        with patch("subprocess.Popen", side_effect=track_popen):
+            with patch("time.sleep"):
+                runner.run("test prompt", "/tmp")
+        self.assertEqual(len(calls), 5)
+
+    def test_custom_max_rounds_respected(self):
+        runner = ClaudeRunner()
+        calls = []
+        mock_process = MockProcess(["No signal\n"])
+
+        def track_popen(*args, **kwargs):
+            calls.append(args)
+            return mock_process
+
+        with patch("subprocess.Popen", side_effect=track_popen):
+            with patch("time.sleep"):
+                runner.run("test prompt", "/tmp", max_rounds=3)
+        self.assertEqual(len(calls), 3)
+
+    def test_first_round_complete_exits_early(self):
+        runner = ClaudeRunner()
+        mock_process = MockProcess(["<promise>COMPLETE</promise>\n"])
+        with patch("subprocess.Popen", return_value=mock_process):
+            with patch("time.sleep") as mock_sleep:
+                returncode = runner.run("test prompt", "/tmp", max_rounds=5)
+        self.assertEqual(returncode, 0)
+        mock_sleep.assert_not_called()
+
+    def test_sleep_between_rounds(self):
+        runner = ClaudeRunner()
+        mock_process = MockProcess(["No signal\n"])
+        with patch("subprocess.Popen", return_value=mock_process):
+            with patch("time.sleep") as mock_sleep:
+                runner.run("test prompt", "/tmp", max_rounds=3)
+        self.assertEqual(mock_sleep.call_count, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

{tloop_cli-0.5.0 → tloop_cli-0.6.0}/test/test_cli.py

@@ -814,6 +814,125 @@ class RunTaskGitIntegrationTests(unittest.TestCase):
         self.assertEqual(state["tasks"]["0"]["status"], "failed")
 
 
+class RunnerSelectionTests(unittest.TestCase):
+    """T5.11: Tests for runner selection based on task 'use' field."""
+
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        _init_git_repo(self.tmpdir)
+        self.home = Path(tempfile.mkdtemp()) / "tloop"
+        self.home.mkdir(parents=True)
+        (self.home / "logs").mkdir()
+        (self.home / "archive").mkdir()
+        self.patches = [
+            patch.object(config, "TLOOP_HOME", self.home),
+            patch.object(config, "TASKS_FILE", self.home / "tasks.yaml"),
+            patch.object(config, "STATE_FILE", self.home / "state.json"),
+            patch.object(config, "LOGS_DIR", self.home / "logs"),
+            patch.object(config, "ARCHIVE_DIR", self.home / "archive"),
+        ]
+        for p in self.patches:
+            p.start()
+
+    def tearDown(self):
+        for p in self.patches:
+            p.stop()
+
+    @patch.object(task_mod, "ensure_clean_git", return_value=True)
+    @patch.object(task_mod, "create_task_branch", return_value=True)
+    @patch("runner.claude.subprocess.Popen")
+    def test_use_claude_selects_claude_runner(self, mock_popen, mock_branch, mock_clean):
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["<promise>COMPLETE</promise>\n"])
+        mock_proc.returncode = 0
+        mock_proc.stdin = MagicMock()
+        mock_proc.wait.return_value = 0
+        mock_popen.return_value = mock_proc
+
+        state = {"tasks": {}, "version": 1}
+        task = {
+            "name": "test claude task",
+            "dir": self.tmpdir,
+            "prompt": "do something",
+            "use": "claude",
+            "branch": "feat/test",
+        }
+        result = task_mod.run_task(task, 0, state)
+        self.assertTrue(result)
+        self.assertEqual(state["tasks"]["0"]["status"], "done")
+
+    @patch.object(task_mod, "ensure_clean_git", return_value=True)
+    @patch.object(task_mod, "create_task_branch", return_value=True)
+    @patch("runner.claude.subprocess.Popen")
+    def test_use_claude_max_rounds_respected(self, mock_popen, mock_branch, mock_clean):
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["no completion\n"])
+        mock_proc.returncode = 0
+        mock_proc.stdin = MagicMock()
+        mock_proc.wait.return_value = 0
+        mock_popen.return_value = mock_proc
+
+        state = {"tasks": {}, "version": 1}
+        task = {
+            "name": "test claude task",
+            "dir": self.tmpdir,
+            "prompt": "do something",
+            "use": "claude",
+            "max_rounds": 3,
+            "branch": "feat/test",
+        }
+        with patch("time.sleep"):
+            result = task_mod.run_task(task, 0, state)
+        self.assertFalse(result)
+        self.assertEqual(state["tasks"]["0"]["status"], "failed")
+        self.assertEqual(mock_popen.call_count, 3)
+
+    @patch.object(task_mod, "ensure_clean_git", return_value=True)
+    @patch.object(task_mod, "create_task_branch", return_value=True)
+    @patch("runner.cybervisor.subprocess.Popen")
+    def test_use_cybervisor_selects_cybervisor_runner(self, mock_popen, mock_branch, mock_clean):
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["output\n"])
+        mock_proc.returncode = 0
+        mock_proc.stdin = MagicMock()
+        mock_proc.wait.return_value = 0
+        mock_popen.return_value = mock_proc
+
+        state = {"tasks": {}, "version": 1}
+        task = {
+            "name": "test cybervisor task",
+            "dir": self.tmpdir,
+            "prompt": "do something",
+            "use": "cybervisor",
+            "branch": "feat/test",
+        }
+        result = task_mod.run_task(task, 0, state)
+        self.assertTrue(result)
+        self.assertEqual(state["tasks"]["0"]["status"], "done")
+
+    @patch.object(task_mod, "ensure_clean_git", return_value=True)
+    @patch.object(task_mod, "create_task_branch", return_value=True)
+    @patch("runner.cybervisor.subprocess.Popen")
+    def test_missing_use_field_defaults_to_cybervisor(self, mock_popen, mock_branch, mock_clean):
+        mock_proc = MagicMock()
+        mock_proc.stdout = iter(["output\n"])
+        mock_proc.returncode = 0
+        mock_proc.stdin = MagicMock()
+        mock_proc.wait.return_value = 0
+        mock_popen.return_value = mock_proc
+
+        state = {"tasks": {}, "version": 1}
+        task = {
+            "name": "test default task",
+            "dir": self.tmpdir,
+            "prompt": "do something",
+            "branch": "feat/test",
+        }
+        result = task_mod.run_task(task, 0, state)
+        self.assertTrue(result)
+        self.assertEqual(state["tasks"]["0"]["status"], "done")
+
+
 class EditorSelectionTests(unittest.TestCase):
     """Tests for editor selection and persistence in cmd_edit."""
 

tloop_cli-0.5.0/src/runner/claude.py

@@ -1,10 +0,0 @@
-"""Claude Code runner backend (placeholder)."""
-
-from runner import Runner
-
-
-class ClaudeRunner(Runner):
-    """Claude Code runner (not yet implemented)."""
-
-    def run(self, prompt, cwd, model=None, log_file=None):
-        raise NotImplementedError("Claude Code runner not yet implemented")