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

algo_cli/intelligence/cross_source.py

@@ -0,0 +1,113 @@
+"""B66. Cross-Source Analysis.
+
+Sentiment, consensus, disagreements across sources.
+Source: sibyl pattern.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum, auto
+import re
+
+
+class Sentiment(Enum):
+    POSITIVE = auto()
+    NEUTRAL = auto()
+    NEGATIVE = auto()
+    MIXED = auto()
+
+
+@dataclass
+class SourcePosition:
+    source: str
+    title: str
+    position: str  # summary of what this source says
+    sentiment: Sentiment = Sentiment.NEUTRAL
+    key_points: list[str] = field(default_factory=list)
+
+
+@dataclass
+class CrossSourceAnalysis:
+    question: str
+    positions: list[SourcePosition] = field(default_factory=list)
+    consensus: list[str] = field(default_factory=list)
+    disagreements: list[str] = field(default_factory=list)
+    overall_sentiment: Sentiment = Sentiment.NEUTRAL
+    source_count: int = 0
+
+
+class CrossSourceAnalyzer:
+    """Analyze agreement/disagreement across multiple sources."""
+
+    POSITIVE_WORDS = {"good", "great", "excellent", "best", "recommend", "fast", "efficient", "easy", "powerful", "effective"}
+    NEGATIVE_WORDS = {"bad", "poor", "slow", "broken", "fail", "issue", "problem", "difficult", "complex", "deprecated"}
+
+    def analyze(self, question: str,
+                sources: list[tuple[str, str, str]]) -> CrossSourceAnalysis:
+        """Analyze positions across sources.
+
+        Args:
+            question: The question being analyzed
+            sources: List of (source_name, title, content)
+        """
+        result = CrossSourceAnalysis(question=question, source_count=len(sources))
+
+        for src_name, title, content in sources:
+            position = SourcePosition(source=src_name, title=title, position=content[:200])
+            position.sentiment = self._detect_sentiment(content)
+            position.key_points = self._extract_key_points(content)
+            result.positions.append(position)
+
+        result.consensus = self._find_consensus(result.positions)
+        result.disagreements = self._find_disagreements(result.positions)
+        result.overall_sentiment = self._overall_sentiment(result.positions)
+
+        return result
+
+    def _detect_sentiment(self, text: str) -> Sentiment:
+        words = set(text.lower().split())
+        pos = len(words & self.POSITIVE_WORDS)
+        neg = len(words & self.NEGATIVE_WORDS)
+        if pos > neg and pos > 0:
+            return Sentiment.POSITIVE
+        elif neg > pos and neg > 0:
+            return Sentiment.NEGATIVE
+        elif pos > 0 and neg > 0:
+            return Sentiment.MIXED
+        return Sentiment.NEUTRAL
+
+    def _extract_key_points(self, content: str) -> list[str]:
+        sentences = re.split(r"[.!?]+", content)
+        return [s.strip() for s in sentences if len(s.strip()) > 20][:5]
+
+    def _find_consensus(self, positions: list[SourcePosition]) -> list[str]:
+        """Find points mentioned by multiple sources."""
+        point_counts: dict[str, int] = {}
+        for pos in positions:
+            for point in pos.key_points:
+                key = point.lower()[:50]
+                point_counts[key] = point_counts.get(key, 0) + 1
+        return [p for p, c in point_counts.items() if c >= 2]
+
+    def _find_disagreements(self, positions: list[SourcePosition]) -> list[str]:
+        """Find where sources have different sentiments."""
+        disagreements: list[str] = []
+        sentiments = {p.source: p.sentiment for p in positions}
+        unique = set(sentiments.values())
+        if len(unique) > 1:
+            disagreements.append(f"Sources disagree on sentiment: {sentiments}")
+        return disagreements
+
+    def _overall_sentiment(self, positions: list[SourcePosition]) -> Sentiment:
+        if not positions:
+            return Sentiment.NEUTRAL
+        sentiments = [p.sentiment for p in positions]
+        pos = sum(1 for s in sentiments if s == Sentiment.POSITIVE)
+        neg = sum(1 for s in sentiments if s == Sentiment.NEGATIVE)
+        if pos > neg:
+            return Sentiment.POSITIVE
+        elif neg > pos:
+            return Sentiment.NEGATIVE
+        elif pos > 0 and neg > 0:
+            return Sentiment.MIXED
+        return Sentiment.NEUTRAL

algo_cli/intelligence/daemon_mode.py

@@ -0,0 +1,99 @@
+"""B59. Daemon Mode: Multi-Client Shared Agent.
+
+HTTP+SSE server: multiple clients share one agent session.
+Source: qwen-code pattern.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+
+@dataclass
+class ClientSession:
+    client_id: str
+    connected_at: float = field(default_factory=time.time)
+    last_active: float = field(default_factory=time.time)
+    subscriptions: set[str] = field(default_factory=set)
+
+
+@dataclass
+class SharedMessage:
+    id: str
+    role: str  # "user", "assistant", "system"
+    content: str
+    client_id: str | None = None  # who sent it (None = system)
+    timestamp: float = field(default_factory=time.time)
+
+
+class DaemonAgent:
+    """Shared agent session that multiple clients can connect to."""
+
+    def __init__(self, max_clients: int = 10, max_messages: int = 1000) -> None:
+        self._clients: dict[str, ClientSession] = {}
+        self._messages: list[SharedMessage] = []
+        self._max_clients = max_clients
+        self._max_messages = max_messages
+        self._message_counter = 0
+        self._event_handlers: dict[str, list[Callable]] = {}
+
+    def connect(self, client_id: str) -> ClientSession:
+        if len(self._clients) >= self._max_clients:
+            raise RuntimeError(f"Max clients ({self._max_clients}) reached")
+        if client_id in self._clients:
+            return self._clients[client_id]
+        session = ClientSession(client_id=client_id)
+        self._clients[client_id] = session
+        self._emit("client_connected", client_id)
+        return session
+
+    def disconnect(self, client_id: str) -> None:
+        self._clients.pop(client_id, None)
+        self._emit("client_disconnected", client_id)
+
+    def send_message(self, client_id: str, role: str, content: str) -> SharedMessage:
+        self._message_counter += 1
+        msg = SharedMessage(
+            id=f"msg_{self._message_counter}",
+            role=role,
+            content=content,
+            client_id=client_id,
+        )
+        self._messages.append(msg)
+        if len(self._messages) > self._max_messages:
+            self._messages = self._messages[-self._max_messages:]
+        self._emit("message", msg)
+        return msg
+
+    def get_messages(self, since_id: str | None = None) -> list[SharedMessage]:
+        if since_id is None:
+            return list(self._messages)
+        idx = next(
+            (i for i, m in enumerate(self._messages) if m.id == since_id),
+            0,
+        )
+        return self._messages[idx + 1:]
+
+    def subscribe(self, client_id: str, event: str) -> None:
+        session = self._clients.get(client_id)
+        if session:
+            session.subscriptions.add(event)
+
+    def on_event(self, event: str, handler: Callable) -> None:
+        self._event_handlers.setdefault(event, []).append(handler)
+
+    def _emit(self, event: str, data: Any) -> None:
+        for handler in self._event_handlers.get(event, []):
+            try:
+                handler(data)
+            except Exception:
+                pass
+
+    @property
+    def client_count(self) -> int:
+        return len(self._clients)
+
+    @property
+    def message_count(self) -> int:
+        return len(self._messages)

