handoff-cli 0.3.0__py3-none-any.whl

cli/commands/resume.py

@@ -0,0 +1,179 @@
+"""handoff resume command.
+
+Unifies "reopen a past conversation" into one verb, keyed by seq (or run-id):
+
+  handoff resume <seq>                  — interactive: drop into `claude --resume`
+  handoff resume <seq> - <<'EOF' ...    — non-interactive: dispatch a new task to
+  handoff resume <seq> --text "..."       that same conversation (claude -p --resume),
+                                          running through the normal run pipeline.
+
+The seq → session mapping comes from the runs table: the selected row's
+`session_id` is the underlying claude conversation. `--resume` does not fork, so
+the original seq stays a stable handle — keep using it to add more turns.
+"""
+
+import os
+import sys
+import shlex
+
+from ..core import get_db, find_run, short_path, row_value
+from ..backend import set_backend_env, build_resume_args, resolve_backend_model
+from ..config import Config
+
+
+def cmd_resume(argv: list[str], config: Config):
+    """handoff resume [<run-id|seq>] [--backend <name>] [--pro] [--cwd <dir>]
+    [(<input-file|-> | --text <prompt...>)]."""
+    pro = False
+    cwd = ""
+    backend_arg = ""
+    selector = ""
+    input_src = ""
+    text_mode = False
+    text_parts = []
+    have_selector = False
+
+    i = 0
+    while i < len(argv):
+        a = argv[i]
+        if a == "-":
+            input_src = "-"
+        elif a == "--cwd":
+            i += 1
+            if i >= len(argv):
+                print("handoff resume: --cwd requires a value", file=sys.stderr)
+                sys.exit(2)
+            cwd = argv[i]
+        elif a == "--backend":
+            i += 1
+            if i >= len(argv):
+                print("handoff resume: --backend requires a value", file=sys.stderr)
+                sys.exit(2)
+            backend_arg = argv[i]
+        elif a.startswith("--backend="):
+            backend_arg = a.split("=", 1)[1]
+        elif a == "--text":
+            text_mode = True
+            if input_src:
+                print("handoff resume: --text cannot be combined with an input file", file=sys.stderr)
+                sys.exit(2)
+            if i + 1 >= len(argv):
+                print("handoff resume: --text requires a value", file=sys.stderr)
+                sys.exit(2)
+            if argv[i + 1] == "--":
+                text_parts.extend(argv[i + 2:])
+            else:
+                text_parts.extend(argv[i + 1:])
+            break
+        elif a.startswith("--text="):
+            text_mode = True
+            if input_src:
+                print("handoff resume: --text cannot be combined with an input file", file=sys.stderr)
+                sys.exit(2)
+            text_parts.append(a.split("=", 1)[1])
+            text_parts.extend(argv[i + 1:])
+            break
+        elif a == "--pro":
+            pro = True
+        elif a in ("-h", "--help"):
+            from ..main import usage
+            usage()
+            sys.exit(0)
+        elif a.startswith("-") and a != "-":
+            print(f"handoff resume: unknown option {a}", file=sys.stderr)
+            sys.exit(2)
+        else:
+            # First bare positional is the selector (seq/run-id); a second one is
+            # an input file (prompt source).
+            if not have_selector:
+                selector = a
+                have_selector = True
+            elif text_mode:
+                print("handoff resume: --text cannot be combined with an input file", file=sys.stderr)
+                sys.exit(2)
+            else:
+                input_src = a
+        i += 1
+
+    # Resolve the target conversation.
+    conn = get_db()
+    row = find_run(conn, selector or None)
+
+    if not row:
+        conn.close()
+        print("handoff resume: no run found", file=sys.stderr)
+        sys.exit(1)
+
+    session_id = row_value(row, "session_id", "") or row["uuid"]
+    row_cwd = row["cwd"]
+    saved_backend = row_value(row, "backend", "") or ""
+
+    # Decide prompt source → interactive vs continuation.
+    prompt_text = None
+    if text_mode:
+        prompt_text = " ".join(text_parts)
+        if not prompt_text:
+            print("handoff resume: --text requires a non-empty value", file=sys.stderr)
+            sys.exit(2)
+    elif input_src == "-" or (not input_src and not sys.stdin.isatty()):
+        prompt_text = sys.stdin.read()
+    elif input_src:
+        if not os.path.isfile(input_src):
+            print(f"handoff resume: input file not found: {input_src}", file=sys.stderr)
+            sys.exit(2)
+        with open(input_src) as f:
+            prompt_text = f.read()
+
+    if not cwd:
+        cwd = row_cwd
+    if not os.path.isdir(cwd):
+        print(f"handoff resume: cwd not found: {cwd}", file=sys.stderr)
+        sys.exit(2)
+
+    # A continuation must stay on the conversation's original backend — the
+    # session id only means something to the CLI that created it.
+    if backend_arg and saved_backend and backend_arg != saved_backend:
+        print(
+            f"handoff resume: this conversation belongs to backend '{saved_backend}'; "
+            f"it cannot be resumed with --backend {backend_arg}. "
+            f"Use `handoff run --backend {backend_arg}` to start a new conversation.",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+    backend_name = saved_backend or backend_arg or config.default_backend
+
+    if prompt_text is None:
+        # Interactive: reopen the conversation in claude (replaces this process).
+        conn.close()
+        _resume_interactive(config, backend_name, session_id, cwd, pro)
+    else:
+        # Non-interactive: dispatch a new turn through the run pipeline.
+        conn.close()
+        from .run import _execute
+        _execute(cwd, prompt_text, backend_name, pro, config, resume_session_id=session_id)
+
+
+def _resume_interactive(config: Config, backend_name: str, session_id: str, cwd: str, pro: bool):
+    backend_cfg = config.get_backend(backend_name)
+    if not backend_cfg:
+        print(
+            f"handoff: unknown backend '{backend_name}'. "
+            f"Available: {', '.join(sorted(config.backends.keys()))}",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+
+    model = resolve_backend_model(backend_cfg, pro)
+    backend_cfg["_resolved_model"] = model
+    backend_cfg["_system_prompt"] = config.system_prompt
+
+    set_backend_env(backend_cfg, model, backend_cfg.get("pro_model", ""))
+
+    args = build_resume_args(
+        backend_cfg, session_id,
+        pro_model=backend_cfg.get("pro_model", ""),
+    )
+
+    print(f"cd {short_path(cwd)}; {' '.join(shlex.quote(p) for p in args)}", file=sys.stderr)
+    os.chdir(cwd)
+    os.execvp(args[0], args)

cli/commands/run.py

@@ -0,0 +1,211 @@
+"""handoff run command."""
+
+from __future__ import annotations
+
+import os
+import sys
+import datetime
+
+from ..core import get_db, create_run, task_paths, UUID_RE
+from ..backend import (
+    set_backend_env,
+    build_args,
+    backend_type,
+    ensure_backend_token_ready,
+    resolve_backend_model,
+    wrap_with_pty,
+)
+from ..stream import execute_run
+from ..config import Config
+
+
+def cmd_run(argv: list[str], config: Config):
+    """handoff run [--backend <name>] [--cwd <dir>] [--pro] (<input-file|-> | --text <prompt...>)."""
+    pro = False
+    cwd = ""
+    backend_arg = ""
+    input_src = ""
+    text_mode = False
+    text_parts = []
+
+    i = 0
+    while i < len(argv):
+        a = argv[i]
+        if a == "-":
+            input_src = "-"
+        elif a == "--cwd":
+            i += 1
+            if i >= len(argv):
+                print("handoff run: --cwd requires a value", file=sys.stderr)
+                sys.exit(2)
+            cwd = argv[i]
+        elif a == "--backend":
+            i += 1
+            if i >= len(argv):
+                print("handoff run: --backend requires a value", file=sys.stderr)
+                sys.exit(2)
+            backend_arg = argv[i]
+        elif a.startswith("--backend="):
+            backend_arg = a.split("=", 1)[1]
+        elif a == "--text":
+            text_mode = True
+            if input_src:
+                print("handoff run: --text cannot be combined with an input file", file=sys.stderr)
+                sys.exit(2)
+            if i + 1 >= len(argv):
+                print("handoff run: --text requires a value", file=sys.stderr)
+                sys.exit(2)
+            if argv[i + 1] == "--":
+                text_parts.extend(argv[i + 2:])
+            else:
+                text_parts.extend(argv[i + 1:])
+            break
+        elif a.startswith("--text="):
+            text_mode = True
+            if input_src:
+                print("handoff run: --text cannot be combined with an input file", file=sys.stderr)
+                sys.exit(2)
+            text_parts.append(a.split("=", 1)[1])
+            text_parts.extend(argv[i + 1:])
+            break
+        elif a == "--pro":
+            pro = True
+        elif a in ("-h", "--help"):
+            from ..main import usage
+            usage()
+            sys.exit(0)
+        elif a == "--":
+            i += 1
+            if i < len(argv):
+                input_src = argv[i]
+            break
+        elif a.startswith("-"):
+            print(f"handoff run: unknown option {a}", file=sys.stderr)
+            sys.exit(2)
+        else:
+            if text_mode:
+                print("handoff run: --text cannot be combined with an input file", file=sys.stderr)
+                sys.exit(2)
+            input_src = a
+        i += 1
+
+    if not cwd:
+        cwd = os.getcwd()
+    if not os.path.isdir(cwd):
+        print(f"handoff run: cwd not found: {cwd}", file=sys.stderr)
+        sys.exit(2)
+
+    if text_mode:
+        if not text_parts:
+            print("handoff run: --text requires a value", file=sys.stderr)
+            sys.exit(2)
+        prompt_text = " ".join(text_parts)
+        if not prompt_text:
+            print("handoff run: --text requires a non-empty value", file=sys.stderr)
+            sys.exit(2)
+    elif input_src == "-" or (not input_src and not sys.stdin.isatty()):
+        prompt_text = sys.stdin.read()
+    elif input_src:
+        if not os.path.isfile(input_src):
+            print(f"handoff run: input file not found: {input_src}", file=sys.stderr)
+            sys.exit(2)
+        with open(input_src) as f:
+            prompt_text = f.read()
+    else:
+        print("handoff run: input file required, or use --text <prompt...> / pipe via '-'", file=sys.stderr)
+        sys.exit(2)
+
+    backend_name = backend_arg or config.default_backend
+
+    _execute(cwd, prompt_text, backend_name, pro, config)
+
+
+def _execute(
+    cwd: str,
+    prompt_text: str,
+    backend_name: str,
+    pro: bool,
+    config: Config,
+    resume_session_id: str | None = None,
+):
+    """Shared execution path for file, stdin, and --text run modes.
+
+    When `resume_session_id` is given, the new run is appended to that existing
+    claude conversation (`claude -p ... --resume <id>`) rather than starting a
+    fresh session; the new row still gets its own run_id/seq/files but shares the
+    session_id. Used by `handoff resume <seq> <prompt>`.
+    """
+    backend_cfg = config.get_backend(backend_name)
+    if not backend_cfg:
+        print(
+            f"handoff: unknown backend '{backend_name}'. "
+            f"Available: {', '.join(sorted(config.backends.keys()))}",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+
+    ensure_backend_token_ready(backend_name, backend_cfg, config.user_config_path)
+
+    conn = get_db()
+    run_id, uid, jsonl_path = create_run(
+        conn, cwd, prompt_text, backend_name, session_id=resume_session_id
+    )
+    conn.commit()
+
+    # tasks dir files
+    prompt_path, out_path, result_path = task_paths(run_id)
+
+    with open(prompt_path, "w") as pf:
+        pf.write(prompt_text)
+
+    # Resolve model
+    model = resolve_backend_model(backend_cfg, pro)
+    if not model:
+        print(
+            f"handoff: backend '{backend_name}' resolves no model. "
+            f"Set backends.{backend_name}.model in {config.user_config_path} "
+            f"(pre-0.3 configs carried this in the now-removed top-level default_model).",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+    backend_cfg["_resolved_model"] = model
+    backend_cfg["_system_prompt"] = config.system_prompt
+
+    btype = backend_type(backend_cfg)
+    set_backend_env(backend_cfg, model, backend_cfg.get("pro_model", ""))
+    if resume_session_id:
+        session_id = resume_session_id
+    elif btype == "claude":
+        session_id = uid if UUID_RE.match(uid) else None
+    else:
+        # codex assigns the thread id itself; it arrives via the
+        # thread.started event and is persisted by execute_run
+        session_id = None
+
+    print(f"RESULT={result_path}")
+    print(f"RESULT={result_path}", file=sys.stderr)
+
+    ts = datetime.datetime.now().strftime("%H:%M:%S")
+    label = "resume" if resume_session_id else "start"
+    print(f"{ts} {label}\tSESSION={session_id or 'pending'}", file=sys.stderr)
+
+    # build backend command (wrapped in script for pty when the type needs it)
+    backend_cmd = build_args(
+        backend_cfg, prompt_text, session_id,
+        model=model,
+        pro_model=backend_cfg.get("pro_model", ""),
+        resume=bool(resume_session_id),
+        cwd=cwd,
+    )
+    cmd = wrap_with_pty(backend_cfg, backend_cmd)
+
+    execute_run(
+        cwd,
+        prompt_text,
+        cmd,
+        conn,
+        uid,
+        jsonl_path,
+        (prompt_path, out_path, result_path),
+        backend_type=btype,
+    )

cli/commands/tail.py

@@ -0,0 +1,48 @@
+"""handoff tail command."""
+
+import sys
+import os
+
+from ..core import get_db, find_run, short_path, prompt_prefix, task_paths
+
+
+def cmd_tail(argv: list[str], config=None):
+    """handoff tail [<run-id|seq>]"""
+    selector = ""
+    for a in argv:
+        if a in ("-h", "--help"):
+            from ..main import usage
+            usage()
+            sys.exit(0)
+        elif a.startswith("-"):
+            print(f"handoff tail: unknown option {a}", file=sys.stderr)
+            sys.exit(2)
+        else:
+            selector = a
+
+    conn = get_db()
+    row = find_run(conn, selector or None)
+    conn.close()
+
+    if not row:
+        print("handoff tail: no run found", file=sys.stderr)
+        sys.exit(1)
+
+    jsonl_path = row["jsonl_path"]
+    if not os.path.exists(jsonl_path):
+        print(f"handoff tail: jsonl not found: {jsonl_path}", file=sys.stderr)
+        sys.exit(1)
+
+    run_id = row["run_id"]
+    prompt_path, out_path, result_path = task_paths(run_id)
+
+    run_info = {
+        "run_id": run_id,
+        "date": row["created_at"],
+        "cwd": short_path(row["cwd"]),
+        "uuid": row["uuid"],
+        "out_path": out_path,
+    }
+
+    from ..jsonl_viewer import run_tail
+    run_tail(jsonl_path, prompt_path, result_path, run_info)