@stylusnexus/work-plan 2026.6.9-1

package/skills/work-plan/commands/set_field.py

@@ -0,0 +1,61 @@
+"""set subcommand — guarded edit of a track's frontmatter scalar/list fields."""
+import json
+from lib.config import load_config, ConfigError
+from lib.tracks import discover_tracks, find_track_by_name, parse_track_repo_arg, AmbiguousTrackError
+from lib.frontmatter import write_file
+from lib.write_guard import needs_confirm, make_token, valid_token
+from lib.prompts import parse_flags
+
+ALLOWED = {"status", "launch_priority", "milestone_alignment", "blockers", "next_up"}
+LIST_FIELDS = {"blockers", "next_up"}
+STATUSES = {"active", "in-progress", "blocked", "parked", "shipped", "abandoned"}
+
+def run(args: list[str]) -> int:
+    # Confirm token is passed as --confirm=<token> (equals form: parse_flags only
+    # understands --key=value or bare --key, so a space-separated token would be
+    # mis-read as a positional). The VS Code extension invokes the equals form.
+    flags, positional = parse_flags(args, {"--confirm", "--repo"})
+    if len(positional) < 2:
+        print("usage: work_plan.py set <track> field=value [field=value …] [--confirm=<token>] [--repo=<key>]"); return 2
+    track_arg, assignments = positional[0], positional[1:]
+    name_from_arg, repo_from_arg = parse_track_repo_arg(track_arg)
+    name = name_from_arg
+    repo_flag = flags.get("--repo") if flags.get("--repo") is not True else None
+    repo_qualifier = repo_from_arg or repo_flag
+    parsed = {}
+    for a in assignments:
+        if "=" not in a:
+            print(f"ERROR: bad assignment {a!r} (expected field=value)"); return 2
+        k, v = a.split("=", 1)
+        if k not in ALLOWED:
+            print(f"ERROR: field {k!r} not settable (allowed: {sorted(ALLOWED)})"); return 2
+        if k in LIST_FIELDS:
+            try:
+                parsed[k] = [int(x) for x in v.split(",") if x.strip()] if v.strip() else []
+            except ValueError:
+                print(f"ERROR: {k} takes comma-separated integers (got {v!r})"); return 2
+        elif k == "status" and v not in STATUSES:
+            print(f"ERROR: status {v!r} invalid (allowed: {sorted(STATUSES)})"); return 2
+        else:
+            parsed[k] = v
+    try:
+        cfg = load_config()
+    except ConfigError as e:
+        print(f"ERROR: {e}"); return 1
+    try:
+        track = find_track_by_name(name, discover_tracks(cfg), repo=repo_qualifier)
+    except AmbiguousTrackError as e:
+        print(str(e)); return 1
+    if not track:
+        print(f"No track matching {name!r}."); return 1
+    # Public-repo confirm gate (the extension surfaces this as a modal).
+    confirm = flags.get("--confirm")
+    if track.repo and needs_confirm(track.repo, cfg) and not (isinstance(confirm, str) and valid_token(confirm, track.repo, track.name)):
+        print(json.dumps({"needs_confirm": True,
+                          "reason": f"{track.repo} is PUBLIC (or visibility unknown); edit will be written there.",
+                          "token": make_token(track.repo, track.name)}))
+        return 0
+    track.meta.update(parsed)
+    write_file(track.path, track.meta, track.body)
+    print(f"✓ set {', '.join(parsed)} on {track.name}")
+    return 0

package/skills/work-plan/commands/set_notes_root.py