algo_cli/intelligence/dag_orchestration.py

@@ -0,0 +1,151 @@
+"""B53. Dependency Graph Agent Orchestration.
+
+Orchestrate agents as a dependency graph with parallel fanout,
+iterative cycles, and scratchboard shared memory.
+Source: agentflow pattern.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Any, Callable
+
+
+class NodeStatus(Enum):
+    PENDING = auto()
+    RUNNING = auto()
+    DONE = auto()
+    FAILED = auto()
+    SKIPPED = auto()
+
+
+@dataclass
+class DAGNode:
+    id: str
+    execute: Callable[[dict], Any]
+    depends_on: list[str] = field(default_factory=list)
+    status: NodeStatus = NodeStatus.PENDING
+    result: Any = None
+    error: str | None = None
+
+
+@dataclass
+class DAGEdge:
+    source: str
+    target: str
+
+
+@dataclass
+class CycleSpec:
+    """Iterative cycle: repeat until success criteria met."""
+    nodes: list[str]
+    max_iterations: int = 5
+    success_check: Callable[[dict], bool] | None = None
+
+
+class DependencyGraph:
+    """DAG executor with parallel fanout and iterative cycles."""
+
+    def __init__(self) -> None:
+        self._nodes: dict[str, DAGNode] = {}
+        self._edges: list[DAGEdge] = []
+        self._cycles: list[CycleSpec] = []
+        self._scratchboard: dict[str, Any] = {}
+
+    def add_node(self, node: DAGNode) -> None:
+        self._nodes[node.id] = node
+
+    def add_edge(self, source: str, target: str) -> None:
+        self._edges.append(DAGEdge(source, target))
+
+    def add_cycle(self, cycle: CycleSpec) -> None:
+        self._cycles.append(cycle)
+
+    def topological_order(self) -> list[str]:
+        """Kahn's algorithm for topological sort."""
+        in_degree: dict[str, int] = {n: 0 for n in self._nodes}
+        adj: dict[str, list[str]] = {n: [] for n in self._nodes}
+        for e in self._edges:
+            adj[e.source].append(e.target)
+            in_degree[e.target] += 1
+
+        queue = [n for n, d in in_degree.items() if d == 0]
+        order: list[str] = []
+        while queue:
+            node = queue.pop(0)
+            order.append(node)
+            for neighbor in adj[node]:
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        if len(order) != len(self._nodes):
+            raise ValueError("Cycle detected in DAG")
+        return order
+
+    def _get_ready_nodes(self) -> list[str]:
+        """Nodes whose dependencies are all DONE."""
+        ready = []
+        for nid, node in self._nodes.items():
+            if node.status != NodeStatus.PENDING:
+                continue
+            deps = self._dependencies(nid)
+            if all(self._nodes[d].status == NodeStatus.DONE for d in deps):
+                ready.append(nid)
+        return ready
+
+    def _dependencies(self, node_id: str) -> list[str]:
+        return [e.source for e in self._edges if e.target == node_id]
+
+    def run(self, initial_context: dict | None = None) -> dict[str, Any]:
+        """Execute the DAG, returning results for all nodes."""
+        ctx = initial_context or {}
+        ctx.update(self._scratchboard)
+
+        for _ in range(len(self._nodes) * 2):  # safety limit
+            ready = self._get_ready_nodes()
+            if not ready:
+                break
+            for nid in ready:
+                node = self._nodes[nid]
+                node.status = NodeStatus.RUNNING
+                try:
+                    dep_results = {d: self._nodes[d].result for d in self._dependencies(nid)}
+                    ctx.setdefault("_results", {}).update(dep_results)
+                    node.result = node.execute(ctx)
+                    if node.result is not None:
+                        ctx[nid] = node.result
+                    node.status = NodeStatus.DONE
+                except Exception as e:
+                    node.error = str(e)
+                    node.status = NodeStatus.FAILED
+                    ctx.setdefault("_errors", []).append({"node": nid, "error": str(e)})
+
+        # Handle cycles
+        for cycle in self._cycles:
+            for iteration in range(cycle.max_iterations):
+                for nid in cycle.nodes:
+                    node = self._nodes[nid]
+                    node.status = NodeStatus.PENDING
+                for nid in cycle.nodes:
+                    node = self._nodes[nid]
+                    node.status = NodeStatus.RUNNING
+                    try:
+                        dep_results = {d: self._nodes[d].result for d in self._dependencies(nid)}
+                        ctx.setdefault("_results", {}).update(dep_results)
+                        node.result = node._DAGNode__wrapped_execute(ctx) if hasattr(node, "_DAGNode__wrapped_execute") else node.execute(ctx)
+                        if node.result is not None:
+                            ctx[nid] = node.result
+                        node.status = NodeStatus.DONE
+                    except Exception:
+                        node.status = NodeStatus.FAILED
+
+                if cycle.success_check and cycle.success_check(ctx):
+                    break
+
+        self._scratchboard.update(ctx)
+        return dict(ctx)
+
+    @property
+    def scratchboard(self) -> dict[str, Any]:
+        return dict(self._scratchboard)

