notegraph 0.2.0__py3-none-any.whl

note_cli/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: note
+description: Use when working on a repo that has a note store — record each attempt in the decision graph and score it against the project's goal criteria before moving on.
+---
+
+# note
+
+`note` keeps one decision graph and one goal per repo, in `<repo>/.git/notes/`.
+Every git worktree of the repo shares that store, so what you record is visible
+to agents working other branches in parallel.
+
+## The loop
+
+1. **Read the standard.** `note goal` prints the final goal and its weighted
+   criteria, each with a one-line rubric. Score against those rubrics, never
+   against a standard you invent.
+2. **Do the work.**
+3. **Record the attempt.** `note add "what you tried" --type attempt --tags arm-b1`
+   prints its id. The current branch is tagged automatically.
+4. **Point it at a goal.** `note link <attempt> <goal> --rel targets`. A scored
+   attempt that targets nothing shows up under `(unassigned)` in `note goals` —
+   that is a linking mistake, not a category of work.
+5. **Score it.** `note score <attempt> consistency=0.8 legibility=0.6 --note "why"`.
+   Each criterion is 0.0–1.0. The `--note` is where the justification goes;
+   a score with no stated reason cannot be argued with later.
+
+6. **Confirm the loop closed.** `note check` exits nonzero while any attempt
+   targets no goal or carries no score, and names them. Run it before you
+   consider a piece of work done.
+
+## Rules
+
+- **Never score a goal node.** Scores go on attempts. A goal's score is derived
+  as the maximum over the attempts that target it.
+- **Re-scoring replaces wholesale.** A criterion left out of a new score line
+  counts as 0, not as its previous value. Submit the full set every time.
+- **Only criteria named in the current goal are accepted.** If a rubric no
+  longer fits the work, change the goal (`note goal --set ... --criterion ...`)
+  rather than inventing a criterion at score time.
+- **Totals are recomputed against the current goal.** When the goal moves, old
+  attempts visibly drop until they are re-judged. That is correct.
+
+## Correcting a node
+
+Nothing is ever edited in place. `note supersede <id> "corrected content"`
+appends a new node and an edge `old -superseded_by-> new`, which moves the
+frontier to the new node and takes the old one out of `note tails`. Type and
+tags are inherited unless you pass new ones.
+
+## Orientation
+
+- `note status` — goal, criteria, per-goal best and the frontier, in one screen
+- `note check` — what still breaks the loop (exit 1 if anything does)
+- `note goals` — per-goal best attempt and which one set it
+- `note tails` — the working frontier (goal nodes excluded)
+- `note trace <id>` — what an attempt ultimately feeds
+- `note trace <goal-id> --up` — which attempts feed a goal
+- `note search <keyword>` — find a node to start from

note_cli/__init__.py

@@ -0,0 +1,7 @@
+"""note — a decision-graph and goal notebook for a git repo."""
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("notegraph")
+except PackageNotFoundError:          # running from a source tree, not installed
+    __version__ = "0+unknown"

note_cli/_cli_check.py

@@ -0,0 +1,103 @@
+"""End-to-end drive of every command. Run: python -m note_cli._cli_check"""
+import os
+import subprocess
+import tempfile
+
+from note_cli.cli import main
+
+
+def run(*args):
+    main(list(args))
+
+
+def main_check():
+    os.chdir(tempfile.mkdtemp())
+    subprocess.run(["git", "init", "-q"], check=True)
+
+    try:
+        run("heads")
+        raise AssertionError("expected SystemExit before init")
+    except SystemExit as e:
+        assert "note init" in str(e), e
+
+    run("init")
+    run("init")                                   # idempotent, must not raise
+    run("goal", "--set", "ship it",
+        "--criterion", "consistency:3:style holds: across seeds",
+        "--criterion", "legibility:1:readable")
+    run("goal")
+    run("goal", "--history")
+
+    run("add", "legible text", "--type", "goal")           # id 1
+    run("add", "arm B1_P1", "--type", "attempt", "--tags", "p1,ref")   # id 2
+    run("add", "arm B1_P2", "--type", "attempt")           # id 3
+    run("link", "2", "1", "--rel", "targets")
+    run("link", "3", "1", "--rel", "targets")
+    run("link", "2", "3", "--rel", "leads_to")
+    run("score", "2", "consistency=0.4")
+    run("score", "3", "consistency=1.0", "legibility=0.8", "--note", "best so far")
+    run("goals")
+    run("show", "3")        # 2 -leads_to-> 3 and nothing else: not yet a merge
+    run("add", "arm B1_P3", "--type", "attempt")           # id 4
+    run("link", "4", "3", "--rel", "leads_to")
+    run("show", "3")        # now in-degree 2: must print the merge-point line
+    run("search", "B1")
+    run("trace", "2")
+    run("trace", "1", "--up")
+    run("heads")
+    run("tails")
+    run("graph")
+    run("graph", "--from", "2", "--depth", "1")
+
+    from note_cli import store
+    assert (store.store_dir() / "graph.dot").exists()
+
+    # `check` must exit nonzero while an attempt is untargeted or unscored
+    run("add", "unlinked try", "--type", "attempt")         # id 5
+    try:
+        run("check")
+        raise AssertionError("expected SystemExit(1) with a loose attempt")
+    except SystemExit as e:
+        assert e.code == 1, e.code
+    run("link", "5", "1", "--rel", "targets")
+    try:
+        run("check")
+        raise AssertionError("expected SystemExit(1) with an unscored attempt")
+    except SystemExit as e:
+        assert e.code == 1, e.code
+    run("score", "5", "consistency=0.1")
+    # node 4 was added earlier as a merge-point helper and never targeted a
+    # goal — `check` caught that, which is the point of the command
+    run("link", "4", "1", "--rel", "targets")
+    run("score", "4", "consistency=0.5")
+    run("check")                                            # now clean: must not raise
+
+    # supersede: the new node becomes the frontier, the old drops out
+    before = {n["id"] for n in graphtails()}
+    run("supersede", "5", "unlinked try, corrected")         # id 6
+    after = {n["id"] for n in graphtails()}
+    assert 5 not in after and 6 in after, (before, after)
+
+    run("status")
+
+    # --version must report what the package metadata says, so a bug report
+    # names a real release
+    from note_cli import __version__
+    try:
+        run("--version")
+        raise AssertionError("argparse should exit after --version")
+    except SystemExit as e:
+        assert e.code == 0, e.code
+    import importlib.metadata as md
+    assert __version__ == md.version("notegraph"), (__version__, md.version("notegraph"))
+
+    print("cli: ok")
+
+
+def graphtails():
+    from note_cli import graph as g, store
+    return g.tails(store.read("nodes.jsonl"), store.read("edges.jsonl"))
+
+
+if __name__ == "__main__":
+    main_check()

