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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tloop-cli
-Version: 0.4.0
+Version: 0.6.0
 Summary: Automated Claude Code task runner
 License-Expression: MIT
 Requires-Python: >=3.9
@@ -16,8 +16,8 @@ Dynamic: license-file
 ## 安装
 
 ```bash
-pip install t-loop            # 从 PyPI 安装
-pip install -e .              # 本地开发安装
+pip install tloop-cli           # 从 PyPI 安装
+pip install -e .                # 本地开发安装
 ```
 
 需要 Python >=3.9，唯一外部依赖：`pyyaml`。
@@ -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.4.0 → tloop_cli-0.6.0}/README.md

@@ -5,8 +5,8 @@
 ## 安装
 
 ```bash
-pip install t-loop            # 从 PyPI 安装
-pip install -e .              # 本地开发安装
+pip install tloop-cli           # 从 PyPI 安装
+pip install -e .                # 本地开发安装
 ```
 
 需要 Python >=3.9，唯一外部依赖：`pyyaml`。
@@ -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.4.0 → tloop_cli-0.6.0}/pyproject.toml

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

{tloop_cli-0.4.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.6.0/src/cmd_edit.py

@@ -0,0 +1,110 @@
+"""tloop edit — open ~/.tloop/tasks.yaml in editor."""
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+
+import config
+
+KNOWN_EDITORS = {
+    "code": ("Visual Studio Code", "code"),
+    "vim": ("Vim", "vim"),
+    "nano": ("Nano", "nano"),
+}
+
+EDIT_HELP = """\
+Open ~/.tloop/tasks.yaml in your editor.
+
+On first run, you will be prompted to choose an editor (VS Code, Vim, Nano,
+or a custom command). The choice is saved to ~/.tloop/settings.json.
+Override anytime with: tloop edit --editor <command>
+
+Task file format (~/.tloop/tasks.yaml):
+
+  tasks:
+    - name: My task
+      dir: ~/projects/my-project
+      prompt: |
+        Describe what Claude should do.
+      # 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.
+"""
+
+
+def _load_settings():
+    if config.SETTINGS_FILE.exists():
+        try:
+            return json.loads(config.SETTINGS_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            pass
+    return {}
+
+
+def _save_settings(settings):
+    config.TLOOP_HOME.mkdir(exist_ok=True)
+    config.SETTINGS_FILE.write_text(json.dumps(settings, indent=2) + "\n")
+
+
+def _prompt_editor():
+    options = []
+    for key, (label, cmd) in KNOWN_EDITORS.items():
+        if shutil.which(cmd):
+            options.append((key, label, cmd))
+
+    print(f"{config.BOLD}Choose your editor for tasks.yaml:{config.RESET}\n")
+    for i, (key, label, _) in enumerate(options, 1):
+        print(f"  {i}) {label}")
+    print(f"  {len(options) + 1}) Other (enter command manually)")
+    print()
+
+    while True:
+        choice = input(f"Enter number [1-{len(options) + 1}]: ").strip()
+        if choice.isdigit():
+            idx = int(choice)
+            if 1 <= idx <= len(options):
+                return options[idx - 1][2]
+            if idx == len(options) + 1:
+                cmd = input("Enter editor command: ").strip()
+                if cmd:
+                    return cmd
+        print("Invalid choice, try again.")
+
+
+def _resolve_editor(cli_editor=None):
+    if cli_editor:
+        return cli_editor
+    settings = _load_settings()
+    if "editor" in settings:
+        return settings["editor"]
+    editor = _prompt_editor()
+    _save_settings({"editor": editor})
+    print(f"{config.GREEN}Editor saved. Change anytime with: tloop edit --editor <command>{config.RESET}\n")
+    return editor
+
+
+def add_parser(subparsers):
+    p = subparsers.add_parser(
+        "edit",
+        help="Open ~/.tloop/tasks.yaml in editor",
+        description=EDIT_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("--editor", help="Override editor command for this session")
+    p.set_defaults(func=handle)
+
+
+def handle(args):
+    config.TLOOP_HOME.mkdir(exist_ok=True)
+    if not config.TASKS_FILE.exists():
+        config.TASKS_FILE.write_text(config.SAMPLE_TASKS_YAML)
+
+    editor = _resolve_editor(getattr(args, "editor", None))
+    subprocess.run([editor, str(config.TASKS_FILE)])

{tloop_cli-0.4.0 → tloop_cli-0.6.0}/src/cmd_run.py

@@ -24,7 +24,6 @@ def handle(args):
 
     cfg = load_config()
     tasks = cfg.get("tasks", [])
-    defaults = cfg.get("defaults", {})
 
     if not tasks:
         print("No tasks defined in tasks.yaml")
@@ -71,7 +70,7 @@ def handle(args):
                 continue
 
         ran_any = True
-        success = run_task(tasks[i], i, state, defaults)
+        success = run_task(tasks[i], i, state)
         if not success and not args.continue_on_fail:
             print(f"\n{config.YELLOW}Stopped. Use -c to continue after failures.{config.RESET}")
             break

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

@@ -8,6 +8,7 @@ import yaml
 TLOOP_HOME = Path.home() / ".tloop"
 TASKS_FILE = TLOOP_HOME / "tasks.yaml"
 STATE_FILE = TLOOP_HOME / "state.json"
+SETTINGS_FILE = TLOOP_HOME / "settings.json"
 LOGS_DIR = TLOOP_HOME / "logs"
 ARCHIVE_DIR = TLOOP_HOME / "archive"
 
@@ -18,34 +19,7 @@ CYAN = "\033[96m"
 BOLD = "\033[1m"
 RESET = "\033[0m"
 
-SAMPLE_TASKS_YAML = """\
-# t-loop tasks.yaml
-# Define your Claude Code automation tasks here.
-#
-# Location: ~/.tloop/tasks.yaml
-#
-# Each task runs "cybervisor run <prompt>" in the specified directory.
-# Completed tasks are automatically archived after each run cycle.
-# View archives with: tloop archive
-#
-# prompt_file paths resolve in this order:
-#   1. Absolute path (after ~ expansion)
-#   2. Relative to ~/.tloop/
-#   3. Relative to the task's dir
-
-defaults:
-  # model: opus
-
-tasks: []
-  # - name: My first task
-  #   dir: ~/projects/my-project
-  #   prompt: |
-  #     Describe what Claude should do here.
-  #
-  # - name: Task with prompt file
-  #   dir: ~/projects/my-project
-  #   prompt_file: ./prompts/my-task.md
-"""
+SAMPLE_TASKS_YAML = "# Run 'tloop edit --help' for details on how to write this file.\ntasks: []\n"
 
 
 def ensure_tloop_home():
@@ -65,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.4.0 → tloop_cli-0.6.0}/src/runner/__init__.py

@@ -5,6 +5,6 @@ from abc import ABC, abstractmethod
 
 class Runner(ABC):
     @abstractmethod
-    def run(self, prompt, cwd, model=None, log_file=None):
+    def run(self, prompt, cwd, log_file=None):
         """Run a task. Returns exit code (0=success)."""
         ...

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.6.0/src/runner/cybervisor.py

@@ -0,0 +1,35 @@
+"""Cybervisor runner backend."""
+
+import subprocess
+
+from runner import Runner
+
+
+class CybervisorRunner(Runner):
+    def run(self, prompt, cwd, log_file=None, prompt_file=None):
+        cmd = ["cybervisor", "run"]
+
+        with open(log_file, "a") if log_file else open("/dev/null", "a") as log:
+            stdin_fh = open(prompt_file, "r") if prompt_file else None
+            try:
+                process = subprocess.Popen(
+                    cmd,
+                    cwd=cwd,
+                    stdin=stdin_fh if stdin_fh else subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                )
+                if not stdin_fh:
+                    process.stdin.write(prompt)
+                    process.stdin.close()
+                for line in process.stdout:
+                    print(line, end="")
+                    log.write(line)
+                log.flush()
+                process.wait()
+            finally:
+                if stdin_fh:
+                    stdin_fh.close()
+
+        return process.returncode

{tloop_cli-0.4.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
 
 
@@ -28,12 +29,11 @@ def resolve_prompt_file(prompt_file, dir_path):
     return Path(prompt_file)
 
 
-def run_task(task, index, state, defaults):
+def run_task(task, index, state):
     name = task.get("name", f"Task {index + 1}")
-    dir_path = expand_dir(task.get("dir", defaults.get("dir", ".")))
+    dir_path = expand_dir(task.get("dir", "."))
     prompt = task.get("prompt", "")
     prompt_file = task.get("prompt_file")
-    model = task.get("model", defaults.get("model"))
     branch_config = task.get("branch", True)
 
     if not os.path.isdir(dir_path):
@@ -46,10 +46,11 @@ def run_task(task, index, state, defaults):
         save_state(state)
         return False
 
+    resolved_pf = None
     if prompt_file:
-        pf = resolve_prompt_file(prompt_file, dir_path)
-        if pf.exists():
-            prompt = pf.read_text()
+        resolved_pf = resolve_prompt_file(prompt_file, dir_path)
+        if resolved_pf.exists():
+            prompt = resolved_pf.read_text()
         else:
             print(f"{config.RED}  Prompt file not found: {prompt_file}{config.RESET}")
             return False
@@ -100,12 +101,24 @@ def run_task(task, index, state, defaults):
     try:
         with open(log_file, "a") as log:
             log.write(f"Started: {started}\n")
-            log.write(f"Command: cybervisor run <prompt>\n")
-            log.write("-" * 60 + "\n\n")
             log.flush()
 
-        runner = CybervisorRunner()
-        returncode = runner.run(prompt, dir_path, model=model, log_file=log_file)
+            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, defaults):
         print(f"\n{config.RED}❌ Task [{index + 1}] error: {e}{config.RESET}")
         return False
 
-    return True
+    return True

{tloop_cli-0.4.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.4.0
+Version: 0.6.0
 Summary: Automated Claude Code task runner
 License-Expression: MIT
 Requires-Python: >=3.9
@@ -16,8 +16,8 @@ Dynamic: license-file
 ## 安装
 
 ```bash
-pip install t-loop            # 从 PyPI 安装
-pip install -e .              # 本地开发安装
+pip install tloop-cli           # 从 PyPI 安装
+pip install -e .                # 本地开发安装
 ```
 
 需要 Python >=3.9，唯一外部依赖：`pyyaml`。
@@ -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.4.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.4.0 → tloop_cli-0.6.0}/test/test_cli.py

@@ -15,6 +15,7 @@ import config
 import state as state_mod
 import task as task_mod
 import cmd_run
+import cmd_edit
 
 
 def _init_git_repo(tmpdir):
@@ -44,6 +45,7 @@ def _setup_home(tmp_path):
         patch.object(config, "TLOOP_HOME", home),
         patch.object(config, "TASKS_FILE", home / "tasks.yaml"),
         patch.object(config, "STATE_FILE", home / "state.json"),
+        patch.object(config, "SETTINGS_FILE", home / "settings.json"),
         patch.object(config, "LOGS_DIR", home / "logs"),
         patch.object(config, "ARCHIVE_DIR", home / "archive"),
     ]
@@ -60,6 +62,7 @@ class EnsureTloopHomeTests(unittest.TestCase):
             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, "SETTINGS_FILE", self.home / "settings.json"),
             patch.object(config, "LOGS_DIR", self.home / "logs"),
             patch.object(config, "ARCHIVE_DIR", self.home / "archive"),
         ]
