@0dai-dev/cli 4.3.6 → 4.3.8

package/lib/python/graph.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""Compatibility facade for the split graph modules."""
+
+import graph_core as _graph_core
+import graph_legacy as _graph_legacy
+
+from graph_legacy import *  # noqa: F403
+from graph_core import *  # noqa: F403
+from graph_validation import *  # noqa: F403
+from graph_io import *  # noqa: F403
+from graph_slice import *  # noqa: F403
+from graph_queries import *  # noqa: F403
+from graph_outcomes_core import *  # noqa: F403
+
+_now_iso = _graph_core._now_iso
+_slug = _graph_core._slug
+_summary = _graph_legacy._summary
+_parse_constraints_yaml = _graph_legacy._parse_constraints_yaml
+_extract_violation_pattern = _graph_legacy._extract_violation_pattern

package/lib/python/graph_core.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""Core graph registries and mutation helpers."""
+
+from __future__ import annotations
+
+import datetime as _dt
+import logging
+import re
+from typing import Any, Optional
+
+log = logging.getLogger("0dai.graph")
+
+SCHEMA_VERSION = 1
+
+NODE_TYPES = frozenset({
+    "Component",
+    "Technology",
+    "Decision",
+    "Requirement",
+    "Risk",
+    "TestPlan",
+    "Endpoint",
+    "DesignArtifact",
+    "MarketEntity",
+    "Session",
+    "Deliberation",
+    "Outcome",
+    "Artifact",
+    "Event",
+    "Constraint",
+})
+
+NODE_ID_PREFIXES: dict[str, str] = {
+    "Component": "comp",
+    "Technology": "tech",
+    "Decision": "dec",
+    "Requirement": "req",
+    "Risk": "risk",
+    "TestPlan": "test",
+    "Endpoint": "ep",
+    "DesignArtifact": "design",
+    "MarketEntity": "mkt",
+    "Session": "session",
+    "Deliberation": "delib",
+    "Outcome": "outcome",
+    "Artifact": "artifact",
+    "Event": "event",
+    "Constraint": "cstr",
+}
+
+EDGE_TYPES = frozenset({
+    "uses",
+    "depends_on",
+    "exposes",
+    "part_of",
+    "affects",
+    "chose",
+    "satisfies",
+    "supersedes",
+    "introduces",
+    "mitigates",
+    "decided_in",
+    "covers",
+    "tests",
+    "blocks",
+    "violates",
+    "designs",
+    "follows",
+    "targets",
+    "competes_with",
+    "owned_by",
+    "identified_by",
+    "created_by",
+    "approved_by",
+    "produced",
+    "updated",
+    "evaluates",
+    "decision_outcome",
+    "decision_ancestry",
+    "released_as",
+    "contains",
+    "triggered_by",
+    "observed_in",
+    "declared_by",
+    "implies",
+    "constrains",
+    "forbids",
+})
+
+OUTCOME_STATUSES = frozenset({
+    "confirmed",
+    "revised",
+    "reverted",
+    "partially_applied",
+})
+
+STAGE_OUTCOME_THRESHOLDS_DAYS: dict[str, int] = {
+    "idea": 14,
+    "mvp": 14,
+    "growth": 30,
+    "scale": 60,
+}
+DEFAULT_STAGE_THRESHOLD_DAYS = 30
+
+ROLE_TYPE_INTERESTS: dict[str, frozenset[str]] = {
+    "cto": frozenset({"Decision", "Technology", "Risk", "Component", "Requirement", "Constraint"}),
+    "arch": frozenset({"Component", "Technology", "Endpoint", "Requirement", "Risk", "Constraint"}),
+    "designer": frozenset({"DesignArtifact", "Component", "Requirement"}),
+    "art_director": frozenset({"DesignArtifact", "Component", "MarketEntity"}),
+    "qa": frozenset({"TestPlan", "Component", "Risk", "Requirement", "Constraint"}),
+    "security": frozenset({"Risk", "Requirement", "Component", "Technology", "Constraint"}),
+    "sre": frozenset({"Component", "Technology", "Risk", "Endpoint", "Constraint"}),
+    "cmo": frozenset({"MarketEntity", "Requirement", "Component", "Decision"}),
+}
+
+DEFAULT_EDGE_WEIGHT = 1.0
+HOP2_WEIGHT_THRESHOLD = 0.5
+
+CHARS_PER_TOKEN = 4
+DEFAULT_SLICE_TOKEN_BUDGET = 400
+
+DETERMINISTIC_SOURCES = frozenset({
+    "bootstrap",
+    "file_parse",
+    "git_diff",
+    "operator",
+    "tool_output",
+})
+
+AI_DERIVED_SOURCES = frozenset({
+    "scout_ai",
+    "deliberation_ai",
+    "hard_block",
+    "red_team_ai",
+    "forecast_ai",
+    "pattern_ai",
+})
+
+DEFAULT_SOURCE = "operator"
+
+
+def is_deterministic_source(source_type: str) -> bool:
+    return source_type in DETERMINISTIC_SOURCES
+
+
+def source_marker(source_type: str) -> str:
+    if is_deterministic_source(source_type):
+        return "✓"
+    if source_type in AI_DERIVED_SOURCES:
+        return "~"
+    return "?"
+
+
+def empty_graph() -> dict:
+    now = _now_iso()
+    return {
+        "nodes": {},
+        "edges": [],
+        "meta": {
+            "schema_version": SCHEMA_VERSION,
+            "created_at": now,
+            "updated_at": now,
+            "node_count": 0,
+            "edge_count": 0,
+        },
+    }
+
+
+def _now_iso() -> str:
+    return _dt.datetime.now(_dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _slug(text: str) -> str:
+    cleaned = re.sub(r"[^a-zA-Z0-9]+", "_", text.strip().lower())
+    return cleaned.strip("_") or "unnamed"
+
+
+def make_node_id(node_type: str, name: str) -> str:
+    prefix = NODE_ID_PREFIXES.get(node_type)
+    if not prefix:
+        raise ValueError(f"unknown node type: {node_type}")
+    return f"{prefix}_{_slug(name)}"
+
+
+def add_node(
+    graph: dict,
+    node_id: str,
+    node_type: str,
+    name: str,
+    *,
+    status: str = "active",
+    description: str = "",
+    source_type: str = DEFAULT_SOURCE,
+    extra: Optional[dict[str, Any]] = None,
+) -> dict:
+    if node_type not in NODE_TYPES:
+        raise ValueError(f"unknown node type: {node_type!r}")
+    if not node_id:
+        raise ValueError("node id must be non-empty")
+
+    now = _now_iso()
+    existing = graph["nodes"].get(node_id)
+    if existing:
+        existing["type"] = node_type
+        existing["name"] = name
+        existing["status"] = status
+        existing["description"] = description
+        existing["updated_at"] = now
+        existing_source = existing.get("source_type", DEFAULT_SOURCE)
+        if is_deterministic_source(source_type):
+            existing["source_type"] = source_type
+        elif not is_deterministic_source(existing_source):
+            existing["source_type"] = source_type
+        if extra:
+            existing.update(extra)
+        graph["meta"]["updated_at"] = now
+        return existing
+
+    node = {
+        "id": node_id,
+        "type": node_type,
+        "name": name,
+        "status": status,
+        "description": description,
+        "source_type": source_type,
+        "created_at": now,
+        "updated_at": now,
+    }
+    if extra:
+        node.update(extra)
+    graph["nodes"][node_id] = node
+    graph["meta"]["node_count"] = len(graph["nodes"])
+    graph["meta"]["updated_at"] = now
+    return node
+
+
+def add_edge(
+    graph: dict,
+    source: str,
+    target: str,
+    edge_type: str,
+    *,
+    weight: float = DEFAULT_EDGE_WEIGHT,
+    extra: Optional[dict[str, Any]] = None,
+) -> dict:
+    if edge_type not in EDGE_TYPES:
+        raise ValueError(f"unknown edge type: {edge_type!r}")
+    if source not in graph["nodes"]:
+        raise ValueError(f"edge source {source!r} not in graph")
+    if target not in graph["nodes"]:
+        raise ValueError(f"edge target {target!r} not in graph")
+
+    edge = {
+        "from": source,
+        "to": target,
+        "type": edge_type,
+        "weight": float(weight),
+        "created_at": _now_iso(),
+    }
+    if extra:
+        edge.update(extra)
+    graph["edges"].append(edge)
+    graph["meta"]["edge_count"] = len(graph["edges"])
+    graph["meta"]["updated_at"] = edge["created_at"]
+    return edge
+
+
+def find_edge(
+    graph: dict,
+    source: str,
+    target: str,
+    edge_type: Optional[str] = None,
+) -> Optional[dict]:
+    for edge in graph["edges"]:
+        if edge["from"] == source and edge["to"] == target:
+            if edge_type is None or edge["type"] == edge_type:
+                return edge
+    return None
+
+
+def outgoing_edges(graph: dict, node_id: str) -> list[dict]:
+    return [e for e in graph["edges"] if e["from"] == node_id]
+
+
+def incoming_edges(graph: dict, node_id: str) -> list[dict]:
+    return [e for e in graph["edges"] if e["to"] == node_id]
+
+
+def nodes_by_type(graph: dict, node_type: str) -> list[dict]:
+    return sorted(
+        (n for n in graph["nodes"].values() if n.get("type") == node_type),
+        key=lambda n: n["id"],
+    )

package/lib/python/graph_io.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Graph JSON I/O and usage tracking."""
+
+from __future__ import annotations
+
+import json
+import pathlib
+
+from graph_core import _now_iso, empty_graph, log
+from graph_validation import GraphValidationError, validate_graph
+
+
+def _usage_path(path: pathlib.Path) -> pathlib.Path:
+    path = pathlib.Path(path)
+    return path.with_name(f"{path.stem}_usage{path.suffix}")
+
+
+def _default_usage() -> dict:
+    return {
+        "schema_version": 1,
+        "updated_at": _now_iso(),
+        "totals": {
+            "loads": 0,
+            "queries": 0,
+            "updates": 0,
+            "saves": 0,
+        },
+        "operations": {},
+        "recent": [],
+    }
+
+
+def load_graph_usage(path: pathlib.Path) -> dict:
+    usage_path = _usage_path(path)
+    if not usage_path.exists():
+        return _default_usage()
+    try:
+        payload = json.loads(usage_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return _default_usage()
+
+    default = _default_usage()
+    if not isinstance(payload, dict):
+        return default
+
+    totals = payload.get("totals")
+    if not isinstance(totals, dict):
+        payload["totals"] = default["totals"]
+    else:
+        for key, value in default["totals"].items():
+            totals[key] = int(totals.get(key, value) or 0)
+
+    operations = payload.get("operations")
+    if not isinstance(operations, dict):
+        payload["operations"] = {}
+
+    recent = payload.get("recent")
+    if not isinstance(recent, list):
+        payload["recent"] = []
+
+    payload["schema_version"] = int(payload.get("schema_version", 1) or 1)
+    payload["updated_at"] = str(payload.get("updated_at") or default["updated_at"])
+    return payload
+
+
+def save_graph_usage(path: pathlib.Path, usage: dict) -> None:
+    usage_path = _usage_path(path)
+    usage_path.parent.mkdir(parents=True, exist_ok=True)
+    usage_path.write_text(json.dumps(usage, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+def record_graph_usage(
+    graph: dict,
+    operation: str,
+    *,
+    kind: str = "queries",
+    count: int = 1,
+) -> None:
+    usage_path_raw = graph.get("_usage_path")
+    if not usage_path_raw:
+        return
+
+    try:
+        graph_path = pathlib.Path(str(usage_path_raw))
+        payload = load_graph_usage(graph_path)
+    except (TypeError, ValueError):
+        return
+
+    totals = payload.setdefault("totals", _default_usage()["totals"])
+    if kind in totals:
+        totals[kind] = int(totals.get(kind, 0) or 0) + count
+    operations = payload.setdefault("operations", {})
+    operations[operation] = int(operations.get(operation, 0) or 0) + count
+    payload["updated_at"] = _now_iso()
+    recent = payload.setdefault("recent", [])
+    recent.insert(0, {
+        "operation": operation,
+        "kind": kind,
+        "count": count,
+        "at": payload["updated_at"],
+    })
+    del recent[20:]
+
+    try:
+        save_graph_usage(graph_path, payload)
+    except OSError:
+        return
+
+
+def summarize_graph_usage(path: pathlib.Path) -> dict:
+    usage = load_graph_usage(path)
+    operations = usage.get("operations", {})
+    if isinstance(operations, dict):
+        usage["top_operations"] = [
+            {"operation": name, "count": count}
+            for name, count in sorted(
+                ((str(name), int(count or 0)) for name, count in operations.items()),
+                key=lambda item: (-item[1], item[0]),
+            )[:8]
+        ]
+    else:
+        usage["top_operations"] = []
+    return usage
+
+
+def load_graph(path: pathlib.Path, *, track_usage: bool = True) -> dict:
+    path = pathlib.Path(path)
+    if not path.exists():
+        log.info("graph file %s does not exist; returning empty graph", path)
+        graph = empty_graph()
+        if track_usage:
+            graph["_usage_path"] = str(path)
+            record_graph_usage(graph, "load_graph", kind="loads")
+        return graph
+
+    with path.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+    if track_usage:
+        data["_usage_path"] = str(path)
+        record_graph_usage(data, "load_graph", kind="loads")
+    else:
+        data.pop("_usage_path", None)
+
+    errors = validate_graph(data)
+    if errors:
+        raise GraphValidationError(
+            f"graph at {path} failed validation:\n  " + "\n  ".join(errors)
+        )
+    return data
+
+
+def save_graph(path: pathlib.Path, graph: dict, *, validate: bool = True) -> None:
+    path = pathlib.Path(path)
+    if validate:
+        errors = validate_graph(graph)
+        if errors:
+            raise GraphValidationError(
+                "refusing to save invalid graph:\n  " + "\n  ".join(errors)
+            )
+
+    graph["meta"]["updated_at"] = _now_iso()
+    graph["meta"]["node_count"] = len(graph["nodes"])
+    graph["meta"]["edge_count"] = len(graph["edges"])
+
+    stable = {
+        "meta": graph["meta"],
+        "nodes": dict(sorted(graph["nodes"].items())),
+        "edges": sorted(
+            graph["edges"],
+            key=lambda e: (e.get("from", ""), e.get("to", ""), e.get("type", "")),
+        ),
+    }
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(stable, f, indent=2, ensure_ascii=False)
+        f.write("\n")
+    graph["_usage_path"] = str(path)
+    record_graph_usage(graph, "save_graph", kind="saves")