awgit 0.1.0__tar.gz → 0.3.0__tar.gz

{awgit-0.1.0 → awgit-0.3.0}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: awgit
-Version: 0.1.0
+Version: 0.3.0
 Summary: Aither World-Graph git — semantic version control on top of git: edit-ops keyed on stable node ids, content-addressed bodies, differential sync.
 License: Apache-2.0
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.25.0
+Provides-Extra: multilang
+Requires-Dist: repowise>=0.31.0; extra == "multilang"
 Dynamic: license-file
 
 # awgit — Aither World-Graph git
@@ -52,7 +54,7 @@ what changed, never the snapshot.
 ## Install
 
 ```bash
-pip install awgit            # from PyPI (when published)
+pip install awgit
 # or from source:
 git clone https://github.com/aitherium/awgit && cd awgit
 pip install -e .

{awgit-0.1.0 → awgit-0.3.0}/README.md

@@ -41,7 +41,7 @@ what changed, never the snapshot.
 ## Install
 
 ```bash
-pip install awgit            # from PyPI (when published)
+pip install awgit
 # or from source:
 git clone https://github.com/aitherium/awgit && cd awgit
 pip install -e .

{awgit-0.1.0 → awgit-0.3.0}/awgit/capture.py

@@ -128,10 +128,23 @@ def resolve_actor(
     """
     github = _github_identity(data_root)
     env_actor = os.environ.get("AITHER_ACTOR")
+    # The SESSION, before the GitHub login. Every agent on this box shares one
+    # GitHub identity, so resolving to `github` collapsed every session into one
+    # actor: measured 2026-08-09, an op-log of 188 ops across 189 files had
+    # exactly ONE actor, which makes "two actors touched this node" impossible to
+    # express and the collision view structurally blind. The schema already
+    # separates CLAIMED from VERIFIED — `verified_actor` still records the
+    # GitHub identity below — so the claimed actor is free to be the session
+    # that actually made the edit, which is what attribution is for. Matches
+    # the lease gate's `_actor()`, and the two disagreeing is what made leases
+    # discriminate per session while captures did not.
+    session = os.environ.get("CLAUDE_CODE_SESSION_ID")
     if actor_arg:
         actor, source = actor_arg, "arg"
     elif env_actor:
         actor, source = env_actor, "env"
+    elif session:
+        actor, source = f"claude:{session}", "session"
     elif github:
         actor, source = github, "github"
     else:
@@ -154,6 +167,29 @@ def _ancestor_shas(repo: Path, sha: str) -> List[str]:
 def _node_records(src: Optional[bytes], rel_path: str) -> List[Dict[str, Any]]:
     if src is None:
         return []
+    if not rel_path.endswith(".py"):
+        # NON-PYTHON: identity comes from repowise, which parses 75 extensions
+        # across 20+ languages and emits ids of the form `path::qualified_name`
+        # — verified stable across a symbol MOVING and its body changing, which
+        # is the property node-level merge rests on. Without this every
+        # .ts/.tsx/.go/.cs file was invisible to awgit: of the 20,451 files
+        # repowise has indexed in this repo, 12,600+ are not Python.
+        from awgit.repowise_parser import parse_symbols
+
+        text = src.decode("utf-8", errors="ignore").split("\n")
+        out: List[Dict[str, Any]] = []
+        for sym in parse_symbols(src, rel_path):
+            start, end = sym.get("start_line") or 0, sym.get("end_line") or 0
+            body = "\n".join(text[start - 1:end]) if start and end else ""
+            out.append({
+                "name": sym["symbol"] or sym["node_id"],
+                "path": rel_path,
+                "type": sym.get("kind") or "symbol",
+                "signature": "",
+                "body": body,
+            })
+        return out
+
     # lazy: CodeGraph's import chain is ~15s (AitherConfig auto-tune etc.); only
     # pay it when actually parsing (capture/diff/merge runtime), never for
     # `vcs lease`/`status` which import this module but never parse.
@@ -401,8 +437,13 @@ def capture_ops(
         manager = StableNodeIDManager(path=data / "nodes.json", persist=True)
         store = BodyStore(data_root=data)
         node_changes: List[NodeChange] = []
+        from awgit.repowise_parser import language_for
+
         for rel in files:
-            if not rel.endswith(".py"):
+            # Python natively; anything else only when repowise can parse it,
+            # so a file type nobody can give node identity to is skipped rather
+            # than recorded as an empty change.
+            if not rel.endswith(".py") and not language_for(rel):
                 continue
             old_src = git_blob(repo, parent, rel)
             new_src = git_blob(repo, git_sha, rel)

{awgit-0.1.0 → awgit-0.3.0}/awgit/cli.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 import argparse
 import os
+import platform
 import subprocess
 import sys
 from pathlib import Path
@@ -28,11 +29,38 @@ from awgit.oplog import OpLog
 
 
 def _actor(args: argparse.Namespace) -> str:
-    return (
-        getattr(args, "actor", None)
-        or os.environ.get("AITHER_ACTOR")
-        or "unknown"
-    )
+    """Who is committing. MUST differ per concurrent agent, or leases are useless.
+
+    Explicit forms win, then one is DERIVED. Deriving is the point: with only
+    ``AITHER_ACTOR`` this returned "unknown", and ``lease-check`` rejects an
+    unknown actor — so turning enforcement on would have blocked every commit on
+    the box until every session remembered to export a variable. A guard that can
+    only be switched on by breaking the machine never gets switched on, and it
+    never was: measured 2026-08-09, ``awgit lease list`` had never returned a
+    single lease while a concurrent session overwrote one file four times, the
+    last overwrite silently reverting a fix already committed to origin.
+
+    ``CLAUDE_CODE_SESSION_ID`` is the right derivation: the harness sets it per
+    session, it is stable for that session's life, and it is inherited by the git
+    hook's subprocess (verified). A per-PID value would NOT do — every ``awgit``
+    invocation is a new process, so a lease taken by one command would not match
+    the next.
+
+    ``user@host`` is the last resort, for humans and other tooling. It is
+    deliberately not what agents get: every session here shares one OS account
+    and one GitHub identity, so a shared actor makes session A's lease cover
+    session B's commit — all of the friction, none of the protection.
+    """
+    explicit = getattr(args, "actor", None) or os.environ.get("AITHER_ACTOR")
+    if explicit:
+        return explicit
+    session = os.environ.get("CLAUDE_CODE_SESSION_ID")
+    if session:
+        return f"claude:{session}"
+    user = os.environ.get("USERNAME") or os.environ.get("USER")
+    if user:
+        return f"{user}@{platform.node() or 'localhost'}"
+    return "unknown"
 
 
 def _cmd_capture(args: argparse.Namespace) -> int:
@@ -119,9 +147,26 @@ def _cmd_lease(args: argparse.Namespace) -> int:
     cmd = args.lease_cmd
     who = _actor(args)
     if cmd == "acquire":
+        targets = list(args.targets or [])
+        if getattr(args, "staged", False):
+            # Lease exactly what the gate will check. Without this, widening
+            # coverage beyond .py (D-1880) would have made a routine commit a
+            # per-file chore, and a gate that heavy gets routed around instead
+            # of satisfied.
+            from awgit.leases import is_guarded
+
+            repo = Path(os.environ.get("VCS_REPO_ROOT", os.getcwd()))
+            targets += [f for f in _staged_files(repo) if is_guarded(f)]
+            targets = sorted(set(targets))
+            if not targets:
+                print("vcs: nothing staged that the gate guards — no leases needed")
+                return 0
+        if not targets:
+            print("vcs: acquire needs targets (or --staged)", file=sys.stderr)
+            return 1
         try:
             leases = registry.acquire(
-                who, args.targets, ttl_sec=args.ttl, reason=args.reason
+                who, targets, ttl_sec=args.ttl, reason=args.reason
             )
         except LeaseConflictError as exc:
             print(f"vcs: {exc}", file=sys.stderr)
@@ -178,6 +223,25 @@ def _cmd_lease_check(args: argparse.Namespace) -> int:
     return 0
 
 
+
+def _cmd_graph(args: argparse.Namespace) -> int:
+    from awgit.graph import build, to_json, to_mermaid
+
+    g = build(since=args.since, actor=args.actor)
+    text = to_json(g) if args.format == "json" else to_mermaid(g)
+    if args.out:
+        try:
+            Path(args.out).write_text(text, encoding="utf-8")
+        except OSError as exc:
+            print(f"vcs: cannot write {args.out}: {exc}", file=sys.stderr)
+            return 2
+        print(f"vcs: wrote {args.format} graph to {args.out} "
+              f"({g['ops']} ops, {len(g['collisions'])} collision(s))")
+    else:
+        print(text)
+    return 0
+
+
 def _cmd_bodies(args: argparse.Namespace) -> int:
     from awgit.bodies import BodyStore
 
@@ -360,6 +424,15 @@ def main(argv: Optional[List[str]] = None) -> int:
     p_diff.add_argument("b", help="target sha")
 
     sub.add_parser("status", help="op-log status")
+    p_graph = sub.add_parser(
+        "graph", help="render the op-log as a graph (mermaid or json)")
+    p_graph.add_argument("--format", choices=("mermaid", "json"),
+                         default="mermaid")
+    p_graph.add_argument("--since", default=None,
+                         help="ISO timestamp — only ops at or after it")
+    p_graph.add_argument("--actor", default=None, help="restrict to one actor")
+    p_graph.add_argument("--out", default=None,
+                         help="write to a file instead of stdout")
 
     p_mp = sub.add_parser("merge-preview", help="node-level merge preview of two shas")
     p_mp.add_argument("a", help="base-side sha")
@@ -376,7 +449,10 @@ def main(argv: Optional[List[str]] = None) -> int:
     p_lease = sub.add_parser("lease", help="lease registry operations")
     lsub = p_lease.add_subparsers(dest="lease_cmd", required=True)
     p_la = lsub.add_parser("acquire", help="acquire leases for targets")
-    p_la.add_argument("targets", nargs="+")
+    p_la.add_argument("targets", nargs="*")
+    p_la.add_argument("--staged", action="store_true",
+                      help="also lease every STAGED file the gate guards "
+                           "(the one-command way to satisfy the pre-commit gate)")
     p_la.add_argument("--ttl", type=int, default=300)
     p_la.add_argument("--reason", default="")
     p_la.add_argument("--actor", default=None)
@@ -470,6 +546,8 @@ def main(argv: Optional[List[str]] = None) -> int:
         return _cmd_lease(args)
     if args.cmd == "lease-check":
         return _cmd_lease_check(args)
+    if args.cmd == "graph":
+        return _cmd_graph(args)
     if args.cmd == "bodies":
         return _cmd_bodies(args)
     if args.cmd == "dedupe":

awgit-0.3.0/awgit/graph.py

@@ -0,0 +1,133 @@
+"""Render the op-log as a GRAPH — awgit's own data, drawn.
+
+awgit is already a graph and was only ever printed as lines. Every edit op is
+an edge: an ACTOR touched a NODE (a function or class with a stable id) that
+lives in a FILE, at a commit. Rendering that answers, at a glance, the question
+the whole lease plane exists for — *who is working where, and where are two
+actors standing on the same node* — instead of making someone reconstruct it
+from `awgit ledger` output.
+
+Two shapes, deliberately:
+
+- ``mermaid`` for humans: files as subgraphs, code nodes inside them, actors as
+  rounded nodes with edges into what they touched. A node TWO OR MORE actors
+  touched is drawn as a collision, because that is the only part of the picture
+  that means anything is wrong.
+- ``json`` for machines: plain nodes/edges so the platform's graph plane can
+  ingest it. awgit's graph is one graph among many — code, services, memory —
+  and this is the seam that lets it be a subgraph of that larger graph rather
+  than a private format nothing else can read.
+
+Deliberately NO layout, colours-by-actor or clustering heuristics: this renders
+what the op-log says. If the picture is wrong, the op-log is wrong, and that is
+worth seeing rather than smoothing over.
+"""
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from typing import Optional
+
+from awgit.oplog import OpLog
+
+
+def _short(text: str, keep: int = 28) -> str:
+    text = text or "?"
+    return text if len(text) <= keep else text[:keep - 1] + "…"
+
+
+def build(data_root=None, since: Optional[str] = None, actor: Optional[str] = None) -> dict:
+    """Collect the op-log into {nodes, edges, collisions}. Pure data, no rendering."""
+    log = OpLog(data_root=data_root)
+    ops = log.ops_since(since) if since else log.all_ops()
+    if actor:
+        ops = [o for o in ops if getattr(o, "actor", None) == actor]
+
+    files: dict = defaultdict(set)      # path -> {(node_id, symbol)}
+    touched: dict = defaultdict(set)    # (path, node_id) -> {actor}
+    actors: set = set()
+    for op in ops:
+        who = getattr(op, "actor", None) or "unknown"
+        actors.add(who)
+        for ch in (getattr(op, "node_changes", None) or []):
+            nid = getattr(ch, "node_id", None)
+            if not nid:
+                continue
+            path = getattr(ch, "path", None) or "?"
+            files[path].add((nid, getattr(ch, "symbol", None) or nid[:12]))
+            touched[(path, nid)].add(who)
+
+    collisions = sorted(k for k, v in touched.items() if len(v) > 1)
+    return {
+        "ops": len(ops),
+        "actors": sorted(actors),
+        "files": {p: sorted(v) for p, v in files.items()},
+        "touched": {f"{p}::{n}": sorted(v) for (p, n), v in touched.items()},
+        "collisions": [{"path": p, "node_id": n, "actors": sorted(touched[(p, n)])}
+                       for p, n in collisions],
+    }
+
+
+def to_mermaid(g: dict) -> str:
+    """A mermaid `graph LR` of actors -> nodes, grouped by file."""
+    out = ["graph LR"]
+    if not g["files"]:
+        # An empty graph must SAY it is empty. A bare `graph LR` renders as a
+        # blank box, which reads as "nothing is wrong" rather than "no data".
+        out.append('  empty["op-log is empty — no captures yet"]')
+        return "\n".join(out)
+
+    ids: dict = {}
+    for fi, (path, nodes) in enumerate(sorted(g["files"].items())):
+        out.append(f'  subgraph F{fi}["{_short(path, 40)}"]')
+        for ni, (nid, symbol) in enumerate(nodes):
+            key = f"N{fi}_{ni}"
+            ids[(path, nid)] = key
+            hits = g["touched"].get(f"{path}::{nid}", [])
+            marker = "💥 " if len(hits) > 1 else ""
+            out.append(f'    {key}["{marker}{_short(symbol)}"]')
+        out.append("  end")
+
+    for ai, who in enumerate(g["actors"]):
+        out.append(f'  A{ai}("{_short(who, 34)}")')
+
+    seen = set()
+    for key, whos in g["touched"].items():
+        path, _, nid = key.rpartition("::")
+        target = ids.get((path, nid))
+        if not target:
+            continue
+        for who in whos:
+            ai = g["actors"].index(who)
+            edge = (ai, target)
+            if edge in seen:
+                continue
+            seen.add(edge)
+            out.append(f"  A{ai} --> {target}")
+
+    for c in g["collisions"]:
+        target = ids.get((c["path"], c["node_id"]))
+        if target:
+            out.append(f"  style {target} fill:#a33,stroke:#f66,color:#fff")
+    return "\n".join(out)
+
+
+def to_json(g: dict) -> str:
+    """Node/edge form for ingestion into the platform's graph-of-graphs."""
+    nodes = [{"id": f"actor:{a}", "kind": "actor", "label": a} for a in g["actors"]]
+    edges = []
+    for path, entries in g["files"].items():
+        nodes.append({"id": f"file:{path}", "kind": "file", "label": path})
+        for nid, symbol in entries:
+            nodes.append({"id": f"node:{path}::{nid}", "kind": "code_node",
+                          "label": symbol, "path": path})
+            edges.append({"src": f"node:{path}::{nid}", "dst": f"file:{path}",
+                          "rel": "in_file"})
+    for key, whos in g["touched"].items():
+        for who in whos:
+            edges.append({"src": f"actor:{who}", "dst": f"node:{key}",
+                          "rel": "touched"})
+    return json.dumps({
+        "graph": "awgit.oplog", "ops": g["ops"],
+        "nodes": nodes, "edges": edges, "collisions": g["collisions"],
+    }, indent=2)

{awgit-0.1.0 → awgit-0.3.0}/awgit/leases.py

@@ -243,16 +243,60 @@ class LeaseRegistry:
         return [lz for lz in self._leases.values() if lz.actor == actor]
 
 
+# Files worth guarding: the ones two agents plausibly edit at the same time.
+# Widened from ".py only" on 2026-08-09 (D-1880). The old scope let a `.yml`
+# commit print "lease-check OK" while checking NOTHING, so compose files,
+# workflows, skills and .mcp.json were exactly as clobberable as before the
+# gate existed — and that same day edits to docker-compose.aitheros.yml and
+# concurrent-safe-git/SKILL.md had to be hand-restored after a concurrent
+# overwrite, while the .py the gate did cover was overwritten four times.
+GUARDED_SUFFIXES = (
+    ".py", ".ts", ".tsx", ".js", ".jsx", ".mjs",          # source
+    ".yml", ".yaml", ".toml", ".json", ".ini", ".cfg",    # config
+    ".sh", ".bash", ".ps1", ".psm1",                      # scripts
+    ".md",                                                # rules, skills, docs
+    ".sql", ".proto", ".env",
+)
+# Bulk content nobody races on. Guarding these would make a routine content
+# commit need dozens of leases, and a gate that heavy gets ROUTED AROUND rather
+# than satisfied — the exact failure that produced this repo's per-file-ignores.
+UNGUARDED_PREFIXES = (
+    "AitherOS/apps/AitherVeil/content/",   # blog posts, one author at a time
+    "AitherOS/Library/",                   # generated training/runtime data
+    ".DELIVERABLES/",                      # published artifacts
+    ".RESEARCH/INTAKE/",                   # dossiers
+    "TECH_DEBT_ARCHIVE",                   # frozen
+)
+
+
+def is_guarded(path: str) -> bool:
+    """Does the lease gate care about this path?
+
+    Extension-based with a bulk-content escape, rather than "everything": the
+    trade is deliberate. Covering every path means a 50-file commit needs 50
+    leases; covering none is where this started.
+    """
+    p = (path or "").replace("\\", "/").strip()
+    if not p:
+        return False
+    if p.startswith(UNGUARDED_PREFIXES):
+        return False
+    return p.endswith(GUARDED_SUFFIXES)
+
+
 def coverage_gap(
     changed_files: List[str],
     actor: str,
     data_root: Optional[Path] = None,
 ) -> List[str]:
-    """Changed Python files NOT covered by the actor's active path-leases.
+    """Changed GUARDED files not covered by the actor's active path-leases.
+
+    The pre-commit gate's primitive: a commit touching a guarded file with no
+    active path-lease is an unleased edit — rejected when leases are enforced
+    (VCS_LEASES_ENFORCE=1), recorded as ``leased=false`` otherwise.
 
-    The pre-commit gate's primitive: a commit touching a Python file with no
-    active path-lease is an unleased edit — a visible risk flag when leases
-    are enforced (VCS_LEASES_ENFORCE=1), recorded as ``leased=false`` otherwise.
+    ``awgit lease acquire --staged`` takes leases on exactly this set, so
+    complying is one command rather than a per-file chore.
     """
     registry = LeaseRegistry(data_root=data_root)
     registry.sweep_expired()
@@ -261,4 +305,4 @@ def coverage_gap(
         for lz in registry.active_leases()
         if lz.actor == actor and lz.kind == "path"
     }
-    return [f for f in changed_files if f.endswith(".py") and f not in covered]
+    return [f for f in changed_files if is_guarded(f) and f not in covered]

awgit-0.3.0/awgit/repowise_parser.py

@@ -0,0 +1,107 @@
+"""Multi-language node identity for awgit, borrowed from repowise.
+
+WHY (2026-08-09). awgit's node model is Python-only: ``parse_source_bytes``
+routes to CPython's ``ast``, so every `.ts`, `.tsx`, `.go`, `.cs` file is
+invisible to the diff, the merge engine and the graph. Measured on this repo,
+that is not a corner case — repowise's index holds 20,451 files, of which
+**7,824 are Python and 12,600+ are not** (2,859 `.tsx`, 2,163 `.ts`, 1,423
+yaml, 1,015 json, …). The lease gate was widened to guard those files, but a
+lease is all awgit could offer them: no node identity, nothing to merge,
+nothing to draw.
+
+Rather than grow a second tree-sitter stack inside awgit, this adapts the one
+the platform already runs. repowise (PyPI, third-party) parses **75 extensions
+across 20+ languages** and — the fact that decides it — emits symbol ids of the
+form ``path::qualified_name``, which are STABLE. Verified before writing any of
+this: a TypeScript function that MOVED position and had its BODY changed kept
+the id ``probe.ts::alpha`` across both edits. Stability under movement is the
+whole basis of node-level merge; without it this would be worthless.
+
+Deliberately a THIN adapter:
+  * Python still goes to CodeGraph. It is the semantics awgit was built on, its
+    node ids are already in the op-log, and switching would orphan every op
+    recorded so far.
+  * repowise is OPTIONAL. It is a third-party dependency and the standalone
+    package must not hard-require it — `available()` is false when it is absent
+    and callers fall back, rather than awgit failing to import.
+"""
+from __future__ import annotations
+
+from typing import List, Optional, Tuple
+
+_PARSER = None
+_UNAVAILABLE: Optional[str] = None
+
+
+def available() -> Tuple[bool, str]:
+    """(usable, why-not). Never raises: absence is a fallback, not a failure."""
+    global _PARSER, _UNAVAILABLE
+    if _PARSER is not None:
+        return True, ""
+    if _UNAVAILABLE is not None:
+        return False, _UNAVAILABLE
+    try:
+        from repowise.core.ingestion import ASTParser  # noqa: PLC0415
+        _PARSER = ASTParser()
+        return True, ""
+    except Exception as exc:
+        _UNAVAILABLE = f"repowise unavailable ({type(exc).__name__})"
+        return False, _UNAVAILABLE
+
+
+def language_for(path: str) -> Optional[str]:
+    """repowise's language for a path, or None when it does not handle it."""
+    ok, _ = available()
+    if not ok:
+        return None
+    try:
+        from repowise.core.ingestion import EXTENSION_TO_LANGUAGE  # noqa: PLC0415
+    except Exception:
+        return None
+    _, _, ext = (path or "").rpartition(".")
+    return EXTENSION_TO_LANGUAGE.get("." + ext.lower()) if ext else None
+
+
+def parse_symbols(content: bytes, path: str) -> List[dict]:
+    """Symbols in `content` as awgit-shaped dicts. [] when it cannot parse.
+
+    Returns node_id/symbol/kind/start_line/end_line/language. The node_id is
+    repowise's own ``path::qualified_name``, NOT a hash of the body — that is
+    precisely why it survives a move, and why it can be compared across two
+    commits the way awgit's Python node ids are.
+    """
+    ok, _ = available()
+    if not ok:
+        return []
+    lang = language_for(path)
+    if not lang:
+        return []
+    try:
+        from repowise.core.ingestion import FileInfo  # noqa: PLC0415
+
+        info = FileInfo(
+            path=path, abs_path=path, language=lang, size_bytes=len(content),
+            git_hash="", last_modified=0.0, is_test=False, is_config=False,
+            is_api_contract=False, is_entry_point=False,
+        )
+        parsed = _PARSER.parse_file(info, content)
+    except Exception:
+        # A file repowise chokes on must degrade to "no symbols", never take
+        # the capture down: awgit records what it can see, and a parser crash
+        # on one file is not a reason to lose the whole commit's op.
+        return []
+
+    out = []
+    for sym in (getattr(parsed, "symbols", None) or []):
+        nid = getattr(sym, "id", None)
+        if not nid:
+            continue
+        out.append({
+            "node_id": str(nid),
+            "symbol": getattr(sym, "qualified_name", None) or getattr(sym, "name", ""),
+            "kind": str(getattr(sym, "kind", "") or ""),
+            "start_line": getattr(sym, "start_line", 0),
+            "end_line": getattr(sym, "end_line", 0),
+            "language": lang,
+        })
+    return out

{awgit-0.1.0 → awgit-0.3.0}/awgit.egg-info/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: awgit
-Version: 0.1.0
+Version: 0.3.0
 Summary: Aither World-Graph git — semantic version control on top of git: edit-ops keyed on stable node ids, content-addressed bodies, differential sync.
 License: Apache-2.0
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.25.0
+Provides-Extra: multilang
+Requires-Dist: repowise>=0.31.0; extra == "multilang"
 Dynamic: license-file
 
 # awgit — Aither World-Graph git
@@ -52,7 +54,7 @@ what changed, never the snapshot.
 ## Install
 
 ```bash
-pip install awgit            # from PyPI (when published)
+pip install awgit
 # or from source:
 git clone https://github.com/aitherium/awgit && cd awgit
 pip install -e .

{awgit-0.1.0 → awgit-0.3.0}/awgit.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ awgit/capture.py
 awgit/cli.py
 awgit/data_root.py
 awgit/diff.py
+awgit/graph.py
 awgit/identity.py
 awgit/leases.py
 awgit/ledger.py
@@ -16,6 +17,7 @@ awgit/merge.py
 awgit/nodeid.py
 awgit/oplog.py
 awgit/parser.py
+awgit/repowise_parser.py
 awgit/schema.py
 awgit/sync.py
 awgit.egg-info/PKG-INFO

awgit-0.3.0/awgit.egg-info/requires.txt

@@ -0,0 +1,4 @@
+httpx>=0.25.0
+
+[multilang]
+repowise>=0.31.0

{awgit-0.1.0 → awgit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "awgit"
-version = "0.1.0"
+version = "0.3.0"
 description = "Aither World-Graph git — semantic version control on top of git: edit-ops keyed on stable node ids, content-addressed bodies, differential sync."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -13,6 +13,14 @@ dependencies = [
     "httpx>=0.25.0",
 ]
 
+# OPTIONAL on purpose. Python node identity is native (CPython's ast); repowise
+# adds identity for the other 20+ languages it parses. Making it a hard
+# dependency would drag a large third-party parser into every install of a tool
+# whose core does not need it — and awgit must still import, and still guard
+# Python, when it is absent (see awgit/repowise_parser.available()).
+[project.optional-dependencies]
+multilang = ["repowise>=0.31.0"]
+
 [project.scripts]
 awgit = "awgit.cli:main"
 

awgit-0.1.0/awgit.egg-info/requires.txt

@@ -1 +0,0 @@
-httpx>=0.25.0