@@ -86,7 +89,7 @@ class EnsureTloopHomeTests(unittest.TestCase):
         self.assertTrue(tasks_file.exists())
         content = tasks_file.read_text()
         self.assertIn("tasks:", content)
-        self.assertIn("defaults:", content)
+        self.assertTrue(content.startswith("# Run 'tloop edit --help'"))
 
     def test_idempotent_no_exit_when_tasks_exist(self):
         self.home.mkdir(parents=True, exist_ok=True)
@@ -765,7 +768,7 @@ class RunTaskGitIntegrationTests(unittest.TestCase):
             "prompt": "do something",
             "branch": "feat/test",
         }
-        result = task_mod.run_task(task, 0, state, {})
+        result = task_mod.run_task(task, 0, state)
         self.assertTrue(result)
         mock_clean.assert_called_once()
         mock_branch.assert_called_once_with(self.tmpdir, "feat/test")
@@ -778,7 +781,7 @@ class RunTaskGitIntegrationTests(unittest.TestCase):
             "dir": self.tmpdir,
             "prompt": "do something",
         }
-        result = task_mod.run_task(task, 0, state, {})
+        result = task_mod.run_task(task, 0, state)
         self.assertFalse(result)
         self.assertEqual(state["tasks"]["0"]["status"], "failed")
         self.assertIn("auto-commit", state["tasks"]["0"]["error"])