note_cli/_concurrency_check.py

@@ -0,0 +1,40 @@
+"""Two processes adding under the lock must produce two distinct ids.
+
+Separate from store.demo() because it forks; run it directly:
+    python -m note_cli._concurrency_check
+"""
+import os
+import subprocess
+import tempfile
+
+from note_cli import store
+
+
+def main():
+    d = tempfile.mkdtemp()
+    os.chdir(d)
+    subprocess.run(["git", "init", "-q"], check=True)
+    store.init()
+
+    reads, writes = zip(*(os.pipe() for _ in range(8)))
+    for i, w in enumerate(writes):
+        if os.fork() == 0:
+            nid = store.add_node(f"child {i}")
+            os.write(w, str(nid).encode())
+            os._exit(0)
+    for w in writes:
+        os.close(w)
+    ids = []
+    for r in reads:
+        ids.append(int(os.read(r, 16)))
+        os.close(r)
+    for _ in writes:
+        os.wait()
+
+    assert len(set(ids)) == len(ids), f"duplicate ids under concurrency: {sorted(ids)}"
+    assert sorted(ids) == list(range(1, len(ids) + 1)), sorted(ids)
+    print("concurrency: ok")
+
+
+if __name__ == "__main__":
+    main()

note_cli/cli.py

@@ -0,0 +1,306 @@
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+if not hasattr(__import__("os"), "fork"):
+    # store.py locks with fcntl.flock, which Windows has no equivalent of.
+    # pip installs regardless of the POSIX classifier, so say so plainly
+    # instead of letting `import fcntl` raise ModuleNotFoundError.
+    sys.exit("note requires a POSIX system (Linux, macOS, WSL): it locks the "
+             "store with fcntl.flock, which Windows does not provide.")
+
+from note_cli import __version__
+from note_cli import goal as goalmod
+from note_cli import graph as graphmod
+from note_cli import render, store
+
+
+def _nodes_edges():
+    return store.read("nodes.jsonl"), store.read("edges.jsonl")
+
+
+def _line(n):
+    tags = f" [{','.join(n['tags'])}]" if n.get("tags") else ""
+    return f"  {n['id']:>4}  {n['type']:<10} {n['content']}{tags}  ({n.get('branch')})"
+
+
+def _print_nodes(title, nodes):
+    print(title)
+    for n in nodes:
+        print(_line(n))
+    if not nodes:
+        print("  (none)")
+
+
+def cmd_init(args):
+    path, created = store.init()
+    print(f"store: {path}")
+    print(f"created: {', '.join(created)}" if created else "already initialized")
+
+
+def cmd_goal(args):
+    if args.history:
+        for i, g in enumerate(goalmod.history(), 1):
+            print(f"{i}. [{g['timestamp']}] {g['goal']}")
+            for c in g["criteria"]:
+                print(f"     {c['weight']:<5} {c['name']}: {c['rubric']}")
+        return
+    if args.set is not None:
+        criteria = [goalmod.parse_criterion(c) for c in (args.criterion or [])]
+        if not criteria:
+            raise SystemExit("--set needs at least one --criterion name:weight:rubric")
+        goalmod.set_goal(args.set, criteria)
+        print(f"goal set, {len(criteria)} criteria")
+        return
+    g = goalmod.current_goal()
+    if not g:
+        raise SystemExit("no goal set — run `note goal --set ... --criterion ...`")
+    print(g["goal"])
+    denom = sum(c["weight"] for c in g["criteria"])
+    for c in g["criteria"]:
+        print(f"  {c['weight'] / denom:>5.0%}  {c['name']}: {c['rubric']}")
+
+
+def cmd_add(args):
+    tags = args.tags.split(",") if args.tags else []
+    print(store.add_node(args.content, type=args.type, tags=tags))
+
+
+def cmd_link(args):
+    store.add_edge(args.src, args.dst, args.rel)
+    print(f"{args.src} -{args.rel}-> {args.dst}")
+
+
+def cmd_score(args):
+    scores = {}
+    for pair in args.pairs:
+        if "=" not in pair:
+            raise SystemExit(f"want name=value, got {pair!r}")
+        k, v = pair.split("=", 1)
+        try:
+            scores[k] = float(v)
+        except ValueError:
+            raise SystemExit(f"{k}: {v!r} is not a number")
+        if not 0.0 <= scores[k] <= 1.0:
+            raise SystemExit(f"{k}: scores are 0.0-1.0, got {scores[k]}")
+    print(f"{goalmod.add_score(args.id, scores, args.note):.3f}")
+
+
+def cmd_goals(args):
+    rows, unassigned = goalmod.rollup()
+    for n, best in rows:
+        if best:
+            total, aid, ts = best
+            print(f"{n['id']:>4}  {n['content']}\n        best {total:.3f} from #{aid} ({ts})")
+        else:
+            print(f"{n['id']:>4}  {n['content']}\n        (no scored attempts)")
+    if unassigned:
+        print("\n(unassigned) — scored but targeting no goal:")
+        for n, total, ts in unassigned:
+            print(f"{n['id']:>4}  {total:.3f}  {n['content']} ({ts})")
+
+
+def cmd_supersede(args):
+    tags = args.tags.split(",") if args.tags else []
+    print(store.supersede(args.id, args.content, type=args.type, tags=tags))
+
+
+def cmd_check(args):
+    """Exit nonzero while any attempt is loose, so a hook or an agent can gate
+    on it rather than trusting itself to remember the loop."""
+    untargeted, unscored = goalmod.unfinished()
+    if not untargeted and not unscored:
+        print("clean: every attempt targets a goal and carries a score")
+        return
+    if untargeted:
+        print("attempts targeting no goal — `note link <id> <goal> --rel targets`:")
+        for n in untargeted:
+            print(_line(n))
+    if unscored:
+        print("attempts with no score — `note score <id> name=0.0-1.0`:")
+        for n in unscored:
+            print(_line(n))
+    raise SystemExit(1)
+
+
+def cmd_status(args):
+    g = goalmod.current_goal()
+    if not g:
+        print("no goal set — run `note goal --set ... --criterion ...`")
+    else:
+        print(g["goal"])
+        denom = sum(c["weight"] for c in g["criteria"])
+        for c in g["criteria"]:
+            print(f"  {c['weight'] / denom:>5.0%}  {c['name']}: {c['rubric']}")
+    print()
+    cmd_goals(args)
+    nodes, edges = _nodes_edges()
+    _print_nodes("\nfrontier:", graphmod.tails(nodes, edges))
+
+
+def cmd_show(args):
+    nodes, edges = _nodes_edges()
+    by_id = {n["id"]: n for n in nodes}
+    if args.id not in by_id:
+        raise SystemExit(f"no node {args.id}")
+    n = by_id[args.id]
+    print(f"#{n['id']} [{n['type']}] {n['content']}")
+    print(f"  tags: {', '.join(n.get('tags') or []) or '-'}")
+    print(f"  branch: {n.get('branch')}   {n['timestamp']}")
+    s = goalmod.latest_scores().get(args.id)
+    if s:
+        g = goalmod.current_goal()
+        total = goalmod.weighted_total(s["scores"], g["criteria"] if g else [])
+        print(f"  score: {total:.3f}  {s['scores']}  ({s['timestamp']})")
+        if s.get("note"):
+            print(f"         {s['note']}")
+    if args.id in {m["id"] for m in graphmod.merges(nodes, edges)}:
+        print("  (merge point: two or more lines of work converge here)")
+    for e in edges:
+        if e["from"] == args.id:
+            print(f"  -> {e['to']:<4} {e['relation']}")
+        if e["to"] == args.id:
+            print(f"  <- {e['from']:<4} {e['relation']}")
+
+
+def cmd_search(args):
+    k = args.keyword.lower()
+    nodes, _ = _nodes_edges()
+    _print_nodes(f"matches for {args.keyword!r}:",
+                 [n for n in nodes
+                  if k in n["content"].lower()
+                  or any(k in t.lower() for t in n.get("tags") or [])])
+
+
+def cmd_trace(args):
+    nodes, edges = _nodes_edges()
+    by_id = {n["id"]: n for n in nodes}
+    if args.id not in by_id:
+        raise SystemExit(f"no node {args.id}")
+
+    def show(tree, depth, rel=None):
+        nid, kids = tree
+        n = by_id.get(nid)
+        arrow = f"-{rel}-> " if rel else ""
+        print("  " * depth + f"{arrow}#{nid} {n['content'] if n else '?'}")
+        for r, kid in kids:
+            show(kid, depth + 1, r)
+
+    show(graphmod.trace(args.id, edges, args.direction), 0)
+
+
+def cmd_heads(args):
+    nodes, edges = _nodes_edges()
+    _print_nodes("heads:", graphmod.heads(nodes, edges))
+
+
+def cmd_tails(args):
+    nodes, edges = _nodes_edges()
+    _print_nodes("tails:", graphmod.tails(nodes, edges))
+
+
+def cmd_graph(args):
+    nodes, edges = _nodes_edges()
+    if args.frm is not None:
+        keep = graphmod.subgraph(args.frm, edges, args.depth)
+        nodes = [n for n in nodes if n["id"] in keep]
+        edges = [e for e in edges if e["from"] in keep and e["to"] in keep]
+    src = render.dot_source(nodes, edges, goalmod.current_goal())
+    dot_file, svg = render.write_graph(store.require_store(), src)
+    print(f"wrote {dot_file}")
+    if svg:
+        print(f"wrote {svg}")
+    else:
+        print("graphviz `dot` not found — install it to also render an .svg")
+
+
+def cmd_skill(args):
+    src = Path(__file__).parent / "SKILL.md"
+    dst = Path.home() / ".claude" / "skills" / "note" / "SKILL.md"
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(src, dst)
+    print(f"wrote {dst}")
+
+
+def build_parser():
+    p = argparse.ArgumentParser(prog="note", description=__doc__)
+    p.add_argument("--version", action="version", version=f"note {__version__}")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sub.add_parser("init", help="create the store").set_defaults(fn=cmd_init)
+
+    g = sub.add_parser("goal", help="show or set the final goal")
+    g.add_argument("--set")
+    g.add_argument("--criterion", action="append", metavar="name:weight:rubric")
+    g.add_argument("--history", action="store_true")
+    g.set_defaults(fn=cmd_goal)
+
+    a = sub.add_parser("add", help="append a node")
+    a.add_argument("content")
+    a.add_argument("--type", default="note")
+    a.add_argument("--tags")
+    a.set_defaults(fn=cmd_add)
+
+    ln = sub.add_parser("link", help="append an edge")
+    ln.add_argument("src", type=int)
+    ln.add_argument("dst", type=int)
+    ln.add_argument("--rel", required=True)
+    ln.set_defaults(fn=cmd_link)
+
+    sc = sub.add_parser("score", help="score an attempt against the goal criteria")
+    sc.add_argument("id", type=int)
+    sc.add_argument("pairs", nargs="+", metavar="name=0.0-1.0")
+    sc.add_argument("--note")
+    sc.set_defaults(fn=cmd_score)
+
+    sub.add_parser("goals", help="per-goal best attempt").set_defaults(fn=cmd_goals)
+    sub.add_parser("status", help="goal, criteria, best attempts and frontier"
+                   ).set_defaults(fn=cmd_status)
+    sub.add_parser("check", help="exit 1 if any attempt is untargeted or unscored"
+                   ).set_defaults(fn=cmd_check)
+
+    sp = sub.add_parser("supersede", help="correct a node with a new one")
+    sp.add_argument("id", type=int)
+    sp.add_argument("content")
+    sp.add_argument("--type")
+    sp.add_argument("--tags")
+    sp.set_defaults(fn=cmd_supersede)
+
+    sh = sub.add_parser("show", help="one node in full")
+    sh.add_argument("id", type=int)
+    sh.set_defaults(fn=cmd_show)
+
+    se = sub.add_parser("search", help="substring match over content and tags")
+    se.add_argument("keyword")
+    se.set_defaults(fn=cmd_search)
+
+    tr = sub.add_parser("trace", help="DFS from a node")
+    tr.add_argument("id", type=int)
+    tr.add_argument("--up", dest="direction", action="store_const", const="up")
+    tr.add_argument("--down", dest="direction", action="store_const", const="down")
+    tr.add_argument("--both", dest="direction", action="store_const", const="both")
+    tr.set_defaults(fn=cmd_trace, direction="down")
+
+    sub.add_parser("heads", help="in-degree-0 work nodes").set_defaults(fn=cmd_heads)
+    sub.add_parser("tails", help="the working frontier").set_defaults(fn=cmd_tails)
+
+    gr = sub.add_parser("graph", help="emit Graphviz DOT")
+    gr.add_argument("--from", dest="frm", type=int)
+    gr.add_argument("--depth", type=int)
+    gr.set_defaults(fn=cmd_graph)
+
+    sk = sub.add_parser("skill", help="install the agent skill")
+    sk.add_argument("--install", action="store_true", required=True)
+    sk.set_defaults(fn=cmd_skill)
+
+    return p
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    args.fn(args)
+
+
+if __name__ == "__main__":
+    main()

