tloop-cli 0.4.0__py3-none-any.whl

claude_runner.py

@@ -0,0 +1,82 @@
+"""Reusable Claude CLI runner with retry and verification."""
+
+import subprocess
+
+GREEN = "\033[92m"
+RED = "\033[91m"
+YELLOW = "\033[93m"
+RESET = "\033[0m"
+
+DEFAULT_MAX_RETRIES = 3
+
+# Append this to prompts where Claude might just plan instead of executing.
+EXECUTION_SUFFIX = (
+    "\n\nIMPORTANT: Execute the steps above immediately. "
+    "Do NOT ask for confirmation, do NOT just describe what you would do. "
+    "Perform every step now using your available tools."
+)
+
+
+def run_claude(prompt, cwd, max_retries=DEFAULT_MAX_RETRIES, verify_fn=None, log_file=None):
+    """Run `claude -p` with --dangerously-skip-permissions and optional retry loop.
+
+    Args:
+        prompt: The prompt text to send to Claude.
+        cwd: Working directory for the subprocess.
+        max_retries: Max attempts before giving up.
+        verify_fn: Optional callable(cwd) -> bool that checks if the work was actually done.
+        log_file: Optional path to append logs.
+
+    Returns:
+        True if Claude succeeded (and passed verification if provided), False otherwise.
+    """
+    enriched_prompt = prompt + EXECUTION_SUFFIX
+    cmd = ["claude", "--dangerously-skip-permissions", "--print", enriched_prompt]
+
+    for attempt in range(1, max_retries + 1):
+        if attempt > 1:
+            hint = (
+                f"This is attempt {attempt}/{max_retries}. "
+                "The previous attempt did not complete the task. "
+                "You MUST execute the steps now, not describe them."
+            )
+            attempt_prompt = prompt + "\n\n" + hint + EXECUTION_SUFFIX
+            attempt_cmd = ["claude", "--dangerously-skip-permissions", "--print", attempt_prompt]
+        else:
+            attempt_cmd = cmd
+
+        result = subprocess.run(
+            attempt_cmd,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+        )
+
+        if log_file:
+            with open(log_file, "a") as log:
+                log.write(f"[claude_runner] attempt {attempt}/{max_retries} exit={result.returncode}\n")
+                if result.stdout:
+                    log.write(result.stdout + "\n")
+                if result.stderr:
+                    log.write(result.stderr + "\n")
+                log.flush()
+
+        if result.returncode != 0:
+            print(f"{YELLOW}  Claude exited with code {result.returncode} (attempt {attempt}/{max_retries}){RESET}")
+            if attempt < max_retries:
+                continue
+            return False
+
+        # If no verification function, trust the exit code.
+        if verify_fn is None:
+            return True
+
+        if verify_fn(cwd):
+            return True
+
+        print(f"{YELLOW}  Claude completed but verification failed (attempt {attempt}/{max_retries}){RESET}")
+        if attempt >= max_retries:
+            print(f"{RED}  Max retries reached. Giving up.{RESET}")
+            return False
+
+    return False

cmd_archive.py

@@ -0,0 +1,15 @@
+"""tloop archive — view archived task runs."""
+
+import config
+from state import show_archives
+
+
+def add_parser(subparsers):
+    p = subparsers.add_parser("archive", help="View archived task runs")
+    p.add_argument("--latest", action="store_true", help="Show most recent archive details")
+    p.set_defaults(func=handle)
+
+
+def handle(args):
+    config.ARCHIVE_DIR.mkdir(parents=True, exist_ok=True)
+    show_archives(latest=args.latest)

cmd_edit.py

