project-manager-tui 0.1.0__tar.gz

project_manager_tui-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: project-manager-tui
+Version: 0.1.0
+Summary: Rich-based TUI for managing projects/tasks with git worktrees
+Requires-Python: >=3.9
+Requires-Dist: rich>=13.0
+Requires-Dist: tomli>=2.0; python_version < "3.11"

project_manager_tui-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "project-manager-tui"
+version = "0.1.0"
+description = "Rich-based TUI for managing projects/tasks with git worktrees"
+requires-python = ">=3.9"
+dependencies = [
+    "rich>=13.0",
+    "tomli>=2.0; python_version < '3.11'",
+]
+
+[project.scripts]
+pm-tui = "project_manager_tui.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

project_manager_tui-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

project_manager_tui-0.1.0/src/project_manager_tui/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

project_manager_tui-0.1.0/src/project_manager_tui/cli.py

@@ -0,0 +1,21 @@
+"""Entry point for project-manager-tui."""
+
+import argparse
+from pathlib import Path
+
+from project_manager_tui.config import load_config
+from project_manager_tui.tui import main as tui_main
+
+
+def main():
+  parser = argparse.ArgumentParser(description="Project management TUI")
+  parser.add_argument("--config", type=Path, default=None,
+                      help="Path to config file (default: ~/.project-manager-tui.toml)")
+  args = parser.parse_args()
+
+  config = load_config(args.config)
+  tui_main(config)
+
+
+if __name__ == "__main__":
+  main()

project_manager_tui-0.1.0/src/project_manager_tui/config.py

@@ -0,0 +1,56 @@
+"""Configuration loading for project-manager-tui."""
+
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+try:
+  import tomllib
+except ModuleNotFoundError:
+  import tomli as tomllib
+
+
+CONFIG_PATH = Path.home() / ".project-manager-tui.toml"
+
+
+@dataclass
+class Config:
+  agent_worktree_script: Path
+  projects_dir: Path
+  projects_filename: str = "Projects.md"
+  editor: str = field(default_factory=lambda: os.environ.get("EDITOR", "vim"))
+  git_repo_dir: Path = field(default_factory=lambda: Path("."))
+  sync_interval: int = 300
+
+  @property
+  def projects_file(self) -> Path:
+    return self.projects_dir / self.projects_filename
+
+
+def load_config(config_path: Path | None = None) -> Config:
+  """Load config from TOML file."""
+  path = config_path or CONFIG_PATH
+  if not path.exists():
+    print(f"Error: config file not found: {path}")
+    print(f"Create {CONFIG_PATH} with at least:")
+    print('  agent_worktree_script = "/path/to/agent-worktree.sh"')
+    print('  projects_dir = "/path/to/projects"')
+    sys.exit(1)
+
+  with open(path, "rb") as f:
+    data = tomllib.load(f)
+
+  missing = [k for k in ("agent_worktree_script", "projects_dir") if k not in data]
+  if missing:
+    print(f"Error: missing required config keys: {', '.join(missing)}")
+    sys.exit(1)
+
+  return Config(
+      agent_worktree_script=Path(data["agent_worktree_script"]),
+      projects_dir=Path(data["projects_dir"]),
+      projects_filename=data.get("projects_filename", "Projects.md"),
+      editor=data.get("editor", os.environ.get("EDITOR", "vim")),
+      git_repo_dir=Path(data.get("git_repo_dir", ".")),
+      sync_interval=data.get("sync_interval", 300),
+  )

project_manager_tui-0.1.0/src/project_manager_tui/core.py