@@ -0,0 +1,53 @@
+"""set-notes-root subcommand — non-interactively relocate notes_root in config.
+
+Called by the VS Code viewer's cold-start onboarding when the user picks a
+folder. Config writes stay in the CLI (the engine), not the extension.
+
+Usage: set-notes-root <path>
+"""
+import subprocess
+from pathlib import Path
+
+from lib.config import load_config, DEFAULT_CONFIG_PATH
+from lib.prompts import parse_flags
+from lib.tracks import discover_tracks
+
+
+def run(args: list[str]) -> int:
+    _, positional = parse_flags(args, set())
+
+    if not positional:
+        print("usage: work_plan.py set-notes-root <path>")
+        return 2
+
+    new_root = Path(positional[0]).expanduser().resolve()
+
+    cfg = load_config()
+    current_root = Path(cfg["notes_root"]).expanduser().resolve()
+
+    # Orphan warning (informational only — no moves, no prompt)
+    if new_root != current_root:
+        tracks = discover_tracks(cfg)
+        if tracks:
+            print(
+                f"WARN: {len(tracks)} track(s) exist under {current_root}. "
+                "They will NOT be moved — move them manually to the new location "
+                "before using the viewer, or they won't appear."
+            )
+
+    # Ensure the target directory exists
+    new_root.mkdir(parents=True, exist_ok=True)
+
+    # Write the new notes_root into config via yq (mikefarah/yq)
+    yq_expr = f'.notes_root = "{new_root}"'
+    try:
+        subprocess.run(
+            ["yq", "-i", yq_expr, str(DEFAULT_CONFIG_PATH)],
+            check=True, capture_output=True, text=True,
+        )
+    except subprocess.CalledProcessError as e:
+        print(f"ERROR: yq failed to update config: {e.stderr}")
+        return 1
+
+    print(f"✓ notes_root set to {new_root}")
+    return 0

package/skills/work-plan/commands/slot.py

