mirror of
https://github.com/openai/codex.git
synced 2026-05-01 01:47:18 +00:00
305 lines
12 KiB
Python
305 lines
12 KiB
Python
"""
|
|
CLI for managing agentydragon tasks: status, set-status, set-deps, dispose, launch.
|
|
"""
|
|
import subprocess
|
|
import re
|
|
import sys
|
|
from datetime import datetime
|
|
|
|
import click
|
|
from tasklib import load_task, repo_root, save_task, task_dir, TaskMeta, worktree_dir
|
|
import shutil
|
|
|
|
try:
|
|
from tabulate import tabulate
|
|
except ImportError:
|
|
tabulate = None
|
|
|
|
|
|
@click.group()
|
|
def cli():
|
|
"""Manage agentydragon tasks."""
|
|
pass
|
|
|
|
@cli.command()
|
|
def status():
|
|
"""Show a table of task id, title, status, dependencies, last_updated.
|
|
|
|
If tabulate is installed, render as GitHub-flavored Markdown table;
|
|
otherwise fallback to fixed-width formatting.
|
|
"""
|
|
# Load all task metadata, reporting load errors with file path
|
|
all_meta: dict[str, TaskMeta] = {}
|
|
path_map: dict[str, Path] = {}
|
|
wt_root = worktree_dir()
|
|
for md in sorted(task_dir().rglob('[0-9][0-9]-*.md')):
|
|
# skip task template, plan files, and any worktree copies
|
|
if md.name in ('task-template.md',) or md.name.endswith('-plan.md') or md.is_relative_to(wt_root):
|
|
continue
|
|
try:
|
|
meta, _ = load_task(md)
|
|
except Exception as e:
|
|
print(f"Error loading {md}: {e}")
|
|
continue
|
|
all_meta[meta.id] = meta
|
|
path_map[meta.id] = md
|
|
|
|
# Build dependency graph, excluding already merged tasks
|
|
merged_ids = {tid for tid, m in all_meta.items() if m.status == 'Merged'}
|
|
deps_map: dict[str, list[str]] = {}
|
|
for tid, meta in all_meta.items():
|
|
deps_map[tid] = [d for d in re.findall(r"\d+", meta.dependencies)
|
|
if d in all_meta and d not in merged_ids]
|
|
|
|
# Topologically sort tasks by dependencies, fall back on filename order on error
|
|
try:
|
|
sorted_ids: list[str] = []
|
|
temp: set[str] = set()
|
|
perm: set[str] = set()
|
|
def visit(n: str) -> None:
|
|
if n in perm:
|
|
return
|
|
if n in temp:
|
|
raise RuntimeError(f"Circular dependency detected at task {n}")
|
|
temp.add(n)
|
|
for m in deps_map.get(n, []):
|
|
visit(m)
|
|
temp.remove(n)
|
|
perm.add(n)
|
|
sorted_ids.append(n)
|
|
for n in all_meta:
|
|
visit(n)
|
|
except Exception as e:
|
|
print(f"Warning: cannot topo-sort tasks ({e}); falling back to filename order")
|
|
sorted_ids = [m.id for m in sorted(all_meta.values(), key=lambda m: path_map[m.id].name)]
|
|
|
|
# Identify tasks that are merged with no branch and no worktree (bottom summary)
|
|
bottom_merged_ids: set[str] = set()
|
|
for tid in sorted_ids:
|
|
meta = all_meta[tid]
|
|
if meta.status != 'Merged':
|
|
continue
|
|
branches = subprocess.run(
|
|
['git', 'for-each-ref', '--format=%(refname:short)',
|
|
f'refs/heads/agentydragon-{tid}-*'],
|
|
capture_output=True, text=True, cwd=repo_root()
|
|
).stdout.strip().splitlines()
|
|
wt_dir = task_dir() / '.worktrees' / path_map[tid].stem
|
|
if not branches and not wt_dir.exists():
|
|
bottom_merged_ids.add(tid)
|
|
|
|
rows: list[tuple] = []
|
|
merged_tasks: list[tuple[str, str]] = []
|
|
root = repo_root()
|
|
|
|
for tid in sorted_ids:
|
|
meta = all_meta[tid]
|
|
md = path_map[tid]
|
|
slug = md.stem
|
|
# branch detection
|
|
branches = subprocess.run(
|
|
['git', 'for-each-ref', '--format=%(refname:short)',
|
|
f'refs/heads/agentydragon-{tid}-*'],
|
|
capture_output=True, text=True, cwd=root
|
|
).stdout.strip().splitlines()
|
|
branch_exists = 'Y' if branches and branches[0].strip() else 'N'
|
|
merged_flag = 'N'
|
|
if branch_exists == 'Y':
|
|
b = branches[0].lstrip('*+ ').strip()
|
|
if subprocess.run(['git', 'merge-base', '--is-ancestor', b, 'agentydragon'], cwd=root).returncode == 0:
|
|
merged_flag = 'Y'
|
|
# worktree detection
|
|
wt_dir = worktree_dir() / slug
|
|
wt_info = 'none'
|
|
if wt_dir.exists():
|
|
st = subprocess.run(['git', 'status', '--porcelain'], cwd=wt_dir,
|
|
capture_output=True, text=True).stdout.strip()
|
|
wt_info = 'clean' if not st else 'dirty'
|
|
|
|
# skip fully merged tasks (no branch, no worktree)
|
|
if meta.status == 'Merged' and branch_exists == 'N' and wt_info == 'none':
|
|
merged_tasks.append((tid, meta.title))
|
|
continue
|
|
|
|
# filter out dependencies on bottom-summary merged tasks
|
|
deps = [d for d in deps_map.get(tid, []) if d not in bottom_merged_ids]
|
|
deps_str = ','.join(deps)
|
|
|
|
# determine branch_info text
|
|
if branch_exists == 'N':
|
|
branch_info = 'no branch'
|
|
elif merged_flag == 'Y':
|
|
branch_info = 'merged'
|
|
else:
|
|
a_cnt, b_cnt = subprocess.check_output(
|
|
['git', 'rev-list', '--left-right', '--count',
|
|
f'{branches[0]}...agentydragon'], cwd=root
|
|
).decode().split()
|
|
# compact diffstat: e.g. "56 files changed, 1265 insertions(+), 342 deletions(-)" -> "56f,1265i,342d"
|
|
raw = subprocess.check_output(
|
|
['git', 'diff', '--shortstat', f'{branches[0]}...agentydragon'], cwd=root
|
|
).decode().strip()
|
|
stat = (
|
|
raw.replace(' files changed', 'f')
|
|
.replace(' file changed', 'f')
|
|
.replace(' insertions(+)', 'i')
|
|
.replace(' deletions(-)', 'd')
|
|
.replace(', ', ',')
|
|
)
|
|
base = subprocess.check_output(
|
|
['git', 'merge-base', 'agentydragon', branches[0]], cwd=root
|
|
).decode().strip()
|
|
mtree = subprocess.check_output(
|
|
['git', 'merge-tree', base, 'agentydragon', branches[0]], cwd=root
|
|
).decode(errors='ignore')
|
|
conflict = 'conflict' if '<<<<<<<' in mtree else 'ok'
|
|
if a_cnt == '0' and b_cnt == '0':
|
|
branch_info = f'up-to-date (+{stat or 0})'
|
|
else:
|
|
branch_info = f'{b_cnt} behind / {a_cnt} ahead (+{stat or 0}) {conflict}'
|
|
|
|
# colorize status/worktree
|
|
stat_disp = meta.status
|
|
if meta.status in ('Done', 'Merged'):
|
|
stat_disp = f"\033[32m{meta.status}\033[0m"
|
|
wt_disp = wt_info
|
|
if wt_info == 'dirty':
|
|
wt_disp = f"\033[31m{wt_info}\033[0m"
|
|
|
|
rows.append((
|
|
tid, meta.title, stat_disp,
|
|
deps_str, meta.last_updated.strftime('%Y-%m-%d %H:%M'),
|
|
branch_info, wt_disp
|
|
))
|
|
|
|
headers = ['ID', 'Title', 'Status', 'Dependencies', 'Updated',
|
|
'Branch Status', 'Worktree Status']
|
|
if tabulate:
|
|
print(tabulate(rows, headers=headers, tablefmt='github'))
|
|
else:
|
|
fmt = '{:>2} {:<30} {:<12} {:<20} {:<16} {:<40} {:<10}'
|
|
print(fmt.format(*headers))
|
|
for r in rows:
|
|
print(fmt.format(*r))
|
|
|
|
# summary of fully merged tasks (no branch, no worktree)
|
|
if merged_tasks:
|
|
items = ' '.join(f"{tid} ({title})" for tid, title in merged_tasks)
|
|
print(f"\n\033[32mMerged:\033[0m {items}")
|
|
|
|
# summary of tasks Ready to merge (Done with branch commits)
|
|
ready_tasks: list[tuple[str, str]] = []
|
|
for tid in sorted_ids:
|
|
meta = all_meta[tid]
|
|
if meta.status != 'Done':
|
|
continue
|
|
# detect branch existence and ahead commits
|
|
branches = subprocess.run(
|
|
['git', 'for-each-ref', '--format=%(refname:short)', f'refs/heads/agentydragon-{tid}-*'],
|
|
capture_output=True, text=True, cwd=repo_root()
|
|
).stdout.strip().splitlines()
|
|
if not branches or not branches[0].strip():
|
|
continue
|
|
bname = branches[0].lstrip('*+ ').strip()
|
|
# count commits ahead of integration branch
|
|
a_cnt, _b_cnt = subprocess.check_output(
|
|
['git', 'rev-list', '--left-right', '--count', f'{bname}...agentydragon'], cwd=repo_root()
|
|
).decode().split()
|
|
if int(a_cnt) > 0:
|
|
ready_tasks.append((tid, meta.title))
|
|
if ready_tasks:
|
|
items = ' '.join(f"{tid} ({title})" for tid, title in ready_tasks)
|
|
print(f"\n\033[33mReady to merge:\033[0m {items}")
|
|
|
|
# identify unblocked tasks (no remaining dependencies)
|
|
unblocked = [tid for tid in sorted_ids if tid not in merged_ids and not deps_map.get(tid)]
|
|
if unblocked:
|
|
print(f"\n\033[1mUnblocked:\033[0m {' '.join(unblocked)}")
|
|
print(f"\033[1mLaunch unblocked in tmux:\033[0m create-task-worktree.sh --agent --tmux {' '.join(unblocked)}")
|
|
|
|
@cli.command()
|
|
@click.argument('task_id')
|
|
@click.argument('status')
|
|
def set_status(task_id, status):
|
|
"""Set status of TASK_ID to STATUS"""
|
|
md = task_dir() / f"{task_id}-*.md"
|
|
files = list(task_dir().glob(f'{task_id}-*.md'))
|
|
if not files:
|
|
click.echo(f'Task {task_id} not found', err=True)
|
|
sys.exit(1)
|
|
path = files[0]
|
|
meta, body = load_task(path)
|
|
meta.status = status
|
|
meta.last_updated = datetime.utcnow()
|
|
save_task(path, meta, body)
|
|
|
|
@cli.command()
|
|
@click.argument('task_id')
|
|
@click.argument('deps', nargs=-1)
|
|
def set_deps(task_id, deps):
|
|
"""Set dependencies of TASK_ID"""
|
|
files = list(task_dir().glob(f'{task_id}-*.md'))
|
|
if not files:
|
|
click.echo(f'Task {task_id} not found', err=True)
|
|
sys.exit(1)
|
|
path = files[0]
|
|
meta, body = load_task(path)
|
|
now = datetime.utcnow().isoformat()
|
|
meta.dependencies = f'as of {now}: ' + ', '.join(deps)
|
|
meta.last_updated = datetime.utcnow()
|
|
save_task(path, meta, body)
|
|
|
|
@cli.command()
|
|
@click.argument('task_id', nargs=-1)
|
|
def dispose(task_id):
|
|
"""Dispose worktree and delete branch for TASK_ID(s)"""
|
|
root = repo_root()
|
|
wt_base = worktree_dir()
|
|
for tid in task_id:
|
|
# Remove any matching worktree directories
|
|
g = f'{tid}-*'
|
|
matching_wts = wt_base.glob(g)
|
|
for wt_dir in matching_wts:
|
|
click.echo(f"Disposing worktree {wt_dir}")
|
|
# unregister worktree; then delete the directory if still present
|
|
rel = wt_dir.relative_to(root)
|
|
subprocess.run(['git', 'worktree', 'remove', str(rel), '--force'], cwd=root)
|
|
if wt_dir.exists():
|
|
shutil.rmtree(wt_dir)
|
|
else:
|
|
print(f"No worktrees matching {g} in {wt_base}")
|
|
# prune any stale worktree entries
|
|
subprocess.run(['git', 'worktree', 'prune'], cwd=root)
|
|
# Delete any matching branches
|
|
# delete any matching local branches cleanly via for-each-ref
|
|
ref_pattern = f'refs/heads/agentydragon-{tid}-*'
|
|
branches = subprocess.run(
|
|
['git', 'for-each-ref', '--format=%(refname:short)', ref_pattern],
|
|
capture_output=True, text=True, cwd=root
|
|
).stdout.splitlines()
|
|
branches = [br for br in branches if br]
|
|
if branches:
|
|
click.echo(f"Disposing branches: {branches}")
|
|
subprocess.run(['git', 'branch', '-D', *branches], cwd=root)
|
|
else:
|
|
click.echo(f"No branches matching {ref_pattern}")
|
|
click.echo(f'Disposed task {tid}')
|
|
|
|
@cli.command()
|
|
@click.argument('task_id', nargs=-1)
|
|
def launch(task_id):
|
|
"""Copy tmux launch one-liner for TASK_ID(s) to clipboard"""
|
|
cmd = ['create-task-worktree.sh', '--agent', '--tmux'] + list(task_id)
|
|
line = ' '.join(cmd)
|
|
# system clipboard
|
|
try:
|
|
subprocess.run(['pbcopy'], input=line.encode(), check=True)
|
|
click.echo('Copied to clipboard:')
|
|
except FileNotFoundError:
|
|
click.echo(line)
|
|
return
|
|
click.echo(line)
|
|
|
|
if __name__ == '__main__':
|
|
cli()
|