@@ -793,7 +796,7 @@ class RunTaskGitIntegrationTests(unittest.TestCase):
             "prompt": "do something",
             "branch": True,
         }
-        result = task_mod.run_task(task, 0, state, {})
+        result = task_mod.run_task(task, 0, state)
         self.assertFalse(result)
         self.assertEqual(state["tasks"]["0"]["status"], "failed")
         self.assertIn("branch", state["tasks"]["0"]["error"])
@@ -806,10 +809,182 @@ class RunTaskGitIntegrationTests(unittest.TestCase):
             "dir": self.tmpdir,
             "prompt": "do something",
         }
-        task_mod.run_task(task, 0, state, {})
+        task_mod.run_task(task, 0, state)
         self.assertNotEqual(state["tasks"]["0"]["status"], "running")
         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."""
+
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.home = Path(self.tmpdir) / "tloop"
+        self.home.mkdir(parents=True)
+        self.patches = [
+            patch.object(config, "TLOOP_HOME", self.home),
+            patch.object(config, "SETTINGS_FILE", self.home / "settings.json"),
+        ]
+        for p in self.patches:
+            p.start()
+
+    def tearDown(self):
+        for p in self.patches:
+            p.stop()
+
+    def test_cli_editor_overrides_settings(self):
+        cmd_edit._save_settings({"editor": "vim"})
+        result = cmd_edit._resolve_editor("code")
+        self.assertEqual(result, "code")
+
+    def test_saved_editor_used_when_no_cli_override(self):
+        cmd_edit._save_settings({"editor": "code"})
+        result = cmd_edit._resolve_editor()
+        self.assertEqual(result, "code")
+
+    def test_prompt_on_first_run(self):
+        with patch("builtins.input", side_effect=["1"]):
+            with patch.object(cmd_edit, "KNOWN_EDITORS", {"code": ("VS Code", "code")}):
+                with patch("shutil.which", return_value="/usr/local/bin/code"):
+                    result = cmd_edit._resolve_editor()
+        self.assertEqual(result, "code")
+        settings = json.loads((self.home / "settings.json").read_text())
+        self.assertEqual(settings["editor"], "code")
+
+    def test_custom_editor_via_prompt(self):
+        with patch("builtins.input", side_effect=["2", "subl"]):
+            with patch.object(cmd_edit, "KNOWN_EDITORS", {"code": ("VS Code", "code")}):
+                with patch("shutil.which", return_value="/usr/local/bin/code"):
+                    result = cmd_edit._resolve_editor()
+        self.assertEqual(result, "subl")
+
+    def test_corrupt_settings_file_triggers_prompt(self):
+        (self.home / "settings.json").write_text("not json")
+        with patch("builtins.input", side_effect=["1"]):
+            with patch.object(cmd_edit, "KNOWN_EDITORS", {"code": ("VS Code", "code")}):
+                with patch("shutil.which", return_value="/usr/local/bin/code"):
+                    result = cmd_edit._resolve_editor()
+        self.assertEqual(result, "code")
+
+
 if __name__ == "__main__":
     unittest.main()

tloop_cli-0.4.0/src/cmd_edit.py

@@ -1,45 +0,0 @@
-"""tloop edit — open ~/.tloop/tasks.yaml in editor."""
-
-import argparse
-import os
-import subprocess
-
-import config
-
-
-EDIT_HELP = """\
-Open ~/.tloop/tasks.yaml in your editor ($EDITOR, defaults to vi).
-
-Task file format (~/.tloop/tasks.yaml):
-
-  defaults:
-    model: opus              # optional default model
-
-  tasks:
-    - name: My task
-      dir: ~/projects/my-project
-      prompt: |
-        Describe what Claude should do.
-      # OR:
-      prompt_file: ./prompts/my-task.md
-      model: opus            # optional override
-      branch: true           # true=auto, "custom/name", false=skip
-
-  Each task runs in the specified directory. Completed tasks are
-  archived to ~/.tloop/archive/ after each run cycle.
-"""
-
-
-def add_parser(subparsers):
-    p = subparsers.add_parser(
-        "edit",
-        help="Open ~/.tloop/tasks.yaml in editor",
-        description=EDIT_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    p.set_defaults(func=handle)
-
-
-def handle(args):
-    editor = os.environ.get("EDITOR", "vi")
-    subprocess.run([editor, str(config.TASKS_FILE)])

tloop_cli-0.4.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")

tloop_cli-0.4.0/src/runner/cybervisor.py

@@ -1,28 +0,0 @@
-"""Cybervisor runner backend."""
-
-import subprocess
-
-from runner import Runner
-
-
-class CybervisorRunner(Runner):
-    def run(self, prompt, cwd, model=None, log_file=None):
-        cmd = ["cybervisor", "run", prompt]
-        if model:
-            cmd.extend(["--model", model])
-
-        with open(log_file, "a") if log_file else open("/dev/null", "a") as log:
-            process = subprocess.Popen(
-                cmd,
-                cwd=cwd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                text=True,
-            )
-            for line in process.stdout:
-                print(line, end="")
-                log.write(line)
-            log.flush()
-            process.wait()
-
-        return process.returncode