@@ -0,0 +1,45 @@
+"""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)])

cmd_migrate.py

@@ -0,0 +1,71 @@
+"""tloop migrate — migrate old data files to ~/.tloop/."""
+
+import shutil
+import sys
+from pathlib import Path
+
+import yaml
+
+import config
+
+
+def add_parser(subparsers):
+    p = subparsers.add_parser("migrate", help="Migrate old data to ~/.tloop/")
+    p.set_defaults(func=handle)
+
+
+def handle(args):
+    project_root = Path(__file__).resolve().parent.parent.parent
+
+    old_tasks = project_root / "tasks.yaml"
+    old_state = project_root / ".tloop-state.json"
+    old_logs = project_root / "logs"
+
+    found = []
+    if old_tasks.exists():
+        found.append(old_tasks)
+    if old_state.exists():
+        found.append(old_state)
+    if old_logs.exists() and old_logs.is_dir():
+        found.append(old_logs)
+
+    if not found:
+        print(f"{config.YELLOW}No old data files found in {project_root}{config.RESET}")
+        print("Nothing to migrate.")
+        return
+
+    if config.TASKS_FILE.exists():
+        print(f"{config.RED}Conflict: {config.TASKS_FILE} already exists{config.RESET}")
+        print("Resolve the conflict manually before migrating.")
+        sys.exit(1)
+
+    config.TLOOP_HOME.mkdir(exist_ok=True)
+    config.LOGS_DIR.mkdir(exist_ok=True)
+    config.ARCHIVE_DIR.mkdir(exist_ok=True)
+
+    if old_tasks.exists():
+        shutil.copy2(old_tasks, config.TASKS_FILE)
+        print(f"  Migrated: tasks.yaml → {config.TASKS_FILE}")
+
+        data = yaml.safe_load(open(old_tasks)) or {}
+        for i, task in enumerate(data.get("tasks", [])):
+            pf = task.get("prompt_file")
+            if pf and not Path(pf).expanduser().is_absolute():
+                print(
+                    f"  {config.YELLOW}Warning: task '{task.get('name', f'Task {i + 1}')}' "
+                    f"has relative prompt_file '{pf}'{config.RESET}"
+                )
+                print(f"    Will resolve from {config.TLOOP_HOME} first, then the task's dir.")
+
+    if old_state.exists():
+        shutil.copy2(old_state, config.STATE_FILE)
+        print(f"  Migrated: .tloop-state.json → {config.STATE_FILE}")
+
+    if old_logs.exists() and old_logs.is_dir():
+        for log_file in old_logs.iterdir():
+            if log_file.is_file():
+                shutil.copy2(log_file, config.LOGS_DIR / log_file.name)
+        print(f"  Migrated: logs/ → {config.LOGS_DIR}/")
+
+    print(f"\n{config.GREEN}Migration complete.{config.RESET}")
+    print(f"Old files still exist in {project_root} — remove them manually when ready.")

cmd_run.py

@@ -0,0 +1,83 @@
+"""tloop run — execute tasks defined in ~/.tloop/tasks.yaml."""
+
+import sys
+
+import config
+from config import ensure_tloop_home, load_config
+from state import load_state, save_state, show_status, archive_completed_tasks
+from task import run_task
+
+
+def add_parser(subparsers):
+    p = subparsers.add_parser("run", help="Run tasks defined in ~/.tloop/tasks.yaml")
+    p.add_argument("--status", "-s", action="store_true", help="Show task status")
+    p.add_argument("--reset", action="store_true", help="Reset all tasks to pending")
+    p.add_argument("--only", type=int, help="Run only task #N (1-based)")
+    p.add_argument("--confirm", "-i", action="store_true", help="Confirm before each task")
+    p.add_argument("--continue", "-c", dest="continue_on_fail", action="store_true",
+                    help="Continue even if a task fails")
+    p.set_defaults(func=handle)
+
+
+def handle(args):
+    ensure_tloop_home()
+
+    cfg = load_config()
+    tasks = cfg.get("tasks", [])
+    defaults = cfg.get("defaults", {})
+
+    if not tasks:
+        print("No tasks defined in tasks.yaml")
+        sys.exit(0)
+
+    state = load_state()
+
+    if args.status:
+        show_status(tasks, state)
+        return
+
+    if args.reset:
+        state = {"tasks": {}, "version": 1}
+        save_state(state)
+        print(f"{config.GREEN}State reset. All tasks are pending.{config.RESET}")
+        return
+
+    if args.only is not None:
+        if args.only < 1 or args.only > len(tasks):
+            print(f"{config.RED}Invalid task number: {args.only}{config.RESET}")
+            sys.exit(1)
+        indices = [args.only - 1]
+    else:
+        indices = list(range(len(tasks)))
+
+    ran_any = False
+    for i in indices:
+        ts = state.get("tasks", {}).get(str(i), {})
+        status = ts.get("status", "pending")
+
+        if status == "done" and args.only is None:
+            print(f"⏭️  Task [{i + 1}] already done, skipping")
+            continue
+
+        if args.confirm:
+            name = tasks[i].get("name", f"Task {i + 1}")
+            try:
+                resp = input(f"\nRun task [{i + 1}] '{name}'? [y/N] ")
+            except (EOFError, KeyboardInterrupt):
+                print("\nAborted.")
+                break
+            if resp.lower() != "y":
+                print("Skipped.")
+                continue
+
+        ran_any = True
+        success = run_task(tasks[i], i, state, defaults)
+        if not success and not args.continue_on_fail:
+            print(f"\n{config.YELLOW}Stopped. Use -c to continue after failures.{config.RESET}")
+            break
+
+    if ran_any:
+        print(f"\n{config.BOLD}--- Final Status ---{config.RESET}")
+        show_status(tasks, state)
+
+    archive_completed_tasks(cfg, state)

config.py

@@ -0,0 +1,69 @@
+"""Configuration constants and helpers for t-loop."""
+
+import sys
+from pathlib import Path
+
+import yaml
+
+TLOOP_HOME = Path.home() / ".tloop"
+TASKS_FILE = TLOOP_HOME / "tasks.yaml"
+STATE_FILE = TLOOP_HOME / "state.json"
+LOGS_DIR = TLOOP_HOME / "logs"
+ARCHIVE_DIR = TLOOP_HOME / "archive"
+
+GREEN = "\033[92m"
+RED = "\033[91m"
+YELLOW = "\033[93m"
+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
+"""
+
+
+def ensure_tloop_home():
+    TLOOP_HOME.mkdir(exist_ok=True)
+    LOGS_DIR.mkdir(exist_ok=True)
+    ARCHIVE_DIR.mkdir(exist_ok=True)
+
+    if not TASKS_FILE.exists():
+        TASKS_FILE.write_text(SAMPLE_TASKS_YAML)
+        print(f"{GREEN}Created {TASKS_FILE}{RESET}")
+        print(f"\nEdit ~/.tloop/tasks.yaml to define your tasks, then run tloop run.")
+        sys.exit(0)
+
+
+def load_config():
+    if not TASKS_FILE.exists():
+        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 {}