note_cli/goal.py

@@ -0,0 +1,213 @@
+from note_cli import store
+
+GOAL_FILE = "goal.jsonl"
+SCORE_FILE = "scores.jsonl"
+
+
+def history():
+    return store.read(GOAL_FILE)
+
+
+def current_goal():
+    """Last line in FILE ORDER wins — appends are serialized by the write
+    lock, so file order is a total order and timestamps are informational."""
+    lines = history()
+    return lines[-1] if lines else None
+
+
+def set_goal(text, criteria):
+    with store.write_lock():
+        store.append(GOAL_FILE, {"goal": text, "criteria": criteria,
+                                 "timestamp": store.now()})
+
+
+def parse_criterion(s):
+    parts = s.split(":", 2)          # first two colons only; rubrics contain colons
+    if len(parts) != 3:
+        raise SystemExit(f"--criterion wants name:weight:rubric, got {s!r}")
+    name, weight, rubric = parts
+    try:
+        weight = float(weight)
+    except ValueError:
+        raise SystemExit(f"criterion {name!r}: weight {weight!r} is not a number")
+    return {"name": name, "weight": weight, "rubric": rubric}
+
+
+def weighted_total(scores, criteria):
+    """Always computed against the CURRENT criteria. A score line that lacks a
+    criterion contributes 0 for it and that criterion's weight still counts in
+    the normalization, so an attempt judged under an older standard visibly
+    drops — the bar moved and it has not been re-judged against it."""
+    denom = sum(c["weight"] for c in criteria)
+    if not denom:
+        return 0.0
+    return sum(c["weight"] * scores.get(c["name"], 0.0) for c in criteria) / denom
+
+
+def latest_scores():
+    """node id -> its last score line. A re-score replaces the previous
+    judgement WHOLESALE; merging would make a node's real score depend on the
+    order of every past line."""
+    out = {}
+    for line in store.read(SCORE_FILE):
+        out[line["node"]] = line
+    return out
+
+
+def add_score(nid, scores, note=None):
+    with store.write_lock():
+        nodes = {n["id"]: n for n in store.read("nodes.jsonl")}
+        if nid not in nodes:
+            raise SystemExit(f"no node {nid}")
+        if nodes[nid]["type"] == "goal":
+            raise SystemExit(f"node {nid} is a goal — scores belong on attempts")
+        g = current_goal()
+        if not g:
+            raise SystemExit("no goal set — run `note goal --set ...`")
+        known = {c["name"] for c in g["criteria"]}
+        unknown = sorted(set(scores) - known)
+        if unknown:
+            raise SystemExit(f"unknown criteria {unknown}; goal has {sorted(known)}")
+        store.append(SCORE_FILE, {"node": nid, "scores": scores, "note": note,
+                                  "timestamp": store.now()})
+        return weighted_total(scores, g["criteria"])
+
+
+def rollup():
+    """Per-goal best attempt, plus scored attempts that target nothing.
+
+    Max, not mean or latest: the working pattern is "run several arms, adopt
+    the best one". A mean would dilute a winning arm with its failed siblings.
+    """
+    nodes = store.read("nodes.jsonl")
+    edges = store.read("edges.jsonl")
+    g = current_goal()
+    criteria = g["criteria"] if g else []
+    latest = latest_scores()
+    by_id = {n["id"]: n for n in nodes}
+
+    targeted, assigned = {}, set()
+    for e in edges:
+        if e["relation"] == "targets":
+            targeted.setdefault(e["to"], []).append(e["from"])
+            assigned.add(e["from"])
+
+    rows = []
+    for n in nodes:
+        if n["type"] != "goal":
+            continue
+        best = None
+        for aid in targeted.get(n["id"], ()):
+            if aid not in latest:
+                continue
+            cand = (weighted_total(latest[aid]["scores"], criteria), aid,
+                    latest[aid]["timestamp"])
+            if best is None or cand[0] > best[0]:
+                best = cand
+        rows.append((n, best))
+
+    # a scored attempt with no goal is a linking mistake, not a category of
+    # work — it must not simply vanish from the rollup
+    unassigned = [(by_id[i], weighted_total(latest[i]["scores"], criteria),
+                   latest[i]["timestamp"])
+                  for i in sorted(latest) if i not in assigned and i in by_id]
+    return rows, unassigned
+
+
+def unfinished():
+    """Attempts that break the loop, as (untargeted, unscored).
+
+    Only `attempt` nodes are held to it — a decision or a plain note has
+    nothing to score. This is what `note check` exits nonzero on, so a hook
+    or an agent can gate on it instead of trusting itself to remember.
+    """
+    nodes = store.read("nodes.jsonl")
+    edges = store.read("edges.jsonl")
+    latest = latest_scores()
+    targeting = {e["from"] for e in edges if e["relation"] == "targets"}
+    untargeted, unscored = [], []
+    for n in nodes:
+        if n["type"] != "attempt":
+            continue
+        if n["id"] not in targeting:
+            untargeted.append(n)
+        elif n["id"] not in latest:
+            unscored.append(n)
+    return untargeted, unscored
+
+
+def demo():
+    import os, subprocess, tempfile
+    os.chdir(tempfile.mkdtemp())
+    subprocess.run(["git", "init", "-q"], check=True)
+    store.init()
+
+    # rubric text routinely contains a colon: split on the first two only
+    c = parse_criterion("legibility:0.3:readable at 512px: no clipping")
+    assert c == {"name": "legibility", "weight": 0.3,
+                 "rubric": "readable at 512px: no clipping"}, c
+    try:
+        parse_criterion("badinput")
+        raise AssertionError("expected SystemExit")
+    except SystemExit:
+        pass
+
+    crit = [{"name": "consistency", "weight": 3.0, "rubric": "style holds"},
+            {"name": "legibility", "weight": 1.0, "rubric": "readable"}]
+    set_goal("ship an education image generator", crit)
+    assert current_goal()["goal"] == "ship an education image generator"
+
+    # weights need not sum to 1 — they are normalized
+    assert weighted_total({"consistency": 1.0, "legibility": 1.0}, crit) == 1.0
+    assert weighted_total({"consistency": 1.0}, crit) == 0.75
+    assert weighted_total({}, crit) == 0.0
+
+    g = store.add_node("legible text", type="goal")
+    a1 = store.add_node("arm B1_P1", type="attempt")
+    a2 = store.add_node("arm B1_P2", type="attempt")
+    orphan = store.add_node("unlinked try", type="attempt")
+    store.add_edge(a1, g, "targets")
+    store.add_edge(a2, g, "targets")
+
+    assert round(add_score(a1, {"consistency": 0.4}), 9) == 0.3   # 3*0.4/4 is not exact
+    assert add_score(a2, {"consistency": 1.0, "legibility": 1.0}) == 1.0
+    add_score(orphan, {"legibility": 1.0})
+
+    # re-score replaces wholesale: the omitted criterion counts 0, not its old value
+    assert add_score(a2, {"legibility": 1.0}) == 0.25
+    assert latest_scores()[a2]["scores"] == {"legibility": 1.0}
+
+    try:
+        add_score(g, {"consistency": 1.0})
+        raise AssertionError("expected SystemExit for scoring a goal node")
+    except SystemExit as e:
+        assert "goal" in str(e), e
+    try:
+        add_score(a1, {"nonesuch": 1.0})
+        raise AssertionError("expected SystemExit for an unknown criterion")
+    except SystemExit as e:
+        assert "nonesuch" in str(e), e
+
+    rows, unassigned = rollup()
+    assert len(rows) == 1
+    node, best = rows[0]
+    assert node["id"] == g
+    assert round(best[0], 9) == 0.3 and best[1] == a1, best   # max; a2 fell on re-score
+    assert [u[0]["id"] for u in unassigned] == [orphan], unassigned
+
+    # orphan targets nothing; a1/a2 target g and are scored
+    untargeted, unscored = unfinished()
+    assert [n["id"] for n in untargeted] == [orphan], untargeted
+    assert unscored == [], unscored
+
+    fresh = store.add_node("just tried, not judged yet", type="attempt")
+    store.add_edge(fresh, g, "targets")
+    untargeted, unscored = unfinished()
+    assert [n["id"] for n in untargeted] == [orphan], untargeted
+    assert [n["id"] for n in unscored] == [fresh], unscored
+
+    print("goal: ok")
+
+
+if __name__ == "__main__":
+    demo()