algo_cli/intelligence/deep_research.py

@@ -0,0 +1,155 @@
+"""B62. Sub-Question Decomposition + Iterative Gap-Filling.
+
+Decompose a complex query into sub-questions, search for each,
+identify gaps, and search again until coverage is sufficient.
+Source: sibyl pattern.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Callable
+
+
+class GapType(Enum):
+    MISSING = auto()       # no answer found
+    SHALLOW = auto()       # answer too brief
+    STALE = auto()         # answer references old info
+    CONTRADICTORY = auto() # conflicting answers
+
+
+@dataclass
+class SubQuestion:
+    id: str
+    question: str
+    search_queries: list[str] = field(default_factory=list)
+    answer: str = ""
+    sources: list[str] = field(default_factory=list)
+    confidence: float = 0.0
+    gaps: list[GapType] = field(default_factory=list)
+
+
+@dataclass
+class DecompositionResult:
+    original_query: str
+    sub_questions: list[SubQuestion] = field(default_factory=list)
+    iterations: int = 0
+    coverage_score: float = 0.0
+    summary: str = ""
+
+
+class QueryDecomposer:
+    """Decompose a complex query into sub-questions."""
+
+    QUESTION_PREFIXES = [
+        "What is", "How does", "Why is", "When was", "Where is",
+        "Who is", "What are the key features of",
+        "What are the limitations of", "How is X different from",
+    ]
+
+    def decompose(self, query: str, max_sub_questions: int = 5) -> list[SubQuestion]:
+        """Split a complex query into focused sub-questions."""
+        # Simple heuristic: split on conjunctions and question marks
+        parts = query.replace(" and ", "|").replace(" vs ", "|").split("|")
+        sub_qs: list[SubQuestion] = []
+        for i, part in enumerate(parts):
+            part = part.strip().rstrip("?")
+            if not part:
+                continue
+            sq = SubQuestion(id=f"sq_{i+1}", question=part)
+            # Generate search queries
+            sq.search_queries = [part, f"{part} overview", f"{part} explained"]
+            sub_qs.append(sq)
+            if len(sub_qs) >= max_sub_questions:
+                break
+
+        if not sub_qs:
+            sub_qs.append(SubQuestion(id="sq_1", question=query, search_queries=[query]))
+
+        return sub_qs
+
+
+class GapFiller:
+    """Identify gaps in answers and generate follow-up searches."""
+
+    def identify_gaps(self, sq: SubQuestion) -> list[GapType]:
+        gaps: list[GapType] = []
+        if not sq.answer:
+            gaps.append(GapType.MISSING)
+        elif len(sq.answer) < 100:
+            gaps.append(GapType.SHALLOW)
+        if sq.confidence < 0.5:
+            gaps.append(GapType.MISSING)
+        return gaps
+
+    def generate_followup(self, sq: SubQuestion) -> list[str]:
+        """Generate follow-up search queries for gaps."""
+        followups: list[str] = []
+        for gap in sq.gaps:
+            if gap == GapType.MISSING:
+                followups.append(f"{sq.question} detailed explanation")
+                followups.append(f"{sq.question} examples")
+            elif gap == GapType.SHALLOW:
+                followups.append(f"{sq.question} in depth analysis")
+            elif gap == GapType.STALE:
+                followups.append(f"{sq.question} 2025 2026 latest")
+        return followups
+
+
+class DeepResearchEngine:
+    """Orchestrate sub-question decomposition with iterative gap-filling."""
+
+    def __init__(self, search_fn: Callable[[str], list[tuple[str, str]]],
+                 max_iterations: int = 3, coverage_threshold: float = 0.8) -> None:
+        self._search = search_fn
+        self._max_iterations = max_iterations
+        self._coverage_threshold = coverage_threshold
+        self._decomposer = QueryDecomposer()
+        self._gap_filler = GapFiller()
+
+    def run(self, query: str) -> DecompositionResult:
+        result = DecompositionResult(original_query=query)
+        result.sub_questions = self._decomposer.decompose(query)
+
+        for iteration in range(self._max_iterations):
+            result.iterations = iteration + 1
+
+            for sq in result.sub_questions:
+                if sq.confidence >= 0.7:
+                    continue
+                # Search for each query
+                for search_q in sq.search_queries:
+                    results = self._search(search_q)
+                    for title, content in results:
+                        sq.sources.append(title)
+                        if not sq.answer:
+                            sq.answer = content
+                        else:
+                            sq.answer += "\n\n" + content
+                    if results:
+                        sq.confidence = min(1.0, sq.confidence + 0.3)
+
+                # Check for gaps
+                sq.gaps = self._gap_filler.identify_gaps(sq)
+                if sq.gaps:
+                    followups = self._gap_filler.generate_followup(sq)
+                    sq.search_queries.extend(followups)
+
+            # Compute coverage
+            answered = sum(1 for sq in result.sub_questions if sq.confidence >= 0.7)
+            result.coverage_score = answered / len(result.sub_questions) if result.sub_questions else 0.0
+
+            if result.coverage_score >= self._coverage_threshold:
+                break
+
+        result.summary = self._synthesize(result)
+        return result
+
+    def _synthesize(self, result: DecompositionResult) -> str:
+        lines = [f"# Research: {result.original_query}", ""]
+        for sq in result.sub_questions:
+            lines.append(f"## {sq.question}")
+            lines.append(sq.answer[:500] if sq.answer else "(no answer found)")
+            lines.append("")
+        lines.append(f"Coverage: {result.coverage_score:.0%} after {result.iterations} iterations")
+        return "\n".join(lines)

algo_cli/intelligence/degenerate_detector.py

@@ -0,0 +1,78 @@
+"""H27 — Degenerate Solution Detection.
+
+Catch solutions that precompute answers without required constructs.
+Mined from GLOSSOPETRAE gradeStructured() — degenerate_precompute detection.
+"""
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+
+@dataclass
+class DegenerateReport:
+    """Report on whether a solution is degenerate."""
+
+    is_degenerate: bool
+    reason: str = ""
+    has_loops: bool = False
+    has_functions: bool = False
+    has_conditionals: bool = False
+    literal_count: int = 0
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "is_degenerate": self.is_degenerate,
+            "reason": self.reason,
+            "has_loops": self.has_loops,
+            "has_functions": self.has_functions,
+            "has_conditionals": self.has_conditionals,
+            "literal_count": self.literal_count,
+        }
+
+
+class DegenerateDetector:
+    """Detect programs that precompute answers without algorithmic structure."""
+
+    def __init__(self, require_loops: bool = True, require_functions: bool = True) -> None:
+        self.require_loops = require_loops
+        self.require_functions = require_functions
+
+    def analyze(self, code: str) -> DegenerateReport:
+        try:
+            tree = ast.parse(code)
+        except SyntaxError as e:
+            return DegenerateReport(
+                is_degenerate=True,
+                reason=f"Syntax error: {e}",
+            )
+        has_loops = False
+        has_functions = False
+        has_conditionals = False
+        literal_count = 0
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.For, ast.While)):
+                has_loops = True
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                has_functions = True
+            elif isinstance(node, ast.If):
+                has_conditionals = True
+            elif isinstance(node, ast.Constant):
+                literal_count += 1
+        missing = []
+        if self.require_loops and not has_loops:
+            missing.append("loops")
+        if self.require_functions and not has_functions:
+            missing.append("functions")
+        is_degenerate = len(missing) > 0 and literal_count > 0
+        reason = ""
+        if is_degenerate:
+            reason = f"Solution has no {' or '.join(missing)} but contains {literal_count} literals — likely precomputed"
+        return DegenerateReport(
+            is_degenerate=is_degenerate,
+            reason=reason,
+            has_loops=has_loops,
+            has_functions=has_functions,
+            has_conditionals=has_conditionals,
+            literal_count=literal_count,
+        )

algo_cli/intelligence/delta_report.py

@@ -0,0 +1,92 @@
+"""H30 — Delta Reporting.
+
+Report what changed since last assessment, not full reports.
+Mined from T3MP3ST VISION.md Vector 4.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class DeltaEntry:
+    """A single change in a delta report."""
+
+    change_type: str  # "added", "removed", "changed"
+    target_id: str
+    old_value: Any = None
+    new_value: Any = None
+    timestamp: float = field(default_factory=time.time)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "change_type": self.change_type,
+            "target_id": self.target_id,
+            "old_value": self.old_value,
+            "new_value": self.new_value,
+            "timestamp": self.timestamp,
+        }
+
+
+@dataclass
+class DeltaReport:
+    """A report of changes between two states."""
+
+    entries: list[DeltaEntry] = field(default_factory=list)
+    generated_at: float = field(default_factory=time.time)
+
+    @property
+    def added(self) -> list[DeltaEntry]:
+        return [e for e in self.entries if e.change_type == "added"]
+
+    @property
+    def removed(self) -> list[DeltaEntry]:
+        return [e for e in self.entries if e.change_type == "removed"]
+
+    @property
+    def changed(self) -> list[DeltaEntry]:
+        return [e for e in self.entries if e.change_type == "changed"]
+
+    @property
+    def is_empty(self) -> bool:
+        return len(self.entries) == 0
+
+    def summary(self) -> str:
+        return (
+            f"Delta: +{len(self.added)} added, -{len(self.removed)} removed, "
+            f"~{len(self.changed)} changed"
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "entries": [e.to_dict() for e in self.entries],
+            "generated_at": self.generated_at,
+            "summary": self.summary(),
+        }
+
+
+class DeltaReporter:
+    """Compute deltas between two state snapshots."""
+
+    @staticmethod
+    def compute(
+        previous: dict[str, Any],
+        current: dict[str, Any],
+    ) -> DeltaReport:
+        """Compute delta between two state dicts keyed by ID."""
+        entries: list[DeltaEntry] = []
+        prev_keys = set(previous.keys())
+        curr_keys = set(current.keys())
+        # Added
+        for key in sorted(curr_keys - prev_keys):
+            entries.append(DeltaEntry("added", key, new_value=current[key]))
+        # Removed
+        for key in sorted(prev_keys - curr_keys):
+            entries.append(DeltaEntry("removed", key, old_value=previous[key]))
+        # Changed
+        for key in sorted(prev_keys & curr_keys):
+            if previous[key] != current[key]:
+                entries.append(DeltaEntry("changed", key, previous[key], current[key]))
+        return DeltaReport(entries=entries)