naudachu
091dceec1d
An issue was a Gitea row that happened to be cached locally: its identity was the tracker's number (42.md), its dependencies were tracker numbers (depends: [#12]), and a local issue existed only as a draft that push deleted on success. Nothing could be planned or tracked without a tracker. Split into layers, with knowledge flowing one way: skills/issue DOMAIN what an issue is: format, validation, dep graph ^ offline; stdlib imports only, no subprocess | imports skills/sync BRIDGE map.py md <-> Gitea JSON, pure, no I/O _gitea.py login pin, api, pagination, filters skills/use REFERENCE tea CLI docs for non-issue entities skills/issue never imports skills/sync. Delete the sync layer and the domain keeps working. Identity is now a slug derived from the title (wire-sqlc-appclick.md) and is stable across retitles and pushes. Tracker numbers live in a `gitea:` field, never in a file name and never in `depends:`; the pair is indexed in .remote.json, which is a cache over the files, not a second source of truth. Behavior changes: - Pushing is additive. The file is never deleted; it gains gitea:/url:/ synced: and origin: flips from local to gitea. `origin: local` is a durable state, not a pending one. - Pushes go in topological order so dependencies get numbers first. - The dependency graph is computed offline from `depends:` metadata; body prose is passed through unchanged in both directions rather than being rewritten between slugs and #N. - `origin` is domain-owned (whether work exists elsewhere is a fact about the work); the handle and how to reach it stay with sync. Script moves: issue_get.py -> sync/pull.py issue_push.py -> sync/push.py issue_list.py -> sync/remote.py issue_index.py -> issue/issue_index.py _tea.py -> split into issue/issue.py, sync/map.py, sync/_gitea.py New: issue/issue_new.py, issue/issue_check.py, issue/issue_tree.py, and sync/comment.py — comment posting was the last issue operation still hand-rolled through raw `tea api`. references/issue-format.md moves to skills/issue/references/format.md; label hex colors move out of it into map.py, since a color is how a tracker paints a chip, not what an issue is. Verified: offline path end to end (new, check, tree, index, push --dry-run) and read-only against Gitea (remote listing, pull with mapping, comment guard). Write paths of push.py and comment.py are not exercised here. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
97 lines
3.4 KiB
Python
97 lines
3.4 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
issue_tree.py — draw the dependency graph of the local store. Offline.
|
|
|
|
Edges come from the `depends:` metadata, which is the authoritative edge list;
|
|
prose in the body is never walked. Because the graph is slugs all the way down,
|
|
this works identically for issues that were never pushed anywhere.
|
|
|
|
issue_tree.py every root (nothing depends on it)
|
|
issue_tree.py wire-sqlc-appclick one subtree
|
|
issue_tree.py --depth 2 --write
|
|
|
|
Downwards is what this draws (what an issue depends on). The other direction is
|
|
a grep, not a flag:
|
|
|
|
grep -ln 'depends:.*migrate-schema' tmp/issues/*.md
|
|
"""
|
|
import argparse
|
|
import os
|
|
import sys
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
import issue # noqa: E402
|
|
|
|
|
|
def label(id, issues, seen, edges):
|
|
iss = issues.get(id)
|
|
if not iss:
|
|
return "%s (not in the store)" % id
|
|
tail = " (see above)" if id in seen and edges.get(id) else ""
|
|
return "%s [%s] %s — %s %s.md%s" % (
|
|
id, iss.type or "-", iss.title, iss.state, id, tail)
|
|
|
|
|
|
def render(roots, issues, edges, depth):
|
|
lines, seen = [], set()
|
|
|
|
def walk(id, prefix, is_last, is_root, level):
|
|
connector = "" if is_root else ("└── " if is_last else "├── ")
|
|
lines.append(prefix + connector + label(id, issues, seen, edges))
|
|
if id in seen or level >= depth:
|
|
return
|
|
seen.add(id)
|
|
kids = edges.get(id) or []
|
|
child_prefix = prefix if is_root else prefix + (" " if is_last else "│ ")
|
|
for i, k in enumerate(kids):
|
|
walk(k, child_prefix, i == len(kids) - 1, False, level + 1)
|
|
|
|
for r in roots:
|
|
if r in seen:
|
|
continue # already drawn as somebody's child — one tree, not two
|
|
walk(r, "", True, True, 0)
|
|
lines.append("")
|
|
|
|
head = roots[0] if len(roots) == 1 else "%d root(s)" % len(roots)
|
|
out = "# Dependency tree — %s\n\n```\n%s```\n" % (head, "\n".join(lines))
|
|
cycles = issue.find_cycles(edges)
|
|
if cycles:
|
|
out += "\n## Cycles\n\n" + "\n".join("- %s" % " -> ".join(c) for c in cycles) + "\n"
|
|
return out
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser(description="Draw the local dependency graph (offline)")
|
|
ap.add_argument("ids", nargs="*", help="roots (default: issues nothing depends on)")
|
|
ap.add_argument("--depth", type=int, default=6, help="max depth (default: 6)")
|
|
ap.add_argument("--write", action="store_true",
|
|
help="also write tmp/issues/tree-<slug>.md")
|
|
ap.add_argument("--out", default=issue.ISSUE_ROOT, help="store root (default: tmp/issues)")
|
|
args = ap.parse_args()
|
|
|
|
issues = issue.load_all(args.out)
|
|
if not issues:
|
|
sys.exit("issue_tree.py: store %s is empty" % args.out)
|
|
edges = issue.graph(issues)
|
|
|
|
roots = args.ids
|
|
for r in roots:
|
|
if r not in issues:
|
|
sys.exit("issue_tree.py: no issue %r in %s" % (r, args.out))
|
|
if not roots:
|
|
depended_on = {d for deps in edges.values() for d in deps}
|
|
roots = sorted(i for i in issues if i not in depended_on) or sorted(issues)
|
|
|
|
text = render(roots, issues, edges, args.depth)
|
|
sys.stdout.write(text)
|
|
if args.write:
|
|
slug = roots[0] if len(roots) == 1 else "all"
|
|
path = os.path.join(args.out, "tree-%s.md" % slug)
|
|
with open(path, "w") as f:
|
|
f.write(text)
|
|
print("written: %s" % path)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|