algo-cli-runtime 0.14.0__py3-none-any.whl

algo_cli/intelligence/code_graph.py

@@ -0,0 +1,180 @@
+"""B77. AST-Based Code Knowledge Graph.
+
+Build a queryable graph from AST: CONTAINS, CALLS, IMPORTS, INHERITS.
+Source: PyCodeKG pattern.
+"""
+from __future__ import annotations
+
+import ast
+import hashlib
+from dataclasses import dataclass
+from enum import Enum, auto
+from pathlib import Path
+
+
+class NodeKind(Enum):
+    MODULE = auto()
+    CLASS = auto()
+    FUNCTION = auto()
+    METHOD = auto()
+
+
+class EdgeKind(Enum):
+    CONTAINS = auto()
+    CALLS = auto()
+    IMPORTS = auto()
+    INHERITS = auto()
+
+
+@dataclass
+class CodeNode:
+    id: str
+    kind: NodeKind
+    name: str
+    qualified_name: str
+    file: str
+    line: int
+    signature: str = ""
+    docstring: str = ""
+
+
+@dataclass
+class CodeEdge:
+    source: str
+    target: str
+    kind: EdgeKind
+
+
+class CodeGraph:
+    """Queryable AST-derived graph of codebase structure."""
+
+    def __init__(self) -> None:
+        self._nodes: dict[str, CodeNode] = {}
+        self._edges: list[CodeEdge] = []
+        self._by_name: dict[str, list[str]] = {}  # name → node IDs
+
+    def build(self, root: Path, pattern: str = "*.py") -> int:
+        """Build graph from Python files. Returns node count."""
+        for py_file in root.rglob(pattern):
+            try:
+                source = py_file.read_text(encoding="utf-8")
+                tree = ast.parse(source, filename=str(py_file))
+                self._process_module(tree, str(py_file), str(root))
+            except Exception:
+                continue
+        return len(self._nodes)
+
+    def _process_module(self, tree: ast.Module, filepath: str, root: str) -> None:
+        module_id = self._node_id(filepath, "module", 0)
+        module_node = CodeNode(
+            id=module_id, kind=NodeKind.MODULE, name=Path(filepath).stem,
+            qualified_name=Path(filepath).relative_to(root).as_posix() if filepath.startswith(root) else filepath,
+            file=filepath, line=0,
+        )
+        self._add_node(module_node)
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                cls_id = self._node_id(filepath, node.name, node.lineno)
+                cls_node = CodeNode(
+                    id=cls_id, kind=NodeKind.CLASS, name=node.name,
+                    qualified_name=f"{module_node.name}.{node.name}",
+                    file=filepath, line=node.lineno,
+                    docstring=ast.get_docstring(node) or "",
+                )
+                self._add_node(cls_node)
+                self._edges.append(CodeEdge(source=module_id, target=cls_id, kind=EdgeKind.CONTAINS))
+
+                # Inheritance
+                for base in node.bases:
+                    if isinstance(base, ast.Name):
+                        self._edges.append(CodeEdge(
+                            source=cls_id, target=base.id, kind=EdgeKind.INHERITS
+                        ))
+
+                # Methods
+                for item in node.body:
+                    if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        method_id = self._node_id(filepath, f"{node.name}.{item.name}", item.lineno)
+                        method_node = CodeNode(
+                            id=method_id, kind=NodeKind.METHOD, name=item.name,
+                            qualified_name=f"{module_node.name}.{node.name}.{item.name}",
+                            file=filepath, line=item.lineno,
+                            signature=self._signature(item),
+                            docstring=ast.get_docstring(item) or "",
+                        )
+                        self._add_node(method_node)
+                        self._edges.append(CodeEdge(source=cls_id, target=method_id, kind=EdgeKind.CONTAINS))
+                        self._process_calls(method_id, item)
+
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                func_id = self._node_id(filepath, node.name, node.lineno)
+                func_node = CodeNode(
+                    id=func_id, kind=NodeKind.FUNCTION, name=node.name,
+                    qualified_name=f"{module_node.name}.{node.name}",
+                    file=filepath, line=node.lineno,
+                    signature=self._signature(node),
+                    docstring=ast.get_docstring(node) or "",
+                )
+                self._add_node(func_node)
+                self._edges.append(CodeEdge(source=module_id, target=func_id, kind=EdgeKind.CONTAINS))
+                self._process_calls(func_id, node)
+
+            elif isinstance(node, (ast.Import, ast.ImportFrom)):
+                self._process_imports(module_id, node)
+
+        return None
+
+    def _process_calls(self, source_id: str, func_node: ast.FunctionDef) -> None:
+        for node in ast.walk(func_node):
+            if isinstance(node, ast.Call):
+                if isinstance(node.func, ast.Name):
+                    self._edges.append(CodeEdge(source=source_id, target=node.func.id, kind=EdgeKind.CALLS))
+                elif isinstance(node.func, ast.Attribute):
+                    self._edges.append(CodeEdge(source=source_id, target=node.func.attr, kind=EdgeKind.CALLS))
+
+    def _process_imports(self, module_id: str, node: ast.Import | ast.ImportFrom) -> None:
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                self._edges.append(CodeEdge(source=module_id, target=alias.name, kind=EdgeKind.IMPORTS))
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module or ""
+            for alias in node.names:
+                target = f"{module}.{alias.name}" if module else alias.name
+                self._edges.append(CodeEdge(source=module_id, target=target, kind=EdgeKind.IMPORTS))
+
+    def _signature(self, node: ast.FunctionDef) -> str:
+        args = [a.arg for a in node.args.args]
+        return f"({', '.join(args)})"
+
+    def _node_id(self, filepath: str, name: str, line: int) -> str:
+        return hashlib.md5(f"{filepath}:{name}:{line}".encode()).hexdigest()[:12]
+
+    def _add_node(self, node: CodeNode) -> None:
+        self._nodes[node.id] = node
+        self._by_name.setdefault(node.name, []).append(node.id)
+
+    def callers(self, name: str) -> list[CodeNode]:
+        """Find all nodes that call the given function name."""
+        caller_ids = {e.source for e in self._edges if e.kind == EdgeKind.CALLS and e.target == name}
+        return [self._nodes[cid] for cid in caller_ids if cid in self._nodes]
+
+    def callees(self, name: str) -> list[str]:
+        """Find all functions called by the given function name."""
+        return [e.target for e in self._edges if e.kind == EdgeKind.CALLS
+                and any(self._nodes[nid].name == name for nid in [e.source] if nid in self._nodes)]
+
+    def dead_code(self) -> list[CodeNode]:
+        """Find functions/methods with zero callers."""
+        called_names = {e.target for e in self._edges if e.kind == EdgeKind.CALLS}
+        return [n for n in self._nodes.values()
+                if n.kind in (NodeKind.FUNCTION, NodeKind.METHOD)
+                and n.name not in called_names]
+
+    @property
+    def node_count(self) -> int:
+        return len(self._nodes)
+
+    @property
+    def edge_count(self) -> int:
+        return len(self._edges)