note_cli/graph.py

@@ -0,0 +1,128 @@
+TARGETS = "targets"
+GOAL_TYPE = "goal"
+
+
+def adjacency(edges):
+    """Work-graph adjacency. `targets` edges are excluded so that merge
+    detection (in-degree > 1) sees only real convergence of work."""
+    out, inn = {}, {}
+    for e in edges:
+        if e["relation"] == TARGETS:
+            continue
+        out.setdefault(e["from"], []).append(e["to"])
+        inn.setdefault(e["to"], []).append(e["from"])
+    return out, inn
+
+
+def heads(nodes, edges):
+    _, inn = adjacency(edges)
+    return [n for n in nodes if n["type"] != GOAL_TYPE and not inn.get(n["id"])]
+
+
+def tails(nodes, edges):
+    """The working frontier.
+
+    Two filters, not one. Dropping `targets` edges is not enough: a goal node
+    whose only edges are inbound `targets` becomes isolated in the filtered
+    graph — in-degree 0 AND out-degree 0 — so it would surface in heads and
+    tails both. Skipping goal-typed nodes is what keeps this list meaningful.
+    """
+    out, _ = adjacency(edges)
+    return [n for n in nodes if n["type"] != GOAL_TYPE and not out.get(n["id"])]
+
+
+def merges(nodes, edges):
+    _, inn = adjacency(edges)
+    return [n for n in nodes if len(inn.get(n["id"], ())) > 1]
+
+
+def _directed(edges, direction):
+    """Neighbour map over ALL edges — traversal ignores the topology filters."""
+    fwd, bwd = {}, {}
+    for e in edges:
+        fwd.setdefault(e["from"], []).append((e["to"], e["relation"]))
+        bwd.setdefault(e["to"], []).append((e["from"], e["relation"]))
+    if direction == "down":
+        return [fwd]
+    if direction == "up":
+        return [bwd]
+    return [fwd, bwd]
+
+
+def trace(root, edges, direction="down"):
+    """DFS from root, as nested (node_id, [(relation, child), ...]).
+
+    The seen-set is per path, not global: it stops cycles from recursing
+    forever while still letting a node legitimately reachable by two routes
+    show under both.
+    """
+    maps = _directed(edges, direction)
+
+    def walk(nid, seen):
+        if nid in seen:
+            return (nid, [])
+        seen = seen | {nid}
+        kids = [(rel, walk(m, seen)) for mp in maps for m, rel in mp.get(nid, ())]
+        return (nid, kids)
+
+    return walk(root, frozenset())
+
+
+def subgraph(root, edges, depth):
+    """Node ids reachable downward from root within `depth` hops (None = all).
+    Follows every relation, `targets` included."""
+    (fwd,) = _directed(edges, "down")
+    seen, frontier, hops = {root}, [root], 0
+    while frontier and (depth is None or hops < depth):
+        nxt = []
+        for nid in frontier:
+            for m, _rel in fwd.get(nid, ()):
+                if m not in seen:
+                    seen.add(m)
+                    nxt.append(m)
+        frontier, hops = nxt, hops + 1
+    return seen
+
+
+def demo():
+    nodes = [
+        {"id": 1, "type": "note"},
+        {"id": 2, "type": "note"},
+        {"id": 3, "type": "note"},
+        {"id": 4, "type": "goal"},
+    ]
+    edges = [
+        {"from": 1, "to": 3, "relation": "leads_to"},
+        {"from": 2, "to": 3, "relation": "leads_to"},
+        {"from": 3, "to": 4, "relation": "targets"},
+        {"from": 1, "to": 4, "relation": "targets"},
+    ]
+
+    out, inn = adjacency(edges)
+    assert out == {1: [3], 2: [3]}, out          # targets edges excluded
+    assert inn == {3: [1, 2]}, inn
+
+    assert [n["id"] for n in heads(nodes, edges)] == [1, 2]
+    # 4 is a goal and is isolated once targets are dropped: it must appear in
+    # NEITHER heads nor tails, which edge-filtering alone would not achieve
+    assert [n["id"] for n in tails(nodes, edges)] == [3]
+    assert [n["id"] for n in merges(nodes, edges)] == [3]
+
+    # trace follows targets; topology filters do not apply to traversal
+    assert trace(1, edges) == (1, [("leads_to", (3, [("targets", (4, []))])),
+                                   ("targets", (4, []))])
+    assert trace(4, edges, "up") == (4, [("targets", (3, [("leads_to", (1, [])),
+                                                         ("leads_to", (2, []))])),
+                                        ("targets", (1, []))])
+
+    cyc = [{"from": 1, "to": 2, "relation": "r"}, {"from": 2, "to": 1, "relation": "r"}]
+    assert trace(1, cyc) == (1, [("r", (2, [("r", (1, []))]))])   # terminates
+
+    assert subgraph(1, edges, None) == {1, 3, 4}
+    assert subgraph(1, edges, 1) == {1, 3, 4}
+    assert subgraph(1, edges, 0) == {1}
+    print("graph: ok")
+
+
+if __name__ == "__main__":
+    demo()

