task-agent 1.3.10__tar.gz → 1.3.11__tar.gz

{task_agent-1.3.10 → task_agent-1.3.11}/.gitignore

@@ -20,3 +20,5 @@ docks/tasks
 
 # task-agent: human-facing store symlink
 docs/tasks
+.map/
+.ma/prompt/

{task_agent-1.3.10 → task_agent-1.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: task-agent
-Version: 1.3.10
+Version: 1.3.11
 Summary: A prioritized, file-based task queue for autonomous agentic workers
 Project-URL: Homepage, https://github.com/InTEGr8or/task-agent
 Project-URL: Repository, https://github.com/InTEGr8or/task-agent.git

{task_agent-1.3.10 → task_agent-1.3.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "task-agent"
-version = "1.3.10"
+version = "1.3.11"
 description = "A prioritized, file-based task queue for autonomous agentic workers"
 readme = "README.md"
 requires-python = ">=3.12"

task_agent-1.3.11/scripts/check_task_worktree_cleanup.py

@@ -0,0 +1,240 @@
+"""Classify task-agent worktrees whose branch is merged and whose task is closed.
+
+A worktree is safe to remove when three local signals all agree:
+
+1. Branch merged: ``issue/<slug>`` is an ancestor of the integration branch
+   (--base, default uat). ``git cherry`` additionally detects content that
+   landed via cherry-pick/rebase (patch-merged); those branches need ``-D``
+   because ``git branch -d`` only trusts ancestry.
+2. Task closed: the task-agent store encodes status as directory location, so
+   the slug under ``completed/YYYY/MM/`` (or ``deleted/``) means closed, while
+   ``active/``, ``pending/``, ``draft/`` mean the worktree may still be a
+   runner staging area.
+3. Nothing to lose: ``git status --porcelain`` in the worktree is empty. A
+   worktree whose directory is gone (prunable registration) counts as clean;
+   removal uses ``git worktree prune`` for those.
+
+Run from any project repo registered in the task-agent registry.
+
+Usage:
+    python scripts/check_task_worktree_cleanup.py            # report only
+    python scripts/check_task_worktree_cleanup.py --remove   # remove safe ones
+    python scripts/check_task_worktree_cleanup.py --remove --allow-patch-merged
+
+--base defaults to the current branch of the repo it runs in.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+REGISTRY_PATH = Path.home() / ".local/share/task-agent/registry.json"
+OPEN_STATUSES = ("active", "pending", "draft")
+CLOSED_STATUSES = ("completed", "deleted")
+
+
+def run_git(
+    args: list[str], cwd: Optional[Path] = None
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *args], capture_output=True, text=True, cwd=cwd, check=False
+    )
+
+
+def moniker_from_remote(url: str) -> Optional[str]:
+    tail = url.removesuffix(".git")
+    tail = tail.rsplit(":", 1)[-1] if ":" in tail else tail
+    parts = [p for p in tail.split("/") if p]
+    if len(parts) >= 2:
+        return f"{parts[-2]}/{parts[-1]}"
+    return None
+
+
+def resolve_store(repo: Path, override: Optional[str]) -> Optional[Path]:
+    if override:
+        return Path(override).expanduser()
+    if not REGISTRY_PATH.is_file():
+        return None
+    try:
+        registry = json.loads(REGISTRY_PATH.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    entries = registry.get("stores", {})
+    for entry in entries.values():
+        if str(repo) in entry.get("host_paths", []):
+            return Path(entry["store_path"])
+    remote = run_git(["remote", "get-url", "origin"], cwd=repo).stdout.strip()
+    moniker = moniker_from_remote(remote)
+    if moniker and moniker in entries:
+        return Path(entries[moniker]["store_path"])
+    return None
+
+
+def task_status(store: Path, slug: str) -> str:
+    for status in OPEN_STATUSES:
+        if (store / status / slug).is_dir():
+            return status
+    if (store / "deleted" / slug).is_dir():
+        return "deleted"
+    for match in (store / "completed").glob(f"*/*/{slug}"):
+        if match.is_dir():
+            return "completed"
+    return "not-found"
+
+
+def merged_state(repo: Path, branch: str, base: str) -> str:
+    if run_git(["merge-base", "--is-ancestor", branch, base], cwd=repo).returncode == 0:
+        return "ancestor"
+    cherry = run_git(["cherry", base, branch], cwd=repo)
+    if cherry.returncode == 0:
+        lines = [line for line in cherry.stdout.splitlines() if line.strip()]
+        if lines and all(line.startswith("-") for line in lines):
+            return "patch"
+    return "no"
+
+
+def dirty_count(worktree: Path) -> Optional[int]:
+    if not worktree.is_dir():
+        return None
+    proc = run_git(["status", "--porcelain"], cwd=worktree)
+    return len([line for line in proc.stdout.splitlines() if line.strip()])
+
+
+def issue_worktrees(repo: Path) -> list[tuple[Path, str]]:
+    proc = run_git(["worktree", "list", "--porcelain"], cwd=repo)
+    pairs: list[tuple[Path, str]] = []
+    worktree: Optional[Path] = None
+    for line in proc.stdout.splitlines():
+        if line.startswith("worktree "):
+            worktree = Path(line.split(" ", 1)[1])
+        elif line.startswith("branch refs/heads/issue/"):
+            branch = line.split(" ", 1)[1][len("refs/heads/") :]
+            if worktree is not None:
+                pairs.append((worktree, branch))
+    return pairs
+
+
+@dataclass
+class Row:
+    slug: str
+    worktree: Path
+    branch: str
+    merged: str
+    status: str
+    dirty: Optional[int]
+    verdict: str
+
+
+def classify(repo: Path, store: Optional[Path], base: str) -> list[Row]:
+    rows: list[Row] = []
+    for worktree, branch in issue_worktrees(repo):
+        slug = branch[len("issue/") :]
+        merged = merged_state(repo, branch, base)
+        status = task_status(store, slug) if store else "unknown-store"
+        dirty = dirty_count(worktree)
+        if status not in CLOSED_STATUSES:
+            verdict = f"KEEP (task {status})"
+        elif merged == "no":
+            verdict = "REVIEW (unmerged)"
+        elif dirty:
+            verdict = "REVIEW (dirty)"
+        elif merged == "patch":
+            verdict = "REMOVE (patch-merged, -D)"
+        else:
+            verdict = "REMOVE"
+        rows.append(Row(slug, worktree, branch, merged, status, dirty, verdict))
+    return rows
+
+
+def remove_row(repo: Path, row: Row, force_branch: bool) -> bool:
+    if row.worktree.is_dir():
+        proc = run_git(["worktree", "remove", str(row.worktree)], cwd=repo)
+    else:
+        proc = run_git(["worktree", "prune"], cwd=repo)
+    if proc.returncode != 0:
+        print(f"  worktree remove FAILED: {row.worktree}")
+        return False
+    delete_flag = "-D" if force_branch else "-d"
+    proc = run_git(["branch", delete_flag, row.branch], cwd=repo)
+    if proc.returncode != 0:
+        print(f"  branch {delete_flag} FAILED: {row.branch}: {proc.stderr.strip()}")
+        return False
+    print(f"  removed {row.branch} ({row.worktree.name})")
+    return True
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--base", help="integration branch (default: current branch)")
+    parser.add_argument("--store", help="task-agent store path override")
+    parser.add_argument(
+        "--remove",
+        action="store_true",
+        help="remove worktrees/branches verdicted REMOVE",
+    )
+    parser.add_argument(
+        "--allow-patch-merged",
+        action="store_true",
+        help="also remove patch-merged branches (deleted with -D)",
+    )
+    args = parser.parse_args(argv)
+
+    toplevel = run_git(["rev-parse", "--show-toplevel"]).stdout.strip()
+    if not toplevel:
+        print("not a git repository")
+        return 1
+    repo = Path(toplevel)
+    store = resolve_store(repo, args.store)
+    base = (
+        args.base
+        or run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd=repo).stdout.strip()
+    )
+    if not base:
+        print("could not determine integration branch; pass --base")
+        return 1
+    if store is None:
+        print("warning: task-agent store not found; task status unavailable")
+    else:
+        print(f"store: {store}")
+
+    rows = sorted(classify(repo, store, base), key=lambda r: (r.verdict, r.slug))
+    for row in rows:
+        if row.dirty is None:
+            dirty = "missing"
+        elif row.dirty:
+            dirty = f"{row.dirty} changed"
+        else:
+            dirty = "clean"
+        print(
+            f"{row.verdict:<26} merged={row.merged:<8} "
+            f"task={row.status:<10} {dirty:<12} {row.branch}"
+        )
+
+    removable = [r for r in rows if r.verdict == "REMOVE"]
+    patchable = [r for r in rows if r.verdict == "REMOVE (patch-merged, -D)"]
+    print(
+        f"\n{len(removable)} removable, {len(patchable)} patch-merged, "
+        f"{len(rows) - len(removable) - len(patchable)} to keep/review"
+    )
+    if patchable and not args.allow_patch_merged:
+        print("patch-merged branches need --allow-patch-merged (or manual -D)")
+
+    if args.remove:
+        ok = True
+        for row in removable:
+            ok = remove_row(repo, row, force_branch=False) and ok
+        if args.allow_patch_merged:
+            for row in patchable:
+                ok = remove_row(repo, row, force_branch=True) and ok
+        return 0 if ok else 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{task_agent-1.3.10 → task_agent-1.3.11}/src/taskagent/cli.py

@@ -7,7 +7,7 @@ from rich.panel import Panel
 from rich.table import Table
 import sys
 
-from taskagent.theme import DEFAULT as theme
+from verkit.theme import DEFAULT as theme  # type: ignore[import-untyped]
 
 # Removed invalid NO_BORDER definition
 import argparse
@@ -949,7 +949,7 @@ def cmd_history(console: Console, manager: TaskAgent, limit: int = 20):
                     str(absolute_idx + 1), date_str, f"{prefix}{slug}", style=style
                 )
 
-            help_text = "[dim]v/l: view | c: copy slug | q: exit[/dim]"
+            help_text = "[dim]v/l: view | c/y: copy slug | q: exit[/dim]"
 
             live.update(
                 Panel(table, subtitle=help_text, box=theme.panel_box), refresh=True
@@ -976,7 +976,7 @@ def cmd_history(console: Console, manager: TaskAgent, limit: int = 20):
                 except Exception:
                     pass
                 live.start()
-            elif key in ["c"]:
+            elif key in ["c", "y"]:
                 # Copy slug to clipboard
                 _, slug = all_completed[cursor]
                 try:
@@ -1843,6 +1843,44 @@ def cmd_done(
                 f"[yellow]Run 'git branch -D {branch_name}' to force delete it.[/yellow]"
             )
 
+    # After standard cleanup, check for any orphaned loosely matching branches or worktrees
+    if not is_cwd_inside_worktree:
+        try:
+            loose_wts = subprocess.run(
+                ["git", "worktree", "list", "--porcelain"],
+                capture_output=True,
+                text=True,
+            ).stdout
+            for line in loose_wts.splitlines():
+                if line.startswith("worktree "):
+                    wt_path = line[len("worktree ") :].strip()
+                    if slug in Path(wt_path).name and (
+                        not worktree_path or str(worktree_path) != wt_path
+                    ):
+                        console.print(
+                            f"[yellow]Found loosely matching orphaned worktree: {wt_path}[/yellow]"
+                        )
+                        console.print(
+                            f"  [yellow]Consider removing it: git worktree remove {wt_path}[/yellow]"
+                        )
+
+            loose_brs = subprocess.run(
+                ["git", "branch", "--list", "--format=%(refname:short)"],
+                capture_output=True,
+                text=True,
+            ).stdout
+            for br in loose_brs.splitlines():
+                br = br.strip()
+                if slug in br and br != f"issue/{slug}":
+                    console.print(
+                        f"[yellow]Found loosely matching orphaned branch: {br}[/yellow]"
+                    )
+                    console.print(
+                        f"  [yellow]Consider deleting it: git branch -D {br}[/yellow]"
+                    )
+        except Exception:
+            pass
+
 
 def cmd_push(console: Console, manager: TaskAgent):
     """Push the mission repository."""
@@ -3423,7 +3461,7 @@ def cmd_list(
     )
     table.add_column("Pri", justify="right", style="cyan", width=3)
     table.add_column("Date", style="dim", width=5)
-    table.add_column("Status", width=6)
+    table.add_column("Status", width=7)
     table.add_column("Blocked", style="yellow", width=8)
     table.add_column("Slug")
 
@@ -3446,8 +3484,8 @@ def cmd_list(
         prefix_plain = "└─ " if depth > 0 else ""
         prefix = "[dim cyan]└─[/dim cyan] " if depth > 0 else ""
 
-        # Fixed columns width: Pri (~4) + Date (5) + Status (6) + Blocked (8) + borders/padding (~12)
-        available_width = max(10, term_width - 35)
+        # Fixed columns width: Pri (~4) + Date (5) + Status (7) + Blocked (8) + borders/padding (~12)
+        available_width = max(10, term_width - 36)
         prefix_len = len(indent) + len(prefix_plain)
         max_slug_len = max(5, available_width - prefix_len)
 
@@ -5166,6 +5204,77 @@ def cmd_worktree(console: Console, manager: TaskAgent, args):
         except subprocess.CalledProcessError as e:
             console.print(f"[red]Error pruning worktrees: {e.stderr}[/red]")
 
+    elif args.action == "cleanup":
+        console.print("[blue]Finding orphaned task worktrees/branches...[/blue]")
+        try:
+            active_issues = {i.slug for i in manager.load_mission()}
+
+            # 1. Clean up orphaned .gwt/ worktrees
+            wt_res = subprocess.run(
+                ["git", "worktree", "list", "--porcelain"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            worktrees = []
+            for line in wt_res.stdout.splitlines():
+                if line.startswith("worktree "):
+                    worktrees.append(Path(line[len("worktree ") :].strip()))
+
+            cwd_gwt = Path.cwd().resolve() / ".gwt"
+            for wt in worktrees:
+                try:
+                    resolved_wt = wt.resolve()
+                    if resolved_wt.is_relative_to(cwd_gwt):
+                        slug = resolved_wt.name
+                        if slug not in active_issues:
+                            console.print(
+                                f"  [yellow]Found orphaned worktree: {wt}[/yellow]"
+                            )
+                            subprocess.run(
+                                ["git", "worktree", "remove", "--force", str(wt)],
+                                capture_output=True,
+                                text=True,
+                                check=True,
+                            )
+                            console.print("    [green]Removed[/green]")
+                except ValueError:
+                    pass  # Not relative to .gwt
+                except subprocess.CalledProcessError as e:
+                    console.print(
+                        f"    [red]Failed to remove: {e.stderr.strip() if hasattr(e, 'stderr') and e.stderr else str(e)}[/red]"
+                    )
+
+            # 2. Clean up orphaned issue/ branches
+            br_res = subprocess.run(
+                ["git", "branch", "--list", "--format=%(refname:short)"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            for br in br_res.stdout.splitlines():
+                br = br.strip()
+                if br.startswith("issue/"):
+                    slug = br[len("issue/") :]
+                    if slug not in active_issues:
+                        console.print(f"  [yellow]Found orphaned branch: {br}[/yellow]")
+                        try:
+                            subprocess.run(
+                                ["git", "branch", "-D", br],
+                                capture_output=True,
+                                text=True,
+                                check=True,
+                            )
+                            console.print("    [green]Deleted[/green]")
+                        except subprocess.CalledProcessError as e:
+                            console.print(
+                                f"    [red]Failed to delete: {e.stderr.strip() if hasattr(e, 'stderr') and e.stderr else str(e)}[/red]"
+                            )
+
+            console.print("[green]Cleanup complete.[/green]")
+        except Exception as e:
+            console.print(f"[red]Error during cleanup: {e}[/red]")
+
 
 def cmd_github(console: Console, manager: TaskAgent, args):
     """Sync with GitHub Issues."""
@@ -5586,6 +5695,7 @@ def cmd_triage(
     indexed_issues = [(issue, depth) for issue, depth in hierarchy]
     cursor = 0
     last_key = ""
+    status_message: Optional[str] = None
 
     with Live(auto_refresh=False, console=console, screen=True) as live:
         while True:
@@ -5672,10 +5782,24 @@ def cmd_triage(
                     style=style,
                 )
 
-            help_text = "[dim]j/k: move | G/gg: bottom/top | ctrl+k/j: prio | p: prom | d: dem | v: view | e: edit | a: add | D: done | A: active | l/h: link/unlink | /: search | y: copy | q: exit[/dim]"
+            if show_completed:
+                if term_width >= 100:
+                    help_text = "[dim]j/k: move | r: restore | y/c: copy | v/e: view/edit | C: active-list | /: search | q: exit[/dim]"
+                else:
+                    help_text = "[dim]j/k: move | r: restore | y/c: copy | v: view | C: back | q: exit[/dim]"
+            else:
+                if term_width >= 130:
+                    help_text = "[dim]j/k: move | ctrl+k/j: prio | A: active | y/c: copy | D: done | p/d: prom/dem | v/e: view/edit | a: add | l/h: link | /: search | C: done-list | q: exit[/dim]"
+                elif term_width >= 100:
+                    help_text = "[dim]j/k: move | ctrl+k/j: prio | A: active | y/c: copy | D: done | v/e: view/edit | a: add | q: exit[/dim]"
+                else:
+                    help_text = "[dim]j/k: move | ctrl+k/j: prio | A: active | y/c: copy | D: done | v: view | q: exit[/dim]"
 
             live.update(
-                Panel(table, subtitle=help_text, box=theme.panel_box), refresh=True
+                Panel(
+                    table, title=status_message, subtitle=help_text, box=theme.panel_box
+                ),
+                refresh=True,
             )
 
             # Input
@@ -5688,36 +5812,47 @@ def cmd_triage(
             elif key == "\r":  # enter (return)
                 break
             elif key == "G":  # shift+g: jump to bottom
+                status_message = None
                 cursor = len(indexed_issues) - 1
             elif key == "g":  # gg: jump to top
+                status_message = None
                 if prev_key == "g":
                     cursor = 0
                 else:
                     last_key = "g"
                 continue
             elif key in ["k", "\x1b[A"]:  # up
+                status_message = None
                 cursor = max(0, cursor - 1)
             elif key in ["j", "\x1b[B"]:  # down
+                status_message = None
                 cursor = min(len(indexed_issues) - 1, cursor + 1)
             elif key == "/":
+                status_message = None
                 live.stop()
                 search_query = questionary.text("Search slug:").ask()
                 issues = get_display_issues(search_query, show_completed)
                 indexed_issues = build_hierarchy(issues)
                 cursor = 0
                 live.start()
-            elif key == "y":
-                slug = indexed_issues[cursor][0].slug
-                pyperclip.copy(slug)
-                console.print(
-                    f"[bold green]Copied slug to clipboard: {slug}[/bold green]"
-                )
-                questionary.press_any_key_to_continue().ask()
-            elif key == "c":
+            elif key in ["y", "c"]:
+                if indexed_issues and 0 <= cursor < len(indexed_issues):
+                    slug = indexed_issues[cursor][0].slug
+                    try:
+                        pyperclip.copy(slug)
+                        status_message = (
+                            f"[bold green]Copied slug to clipboard: {slug}[/bold green]"
+                        )
+                    except Exception as e:
+                        status_message = (
+                            f"[yellow]Failed to copy to clipboard: {e}[/yellow]"
+                        )
+            elif key == "C":
                 show_completed = not show_completed
                 issues = get_display_issues(search_query, show_completed)
                 indexed_issues = build_hierarchy(issues)
                 cursor = 0
+                status_message = f"[dim]Showing {'completed' if show_completed else 'active/pending'} tasks[/dim]"
 
             elif key == "v":
                 live.stop()
@@ -5829,17 +5964,28 @@ def cmd_triage(
                         cursor = min(len(indexed_issues) - 1, cursor)
                 except Exception:
                     pass
-            elif key == "A" and not show_completed:  # active
-                issue = indexed_issues[cursor][0]
-                try:
-                    manager.move_to_active(issue.slug)
-                    issues = get_display_issues(search_query, show_completed)
-                    indexed_issues = build_hierarchy(issues)
-                    new_idx = find_slug_index(issue.slug, indexed_issues)
-                    if new_idx is not None:
-                        cursor = new_idx
-                except Exception:
-                    pass
+            elif key == "A":  # active
+                if show_completed:
+                    status_message = "[yellow]Completed tasks cannot be marked active directly (press 'r' to restore)[/yellow]"
+                elif indexed_issues and 0 <= cursor < len(indexed_issues):
+                    issue = indexed_issues[cursor][0]
+                    if issue.status == "active":
+                        status_message = (
+                            f"[yellow]Task '{issue.slug}' is already active[/yellow]"
+                        )
+                    else:
+                        try:
+                            manager.move_to_active(issue.slug)
+                            issues = get_display_issues(search_query, show_completed)
+                            indexed_issues = build_hierarchy(issues)
+                            new_idx = find_slug_index(issue.slug, indexed_issues)
+                            if new_idx is not None:
+                                cursor = new_idx
+                            status_message = f"[bold green]Task '{issue.slug}' marked as active[/bold green]"
+                        except Exception as e:
+                            status_message = (
+                                f"[red]Failed to activate '{issue.slug}': {e}[/red]"
+                            )
             elif key == "D" and not show_completed:  # done
                 live.stop()
                 issue = indexed_issues[cursor][0]
@@ -6350,7 +6496,7 @@ def main():
     worktree_parser.add_argument(
         "action",
         nargs="?",
-        choices=["add", "list", "remove", "prune"],
+        choices=["add", "list", "remove", "prune", "cleanup"],
         help="Worktree action to perform (shows help if omitted)",
     )
     worktree_parser.add_argument(
@@ -6362,6 +6508,12 @@ def main():
     worktree_parser.add_argument(
         "--commit", action="store_true", help="Create worktree from specific commit SHA"
     )
+    worktree_parser.add_argument(
+        "--days",
+        type=int,
+        default=30,
+        help="Days back to check for completed tasks (for cleanup action)",
+    )
     worktree_parser.add_argument(
         "--copy",
         action="append",