@@ -0,0 +1,154 @@
+"""slot subcommand."""
+import json
+import subprocess
+
+from lib.config import load_config, ConfigError
+from lib.tracks import discover_tracks, find_track_by_name, parse_track_repo_arg, AmbiguousTrackError
+from lib.frontmatter import write_file
+from lib.write_guard import needs_confirm, make_token, valid_token
+from lib.prompts import parse_flags, prompt_input
+
+
+def _find_prior_owners(issue_num: int, repo: str, target_name: str, tracks):
+    """Active tracks in `repo` (excluding `target_name`) whose frontmatter
+    already lists `issue_num`. Lets slot offer a move when GitHub labels
+    moved an issue across tracks but the old frontmatter still claims it."""
+    owners = []
+    for t in tracks:
+        if not t.has_frontmatter or t.name == target_name or t.repo != repo:
+            continue
+        if t.meta.get("status") not in ("active", "in-progress", "blocked"):
+            continue
+        if issue_num in (t.meta.get("github", {}).get("issues") or []):
+            owners.append(t)
+    return owners
+
+
+def run(args: list[str]) -> int:
+    # --confirm uses equals form: --confirm=<token>
+    # --move / --no-move are bare flags
+    # --repo uses equals form: --repo=<key>
+    flags, positional = parse_flags(args, {"--confirm", "--move", "--no-move", "--repo"})
+    if not positional:
+        print("usage: work_plan.py slot <issue-num> [track | track@repo] [--repo=<key>]")
+        return 2
+    try:
+        issue_num = int(positional[0])
+    except ValueError:
+        print(f"ERROR: '{positional[0]}' is not an issue number.")
+        return 2
+    target_arg = positional[1] if len(positional) > 1 else None
+    repo_flag = flags.get("--repo") if flags.get("--repo") is not True else None
+
+    target_name = target_arg
+    repo_qualifier = repo_flag
+    if target_arg:
+        name_from_arg, repo_from_arg = parse_track_repo_arg(target_arg)
+        target_name = name_from_arg
+        if repo_from_arg:
+            repo_qualifier = repo_from_arg
+
+    if "--move" in flags and "--no-move" in flags:
+        print("ERROR: --move and --no-move are mutually exclusive.")
+        return 2
+
+    try:
+        cfg = load_config()
+    except ConfigError as e:
+        print(f"ERROR: {e}")
+        return 1
+
+    tracks = discover_tracks(cfg)
+    active = [t for t in tracks if t.has_frontmatter
+              and t.meta.get("status") in ("active", "in-progress", "blocked")]
+
+    if target_name:
+        try:
+            target = find_track_by_name(target_name, tracks, active_only=True,
+                                        repo=repo_qualifier)
+        except AmbiguousTrackError as e:
+            print(str(e))
+            return 1
+        if not target:
+            print(f"No active track matching '{target_name}'.")
+            return 1
+    else:
+        print("Active tracks:")
+        for i, t in enumerate(active, 1):
+            print(f"  [{i}] {t.name} ({t.meta.get('launch_priority','P3')}, "
+                  f"{t.meta.get('milestone_alignment','—')})")
+        choice = prompt_input("\nSlot into which? (number or name):")
+        if not choice:
+            print("No selection. Cancelled.")
+            return 1
+        if choice.isdigit():
+            idx = int(choice) - 1
+            if not (0 <= idx < len(active)):
+                print("Out of range.")
+                return 1
+            target = active[idx]
+        else:
+            matching = [t for t in active if t.name == choice or t.meta.get("track") == choice]
+            if not matching:
+                print(f"No active track matching '{choice}'.")
+                return 1
+            target = matching[0]
+
+    issues = list(target.meta.get("github", {}).get("issues") or [])
+    if issue_num in issues:
+        print(f"#{issue_num} already in track '{target.name}'.")
+        return 0
+
+    # Public-repo confirm gate (the extension surfaces this as a modal).
+    # Placed after target resolution and the "already in track" no-op so we
+    # don't gate a no-op write.
+    confirm = flags.get("--confirm")
+    if target.repo and needs_confirm(target.repo, cfg) and not (
+        isinstance(confirm, str) and valid_token(confirm, target.repo, target.name)
+    ):
+        print(json.dumps({
+            "needs_confirm": True,
+            "reason": (
+                f"{target.repo} is PUBLIC (or visibility unknown); "
+                f"slotting #{issue_num} will be written there."
+            ),
+            "token": make_token(target.repo, target.name),
+        }))
+        return 0
+
+    # Determine move behavior from flags.
+    # --move: remove issue from prior owners.
+    # Default / --no-move: add-only; print a note naming prior owners.
+    do_move = "--move" in flags
+
+    sources = _find_prior_owners(issue_num, target.repo, target.name, tracks)
+
+    issues.append(issue_num)
+    target.meta.setdefault("github", {})["issues"] = sorted(issues)
+
+    proc = subprocess.run(
+        ["gh", "issue", "view", str(issue_num),
+         "--repo", target.repo, "--json", "milestone"],
+        capture_output=True, text=True,
+    )
+    if proc.returncode == 0:
+        info = json.loads(proc.stdout)
+        m = info.get("milestone", {})
+        if m and m.get("title") and m["title"] != target.meta.get("milestone_alignment"):
+            print(f"⚠  #{issue_num} is on milestone '{m['title']}', "
+                  f"track '{target.name}' aligned to '{target.meta.get('milestone_alignment')}'.")
+
+    if sources and do_move:
+        for src in sources:
+            src_issues = [n for n in (src.meta.get("github", {}).get("issues") or [])
+                          if n != issue_num]
+            src.meta.setdefault("github", {})["issues"] = src_issues
+            write_file(src.path, src.meta, src.body)
+            print(f"  ✓ Removed #{issue_num} from '{src.name}'.")
+    elif sources and not do_move:
+        names = ", ".join(f"'{t.name}'" for t in sources)
+        print(f"ℹ #{issue_num} still listed in {names} — re-run with --move to relocate.")
+
+    write_file(target.path, target.meta, target.body)
+    print(f"✓ Slotted #{issue_num} into '{target.name}'.")
+    return 0

package/skills/work-plan/commands/suggest_priorities.py