note_cli/render.py

@@ -0,0 +1,76 @@
+import shutil
+import subprocess
+
+MAX_LABEL = 40
+
+
+def _label(text):
+    """DOT string literals cannot hold a double quote; swap for a single."""
+    t = text[:MAX_LABEL].replace('"', "'").replace("\n", " ")
+    return t + ("\u2026" if len(text) > MAX_LABEL else "")
+
+
+def dot_source(nodes, edges, goal):
+    """The final goal is drawn as a VIRTUAL node at the far right — it is
+    never stored, so goal.jsonl stays the single source of truth, but the
+    rendering shows the intended shape: attempts converge on branch goals,
+    branch goals converge on the one final goal."""
+    out = ["digraph notes {", "  rankdir=LR;"]
+    for n in nodes:
+        shape = "box" if n["type"] == "goal" else "ellipse"
+        out.append(f'  n{n["id"]} [label="{n["id"]}: {_label(n["content"])}" shape={shape}];')
+    for e in edges:
+        attrs = f'label="{e["relation"]}"'
+        if e["relation"] == "targets":
+            attrs += ", style=dashed"
+        out.append(f'  n{e["from"]} -> n{e["to"]} [{attrs}];')
+    if goal:
+        out.append(f'  FINAL [label="{_label(goal["goal"])}" shape=doubleoctagon];')
+        for n in nodes:
+            if n["type"] == "goal":
+                out.append(f'  n{n["id"]} -> FINAL [style=dashed];')
+    out.append("}")
+    return "\n".join(out) + "\n"
+
+
+def write_graph(store_path, source):
+    """Always write the .dot. Render the .svg only if `dot` is on PATH —
+    a missing graphviz is a warning, not an error."""
+    dot_file = store_path / "graph.dot"
+    dot_file.write_text(source)
+    if shutil.which("dot") is None:
+        return dot_file, None
+    svg = store_path / "graph.svg"
+    subprocess.run(["dot", "-Tsvg", str(dot_file), "-o", str(svg)], check=True)
+    return dot_file, svg
+
+
+def demo():
+    import tempfile
+    from pathlib import Path
+
+    nodes = [{"id": 1, "content": "arm B1_P2", "type": "attempt"},
+             {"id": 2, "content": "legible text", "type": "goal"}]
+    edges = [{"from": 1, "to": 2, "relation": "targets"}]
+    src = dot_source(nodes, edges, {"goal": "ship it"})
+
+    assert src.startswith("digraph notes {")
+    assert src.rstrip().endswith("}")
+    assert 'n1 [label="1: arm B1_P2"' in src
+    assert "shape=doubleoctagon" in src        # the virtual final goal
+    assert "n2 -> FINAL" in src
+    assert "n1 -> n2" in src and "style=dashed" in src
+    assert "FINAL" not in dot_source(nodes, edges, None)
+
+    # a quote in content must not break the DOT string
+    assert '\\"' not in dot_source([{"id": 9, "content": 'say "hi"', "type": "note"}], [], None)
+
+    d = Path(tempfile.mkdtemp())
+    dot_file, svg = write_graph(d, src)
+    assert dot_file == d / "graph.dot" and dot_file.read_text() == src
+    assert svg is None or svg == d / "graph.svg"
+    print("render: ok")
+
+
+if __name__ == "__main__":
+    demo()