@@ -0,0 +1,418 @@
+"""Non-TUI logic: parsing, task operations, worktree commands."""
+
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from project_manager_tui.config import Config
+
+
+def parse_section_projects(projects_file, section_name):
+  """Parse Projects.md and return list of slugs for a given section."""
+  if not projects_file.exists():
+    return []
+
+  content = projects_file.read_text()
+  section_match = re.search(
+      rf"## {section_name}\n(.*?)(?=\n## |\Z)", content, re.DOTALL
+  )
+  if not section_match:
+    return []
+
+  section_content = section_match.group(1)
+  projects = []
+  for line in section_content.strip().split("\n"):
+    slug = line.strip()
+    if slug:
+      projects.append(slug)
+  return projects
+
+
+def get_all_projects_by_section(projects_file):
+  """Get all projects grouped by section."""
+  sections = ["Active", "Future", "Archived"]
+  result = {}
+  for section in sections:
+    result[section] = parse_section_projects(projects_file, section)
+  return result
+
+
+def get_worktree_list_output(config):
+  """Run agent-worktree.sh list once and return the output."""
+  agent_worktree = config.agent_worktree_script
+  if not agent_worktree.exists():
+    return ""
+
+  try:
+    result = subprocess.run(
+        [str(agent_worktree), "list"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+      return ""
+  except Exception:
+    return ""
+
+  return result.stdout
+
+
+def parse_worktree_statuses(worktree_output):
+  """Parse worktree list output to get status per worktree."""
+  statuses = {}
+  for line in worktree_output.strip().split("\n"):
+    if not line:
+      continue
+    if line.startswith("   "):
+      rest = line.lstrip()
+      name_part = rest.split(":")[0].split()[0] if rest else ""
+      if name_part:
+        statuses[name_part] = ""
+    else:
+      parts = line.split()
+      if len(parts) >= 2:
+        status = parts[0]
+        name_part = parts[1].rstrip(":")
+        statuses[name_part] = status
+  return statuses
+
+
+def get_active_task_nums(config, project_slug, worktree_output=None):
+  """Get set of active task numbers for a project from agent-worktree.sh list."""
+  if worktree_output is None:
+    worktree_output = get_worktree_list_output(config)
+
+  active_tasks = set()
+  for match in re.finditer(rf"\b{re.escape(project_slug)}-(\d+)\b", worktree_output):
+    active_tasks.add(int(match.group(1)))
+
+  return active_tasks
+
+
+def parse_tasks(config, project_md_path, project_slug, worktree_output=None):
+  """Parse Project.md and return dict of number -> task info."""
+  if not project_md_path.exists():
+    return {}
+
+  content = project_md_path.read_text()
+  active_tasks = get_active_task_nums(config, project_slug, worktree_output)
+  worktree_statuses = parse_worktree_statuses(worktree_output or "")
+  tasks = {}
+
+  for match in re.finditer(r"^(\d+)\.\s+\[([^\]])\]\s*(.*)$", content, re.MULTILINE):
+    num = int(match.group(1))
+    state_char = match.group(2).lower()
+    done = state_char == "x"
+    snoozed = state_char in ("s", "z")
+    verified = state_char == "v"
+    desc = match.group(3).strip()
+    in_worktree = num in active_tasks
+
+    worktree_name = f"{project_slug}-{num}"
+    worktree_status = worktree_statuses.get(worktree_name, "")
+
+    depends_on = []
+    dep_match = re.search(r"\s*>(\d+(?:,\d+)*)\s*$", desc)
+    if dep_match:
+      depends_on = [int(d) for d in dep_match.group(1).split(",")]
+      desc = desc[:dep_match.start()].strip()
+
+    line_num = content[:match.start()].count('\n') + 1
+    tasks[num] = {"desc": desc, "done": done, "snoozed": snoozed, "verified": verified,
+                  "in_worktree": in_worktree, "worktree_status": worktree_status,
+                  "depends_on": depends_on, "line_num": line_num, "state_char": state_char}
+
+  for num, task in tasks.items():
+    deps_met = all(tasks.get(d, {}).get("state_char", "") in ("v")
+                   for d in task["depends_on"])
+    task["deps_met"] = deps_met
+    task["available"] = not task["done"] and not task["in_worktree"] and deps_met
+
+  return tasks
+
+
+def add_task_to_project(project_md_path):
+  """Add a new empty task to the end of the task list in Project.md."""
+  if not project_md_path.exists():
+    return None, None
+
+  content = project_md_path.read_text()
+
+  existing_nums = []
+  for match in re.finditer(r"^(\d+)\.\s+\[", content, re.MULTILINE):
+    existing_nums.append(int(match.group(1)))
+
+  new_num = max(existing_nums) + 1 if existing_nums else 1
+
+  last_task_end = 0
+  for match in re.finditer(r"^(\d+)\.\s+\[[^\]]\].*$", content, re.MULTILINE):
+    last_task_end = match.end()
+
+  if last_task_end == 0:
+    tasks_match = re.search(r"^## Tasks\s*$", content, re.MULTILINE)
+    if tasks_match:
+      last_task_end = tasks_match.end()
+    else:
+      content = content.rstrip() + "\n\n## Tasks\n"
+      last_task_end = len(content)
+
+  new_task_line = f"\n{new_num}. [ ] "
+  new_content = content[:last_task_end] + new_task_line + content[last_task_end:]
+
+  project_md_path.write_text(new_content)
+
+  line_num = new_content[:last_task_end + 1].count('\n') + 1
+
+  return new_num, line_num
+
+
+def move_project_to_section(projects_file, project_slug, target_section):
+  """Move a project from one section to another in Projects.md."""
+  content = projects_file.read_text()
+
+  content = re.sub(rf"^{re.escape(project_slug)}\s*\n?",
+                   "", content, flags=re.MULTILINE)
+
+  section_match = re.search(rf"(## {target_section})(\n|$)", content)
+  if section_match:
+    insert_pos = section_match.end()
+    prefix = "" if section_match.group(2) == "\n" else "\n"
+    content = content[:insert_pos] + prefix + f"{project_slug}\n" + content[insert_pos:]
+  else:
+    content = content.rstrip() + f"\n\n## {target_section}\n{project_slug}\n"
+
+  projects_file.write_text(content)
+
+
+def snooze_task(project_md_path, task_num):
+  """Snooze a task by changing [ ] to [z] in Project.md."""
+  if not project_md_path.exists():
+    return False
+
+  content = project_md_path.read_text()
+  new_content = re.sub(
+      rf"^({task_num}\.\s+)\[ \]",
+      r"\1[z]",
+      content,
+      flags=re.MULTILINE
+  )
+  if new_content != content:
+    project_md_path.write_text(new_content)
+    return True
+  return False
+
+
+def unsnooze_task(project_md_path, task_num):
+  """Unsnooze a task by changing [s] or [z] to [ ] in Project.md."""
+  if not project_md_path.exists():
+    return False
+
+  content = project_md_path.read_text()
+  new_content = re.sub(
+      rf"^({task_num}\.\s+)\[[sSzZ]\]",
+      r"\1[ ]",
+      content,
+      flags=re.MULTILINE
+  )
+  if new_content != content:
+    project_md_path.write_text(new_content)
+    return True
+  return False
+
+
+def mark_task_done(project_md_path, task_num):
+  """Mark a task as done in Project.md by changing [ ] to [x]."""
+  if not project_md_path.exists():
+    return False
+
+  content = project_md_path.read_text()
+  pattern = rf"^({task_num}\.\s+)\[ \]"
+  new_content, count = re.subn(pattern, r"\1[x]", content, flags=re.MULTILINE)
+
+  if count > 0:
+    project_md_path.write_text(new_content)
+    return True
+  return False
+
+
+def mark_task_verified(project_md_path, task_num):
+  """Mark a task as verified in Project.md by changing any state to [v]."""
+  if not project_md_path.exists():
+    return False
+
+  content = project_md_path.read_text()
+  pattern = rf"^({task_num}\.\s+)\[[^\]]\]"
+  new_content, count = re.subn(pattern, r"\1[v]", content, flags=re.MULTILINE)
+
+  if count > 0:
+    project_md_path.write_text(new_content)
+    return True
+  return False
+
+
+def mark_task_released(project_md_path, task_num):
+  """Mark a task as released in Project.md by changing state to [r]."""
+  if not project_md_path.exists():
+    return False
+
+  content = project_md_path.read_text()
+  pattern = rf"^({task_num}\.\s+)\[[^\]]\]"
+  new_content, count = re.subn(pattern, r"\1[r]", content, flags=re.MULTILINE)
+
+  if count > 0:
+    project_md_path.write_text(new_content)
+    return True
+  return False
+
+
+def delete_task(config, project_slug, task_num):
+  """Delete a task - remove worktree, Task.md directory, and task line from Project.md."""
+  project_dir = config.projects_dir / project_slug
+  project_md = project_dir / "Project.md"
+
+  worktree_name = f"{project_slug}-{task_num}"
+  agent_worktree = config.agent_worktree_script
+
+  if agent_worktree.exists():
+    worktree_output = get_worktree_list_output(config)
+    if worktree_name in worktree_output:
+      result = subprocess.run([str(agent_worktree), "rm", worktree_name])
+      if result.returncode != 0:
+        return False
+
+  task_dir = project_dir / "tasks" / str(task_num)
+  if task_dir.exists():
+    shutil.rmtree(task_dir)
+
+  if project_md.exists():
+    content = project_md.read_text()
+    new_content = re.sub(
+        rf"^{task_num}\.\s+\[[^\]]\].*\n?",
+        "",
+        content,
+        flags=re.MULTILINE
+    )
+    project_md.write_text(new_content)
+
+  return True
+
+
+def ensure_task_md(config, project_md_path, project_slug, task_num, task_desc):
+  """Ensure Task.md exists for a task, creating it if needed. Returns the path."""
+  task_md = config.projects_dir / project_slug / "tasks" / str(task_num) / "Task.md"
+  if not task_md.exists():
+    task_md.parent.mkdir(parents=True, exist_ok=True)
+    task_md.write_text(
+        f"# {task_desc}\n\n<!-- Read {project_md_path} for project context -->\n")
+  return task_md
+
+
+def activate_task(config, project_slug, task_num, task_desc):
+  """Activate a task - create directory and worktree."""
+  project_dir = config.projects_dir / project_slug
+  project_md = project_dir / "Project.md"
+
+  task_md = ensure_task_md(config, project_md, project_slug, task_num, task_desc)
+  print(f"Created: {task_md.parent}")
+
+  worktree_name = f"{project_slug}-{task_num}"
+  agent_worktree = config.agent_worktree_script
+
+  if not agent_worktree.exists():
+    print(f"Warning: {agent_worktree} not found, skipping worktree creation")
+    return
+
+  print(f"Running: agent-worktree.sh add {worktree_name}")
+  subprocess.run([str(agent_worktree), "add", worktree_name])
+
+
+def get_current_branch(config):
+  """Get the current git branch name."""
+  try:
+    result = subprocess.run(
+        ["git", "branch", "--show-current"],
+        capture_output=True,
+        text=True,
+        cwd=str(config.git_repo_dir)
+    )
+    if result.returncode == 0:
+      return result.stdout.strip()
+  except Exception:
+    pass
+  return None
+
+
+def get_all_active_tasks(config):
+  """Get all tasks from active projects.
+
+  Returns list of dicts with: project_slug, task_num, desc, state, task_md_path
+  """
+  active_projects = parse_section_projects(config.projects_file, "Active")
+  if not active_projects:
+    return []
+
+  worktree_output = get_worktree_list_output(config)
+
+  all_tasks = []
+  for project_slug in active_projects:
+    project_dir = config.projects_dir / project_slug
+    project_md = project_dir / "Project.md"
+    if not project_md.exists():
+      continue
+
+    tasks = parse_tasks(config, project_md, project_slug, worktree_output)
+    for task_num, task_info in sorted(tasks.items()):
+      state = task_info.get("state_char", " ")
+      worktree_status = task_info.get("worktree_status", "")
+      task_md_path = project_dir / "tasks" / str(task_num) / "Task.md"
+
+      all_tasks.append({
+          "project_slug": project_slug,
+          "task_num": task_num,
+          "desc": task_info["desc"],
+          "state": state,
+          "worktree_status": worktree_status,
+          "task_md_path": task_md_path,
+          "project_md_path": project_md,
+          "line_num": task_info.get("line_num", 1),
+          "done": task_info["done"],
+          "snoozed": task_info.get("snoozed", False),
+          "verified": task_info.get("verified", False),
+          "in_worktree": task_info["in_worktree"],
+          "depends_on": task_info.get("depends_on", []),
+          "deps_met": task_info.get("deps_met", True),
+      })
+
+  return all_tasks
+
+
+def get_project_line_numbers(projects_file):
+  """Get line numbers for each project in Projects.md."""
+  if not projects_file.exists():
+    return {}
+
+  content = projects_file.read_text()
+  line_nums = {}
+  for i, line in enumerate(content.split("\n"), start=1):
+    slug = line.strip()
+    if slug and not slug.startswith("#"):
+      line_nums[slug] = i
+  return line_nums
+
+
+def get_project_list(config, current_project=None):
+  """Get flat list of projects with section info for display."""
+  projects_by_section = get_all_projects_by_section(config.projects_file)
+  line_nums = get_project_line_numbers(config.projects_file)
+
+  result = []
+  for section in ["Active", "Future", "Archived"]:
+    for slug in projects_by_section.get(section, []):
+      result.append({
+          "slug": slug,
+          "section": section,
+          "is_current": slug == current_project,
+          "line_num": line_nums.get(slug, 1),
+      })
+  return result

project_manager_tui-0.1.0/src/project_manager_tui/tui.py

@@ -0,0 +1,480 @@
+"""Rich TUI display + main loop."""
+
+import select
+import subprocess
+import sys
+import termios
+import time
+import tty
+
+from rich.console import Console, Group
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.live import Live
+
+from project_manager_tui.config import Config
+from project_manager_tui.core import (
+    activate_task,
+    add_task_to_project,
+    delete_task,
+    ensure_task_md,
+    get_all_active_tasks,
+    get_current_branch,
+    get_project_list,
+    get_worktree_list_output,
+    mark_task_released,
+    mark_task_verified,
+    move_project_to_section,
+    parse_tasks,
+    snooze_task,
+    unsnooze_task,
+)
+
+
+def get_key(timeout=None):
+  """Read a single keypress from stdin with optional timeout."""
+  fd = sys.stdin.fileno()
+  old_settings = termios.tcgetattr(fd)
+  try:
+    tty.setraw(fd)
+    if timeout is not None:
+      ready, _, _ = select.select([sys.stdin], [], [], timeout)
+      if not ready:
+        return None
+    ch = sys.stdin.read(1)
+  finally:
+    termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+  return ch
+
+
+def build_display(tasks, selected_idx, show_help=False, show_verified=False, show_snoozed=False, show_blocked=False, show_working=False, current_branch=None):
+  """Build the display renderable."""
+  table = Table(show_header=False, box=None, padding=(0, 0), pad_edge=False)
+  table.add_column(width=5, no_wrap=True)
+  table.add_column(width=24, no_wrap=True, overflow="ellipsis")
+  table.add_column(no_wrap=True, overflow="ellipsis")
+
+  for i, task in enumerate(tasks):
+    wt_status = task.get("worktree_status", "")
+    state_display = f"[{task['state']}]{wt_status}"
+
+    state = task.get("state", " ")
+    if task.get("verified"):
+      state_style = "cyan"
+      row_color = "cyan"
+    elif task["done"]:
+      state_style = "green"
+      row_color = "green"
+    elif task.get("snoozed"):
+      state_style = "magenta"
+      row_color = "magenta"
+    elif state == "r":
+      state_style = "yellow"
+      row_color = "yellow"
+    elif state == "t":
+      state_style = "blue"
+      row_color = "blue"
+    elif not task.get("deps_met", True):
+      state_style = "red"
+      row_color = "red"
+    else:
+      state_style = "white"
+      row_color = ""
+
+    if i == selected_idx:
+      select_style = "reverse"
+      state_style = f"{state_style} reverse"
+      name_style = f"{row_color} reverse" if row_color else "reverse"
+    else:
+      select_style = ""
+      name_style = row_color if row_color else ""
+
+    task_branch = f"{task['project_slug']}-{task['task_num']}"
+    current_marker = "*" if current_branch == task_branch else ""
+
+    desc = task["desc"]
+    table.add_row(
+        Text(state_display, style=state_style),
+        Text(f" {task_branch}{current_marker}", style=name_style),
+        Text(desc, style=select_style),
+    )
+
+  if show_help:
+    help_text = Panel(
+        "[bold]Task View:[/bold]\n"
+        "  j/k  Navigate\n"
+        "  t    Vim Task.md\n"
+        "  p    Vim Project.md\n"
+        "  v    View worktree (awt view)\n"
+        "  s    Switch worktree (awt switch)\n"
+        "  z    Snooze/unsnooze\n"
+        "  c    Complete (close)\n"
+        "  r    Release (mark [r])\n"
+        "  d    Delete task\n"
+        "  V/Z/B/W Toggle verified/snoozed/blocked/working\n"
+        "  P    Project view\n"
+        "\n[bold]Project View:[/bold]\n"
+        "  j/k  Navigate\n"
+        "  n    New task\n"
+        "  p    Vim Project.md\n"
+        "  v    Vim Projects.md\n"
+        "  a    Archive project\n"
+        "  T    Task view\n"
+        "\n[bold]General:[/bold]\n"
+        "  ?    Toggle help\n"
+        "  q    Quit",
+        title="Help",
+        border_style="green",
+    )
+    return Group(table, help_text)
+  else:
+    status = "[dim]? for help, q to quit[/dim]"
+    if show_verified:
+      status += " [cyan](+verified)[/cyan]"
+    if show_snoozed:
+      status += " [magenta](+snoozed)[/magenta]"
+    if show_blocked:
+      status += " [red](+blocked)[/red]"
+    if show_working:
+      status += " [yellow](+working)[/yellow]"
+    return Group(table, Text.from_markup(status))
+
+
+def build_project_display(projects, selected_idx):
+  """Build the project selection display."""
+  table = Table(show_header=False, box=None, padding=(0, 0), pad_edge=False)
+  table.add_column(width=10)
+  table.add_column()
+
+  section_styles = {
+      "Active": "green",
+      "Future": "yellow",
+      "Archived": "dim",
+  }
+
+  current_section = None
+  for i, proj in enumerate(projects):
+    if proj["section"] != current_section:
+      current_section = proj["section"]
+      section_display = current_section
+    else:
+      section_display = ""
+
+    section_style = section_styles.get(proj["section"], "white")
+
+    if i == selected_idx:
+      row_style = "reverse"
+    else:
+      row_style = ""
+
+    table.add_row(
+        Text(section_display, style=section_style),
+        proj["slug"],
+        style=row_style,
+    )
+
+  status = "[dim]j/k navigate, n new task, p vim Project.md, v vim Projects.md, a archive, T task view, q quit[/dim]"
+  return Group(table, Text.from_markup(status))
+
+
+def main(config: Config):
+  console = Console()
+
+  tasks = get_all_active_tasks(config)
+  projects = get_project_list(config)
+
+  if not tasks and not projects:
+    console.print("[yellow]No tasks or projects found[/yellow]")
+    return
+
+  view = ['task']
+  task_idx = [0]
+  proj_idx = [0]
+  show_help = False
+  show_verified = [False]
+  show_snoozed = [False]
+  show_blocked = [False]
+  show_working = [True]
+  current_branch = [get_current_branch(config)]
+  last_sync_time = [time.time()]
+
+  def visible_tasks():
+    result = tasks
+    if not show_verified[0]:
+      result = [t for t in result if not t.get("verified")]
+    if not show_snoozed[0]:
+      result = [t for t in result if not t.get("snoozed")]
+    if not show_blocked[0]:
+      result = [t for t in result if t.get("deps_met", True)]
+    if not show_working[0]:
+      result = [t for t in result if t.get("worktree_status") != "\u23f3"]
+    return result
+
+  def current_display():
+    if view[0] == 'task':
+      return build_display(visible_tasks(), task_idx[0], show_help, show_verified[0], show_snoozed[0], show_blocked[0], show_working[0], current_branch[0])
+    else:
+      return build_project_display(projects, proj_idx[0])
+
+  with Live(current_display(), console=console, screen=True, auto_refresh=False) as live:
+    try:
+      while True:
+        key = get_key(timeout=5)
+
+        if key is None:
+          tasks = get_all_active_tasks(config)
+          current_branch[0] = get_current_branch(config)
+          task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+          if time.time() - last_sync_time[0] >= config.sync_interval:
+            subprocess.run(
+                [str(config.agent_worktree_script), "sync-master"],
+                capture_output=True)
+            last_sync_time[0] = time.time()
+          live.update(current_display(), refresh=True)
+          continue
+
+        if key == "q":
+          break
+
+        elif key == "j" or key == "\x1b":
+          if key == "\x1b":
+            next1 = sys.stdin.read(1) if sys.stdin else ""
+            next2 = sys.stdin.read(1) if sys.stdin else ""
+            if next1 == "[" and next2 == "B":
+              if view[0] == 'task':
+                task_idx[0] = min(task_idx[0] + 1, max(0, len(visible_tasks()) - 1))
+              else:
+                proj_idx[0] = min(proj_idx[0] + 1, len(projects) - 1)
+            elif next1 == "[" and next2 == "A":
+              if view[0] == 'task':
+                task_idx[0] = max(task_idx[0] - 1, 0)
+              else:
+                proj_idx[0] = max(proj_idx[0] - 1, 0)
+          else:
+            if view[0] == 'task':
+              task_idx[0] = min(task_idx[0] + 1, max(0, len(visible_tasks()) - 1))
+            else:
+              proj_idx[0] = min(proj_idx[0] + 1, len(projects) - 1)
+        elif key == "k":
+          if view[0] == 'task':
+            task_idx[0] = max(task_idx[0] - 1, 0)
+          else:
+            proj_idx[0] = max(proj_idx[0] - 1, 0)
+
+        elif key == "T":
+          view[0] = 'task'
+        elif key == "P":
+          vis = visible_tasks()
+          if vis and task_idx[0] < len(vis):
+            current_project = vis[task_idx[0]]["project_slug"]
+            for i, p in enumerate(projects):
+              if p["slug"] == current_project:
+                proj_idx[0] = i
+                break
+          view[0] = 'project'
+
+        elif view[0] == 'task':
+          if key == "V":
+            show_verified[0] = not show_verified[0]
+            task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+          elif key == "Z":
+            show_snoozed[0] = not show_snoozed[0]
+            task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+          elif key == "B":
+            show_blocked[0] = not show_blocked[0]
+            task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+          elif key == "W":
+            show_working[0] = not show_working[0]
+            task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+          elif key == "s":
+            vis = visible_tasks()
+            if vis:
+              task = vis[task_idx[0]]
+              worktree_name = f"{task['project_slug']}-{task['task_num']}"
+              result = subprocess.run(
+                  ["tmux", "display-message", "-p", "#{window_index}"],
+                  capture_output=True, text=True)
+              original_window = result.stdout.strip() if result.returncode == 0 else None
+              live.stop()
+              subprocess.run(
+                  [str(config.agent_worktree_script), "switch", worktree_name])
+              current_branch[0] = get_current_branch(config)
+              if original_window:
+                subprocess.run(["tmux", "select-window", "-t", f":{original_window}"])
+              live.start()
+          elif key == "z":
+            vis = visible_tasks()
+            if vis:
+              task = vis[task_idx[0]]
+              if task.get("snoozed"):
+                unsnooze_task(task["project_md_path"], task["task_num"])
+              else:
+                snooze_task(task["project_md_path"], task["task_num"])
+              tasks = get_all_active_tasks(config)
+              task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+          elif key == "c":
+            vis = visible_tasks()
+            if vis:
+              task = vis[task_idx[0]]
+              confirm_text = Text.from_markup(
+                  f"[bold green]Complete task?[/bold green]\n\n"
+                  f"  {task['project_slug']}-{task['task_num']}: {task['desc']}\n\n"
+                  f"This will remove the worktree and mark task as done.\n\n"
+                  f"[bold]Press 'y' to confirm, any other key to cancel[/bold]"
+              )
+              live.update(confirm_text, refresh=True)
+              confirm_key = get_key()
+              if confirm_key == "y":
+                worktree_name = f"{task['project_slug']}-{task['task_num']}"
+                live.stop()
+                success = True
+                agent_worktree = config.agent_worktree_script
+                if agent_worktree.exists() and task["in_worktree"]:
+                  result = subprocess.run([str(agent_worktree), "rm", worktree_name])
+                  if result.returncode != 0:
+                    success = False
+                    print("\nPress Enter to continue...")
+                    input()
+                if success:
+                  mark_task_verified(task["project_md_path"], task["task_num"])
+                tasks = get_all_active_tasks(config)
+                task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+                live.start()
+          elif key == "t":
+            vis = visible_tasks()
+            if vis:
+              task = vis[task_idx[0]]
+              task_md = ensure_task_md(
+                  config, task["project_md_path"], task["project_slug"], task["task_num"], task["desc"])
+              live.stop()
+              subprocess.run([config.editor, str(task_md)])
+              tasks = get_all_active_tasks(config)
+              task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+              live.start()
+          elif key == "p":
+            vis = visible_tasks()
+            if vis:
+              task = vis[task_idx[0]]
+              project_md = task["project_md_path"]
+              line_num = task["line_num"]
+              live.stop()
+              subprocess.run([config.editor, f"+{line_num}", str(project_md)])
+              tasks = get_all_active_tasks(config)
+              task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+              live.start()
+          elif key == "v":
+            vis = visible_tasks()
+            if vis:
+              task = vis[task_idx[0]]
+              ensure_task_md(config, task["project_md_path"],
+                             task["project_slug"], task["task_num"], task["desc"])
+              worktree_name = f"{task['project_slug']}-{task['task_num']}"
+              live.stop()
+              subprocess.run(
+                  [str(config.agent_worktree_script), "view", worktree_name])
+              live.start()
+          elif key == "r":
+            vis = visible_tasks()
+            if vis:
+              task = vis[task_idx[0]]
+              confirm_text = Text.from_markup(
+                  f"[bold yellow]Release task?[/bold yellow]\n\n"
+                  f"  {task['project_slug']}-{task['task_num']}: {task['desc']}\n\n"
+                  f"[bold]Press 'y' to confirm, any other key to cancel[/bold]"
+              )
+              live.update(confirm_text, refresh=True)
+              confirm_key = get_key()
+              if confirm_key == "y":
+                mark_task_released(task["project_md_path"], task["task_num"])
+                tasks = get_all_active_tasks(config)
+                task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+          elif key == "d":
+            vis = visible_tasks()
+            if vis:
+              task = vis[task_idx[0]]
+              confirm_text = Text.from_markup(
+                  f"[bold red]Delete task?[/bold red]\n\n"
+                  f"  {task['project_slug']}-{task['task_num']}: {task['desc']}\n\n"
+                  f"This will remove the worktree, Task.md, and task line.\n\n"
+                  f"[bold]Press 'y' to confirm, any other key to cancel[/bold]"
+              )
+              live.update(confirm_text, refresh=True)
+              confirm_key = get_key()
+              if confirm_key == "y":
+                live.stop()
+                success = delete_task(config, task["project_slug"], task["task_num"])
+                if not success:
+                  print("\nDelete failed. Press Enter to continue...")
+                  input()
+                tasks = get_all_active_tasks(config)
+                task_idx[0] = min(task_idx[0], max(0, len(visible_tasks()) - 1))
+                live.start()
+          elif key == "?":
+            show_help = not show_help
+
+        elif view[0] == 'project':
+          if key == "p":
+            if projects:
+              selected_project = projects[proj_idx[0]]
+              project_md = config.projects_dir / selected_project["slug"] / "Project.md"
+              if project_md.exists():
+                live.stop()
+                subprocess.run([config.editor, str(project_md)])
+                tasks = get_all_active_tasks(config)
+                live.start()
+          elif key == "v":
+            if projects:
+              selected_project = projects[proj_idx[0]]
+              line_num = selected_project.get("line_num", 1)
+              live.stop()
+              subprocess.run([config.editor, f"+{line_num}", str(config.projects_file)])
+              projects = get_project_list(config)
+              proj_idx[0] = min(proj_idx[0], max(0, len(projects) - 1))
+              live.start()
+          elif key == "a":
+            if projects:
+              selected_project = projects[proj_idx[0]]
+              move_project_to_section(config.projects_file,
+                                      selected_project["slug"], "Archived")
+              projects = get_project_list(config)
+              proj_idx[0] = min(proj_idx[0], max(0, len(projects) - 1))
+          elif key == "n":
+            if projects:
+              selected_project = projects[proj_idx[0]]
+              project_dir = config.projects_dir / selected_project["slug"]
+              project_md = project_dir / "Project.md"
+
+              live.stop()
+
+              if not project_md.exists():
+                project_dir.mkdir(parents=True, exist_ok=True)
+                title = selected_project["slug"].replace("-", " ").title()
+                project_md.write_text(f"# {title}\n\n\n\n## Tasks\n1. [ ] \n")
+                subprocess.run([config.editor, "+6", str(project_md)])
+                new_num = 1
+              else:
+                new_num, line_num = add_task_to_project(project_md)
+                if new_num and line_num:
+                  subprocess.run([config.editor, f"+{line_num}", str(project_md)])
+
+              if new_num:
+                new_tasks = parse_tasks(config, project_md, selected_project["slug"], "")
+                task_desc = new_tasks.get(new_num, {}).get("desc", "")
+                if task_desc:
+                  activate_task(config, selected_project["slug"], new_num, task_desc)
+
+                tasks = get_all_active_tasks(config)
+
+                view[0] = 'task'
+                for i, t in enumerate(visible_tasks()):
+                  if t["project_slug"] == selected_project["slug"] and t["task_num"] == new_num:
+                    task_idx[0] = i
+                    break
+
+              live.start()
+
+        live.update(current_display(), refresh=True)
+
+    except KeyboardInterrupt:
+      pass

project_manager_tui-0.1.0/src/project_manager_tui.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: project-manager-tui
+Version: 0.1.0
+Summary: Rich-based TUI for managing projects/tasks with git worktrees
+Requires-Python: >=3.9
+Requires-Dist: rich>=13.0
+Requires-Dist: tomli>=2.0; python_version < "3.11"

project_manager_tui-0.1.0/src/project_manager_tui.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+pyproject.toml
+src/project_manager_tui/__init__.py
+src/project_manager_tui/cli.py
+src/project_manager_tui/config.py
+src/project_manager_tui/core.py
+src/project_manager_tui/tui.py
+src/project_manager_tui.egg-info/PKG-INFO
+src/project_manager_tui.egg-info/SOURCES.txt
+src/project_manager_tui.egg-info/dependency_links.txt
+src/project_manager_tui.egg-info/entry_points.txt
+src/project_manager_tui.egg-info/requires.txt
+src/project_manager_tui.egg-info/top_level.txt

project_manager_tui-0.1.0/src/project_manager_tui.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

project_manager_tui-0.1.0/src/project_manager_tui.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pm-tui = project_manager_tui.cli:main

project_manager_tui-0.1.0/src/project_manager_tui.egg-info/requires.txt

@@ -0,0 +1,4 @@
+rich>=13.0
+
+[:python_version < "3.11"]
+tomli>=2.0

project_manager_tui-0.1.0/src/project_manager_tui.egg-info/top_level.txt

@@ -0,0 +1 @@
+project_manager_tui