algo_cli/intelligence/coderank.py

@@ -0,0 +1,97 @@
+"""B85. CodeRank: Structural Importance Ranking.
+
+PageRank over code graph to find most structurally important symbols.
+Source: PyCodeKG pattern.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class CodeRankResult:
+    symbol: str
+    rank: float
+    kind: str = ""
+    file: str = ""
+
+
+class CodeRank:
+    """Compute PageRank over a code graph to find critical symbols."""
+
+    def __init__(self, damping: float = 0.85, max_iterations: int = 100,
+                 tolerance: float = 1e-6) -> None:
+        self._damping = damping
+        self._max_iter = max_iterations
+        self._tolerance = tolerance
+
+    def compute(self, nodes: list[str], edges: list[tuple[str, str]],
+                weights: dict[tuple[str, str], float] | None = None) -> list[CodeRankResult]:
+        """Compute PageRank for code symbols.
+
+        Args:
+            nodes: List of node IDs
+            edges: List of (source, target) directed edges
+            weights: Optional edge weights
+        """
+        if not nodes:
+            return []
+
+        n = len(nodes)
+        node_idx = {node: i for i, node in enumerate(nodes)}
+
+        # Build adjacency: out-links and in-links
+        out_links: dict[int, list[int]] = {i: [] for i in range(n)}
+        in_links: dict[int, list[int]] = {i: [] for i in range(n)}
+
+        for src, tgt in edges:
+            if src in node_idx and tgt in node_idx:
+                si, ti = node_idx[src], node_idx[tgt]
+                out_links[si].append(ti)
+                in_links[ti].append(si)
+
+        # Initialize ranks
+        ranks = [1.0 / n] * n
+
+        # Iterate
+        for _ in range(self._max_iter):
+            new_ranks = [0.0] * n
+            for i in range(n):
+                # Base rank from random jump
+                new_ranks[i] = (1 - self._damping) / n
+
+                # Rank from in-links
+                for j in in_links[i]:
+                    out_count = len(out_links[j])
+                    if out_count > 0:
+                        new_ranks[i] += self._damping * ranks[j] / out_count
+                    else:
+                        # Dangling node: distribute rank evenly
+                        new_ranks[i] += self._damping * ranks[j] / n
+
+            # Check convergence
+            diff = sum(abs(new_ranks[i] - ranks[i]) for i in range(n))
+            ranks = new_ranks
+            if diff < self._tolerance:
+                break
+
+        # Sort by rank descending
+        results = [
+            CodeRankResult(symbol=nodes[i], rank=ranks[i])
+            for i in range(n)
+        ]
+        results.sort(key=lambda x: x.rank, reverse=True)
+        return results
+
+    def find_critical(self, results: list[CodeRankResult],
+                      top_k: int = 10) -> list[CodeRankResult]:
+        """Find the top-K most structurally critical symbols."""
+        return results[:top_k]
+
+    def find_bottlenecks(self, results: list[CodeRankResult],
+                         threshold: float = 0.05) -> list[CodeRankResult]:
+        """Find symbols with unusually high rank (potential bottlenecks)."""
+        if not results:
+            return []
+        avg_rank = sum(r.rank for r in results) / len(results)
+        return [r for r in results if r.rank > avg_rank * (1 + threshold)]

algo_cli/intelligence/consistent_hash.py

@@ -0,0 +1,150 @@
+"""Consistent Hashing — minimal redistribution on topology change.
+
+Distributes keys across N nodes using a ring of virtual nodes (vnodes).
+When a node is added or removed, only K/N keys need to move (where K is
+total keys and N is node count), vs. K keys with naive mod-N hashing.
+
+Harness use:
+  - Route requests across multiple Ollama instances
+  - Route embedding batches across multiple model endpoints
+  - Distribute harness indexing work across worker processes
+  - Session affinity — keep the same user on the same node
+
+Operations:
+  - add_node(node): add a node to the ring
+  - remove_node(node): remove a node from the ring
+  - get_node(key): find the node responsible for a key
+  - get_nodes(key, count): get the next N nodes (for replication)
+
+Properties:
+  - O(log V) lookup where V = num_nodes * vnodes_per_node
+  - Monotonic: only keys mapped to removed/added nodes move
+  - Load balanced via virtual nodes
+"""
+from __future__ import annotations
+
+import hashlib
+from collections import defaultdict
+from typing import Any
+
+
+class ConsistentHashRing:
+    """Consistent hash ring with virtual nodes.
+
+    Args:
+        vnodes_per_node: Number of virtual nodes per physical node.
+            Higher = better load distribution, more memory.
+    """
+
+    def __init__(self, vnodes_per_node: int = 150) -> None:
+        self.vnodes_per_node = vnodes_per_node
+        self._ring: dict[int, str] = {}  # hash -> node_name
+        self._sorted_hashes: list[int] = []
+        self._nodes: set[str] = set()
+
+    def _hash(self, key: str) -> int:
+        """Hash a key to a 64-bit integer."""
+        return int.from_bytes(
+            hashlib.md5(key.encode("utf-8")).digest()[:8],
+            "little",
+        )
+
+    def add_node(self, node: str) -> None:
+        """Add a node to the ring with vnodes_per_node virtual nodes."""
+        if node in self._nodes:
+            return
+        self._nodes.add(node)
+        for i in range(self.vnodes_per_node):
+            vnode_key = f"{node}#{i}"
+            h = self._hash(vnode_key)
+            self._ring[h] = node
+        self._sorted_hashes = sorted(self._ring.keys())
+
+    def remove_node(self, node: str) -> None:
+        """Remove a node and all its virtual nodes."""
+        if node not in self._nodes:
+            return
+        self._nodes.discard(node)
+        for i in range(self.vnodes_per_node):
+            vnode_key = f"{node}#{i}"
+            h = self._hash(vnode_key)
+            self._ring.pop(h, None)
+        self._sorted_hashes = sorted(self._ring.keys())
+
+    def get_node(self, key: Any) -> str | None:
+        """Find the node responsible for a key.
+
+        Returns the first node clockwise from the key's hash position.
+        Returns None if the ring is empty.
+        """
+        if not self._sorted_hashes:
+            return None
+        h = self._hash(str(key))
+        # Binary search for the first hash >= h
+        lo, hi = 0, len(self._sorted_hashes)
+        while lo < hi:
+            mid = (lo + hi) // 2
+            if self._sorted_hashes[mid] < h:
+                lo = mid + 1
+            else:
+                hi = mid
+        # Wrap around if we passed the end
+        if lo == len(self._sorted_hashes):
+            lo = 0
+        return self._ring[self._sorted_hashes[lo]]
+
+    def get_nodes(self, key: Any, count: int = 3) -> list[str]:
+        """Get the next *count* distinct nodes for a key (for replication).
+
+        Walks clockwise around the ring collecting distinct nodes.
+        """
+        if not self._sorted_hashes or count <= 0:
+            return []
+        h = self._hash(str(key))
+        lo, hi = 0, len(self._sorted_hashes)
+        while lo < hi:
+            mid = (lo + hi) // 2
+            if self._sorted_hashes[mid] < h:
+                lo = mid + 1
+            else:
+                hi = mid
+        result: list[str] = []
+        seen: set[str] = set()
+        n = len(self._sorted_hashes)
+        for i in range(n):
+            idx = (lo + i) % n
+            node = self._ring[self._sorted_hashes[idx]]
+            if node not in seen:
+                seen.add(node)
+                result.append(node)
+                if len(result) >= count:
+                    break
+        return result
+
+    def node_distribution(self, sample_keys: list[Any]) -> dict[str, int]:
+        """Simulate key distribution across nodes.
+
+        Useful for verifying load balance.
+        """
+        dist: dict[str, int] = defaultdict(int)
+        for key in sample_keys:
+            node = self.get_node(key)
+            if node:
+                dist[node] += 1
+        return dict(dist)
+
+    @property
+    def node_count(self) -> int:
+        return len(self._nodes)
+
+    @property
+    def ring_size(self) -> int:
+        return len(self._ring)
+
+    def stats(self) -> dict[str, Any]:
+        return {
+            "nodes": list(self._nodes),
+            "node_count": len(self._nodes),
+            "vnodes_per_node": self.vnodes_per_node,
+            "ring_size": len(self._ring),
+        }

algo_cli/intelligence/consortium_synthesis.py

@@ -0,0 +1,139 @@
+"""H25 — Consortium Synthesis.
+
+Synthesize ground truth from all model responses (vs H12's pick-winner).
+Mined from G0DM0D3 api/lib/consortium.ts.
+
+Unlike ULTRAPLINIAN (H12) which picks the BEST single response, CONSORTIUM
+collects ALL responses and feeds them to an orchestrator model that
+synthesizes ground truth. Key principles: ground truth over popularity,
+specificity wins, no hedging, attribution-free.
+
+LLM integration: requires an orchestrator model for synthesis. Falls back
+to rule-based merge when no model is available.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ConsortiumResponse:
+    """A single model's response in the consortium."""
+
+    model_name: str
+    response: str
+    confidence: float = 0.0
+
+
+@dataclass
+class SynthesisResult:
+    """Result of consortium synthesis."""
+
+    synthesized: str
+    source_models: list[str] = field(default_factory=list)
+    agreement_score: float = 0.0
+    method: str = "rule-based"  # or "llm-orchestrated"
+    dissenting_models: list[str] = field(default_factory=list)
+
+
+def _extract_claims(text: str) -> set[str]:
+    """Extract claim-like sentences from text (rule-based)."""
+    import re
+    # Split on sentence boundaries
+    sentences = re.split(r"[.!?]\s+", text)
+    # Filter to substantive sentences (not too short, not questions)
+    claims = set()
+    for s in sentences:
+        s = s.strip()
+        if len(s) > 10 and not s.endswith("?"):
+            claims.add(s.lower())
+    return claims
+
+
+def _rule_based_synthesize(responses: list[ConsortiumResponse]) -> SynthesisResult:
+    """Rule-based synthesis: find common claims across models."""
+    if not responses:
+        return SynthesisResult(synthesized="", method="rule-based")
+
+    # Extract claims from each response
+    all_claims: dict[str, set[str]] = {}
+    for resp in responses:
+        all_claims[resp.model_name] = _extract_claims(resp.response)
+
+    # Find claims that appear in multiple responses (agreement)
+    claim_counts: dict[str, int] = {}
+    for model_claims in all_claims.values():
+        for claim in model_claims:
+            claim_counts[claim] = claim_counts.get(claim, 0) + 1
+
+    # Synthesize: claims that appear in majority of responses
+    threshold = max(2, len(responses) // 2 + 1)
+    consensus_claims = [c for c, count in claim_counts.items() if count >= threshold]
+
+    # Sort by frequency (most agreed first)
+    consensus_claims.sort(key=lambda c: -claim_counts[c])
+
+    synthesized = ". ".join(consensus_claims[:10]) if consensus_claims else responses[0].response
+
+    # Agreement score: fraction of claims that reached consensus
+    total_claims = len(claim_counts)
+    consensus_count = len(consensus_claims)
+    agreement = consensus_count / total_claims if total_claims > 0 else 0.0
+
+    # Find dissenting models (low overlap with consensus)
+    consensus_set = set(consensus_claims)
+    dissenting = []
+    for model_name, model_claims in all_claims.items():
+        overlap = len(model_claims & consensus_set)
+        if overlap < len(consensus_set) * 0.3:
+            dissenting.append(model_name)
+
+    return SynthesisResult(
+        synthesized=synthesized,
+        source_models=[r.model_name for r in responses],
+        agreement_score=agreement,
+        method="rule-based",
+        dissenting_models=dissenting,
+    )
+
+
+def synthesize(
+    responses: list[ConsortiumResponse],
+    orchestrator_client: Any | None = None,
+) -> SynthesisResult:
+    """Synthesize ground truth from multiple model responses.
+
+    Args:
+        responses: List of model responses.
+        orchestrator_client: Optional orchestrator model that synthesizes
+                            from all responses. Falls back to rule-based merge.
+
+    Returns:
+        SynthesisResult with synthesized ground truth.
+    """
+    if not responses:
+        return SynthesisResult(synthesized="", method="empty")
+
+    # Try LLM orchestrator if available
+    if orchestrator_client is not None:
+        try:
+            prompt_parts = ["Synthesize ground truth from these model responses:"]
+            for resp in responses:
+                prompt_parts.append(f"\n[{resp.model_name}]: {resp.response}")
+            prompt_parts.append("\n\nPrinciples: ground truth over popularity, specificity wins, no hedging, attribution-free.")
+            prompt = "\n".join(prompt_parts)
+
+            result = orchestrator_client.generate(prompt)
+            if result:
+                return SynthesisResult(
+                    synthesized=result,
+                    source_models=[r.model_name for r in responses],
+                    agreement_score=1.0,
+                    method="llm-orchestrated",
+                )
+        except Exception:
+            pass
+
+    # Fall back to rule-based synthesis
+    return _rule_based_synthesize(responses)