note_cli/store.py

@@ -0,0 +1,211 @@
+import fcntl
+import json
+import os
+import subprocess
+from contextlib import contextmanager
+from datetime import datetime
+from functools import lru_cache
+from pathlib import Path
+
+FILES = ("nodes.jsonl", "edges.jsonl", "goal.jsonl", "scores.jsonl")
+
+
+def _git(*args):
+    """Run a git command, returning stripped stdout; SystemExit on failure."""
+    r = subprocess.run(["git", *args], capture_output=True, text=True)
+    if r.returncode != 0:
+        raise SystemExit(r.stderr.strip() or f"git {' '.join(args)} failed")
+    return r.stdout.strip()
+
+
+@lru_cache(maxsize=1)
+def store_dir():
+    """<repo>/.git/notes — one store shared by every worktree of the repo.
+
+    `--git-common-dir` prints a relative path from the main worktree and an
+    absolute one from a linked worktree; realpath against cwd absorbs both.
+    (`--path-format=absolute` would be cleaner but needs git >= 2.31.)
+    """
+    return Path(os.path.realpath(_git("rev-parse", "--git-common-dir"))) / "notes"
+
+
+def require_store():
+    d = store_dir()
+    if not d.is_dir():
+        raise SystemExit(f"no note store at {d} — run `note init`")
+    return d
+
+
+def init():
+    """Create the store. Idempotent: existing files are never truncated.
+
+    Six worktrees share one store, so a second agent's `init` is a re-entry
+    into a store that already holds everyone's work, not a fresh start.
+    """
+    d = store_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    created = []
+    for name in FILES:
+        f = d / name
+        if not f.exists():
+            f.touch()
+            created.append(name)
+    return d, created
+
+
+@contextmanager
+def write_lock():
+    """Serialize every write path — each is a read-then-append that a
+    concurrent write can invalidate."""
+    d = require_store()
+    with open(d / ".lock", "w") as fh:
+        fcntl.flock(fh, fcntl.LOCK_EX)
+        try:
+            yield d
+        finally:
+            fcntl.flock(fh, fcntl.LOCK_UN)
+
+
+def read(name):
+    with open(require_store() / name) as fh:
+        return [json.loads(line) for line in fh if line.strip()]
+
+
+def append(name, obj):
+    with open(require_store() / name, "a") as fh:
+        fh.write(json.dumps(obj, ensure_ascii=False) + "\n")
+
+
+def now():
+    return datetime.now().isoformat(timespec="seconds")
+
+
+
+def current_branch():
+    """The branch this node was written from. In a shared store, "which arm
+    is this" is otherwise lost. Detached HEAD (a worktree mid-rebase, for
+    one) prints nothing, so fall back to the short SHA."""
+    b = _git("branch", "--show-current")
+    return b or _git("rev-parse", "--short", "HEAD")
+
+
+def add_node(content, type="note", tags=()):
+    with write_lock():
+        nodes = read("nodes.jsonl")
+        # max, not last: immune to a hand-edited file, same cost
+        nid = max((n["id"] for n in nodes), default=0) + 1
+        append("nodes.jsonl", {
+            "id": nid,
+            "content": content,
+            "type": type,
+            "tags": list(tags),
+            "branch": current_branch(),
+            "timestamp": now(),
+        })
+    return nid
+
+
+def add_edge(src, dst, relation):
+    with write_lock():
+        ids = {n["id"] for n in read("nodes.jsonl")}
+        for i in (src, dst):
+            if i not in ids:
+                raise SystemExit(f"no node {i}")
+        append("edges.jsonl", {"from": src, "to": dst, "relation": relation})
+
+
+def supersede(old, content, type=None, tags=()):
+    """Correct a node. Append-only has no edit, so a correction is a new node
+    plus an edge `old -superseded_by-> new`.
+
+    That direction is deliberate. With `new -supersedes-> old` the old node
+    would have out-degree 0 and surface in `tails` as the working frontier,
+    which is backwards. This way the NEW node is the frontier and the
+    corrected one drops out of it. Type and tags are inherited unless given.
+    """
+    with write_lock():
+        nodes = read("nodes.jsonl")
+        by_id = {n["id"]: n for n in nodes}
+        if old not in by_id:
+            raise SystemExit(f"no node {old}")
+        nid = max((n["id"] for n in nodes), default=0) + 1
+        append("nodes.jsonl", {
+            "id": nid,
+            "content": content,
+            "type": type or by_id[old]["type"],
+            "tags": list(tags) or list(by_id[old].get("tags") or []),
+            "branch": current_branch(),
+            "timestamp": now(),
+        })
+        append("edges.jsonl", {"from": old, "to": nid, "relation": "superseded_by"})
+    return nid
+
+
+def demo():
+    import tempfile
+    d = tempfile.mkdtemp()
+    os.chdir(d)                      # chdir BEFORE any store call: store_dir is cached
+    subprocess.run(["git", "init", "-q"], check=True)
+    subprocess.run(["git", "config", "user.email", "t@t"], check=True)
+    subprocess.run(["git", "config", "user.name", "t"], check=True)
+
+    path, created = init()
+    assert path == Path(os.path.realpath(".git")) / "notes", path
+    assert sorted(created) == sorted(FILES), created
+
+    # idempotent and non-truncating: the second init must preserve content
+    append("nodes.jsonl", {"id": 1, "content": "survivor"})
+    path2, created2 = init()
+    assert path2 == path
+    assert created2 == [], created2
+    assert read("nodes.jsonl") == [{"id": 1, "content": "survivor"}]
+
+    with write_lock() as locked:
+        assert locked == path
+
+    assert "T" in now()
+
+    a = add_node("first attempt", type="attempt", tags=["arm-b1"])
+    g = add_node("legible text at 512px", type="goal")
+    assert (a, g) == (2, 3), (a, g)          # id 1 was written by hand above
+
+    rows = {n["id"]: n for n in read("nodes.jsonl")}
+    assert rows[a]["type"] == "attempt"
+    assert rows[a]["tags"] == ["arm-b1"]
+    assert rows[a]["branch"], "branch must never be empty"   # name varies by git config
+    assert "timestamp" in rows[a]
+
+    add_edge(a, g, "targets")
+    assert read("edges.jsonl") == [{"from": a, "to": g, "relation": "targets"}]
+
+    try:
+        add_edge(a, 999, "leads_to")
+        raise AssertionError("expected SystemExit for a nonexistent node")
+    except SystemExit as e:
+        assert "999" in str(e), e
+
+    # detached HEAD must not produce an empty branch field
+    subprocess.run(["git", "commit", "-q", "--allow-empty", "-m", "x"], check=True)
+    head = subprocess.run(["git", "rev-parse", "HEAD"], capture_output=True, text=True).stdout.strip()
+    subprocess.run(["git", "checkout", "-q", head], check=True)
+    assert current_branch(), "detached HEAD must fall back to a short SHA"
+
+    # a correction is a new node plus old -superseded_by-> new, so the NEW one
+    # is the frontier and the old one drops out of tails
+    new_id = supersede(a, "first attempt, corrected")
+    rows = {n["id"]: n for n in read("nodes.jsonl")}
+    assert rows[new_id]["content"] == "first attempt, corrected"
+    assert rows[new_id]["type"] == rows[a]["type"], "type is inherited"
+    assert rows[new_id]["tags"] == rows[a]["tags"], "tags are inherited"
+    assert {"from": a, "to": new_id, "relation": "superseded_by"} in read("edges.jsonl")
+    try:
+        supersede(999, "nope")
+        raise AssertionError("expected SystemExit")
+    except SystemExit as e:
+        assert "999" in str(e), e
+
+    print("store: ok")
+
+
+if __name__ == "__main__":
+    demo()

