@0dai-dev/cli 4.3.5 → 4.3.7

package/lib/python/graph_legacy_helpers.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""Pure helpers extracted from ``graph_legacy.py`` (#757 / #1069 LOC split).
+
+These functions have no I/O, no network, no graph mutation, and no
+``record_graph_usage`` side effects. They depend only on the standard
+library. ``graph_legacy.py`` re-imports them for back-compat so callers and
+tests referencing ``graph_legacy.<helper>`` (and the ``graph`` facade that
+sources ``_parse_constraints_yaml`` / ``_extract_violation_pattern`` from
+``graph_legacy``) keep resolving unchanged.
+
+Behavior-preserving move only — no logic, signature, or control-flow change.
+"""
+from __future__ import annotations
+
+import fnmatch
+import re
+from typing import Any, Optional
+
+
+def _extract_keywords(text: str, min_len: int = 3) -> set[str]:
+    """Extract lowercased keyword tokens from free-form text.
+
+    Used by find_similar_outcomes for semantic matching. Strips
+    punctuation, drops stopwords (a coarse English list is enough —
+    role prompts dominate the vocabulary anyway).
+    """
+    stopwords = frozenset({
+        "the", "a", "an", "and", "or", "but", "if", "in", "on", "at",
+        "to", "for", "of", "with", "by", "from", "as", "is", "was",
+        "are", "be", "been", "being", "this", "that", "these", "those",
+        "i", "we", "you", "they", "it", "its", "our", "your", "their",
+        "how", "what", "when", "where", "why", "which", "who", "should",
+        "would", "could", "can", "will", "do", "does", "did", "have",
+        "has", "had", "not", "no", "yes", "than", "then", "so", "just",
+        "about", "into", "over", "under", "above", "below",
+    })
+    tokens = re.findall(r"[a-zA-Z][a-zA-Z0-9_]{%d,}" % (min_len - 1), text.lower())
+    return {t for t in tokens if t not in stopwords and len(t) >= min_len}
+
+
+def _parse_constraints_yaml(raw: str) -> list[dict[str, Any]]:
+    """Minimal YAML parser for constraints files.
+
+    Handles the common subset:
+      - top-level `constraints:` key
+      - list entries starting with `  - constraint_id:`
+      - string scalars (quoted or unquoted)
+      - list values (implies, forbids) as `  - "item"`
+
+    No PyYAML dependency needed for this limited grammar.
+    """
+    entries: list[dict[str, Any]] = []
+    current: Optional[dict[str, Any]] = None
+    current_list_key: Optional[str] = None
+
+    for line in raw.splitlines():
+        stripped = line.strip()
+
+        # Skip empty lines and comments
+        if not stripped or stripped.startswith("#"):
+            current_list_key = None
+            continue
+
+        # Top-level constraints key
+        if stripped == "constraints:":
+            continue
+
+        # New list entry
+        if stripped.startswith("- constraint_id:") or stripped.startswith("-constraint_id:"):
+            if current is not None:
+                entries.append(current)
+            current = {}
+            current_list_key = None
+            val = stripped.split(":", 1)[1].strip().strip('"').strip("'")
+            current["constraint_id"] = val
+            continue
+
+        # We're inside an entry
+        if current is not None:
+            # List item (indented under implies/forbids/constrains)
+            if stripped.startswith("- ") and current_list_key:
+                val = stripped[2:].strip().strip('"').strip("'")
+                current.setdefault(current_list_key, []).append(val)
+                continue
+
+            # Key-value pair
+            if ":" in stripped:
+                key, _, val = stripped.partition(":")
+                key = key.strip()
+                val = val.strip().strip('"').strip("'")
+
+                if key in ("implies", "forbids", "constrains"):
+                    if val:
+                        # Inline single value: `implies: some rule`
+                        current[key] = [val]
+                    else:
+                        # Multi-line list follows
+                        current[key] = []
+                        current_list_key = key
+                else:
+                    current[key] = val
+                    current_list_key = None
+
+    if current is not None:
+        entries.append(current)
+
+    return entries
+
+
+def _path_patterns_overlap(requested: list[str], scoped: list[str]) -> bool:
+    if not scoped:
+        return True
+    normalized_requested = [p.replace("\\", "/") for p in requested if p]
+    normalized_scoped = [p.replace("\\", "/") for p in scoped if p]
+    for req in normalized_requested:
+        if req in {"*", "**"}:
+            return True
+        for scope in normalized_scoped:
+            if scope in {"*", "**"}:
+                return True
+            if fnmatch.fnmatch(req, scope) or fnmatch.fnmatch(scope, req):
+                return True
+    return False
+
+
+def _parse_diff_lines(diff_content: str) -> tuple[str, list[tuple[int, str]]]:
+    file_path = ""
+    parsed: list[tuple[int, str]] = []
+    current_line = 0
+
+    for raw_line in diff_content.splitlines():
+        if raw_line.startswith("FILE: "):
+            file_path = raw_line[6:].strip()
+            continue
+        if raw_line.startswith("@@"):
+            match = re.search(r"\+(\d+)", raw_line)
+            if match:
+                current_line = int(match.group(1))
+            continue
+        if raw_line.startswith("+++"):
+            continue
+        if raw_line.startswith("+") and not raw_line.startswith("++"):
+            numbered = re.match(r"^\+(\d+):(.*)$", raw_line)
+            if numbered:
+                parsed.append((int(numbered.group(1)), numbered.group(2)))
+                continue
+            current_line = current_line or 1
+            parsed.append((current_line, raw_line[1:]))
+            current_line += 1
+    return file_path, parsed
+
+
+def _extract_violation_pattern(rule: str) -> str:
+    """Extract a concrete search pattern from a natural-language forbids rule.
+
+    Strategy:
+      - If the rule contains quoted text (e.g. "localhost"), use that.
+      - If the rule contains a technical term (camelCase, snake_case, or
+        path-like), extract it.
+      - Otherwise use the first content word.
+    """
+    # Check for quoted text
+    import re as _re
+    quoted = _re.findall(r'["\']([^"\']+)["\']', rule)
+    if quoted:
+        return quoted[0]
+
+    # Check for technical terms (paths, identifiers)
+    tech = _re.findall(r'[a-zA-Z_][a-zA-Z0-9_./:-]+', rule)
+    if tech:
+        # Skip common non-pattern words
+        skip = {"in", "the", "a", "an", "and", "or", "of", "for", "to", "with", "not", "no"}
+        for t in tech:
+            if t.lower() not in skip and len(t) >= 3:
+                return t
+
+    return ""
+
+
+def _line_matches_constraint_rule(rule: str, line: str) -> bool:
+    lower_line = line.lower()
+    if rule == "no-localhost-on-service-bound":
+        if lower_line.lstrip().startswith(("#", "//")):
+            return False
+        return "localhost" in lower_line or "127.0.0.1" in lower_line
+    if rule == "connection-string-consistency":
+        if not re.search(r"(database_url|db_url|postgres(?:ql)?://|sqlalchemy\.url)", lower_line):
+            return False
+        return any(
+            token in lower_line
+            for token in ("mysql://", "sqlite://", "mongodb://", "redis://")
+        )
+
+    pattern = _extract_violation_pattern(rule).lower()
+    return bool(pattern and pattern in lower_line)
+
+
+def matches_constraint_diff(constraint: dict, diff_content: str) -> list[dict[str, Any]]:
+    """Return concrete line-level violations for a constraint within diff content."""
+    file_path, parsed_lines = _parse_diff_lines(diff_content)
+    rule_names = list(constraint.get("diff_rules") or [])
+    if not rule_names:
+        rule_names = list(constraint.get("forbids") or [])
+
+    matches: list[dict[str, Any]] = []
+    for line_no, line in parsed_lines:
+        for rule in rule_names:
+            if not _line_matches_constraint_rule(str(rule), line):
+                continue
+            matches.append(
+                {
+                    "constraint_id": constraint.get("constraint_id", constraint.get("id", "")),
+                    "constraint_name": constraint.get("name", constraint.get("constraint_id", constraint.get("id", ""))),
+                    "enforcement": constraint.get("enforcement", "hard"),
+                    "rule": str(rule),
+                    "file": file_path,
+                    "line": line_no,
+                    "content": line.strip(),
+                }
+            )
+    return matches

package/lib/python/graph_outcomes_core.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Shared outcome-ranking helpers used by the context slice."""
+
+from __future__ import annotations
+
+import re
+
+from graph_core import nodes_by_type
+
+
+def _extract_keywords(text: str, min_len: int = 3) -> set[str]:
+    stopwords = frozenset({
+        "the", "a", "an", "and", "or", "but", "if", "in", "on", "at",
+        "to", "for", "of", "with", "by", "from", "as", "is", "was",
+        "are", "be", "been", "being", "this", "that", "these", "those",
+        "i", "we", "you", "they", "it", "its", "our", "your", "their",
+        "how", "what", "when", "where", "why", "which", "who", "should",
+        "would", "could", "can", "will", "do", "does", "did", "have",
+        "has", "had", "not", "no", "yes", "than", "then", "so", "just",
+        "about", "into", "over", "under", "above", "below",
+    })
+    tokens = re.findall(r"[a-zA-Z][a-zA-Z0-9_]{%d,}" % (min_len - 1), text.lower())
+    return {t for t in tokens if t not in stopwords and len(t) >= min_len}
+
+
+def find_similar_outcomes(
+    graph: dict,
+    task_text: str,
+    limit: int = 3,
+) -> list[dict]:
+    if not task_text.strip():
+        return []
+
+    keywords = _extract_keywords(task_text)
+    if not keywords:
+        return []
+
+    scored: list[tuple[int, str, dict]] = []
+    for node in nodes_by_type(graph, "Outcome"):
+        if node.get("outcome_status") == "confirmed":
+            continue
+
+        node_tags = {str(t).lower() for t in node.get("tags", [])}
+        tag_overlap = len(node_tags & keywords)
+
+        decision_id = node.get("decision_id", "")
+        decision = graph["nodes"].get(decision_id, {})
+        decision_name = decision.get("name", "").lower()
+        decision_match = sum(1 for kw in keywords if kw in decision_name)
+
+        score = tag_overlap * 2 + decision_match
+        if score > 0:
+            scored.append((score, node.get("updated_at", ""), node))
+
+    scored.sort(key=lambda x: (-x[0], x[1]), reverse=False)
+    scored.sort(key=lambda x: (-x[0], -ord(x[1][0]) if x[1] else 0))
+    return [outcome for _score, _ts, outcome in scored[:limit]]
+
+
+def format_lessons_block(outcomes: list[dict], graph: dict) -> str:
+    if not outcomes:
+        return ""
+
+    lines = ["<lessons_learned>"]
+    for outcome in outcomes:
+        decision_id = outcome.get("decision_id", "")
+        decision = graph["nodes"].get(decision_id, {})
+        decision_name = decision.get("name", decision_id)
+        status = outcome.get("outcome_status", "unknown")
+
+        lines.append(
+            f'Similar past decision "{decision_id}: {decision_name}" was {status}.'
+        )
+        actual = outcome.get("actual_result", "").strip()
+        if actual:
+            lines.append(f"Reason: {actual}")
+        lesson = outcome.get("lessons_learned", "").strip()
+        if lesson:
+            lines.append(f"Lesson: {lesson}")
+        lines.append("")
+
+    while lines and not lines[-1]:
+        lines.pop()
+    lines.append("</lessons_learned>")
+    return "\n".join(lines)

package/lib/python/graph_queries.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""Graph query helpers."""
+
+from __future__ import annotations
+
+import datetime as _dt
+
+from graph_core import nodes_by_type
+from graph_io import record_graph_usage
+
+
+def decisions_for(graph: dict, node_id: str) -> list[dict]:
+    record_graph_usage(graph, "decisions_for", kind="queries")
+    results: list[dict] = []
+    for edge in graph["edges"]:
+        if edge["to"] != node_id:
+            continue
+        if edge["type"] not in ("affects", "satisfies", "chose"):
+            continue
+        dec = graph["nodes"].get(edge["from"])
+        if dec and dec.get("type") == "Decision":
+            results.append(dec)
+    return sorted(results, key=lambda n: n.get("created_at", ""))
+
+
+def ancestors_of(graph: dict, node_id: str, max_depth: int = 10) -> list[dict]:
+    record_graph_usage(graph, "ancestors_of", kind="queries")
+    visited: set[str] = {node_id}
+    results: list[dict] = []
+    queue: list[tuple[str, int, str]] = [(node_id, 0, "self")]
+
+    while queue:
+        current_id, depth, edge_type = queue.pop(0)
+        if depth >= max_depth:
+            continue
+        for edge in graph["edges"]:
+            if edge["from"] == current_id and edge["type"] == "decision_ancestry":
+                parent_id = edge["to"]
+                if parent_id not in visited:
+                    visited.add(parent_id)
+                    parent = graph["nodes"].get(parent_id)
+                    if parent and parent.get("type") == "Decision":
+                        results.append({
+                            "node": parent,
+                            "depth": depth + 1,
+                            "edge_type": "decision_ancestry",
+                            "edge_reason": edge.get("reason", ""),
+                        })
+                        queue.append((parent_id, depth + 1, "decision_ancestry"))
+            if edge["from"] == current_id and edge["type"] == "supersedes":
+                old_id = edge["to"]
+                if old_id not in visited:
+                    visited.add(old_id)
+                    old = graph["nodes"].get(old_id)
+                    if old and old.get("type") == "Decision":
+                        results.append({
+                            "node": old,
+                            "depth": depth + 1,
+                            "edge_type": "supersedes",
+                            "edge_reason": edge.get("reason", ""),
+                        })
+                        queue.append((old_id, depth + 1, "supersedes"))
+
+    return results
+
+
+def descendants_of(graph: dict, node_id: str, max_depth: int = 10) -> list[dict]:
+    record_graph_usage(graph, "descendants_of", kind="queries")
+    visited: set[str] = {node_id}
+    results: list[dict] = []
+    queue: list[tuple[str, int, str]] = [(node_id, 0, "self")]
+
+    while queue:
+        current_id, depth, edge_type = queue.pop(0)
+        if depth >= max_depth:
+            continue
+        for edge in graph["edges"]:
+            if edge["to"] == current_id and edge["type"] == "decision_ancestry":
+                child_id = edge["from"]
+                if child_id not in visited:
+                    visited.add(child_id)
+                    child = graph["nodes"].get(child_id)
+                    if child and child.get("type") == "Decision":
+                        results.append({
+                            "node": child,
+                            "depth": depth + 1,
+                            "edge_type": "decision_ancestry",
+                            "edge_reason": edge.get("reason", ""),
+                        })
+                        queue.append((child_id, depth + 1, "decision_ancestry"))
+            if edge["to"] == current_id and edge["type"] == "supersedes":
+                new_id = edge["from"]
+                if new_id not in visited:
+                    visited.add(new_id)
+                    new = graph["nodes"].get(new_id)
+                    if new and new.get("type") == "Decision":
+                        results.append({
+                            "node": new,
+                            "depth": depth + 1,
+                            "edge_type": "supersedes",
+                            "edge_reason": edge.get("reason", ""),
+                        })
+                        queue.append((new_id, depth + 1, "supersedes"))
+
+    return results
+
+
+def tech_context(graph: dict) -> list[dict]:
+    record_graph_usage(graph, "tech_context", kind="queries")
+    return nodes_by_type(graph, "Technology")
+
+
+def open_risks(graph: dict) -> list[dict]:
+    record_graph_usage(graph, "open_risks", kind="queries")
+    mitigated: set[str] = set()
+    for edge in graph["edges"]:
+        if edge["type"] == "mitigates":
+            mitigated.add(edge["to"])
+
+    return [
+        n for n in nodes_by_type(graph, "Risk")
+        if n["id"] not in mitigated and n.get("status", "active") != "resolved"
+    ]
+
+
+def impact(graph: dict, node_id: str) -> dict[str, list[str]]:
+    record_graph_usage(graph, "impact", kind="queries")
+    result: dict[str, list[str]] = {}
+    for edge in graph["edges"]:
+        if edge["to"] != node_id:
+            continue
+        result.setdefault(edge["type"], []).append(edge["from"])
+    return result
+
+
+def stale_tech(graph: dict, max_age_days: int = 7) -> list[dict]:
+    record_graph_usage(graph, "stale_tech", kind="queries")
+    cutoff = _dt.datetime.now(_dt.timezone.utc) - _dt.timedelta(days=max_age_days)
+    result: list[dict] = []
+    for node in nodes_by_type(graph, "Technology"):
+        checked_at_raw = node.get("scout_checked_at")
+        if not checked_at_raw:
+            result.append(node)
+            continue
+        try:
+            checked_at = _dt.datetime.strptime(
+                checked_at_raw.replace("Z", "+0000"),
+                "%Y-%m-%dT%H:%M:%S%z",
+            )
+        except (ValueError, AttributeError):
+            result.append(node)
+            continue
+        if checked_at < cutoff:
+            result.append(node)
+    return result
+
+
+def unsatisfied_reqs(graph: dict) -> list[dict]:
+    record_graph_usage(graph, "unsatisfied_reqs", kind="queries")
+    satisfied: set[str] = set()
+    violated: set[str] = set()
+    for edge in graph["edges"]:
+        if edge["type"] == "satisfies":
+            satisfied.add(edge["to"])
+        elif edge["type"] == "violates":
+            violated.add(edge["to"])
+
+    return [
+        n for n in nodes_by_type(graph, "Requirement")
+        if n["id"] not in satisfied or n["id"] in violated
+    ]

package/lib/python/graph_slice.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Traversal helpers for prompt-context slices."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from graph_core import (
+    CHARS_PER_TOKEN,
+    DEFAULT_EDGE_WEIGHT,
+    DEFAULT_SLICE_TOKEN_BUDGET,
+    HOP2_WEIGHT_THRESHOLD,
+    ROLE_TYPE_INTERESTS,
+    _slug,
+)
+from graph_io import record_graph_usage
+from graph_outcomes_core import find_similar_outcomes, format_lessons_block
+from graph_queries import open_risks, tech_context
+
+
+def extract_anchors(graph: dict, task_text: str, max_anchors: int = 8) -> list[str]:
+    record_graph_usage(graph, "extract_anchors", kind="queries")
+    if not task_text.strip():
+        return []
+
+    text_lower = task_text.lower()
+    scores: dict[str, int] = {}
+
+    for node_id, node in graph["nodes"].items():
+        if node_id in task_text:
+            scores[node_id] = max(scores.get(node_id, 0), 3)
+            continue
+
+        name = node.get("name", "")
+        name_lower = name.lower()
+        if name_lower and name_lower in text_lower:
+            scores[node_id] = max(scores.get(node_id, 0), 2)
+            continue
+
+        slug = _slug(name)
+        if slug and len(slug) >= 3 and slug in text_lower:
+            scores[node_id] = max(scores.get(node_id, 0), 1)
+
+    ranked = sorted(scores.items(), key=lambda kv: (-kv[1], kv[0]))
+    return [node_id for node_id, _score in ranked[:max_anchors]]
+
+
+def expand_bfs(
+    graph: dict,
+    anchors: Iterable[str],
+    *,
+    hops: int = 2,
+    hop2_weight_threshold: float = HOP2_WEIGHT_THRESHOLD,
+) -> set[str]:
+    record_graph_usage(graph, "expand_bfs", kind="queries")
+    if hops < 1:
+        raise ValueError(f"hops must be >= 1, got {hops}")
+
+    visited: set[str] = set()
+    frontier: set[str] = set()
+
+    for anchor in anchors:
+        if anchor in graph["nodes"]:
+            visited.add(anchor)
+            frontier.add(anchor)
+
+    for hop in range(1, hops + 1):
+        next_frontier: set[str] = set()
+        for node_id in frontier:
+            for edge in graph["edges"]:
+                if edge["from"] != node_id and edge["to"] != node_id:
+                    continue
+                if hop >= 2 and edge.get("weight", DEFAULT_EDGE_WEIGHT) < hop2_weight_threshold:
+                    continue
+                neighbor = edge["to"] if edge["from"] == node_id else edge["from"]
+                if neighbor not in visited and neighbor in graph["nodes"]:
+                    next_frontier.add(neighbor)
+                    visited.add(neighbor)
+        if not next_frontier:
+            break
+        frontier = next_frontier
+
+    return visited
+
+
+def filter_by_role(
+    graph: dict,
+    node_ids: Iterable[str],
+    role: str,
+) -> set[str]:
+    record_graph_usage(graph, "filter_by_role", kind="queries")
+    interests = ROLE_TYPE_INTERESTS.get(role)
+    if interests is None:
+        return set(node_ids)
+
+    result: set[str] = set()
+    for node_id in node_ids:
+        node = graph["nodes"].get(node_id)
+        if node and node.get("type") in interests:
+            result.add(node_id)
+    return result
+
+
+def serialize_slice(
+    graph: dict,
+    node_ids: Iterable[str],
+    *,
+    token_budget: int = DEFAULT_SLICE_TOKEN_BUDGET,
+) -> str:
+    record_graph_usage(graph, "serialize_slice", kind="queries")
+    selected = [graph["nodes"][nid] for nid in node_ids if nid in graph["nodes"]]
+    if not selected:
+        return ""
+
+    char_budget = token_budget * CHARS_PER_TOKEN
+
+    by_type: dict[str, list[dict]] = {}
+    for node in selected:
+        by_type.setdefault(node["type"], []).append(node)
+
+    selected_ids = {n["id"] for n in selected}
+    edges_by_source: dict[str, list[str]] = {}
+    for edge in graph["edges"]:
+        src, tgt = edge["from"], edge["to"]
+        if src in selected_ids and tgt in selected_ids:
+            edges_by_source.setdefault(src, []).append(f"{edge['type']}->{tgt}")
+
+    lines: list[str] = []
+    for node_type in sorted(by_type.keys()):
+        lines.append(f"[{node_type}]")
+        for node in sorted(by_type[node_type], key=lambda n: n["id"]):
+            parts = [f"  {node['id']}: {node.get('name', '')}"]
+            status = node.get("status", "")
+            if status and status != "active":
+                parts.append(f"({status})")
+            desc = node.get("description", "")
+            if desc:
+                parts.append(f"— {desc[:100]}")
+            out_edges = edges_by_source.get(node["id"], [])
+            if out_edges:
+                parts.append(f"[{', '.join(out_edges[:3])}]")
+            lines.append(" ".join(parts))
+
+    text = "\n".join(lines)
+    if len(text) > char_budget:
+        truncated_lines: list[str] = []
+        running = 0
+        for line in lines:
+            if running + len(line) + 1 > char_budget:
+                remaining = len(lines) - len(truncated_lines)
+                truncated_lines.append(f"... ({remaining} more)")
+                break
+            truncated_lines.append(line)
+            running += len(line) + 1
+        text = "\n".join(truncated_lines)
+    return text
+
+
+def build_context_slice(
+    graph: dict,
+    task_text: str,
+    role: str,
+    *,
+    hops: int = 2,
+    token_budget: int = DEFAULT_SLICE_TOKEN_BUDGET,
+) -> str:
+    record_graph_usage(graph, "build_context_slice", kind="queries")
+    anchors = extract_anchors(graph, task_text)
+    if not anchors:
+        return ""
+    expanded = expand_bfs(graph, anchors, hops=hops)
+    filtered = filter_by_role(graph, expanded, role)
+    text = serialize_slice(graph, filtered, token_budget=token_budget)
+
+    sections: list[str] = []
+    if text:
+        sections.append(text)
+
+    lessons = find_similar_outcomes(graph, task_text, limit=2)
+    if lessons:
+        sections.append(format_lessons_block(lessons, graph))
+
+    risks = open_risks(graph)
+    if risks:
+        risk_lines = ["[open_risks]"]
+        for r in risks[:5]:
+            sev = r.get("severity", "unknown")
+            risk_lines.append(f"  {r['id']} [{sev}] {r.get('name', '')}")
+        sections.append("\n".join(risk_lines))
+
+    tech = tech_context(graph)
+    if tech:
+        tech_lines = ["[technology]"]
+        for t in tech[:15]:
+            tech_lines.append(f"  {t['id']}: {t.get('name', '')}")
+        sections.append("\n".join(tech_lines))
+
+    return "\n\n".join(sections) if sections else ""