git_ops.py

@@ -0,0 +1,151 @@
+"""Git operations for t-loop: auto-commit, branch management, and safety checks."""
+
+import subprocess
+from datetime import datetime
+
+from claude_runner import run_claude
+
+GREEN = "\033[92m"
+RED = "\033[91m"
+YELLOW = "\033[93m"
+RESET = "\033[0m"
+
+COMMIT_STAGED_PROMPT = (
+    "You are performing a protective auto-commit of STAGED changes in this repository.\n"
+    "Follow these steps exactly:\n"
+    "1. Run `git diff --cached --name-only` to see what is staged.\n"
+    "2. Check each file for sensitive content (e.g., .env, credentials, secret keys, API tokens, private keys). "
+    "If you find any sensitive files staged, unstage them with `git restore --staged <file>` and report what you excluded.\n"
+    "3. If any files remain staged after the sensitive-file check, commit them with a Chinese conventional-commit message "
+    "(format: `<type>: <description>` where type is one of: feat, fix, refactor, docs, style, test, chore, perf, ci, build). "
+    "Do NOT use the `--no-verify` flag.\n"
+    "4. If nothing remains staged after the sensitive-file check, report that there is nothing to commit.\n"
+)
+
+COMMIT_WORKDIR_PROMPT = (
+    "You are performing a protective auto-commit of all remaining UNSTAGED changes in this repository.\n"
+    "Follow these steps exactly:\n"
+    "1. Run `git add -A` to stage all working-directory changes.\n"
+    "2. Run `git diff --cached --name-only` to see what is now staged.\n"
+    "3. Check each file for sensitive content (e.g., .env, credentials, secret keys, API tokens, private keys). "
+    "If you find any sensitive files staged, unstage them with `git restore --staged <file>` and report what you excluded.\n"
+    "4. If any files remain staged after the sensitive-file check, commit them with a Chinese conventional-commit message "
+    "(format: `<type>: <description>` where type is one of: feat, fix, refactor, docs, style, test, chore, perf, ci, build). "
+    "Do NOT use the `--no-verify` flag.\n"
+    "5. If nothing remains staged after the sensitive-file check, report that there is nothing to commit.\n"
+)
+
+
+def _git(dir_path, *args):
+    result = subprocess.run(
+        ["git"] + list(args),
+        cwd=dir_path,
+        capture_output=True,
+        text=True,
+    )
+    return result
+
+
+def is_git_repo(dir_path):
+    result = _git(dir_path, "rev-parse", "--is-inside-work-tree")
+    return result.returncode == 0 and result.stdout.strip() == "true"
+
+
+def is_git_clean(dir_path):
+    result = _git(dir_path, "status", "--porcelain")
+    return result.returncode == 0 and result.stdout.strip() == ""
+
+
+def has_staged_changes(dir_path):
+    result = _git(dir_path, "diff", "--cached", "--quiet")
+    return result.returncode == 1
+
+
+def is_detached_head(dir_path):
+    result = _git(dir_path, "symbolic-ref", "-q", "HEAD")
+    return result.returncode != 0
+
+
+def branch_exists(dir_path, name):
+    result = _git(dir_path, "branch", "--list", name)
+    return result.stdout.strip() != ""
+
+
+def ensure_clean_git(dir_path, task_name, log_file=None):
+    if not is_git_repo(dir_path):
+        return True
+
+    if is_git_clean(dir_path):
+        return True
+
+    if has_staged_changes(dir_path):
+        print(f"{YELLOW}  Dirty working tree detected. Auto-committing staged changes...{RESET}")
+        run_claude(
+            COMMIT_STAGED_PROMPT,
+            cwd=dir_path,
+            verify_fn=is_git_clean,
+            log_file=log_file,
+        )
+
+    if not is_git_clean(dir_path):
+        print(f"{YELLOW}  Committing remaining working-directory changes...{RESET}")
+        run_claude(
+            COMMIT_WORKDIR_PROMPT,
+            cwd=dir_path,
+            verify_fn=is_git_clean,
+            log_file=log_file,
+        )
+
+    if is_git_clean(dir_path):
+        print(f"{GREEN}  Working tree is now clean.{RESET}")
+        return True
+
+    print(f"{RED}  Failed to clean working tree after auto-commit. Skipping task.{RESET}")
+    return False
+
+
+def find_next_available_branch(dir_path, prefix):
+    for n in range(1, 1000):
+        name = f"{prefix}-{n:03d}"
+        if not branch_exists(dir_path, name):
+            return name
+    return None
+
+
+def create_task_branch(dir_path, branch_config):
+    if not is_git_repo(dir_path):
+        return True
+
+    if branch_config is False:
+        return True
+
+    if is_detached_head(dir_path):
+        print(f"{RED}  Cannot create branch: repository is in detached HEAD state.{RESET}")
+        return False
+
+    today = datetime.now().strftime("%Y%m%d")
+
+    if branch_config is True or branch_config is None:
+        prefix = f"feature-{today}"
+        name = find_next_available_branch(dir_path, prefix)
+        if name is None:
+            print(f"{RED}  Could not find an available branch name with prefix {prefix}{RESET}")
+            return False
+    else:
+        custom = str(branch_config)
+        if not branch_exists(dir_path, custom):
+            name = custom
+        else:
+            prefix = custom
+            name = find_next_available_branch(dir_path, prefix)
+            if name is None:
+                print(f"{RED}  Could not find an available branch name with prefix {prefix}{RESET}")
+                return False
+
+    result = _git(dir_path, "checkout", "-b", name)
+    if result.returncode != 0:
+        print(f"{RED}  Failed to create branch '{name}': {result.stderr.strip()}{RESET}")
+        return False
+
+    print(f"{GREEN}  Created and checked out branch: {name}{RESET}")
+    return True