notegraph-0.2.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: notegraph
+Version: 0.2.0
+Summary: Decision-graph and goal notebook for a git repo, shared across every worktree
+Author-email: 송재훈 <sjh030504@i-screammedia.com>
+License: MIT
+Project-URL: Homepage, https://github.com/sjh354/note-cli
+Project-URL: Source, https://github.com/sjh354/note-cli
+Project-URL: Issues, https://github.com/sjh354/note-cli/issues
+Project-URL: Changelog, https://github.com/sjh354/note-cli/blob/main/CHANGELOG.md
+Keywords: git,worktree,notebook,decision-graph,agent,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# notegraph
+
+A decision-graph and goal notebook for a git repo. One store per repo, shared
+by every worktree, kept in `<repo>/.git/notes/` — so it never appears in the
+working tree and needs no `.gitignore` entry.
+
+    pipx install notegraph    # once published; for a checkout: pipx install -e .
+    note init
+    note goal --set "ship an education image generator" \
+      --criterion "consistency:3:the reference style holds across seeds" \
+      --criterion "legibility:1:rendered text is readable at 512px"
+
+    note add "legible text at 512px" --type goal          # -> 1
+    note add "arm B1_P2" --type attempt --tags p2         # -> 2
+    note link 2 1 --rel targets
+    note score 2 consistency=1.0 legibility=0.8 --note "best so far"
+    note goals
+
+    note status                                           # everything at a glance
+    note check                                            # exit 1 if the loop is open
+    note supersede 2 "arm B1_P2, corrected"               # append-only correction
+
+Three names, deliberately: the PyPI distribution is **notegraph**, the git repo
+is **note-cli**, and the command you type is **note**. `note-cli` was taken on
+PyPI by similarity to an existing `notecli`.
+
+Requires a POSIX system (Linux, macOS, WSL) — the store is locked with
+`fcntl.flock`. MIT licensed.
+
+Design: [`docs/superpowers/specs/2026-09-17-note-cli-design.md`](docs/superpowers/specs/2026-09-17-note-cli-design.md)
+
+For an agent working in this repo: `note skill --install`, then follow the
+`note` skill.