@@ -0,0 +1,132 @@
+"""suggest-priorities subcommand: prepare batch for AI labeling.
+
+Two-step:
+1. CLI fetches all unlabeled open issues, writes JSON batch + prints prompt
+2. Agent fills priorities into ~/.claude/work-plan/cache/priorities.answers.json
+3. Run with --apply to apply via gh
+"""
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from lib.config import load_config, ConfigError
+from lib.scratch import cache_dir
+
+
+def _batch_path() -> Path:
+    return cache_dir() / "priorities.json"
+PROMPT_TEMPLATE = """\
+For each GitHub issue below, suggest a priority label (P0/P1/P2/P3) based on
+title, milestone, and labels. Return JSON: [{"number": N, "priority": "P0"}, ...]
+
+Heuristics:
+- P0: launch-critical bugs/features tagged for v0.4.0 or v1.0.0 with urgent verbs (blocks, breaks, must)
+- P1: important but not blocking; v0.4.0/v1.0.0 features
+- P2: should ship eventually; v1.0.0 nice-to-haves, v2.0.0 features
+- P3: backlog; long-tail polish, parked work
+
+Skip issues with insufficient signal. Output ONLY valid JSON.
+
+Issues:
+"""
+
+
+def run(args: list[str]) -> int:
+    apply_mode = "--apply" in args
+    repo_arg = next((a for a in args if a.startswith("--repo=")), None)
+
+    try:
+        cfg = load_config()
+    except ConfigError as e:
+        print(f"ERROR: {e}")
+        return 1
+
+    if apply_mode:
+        return _apply(cfg)
+
+    repos = list(cfg["repos"].keys())
+    if repo_arg:
+        repo_folder = repo_arg.split("=", 1)[1]
+        repos = [repo_folder]
+    elif len(repos) > 1:
+        print("Multiple repos in config. Specify with --repo=<folder-name>.")
+        return 1
+
+    folder = repos[0]
+    repo = cfg["repos"][folder]["github"]
+    print(f"Fetching unlabeled issues in {repo}...")
+
+    proc = subprocess.run(
+        ["gh", "issue", "list", "--repo", repo,
+         "--state", "open", "--limit", "100",
+         "--json", "number,title,milestone,labels,url"],
+        capture_output=True, text=True,
+    )
+    if proc.returncode != 0:
+        print(f"ERROR fetching issues: {proc.stderr}")
+        return 1
+    all_issues = json.loads(proc.stdout) if proc.stdout.strip() else []
+
+    unlabeled = [
+        i for i in all_issues
+        if not any(l["name"].startswith("priority/") for l in i.get("labels", []))
+    ]
+    if not unlabeled:
+        print("All open issues already have priority labels.")
+        return 0
+
+    batch_path = _batch_path()
+    batch_path.write_text(json.dumps({"repo": repo, "issues": unlabeled}, indent=2))
+    print(f"Wrote {len(unlabeled)} issues to {batch_path}")
+    print()
+    print("=" * 60)
+    print(PROMPT_TEMPLATE)
+    for i in unlabeled:
+        m = i.get("milestone", {})
+        m_title = m.get("title", "—") if m else "—"
+        labels = [l["name"] for l in i.get("labels", [])]
+        print(f"#{i['number']} [{m_title}] [{','.join(labels) or 'no-labels'}] {i['title']}")
+    print("=" * 60)
+    print()
+    print(f"After agent returns JSON, save to {batch_path.with_suffix('.answers.json')}")
+    print(f"Then run: python3 ~/.claude/skills/work-plan/work_plan.py suggest-priorities --apply")
+    return 0
+
+
+def _apply(cfg: dict) -> int:
+    batch_path = _batch_path()
+    answers_path = batch_path.with_suffix(".answers.json")
+    if not answers_path.exists():
+        print(f"ERROR: {answers_path} not found. Run without --apply first.")
+        return 1
+    if not batch_path.exists():
+        print(f"ERROR: {batch_path} not found.")
+        return 1
+    batch = json.loads(batch_path.read_text())
+    repo = batch["repo"]
+    allowed_repos = {entry.get("github") for entry in cfg.get("repos", {}).values()}
+    if repo not in allowed_repos:
+        print(f"ERROR: batch repo '{repo}' not in config.yml repos.")
+        return 1
+    answers = json.loads(answers_path.read_text())
+
+    print(f"Applying {len(answers)} priority labels to {repo}...")
+    for ans in answers:
+        num = ans["number"]
+        priority = ans["priority"]
+        if priority not in ("P0", "P1", "P2", "P3"):
+            print(f"  SKIP #{num}: invalid priority '{priority}'")
+            continue
+        proc = subprocess.run(
+            ["gh", "issue", "edit", str(num),
+             "--repo", repo,
+             "--add-label", f"priority/{priority}"],
+            capture_output=True, text=True,
+        )
+        if proc.returncode == 0:
+            print(f"  ✓ #{num} → priority/{priority}")
+        else:
+            print(f"  ✗ #{num}: {proc.stderr.strip()}")
+    print("Done.")
+    return 0