main.py

@@ -0,0 +1,38 @@
+"""t-loop entry point."""
+
+import argparse
+
+__version__ = "0.4.0"
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="tloop",
+        description="t-loop: Automated Claude Code task runner",
+    )
+    parser.add_argument("-v", "--version", action="version",
+                        version=f"tloop {__version__}")
+
+    subparsers = parser.add_subparsers(title="commands")
+
+    from cmd_run import add_parser as add_run
+    from cmd_edit import add_parser as add_edit
+    from cmd_migrate import add_parser as add_migrate
+    from cmd_archive import add_parser as add_archive
+
+    add_run(subparsers)
+    add_edit(subparsers)
+    add_migrate(subparsers)
+    add_archive(subparsers)
+
+    args = parser.parse_args()
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        return
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

runner/__init__.py

@@ -0,0 +1,10 @@
+"""Runner base class for t-loop task execution backends."""
+
+from abc import ABC, abstractmethod
+
+
+class Runner(ABC):
+    @abstractmethod
+    def run(self, prompt, cwd, model=None, log_file=None):
+        """Run a task. Returns exit code (0=success)."""
+        ...

runner/claude.py

@@ -0,0 +1,10 @@
+"""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")

runner/cybervisor.py

@@ -0,0 +1,28 @@
+"""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