notegraph-0.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+note_cli/SKILL.md,sha256=I0finC4UMtoIkx9vilTPIEsgAe7dqB8PSbTLz5nKOiM,2814
+note_cli/__init__.py,sha256=YQiA1KXBKE70_zZBmCvmJyVvI9ciKhI6kHIthX5BbFk,284
+note_cli/_cli_check.py,sha256=BhCVEW7sEuKsK8zjI1zSz0OObu1XY9IBa7NvLX7-smQ,3611
+note_cli/_concurrency_check.py,sha256=zAsuPP3JHV5UbhlO1_5TZcP3kKoHCieZZtYTgsmdFY0,1011
+note_cli/cli.py,sha256=yVZmw73CG60NB6lGr2w9VSAhy4i_glZLfvy9v8JLbK8,10692
+note_cli/goal.py,sha256=XdmprqgY0x0dJ6DRnrj3VsVh4zuaXpemFSOx56UxKdE,7890
+note_cli/graph.py,sha256=Im3iBC_f7ciukOB2Ki7sN5EzQWIYXNHBeDr97xupmi8,4418
+note_cli/render.py,sha256=Y2M4RElbjih0iUaaMPlDcq_IN-g8foySQKOQSzj9gGc,2800
+note_cli/store.py,sha256=tCUmRIzAj8xqgYJx0viidGu7ogiBvwhWr0JrH5R2-iI,7256
+notegraph-0.2.0.dist-info/licenses/LICENSE,sha256=NCGJ-C4hYPcbcO7sOhld-8OKzbQ2V38NRoPOLJo0RMY,1081
+notegraph-0.2.0.dist-info/METADATA,sha256=-RGISY-xo7sI4JJvZAS-3VrPBbnJ_t57uurCcebS8Xw,2920
+notegraph-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+notegraph-0.2.0.dist-info/entry_points.txt,sha256=t59CEGHHaHUf96aEbh_L5QqAvDpmVwQdcvKlLjCkj4M,43
+notegraph-0.2.0.dist-info/top_level.txt,sha256=2dDepLZO893-FXwMH2sNRuMVBnTA5pgtLJ6K8lr3lOs,9
+notegraph-0.2.0.dist-info/RECORD,,

notegraph-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

notegraph-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+note = note_cli.cli:main

notegraph-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 송재훈 (Jaehoon Song)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

notegraph-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+note_cli