state.py

@@ -0,0 +1,141 @@
+"""State management and archiving for t-loop."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+import yaml
+
+import config
+
+
+def load_state():
+    if config.STATE_FILE.exists():
+        with open(config.STATE_FILE) as f:
+            return json.load(f)
+    return {"tasks": {}, "version": 1}
+
+
+def save_state(state):
+    with open(config.STATE_FILE, "w") as f:
+        json.dump(state, f, indent=2, ensure_ascii=False)
+
+
+def get_status_icon(status):
+    return {"pending": "⏳", "running": "🔄", "done": "✅", "failed": "❌"}.get(
+        status, "?"
+    )
+
+
+def show_status(tasks, state):
+    if not tasks:
+        print("  (no tasks)")
+        return
+    for i, task in enumerate(tasks):
+        name = task.get("name", f"Task {i + 1}")
+        ts = state.get("tasks", {}).get(str(i), {})
+        status = ts.get("status", "pending")
+        icon = get_status_icon(status)
+        extra = ""
+        if status == "done" and "finished_at" in ts:
+            extra = f"  ({ts['finished_at'][:16]})"
+        elif status == "failed":
+            extra = "  (see logs/)"
+        print(f"  {icon}  [{i + 1}] {name}{config.RESET}  {config.CYAN}{status}{config.RESET}{extra}")
+    print()
+
+
+def archive_completed_tasks(config_data, state):
+    tasks = config_data.get("tasks", [])
+
+    completed = []
+    remaining = []
+    for i, task in enumerate(tasks):
+        ts = state.get("tasks", {}).get(str(i), {})
+        status = ts.get("status", "pending")
+        if status == "done":
+            completed.append({"task": task, "index": i, "result": ts})
+        else:
+            remaining.append(task)
+
+    if not completed:
+        return
+
+    total = len(tasks)
+    done_count = len(completed)
+    failed_count = sum(
+        1 for i in range(total)
+        if state.get("tasks", {}).get(str(i), {}).get("status") == "failed"
+    )
+
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    archive_data = {
+        "archived_at": datetime.now().isoformat(),
+        "run_summary": {
+            "total": total,
+            "done": done_count,
+            "failed": failed_count,
+            "pending": total - done_count - failed_count,
+        },
+        "tasks": completed,
+    }
+
+    config.ARCHIVE_DIR.mkdir(exist_ok=True)
+    archive_file = config.ARCHIVE_DIR / f"run-{timestamp}.yaml"
+    with open(archive_file, "w") as f:
+        yaml.dump(archive_data, f, default_flow_style=False, allow_unicode=True)
+
+    remaining_config = dict(config_data)
+    remaining_config["tasks"] = remaining
+    with open(config.TASKS_FILE, "w") as f:
+        yaml.dump(remaining_config, f, default_flow_style=False, allow_unicode=True)
+
+    save_state({"tasks": {}, "version": 1})
+
+    print(f"\n{config.GREEN}Archived {done_count} completed task(s) to {archive_file.name}{config.RESET}")
+
+
+def show_archives(latest=False):
+    if not config.ARCHIVE_DIR.exists():
+        print("No archive files found.")
+        return
+
+    archives = sorted(config.ARCHIVE_DIR.glob("run-*.yaml"), reverse=True)
+    if not archives:
+        print("No archive files found.")
+        return
+
+    if latest:
+        with open(archives[0]) as f:
+            data = yaml.safe_load(f)
+        print(f"{config.BOLD}Latest archive: {archives[0].name}{config.RESET}")
+        print(f"  Archived at: {data.get('archived_at', 'unknown')}")
+        summary = data.get("run_summary", {})
+        print(
+            f"  Total: {summary.get('total', 0)}, "
+            f"Done: {summary.get('done', 0)}, "
+            f"Failed: {summary.get('failed', 0)}, "
+            f"Pending: {summary.get('pending', 0)}"
+        )
+        print()
+        for entry in data.get("tasks", []):
+            task = entry.get("task", {})
+            result = entry.get("result", {})
+            name = task.get("name", "Unnamed")
+            status = result.get("status", "unknown")
+            icon = get_status_icon(status)
+            finished = result.get("finished_at", "")
+            extra = f"  ({finished[:16]})" if finished else ""
+            print(f"  {icon} {name}{extra}")
+    else:
+        print(f"{config.BOLD}Archive files:{config.RESET}")
+        for archive in archives:
+            with open(archive) as f:
+                data = yaml.safe_load(f)
+            summary = data.get("run_summary", {})
+            print(
+                f"  {archive.name}  "
+                f"(done: {summary.get('done', 0)}, "
+                f"failed: {summary.get('failed', 0)}, "
+                f"total: {summary.get('total', 0)})"
+            )

task.py

@@ -0,0 +1,142 @@
+"""Single task execution for t-loop."""
+
+import os
+from datetime import datetime
+from pathlib import Path
+
+import config
+from git_ops import ensure_clean_git, create_task_branch
+from runner.cybervisor import CybervisorRunner
+from state import save_state
+
+
+def expand_dir(d):
+    return os.path.expandvars(os.path.expanduser(d))
+
+
+def resolve_prompt_file(prompt_file, dir_path):
+    """Resolve prompt_file: ~ expansion, TLOOP_HOME-relative, then dir-relative."""
+    pf = Path(prompt_file).expanduser()
+    if pf.is_absolute():
+        return pf
+    candidate = config.TLOOP_HOME / prompt_file
+    if candidate.exists():
+        return candidate
+    candidate = Path(dir_path) / prompt_file
+    if candidate.exists():
+        return candidate
+    return Path(prompt_file)
+
+
+def run_task(task, index, state, defaults):
+    name = task.get("name", f"Task {index + 1}")
+    dir_path = expand_dir(task.get("dir", defaults.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):
+        print(f"{config.RED}  Directory not found: {dir_path}{config.RESET}")
+        state.setdefault("tasks", {})[str(index)] = {
+            "status": "failed",
+            "error": f"Directory not found: {dir_path}",
+            "updated_at": datetime.now().isoformat(),
+        }
+        save_state(state)
+        return False
+
+    if prompt_file:
+        pf = resolve_prompt_file(prompt_file, dir_path)
+        if pf.exists():
+            prompt = pf.read_text()
+        else:
+            print(f"{config.RED}  Prompt file not found: {prompt_file}{config.RESET}")
+            return False
+
+    if not prompt.strip():
+        print(f"{config.RED}  No prompt defined for task: {name}{config.RESET}")
+        return False
+
+    print(f"\n{config.BOLD}{'=' * 60}{config.RESET}")
+    print(f"{config.BOLD}  Task [{index + 1}]: {name}{config.RESET}")
+    print(f"  Directory: {config.CYAN}{dir_path}{config.RESET}")
+    print(f"{config.BOLD}{'=' * 60}{config.RESET}\n")
+
+    config.LOGS_DIR.mkdir(exist_ok=True)
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in name)
+    log_file = config.LOGS_DIR / f"{index + 1:03d}-{safe_name}.log"
+
+    with open(log_file, "w") as log:
+        log.write(f"Task: {name}\n")
+        log.write(f"Directory: {dir_path}\n")
+        log.write("-" * 60 + "\n\n")
+
+    if not ensure_clean_git(dir_path, name, log_file):
+        state.setdefault("tasks", {})[str(index)] = {
+            "status": "failed",
+            "error": "Failed to clean working tree via auto-commit",
+            "updated_at": datetime.now().isoformat(),
+        }
+        save_state(state)
+        return False
+
+    if not create_task_branch(dir_path, branch_config):
+        state.setdefault("tasks", {})[str(index)] = {
+            "status": "failed",
+            "error": "Failed to create task branch",
+            "updated_at": datetime.now().isoformat(),
+        }
+        save_state(state)
+        return False
+
+    started = datetime.now().isoformat()
+    state.setdefault("tasks", {})[str(index)] = {
+        "status": "running",
+        "started_at": started,
+    }
+    save_state(state)
+
+    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)
+
+        if returncode == 0:
+            state["tasks"][str(index)] = {
+                "status": "done",
+                "started_at": started,
+                "finished_at": datetime.now().isoformat(),
+            }
+            save_state(state)
+            print(f"\n{config.GREEN}✅ Task [{index + 1}] done{config.RESET}")
+        else:
+            state["tasks"][str(index)] = {
+                "status": "failed",
+                "started_at": started,
+                "finished_at": datetime.now().isoformat(),
+                "returncode": returncode,
+            }
+            save_state(state)
+            print(
+                f"\n{config.RED}❌ Task [{index + 1}] failed (exit code: {returncode}){config.RESET}"
+            )
+            print(f"   Log: {log_file}")
+            return False
+
+    except Exception as e:
+        state["tasks"][str(index)] = {
+            "status": "failed",
+            "started_at": started,
+            "error": str(e),
+        }
+        save_state(state)
+        print(f"\n{config.RED}❌ Task [{index + 1}] error: {e}{config.RESET}")
+        return False
+
+    return True

tloop_cli-0.4.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: tloop-cli
+Version: 0.4.0
+Summary: Automated Claude Code task runner
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file
+
+# t-loop
+
+自动化 Claude Code 任务运行器。用 YAML 定义任务，t-loop 按顺序执行，自带 git 安全保护。
+
+## 安装
+
+```bash
+pip install t-loop            # 从 PyPI 安装
+pip install -e .              # 本地开发安装
+```
+
+需要 Python >=3.9，唯一外部依赖：`pyyaml`。
+
+## 快速开始
+
+```bash
+# 首次运行会创建 ~/.tloop/tasks.yaml 示例配置
+tloop run
+
+# 编辑任务后运行
+tloop edit
+tloop run
+```
+
+## 任务配置
+
+编辑 `~/.tloop/tasks.yaml`：
+
+```yaml
+tasks:
+  - name: 我的第一个任务
+    dir: ~/projects/my-project
+    prompt: |
+      描述 Claude 应该做什么。
+
+  - name: 使用 prompt 文件的任务
+    dir: ~/projects/my-project
+    prompt_file: ./prompts/my-task.md
+    branch: feat/login   # 自定义分支名
+```
+
+### 任务字段
+
+| 字段 | 说明 |
+|-------|-------------|
+| `name` | 任务显示名称 |
+| `dir` | 任务工作目录 |
+| `prompt` | 内联 prompt 文本 |
+| `prompt_file` | prompt 文件路径（解析顺序：绝对路径 → `~/.tloop/` 相对 → 任务目录相对） |
+| `model` | 覆盖该任务的模型 |
+| `branch` | `true`（自动 `feature-YYYYMMDD-NNN`）、`"custom/name"`、或 `false`（跳过分支） |
+
+## 用法
+
+```bash
+tloop run                  # 运行所有待执行任务
+tloop run --status         # 查看任务状态
+tloop run --only 2         # 只运行第 2 个任务
+tloop run --confirm        # 每个任务前确认
+tloop run -c               # 失败后继续执行
+tloop run --reset          # 重置所有任务为待执行
+tloop edit                 # 用 $EDITOR 打开 tasks.yaml
+tloop archive              # 列出归档记录
+tloop archive --latest     # 显示最近一次归档详情
+tloop migrate              # 迁移旧的项目本地数据到 ~/.tloop/
+```
+
+## 工作原理
+
+每个任务的执行流程：
+
+1. **自动提交** — 如果工作目录有未提交的更改，t-loop 会用 Claude 先提交暂存区内容，再提交剩余更改。敏感文件（.env、密钥等）会被排除。
+2. **创建分支** — 创建任务分支（默认 `feature-YYYYMMDD-NNN`）隔离更改。
+3. **执行任务** — 在目标目录运行 `cybervisor run <prompt>`。
+4. **归档** — 已完成的任务移至 `~/.tloop/archive/`，并从 `tasks.yaml` 中移除。
+
+## 文件位置
+
+```
+~/.tloop/
+├── tasks.yaml      # 任务定义
+├── state.json      # 运行时状态（任务状态）
+├── logs/           # 执行日志
+└── archive/        # 已完成任务的归档
+```
+
+## 开发
+
+```bash
+pip install -e .
+python -m pytest test/ -v
+```
+
+## 许可证
+
+MIT

tloop_cli-0.4.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+claude_runner.py,sha256=Tga-aOaKnpRMts-wW__f2FvtZoTCbrV_DjrSNQjt8-g,2899
+cmd_archive.py,sha256=mg1Ltg8YCYAlWzlk-ABPwDTqhzeixgg3FMyzhGRB-FM,440
+cmd_edit.py,sha256=Ns0-7C2fTHYOWk-Vr7yINRPpCyoT_S-WEPBPOli_MqA,1099
+cmd_migrate.py,sha256=dfPNXVsdTebZAj8uKhC6mMA1xj6aNGc6az9aG2wx2qw,2435
+cmd_run.py,sha256=9SqUlY_uL88mxxkvRil15VpugwUPwqIvLHNZwaCPMtM,2724
+config.py,sha256=OBlwVP4rz6WaNk5YNtwmJ0XzCNQA1olh9LjVVaMyZoM,1773
+git_ops.py,sha256=iOvtqYstAeqd37G77vzTcrlgiYRsIgca761AHuWJtr8,5430
+main.py,sha256=joFC2oL0sDCpc-fbagTGxFeEOJG_AnRInnpzjZ7iEHw,866
+state.py,sha256=ierDMWgPRuEiQIk_yGL027291zFnU9XAJNjSc1wTHyk,4518
+task.py,sha256=QLSbIfY2aMQZxG3QEZGeOM4A59Qikiq8kCXwl7X2Gt8,4739
+runner/__init__.py,sha256=qC1bhmC9Qncx6ZRGD0_Gz2_kjUeAGHDW01sI8kzQrsA,266
+runner/claude.py,sha256=y211t1vdN3l-MQf-ykh4kuxCCcyu4-bCr5jivuZb-jM,293
+runner/cybervisor.py,sha256=dDbgtuPVzx4ubVcIAdlJRCQ0Pis06dG3_vQhVZRqMiU,762
+tloop_cli-0.4.0.dist-info/licenses/LICENSE,sha256=RK9GmSj0e7HTwoxX88OHwqjgh76C1LcyDUFxt5dYHAo,1069
+tloop_cli-0.4.0.dist-info/METADATA,sha256=bTvQ7ogNoQztxcZR9n2F9i1yTcuzIyGyTL6S8ijTK1o,2880
+tloop_cli-0.4.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+tloop_cli-0.4.0.dist-info/entry_points.txt,sha256=pz8TL9_xikjuXCJsEJvFNJtmk6PjOUDU3m1tAA_wA8k,36
+tloop_cli-0.4.0.dist-info/top_level.txt,sha256=PQkmT-TbTpWGdRdrDvw3GUW6gAppl4Naex9DGFDIfYs,93
+tloop_cli-0.4.0.dist-info/RECORD,,

tloop_cli-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tloop_cli-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tloop = main:main

tloop_cli-0.4.0.dist-info/licenses/LICENSE

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

tloop_cli-0.4.0.dist-info/top_level.txt

@@ -0,0 +1,11 @@
+claude_runner
+cmd_archive
+cmd_edit
+cmd_migrate
+cmd_run
+config
+git_ops
+main
+runner
+state
+task