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

algo_cli/intelligence/lsp_integration.py

@@ -0,0 +1,147 @@
+"""B60. LSP Integration for Code Intelligence.
+
+Language Server Protocol integration for go-to-definition, hover,
+diagnostics, and references.  Source: copilot-cli pattern.
+"""
+from __future__ import annotations
+
+import subprocess
+import json
+from dataclasses import dataclass
+from enum import Enum, auto
+from pathlib import Path
+from typing import Any
+
+
+class LSPServerStatus(Enum):
+    STOPPED = auto()
+    STARTING = auto()
+    READY = auto()
+    ERROR = auto()
+
+
+@dataclass
+class LSPDiagnostic:
+    severity: str  # "error", "warning", "info", "hint"
+    message: str
+    line: int  # 0-based
+    col: int
+    end_line: int = 0
+    end_col: int = 0
+    source: str = ""
+    code: str = ""
+
+
+@dataclass
+class LSPDefinition:
+    file: str
+    line: int
+    col: int
+
+
+@dataclass
+class LSPHover:
+    contents: str
+    range_line: int = 0
+
+
+@dataclass
+class LSPServer:
+    name: str
+    command: list[str]
+    languages: list[str]
+    status: LSPServerStatus = LSPServerStatus.STOPPED
+    process: Any = None
+
+
+class LSPManager:
+    """Manage LSP servers and provide code intelligence."""
+
+    # Common LSP server configs
+    SERVER_CONFIGS: dict[str, LSPServer] = {
+        "pyright": LSPServer(
+            name="pyright",
+            command=["pyright-langserver", "--stdio"],
+            languages=["python"],
+        ),
+        "pylsp": LSPServer(
+            name="pylsp",
+            command=["pylsp"],
+            languages=["python"],
+        ),
+        "typescript": LSPServer(
+            name="typescript-language-server",
+            command=["typescript-language-server", "--stdio"],
+            languages=["typescript", "javascript"],
+        ),
+        "rust-analyzer": LSPServer(
+            name="rust-analyzer",
+            command=["rust-analyzer"],
+            languages=["rust"],
+        ),
+    }
+
+    def __init__(self) -> None:
+        self._servers: dict[str, LSPServer] = {}
+        self._file_to_server: dict[str, str] = {}
+
+    def register_server(self, server: LSPServer) -> None:
+        self._servers[server.name] = server
+        for lang in server.languages:
+            self._file_to_server[lang] = server.name
+
+    def get_server_for_file(self, file_path: str) -> LSPServer | None:
+        ext = Path(file_path).suffix.lower()
+        lang_map = {
+            ".py": "python",
+            ".ts": "typescript",
+            ".js": "javascript",
+            ".rs": "rust",
+        }
+        lang = lang_map.get(ext)
+        if not lang:
+            return None
+        server_name = self._file_to_server.get(lang)
+        if not server_name:
+            return None
+        return self._servers.get(server_name)
+
+    def parse_diagnostics(self, output: str) -> list[LSPDiagnostic]:
+        """Parse LSP diagnostic output."""
+        diags: list[LSPDiagnostic] = []
+        try:
+            data = json.loads(output)
+            for item in data.get("diagnostics", []):
+                diags.append(LSPDiagnostic(
+                    severity=item.get("severity", "info"),
+                    message=item.get("message", ""),
+                    line=item.get("range", {}).get("start", {}).get("line", 0),
+                    col=item.get("range", {}).get("start", {}).get("character", 0),
+                    end_line=item.get("range", {}).get("end", {}).get("line", 0),
+                    end_col=item.get("range", {}).get("end", {}).get("character", 0),
+                    source=item.get("source", ""),
+                    code=item.get("code", ""),
+                ))
+        except (json.JSONDecodeError, KeyError):
+            pass
+        return diags
+
+    def check_available(self) -> dict[str, bool]:
+        """Check which LSP servers are installed."""
+        available: dict[str, bool] = {}
+        for name, server in self.SERVER_CONFIGS.items():
+            try:
+                cmd = server.command[0]
+                result = subprocess.run(
+                    ["where" if _is_windows() else "which", cmd],
+                    capture_output=True, timeout=5,
+                )
+                available[name] = result.returncode == 0
+            except Exception:
+                available[name] = False
+        return available
+
+
+def _is_windows() -> bool:
+    import sys
+    return sys.platform == "win32"

algo_cli/intelligence/memory_evolution.py

@@ -0,0 +1,117 @@
+"""B56. Memory Skill Evolution.
+
+Learn reusable memory skills from task feedback.  Evolve from hard cases.
+Source: MemSkill pattern.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from enum import Enum, auto
+
+
+class SkillStatus(Enum):
+    CANDIDATE = auto()
+    ACTIVE = auto()
+    DEPRECATED = auto()
+    EVOLVED = auto()
+
+
+@dataclass
+class MemorySkill:
+    name: str
+    pattern: str  # what to remember
+    trigger: str  # when to apply
+    confidence: float = 0.5
+    uses: int = 0
+    successes: int = 0
+    failures: int = 0
+    status: SkillStatus = SkillStatus.CANDIDATE
+    created_at: float = field(default_factory=time.time)
+    evolved_from: str | None = None
+    hard_cases: list[str] = field(default_factory=list)
+
+
+@dataclass
+class TaskFeedback:
+    task: str
+    memory_used: list[str]  # skill names
+    outcome: str  # "success", "failure", "partial"
+    missing_info: str = ""  # what was missing?
+    wrong_info: str = ""  # what was wrong/stale?
+
+
+class MemorySkillEvolver:
+    """Evolve memory skills from task feedback."""
+
+    def __init__(self, confidence_threshold: float = 0.7,
+                 deprecation_threshold: float = 0.3) -> None:
+        self._skills: dict[str, MemorySkill] = {}
+        self._feedback_history: list[TaskFeedback] = []
+        self._confidence_threshold = confidence_threshold
+        self._deprecation_threshold = deprecation_threshold
+
+    def register(self, skill: MemorySkill) -> None:
+        self._skills[skill.name] = skill
+
+    def record_feedback(self, feedback: TaskFeedback) -> None:
+        self._feedback_history.append(feedback)
+        for skill_name in feedback.memory_used:
+            skill = self._skills.get(skill_name)
+            if not skill:
+                continue
+            skill.uses += 1
+            if feedback.outcome == "success":
+                skill.successes += 1
+            elif feedback.outcome == "failure":
+                skill.failures += 1
+                if feedback.wrong_info:
+                    skill.hard_cases.append(feedback.wrong_info)
+
+    def _confidence(self, skill: MemorySkill) -> float:
+        if skill.uses == 0:
+            return skill.confidence
+        return skill.successes / skill.uses
+
+    def evolve(self) -> list[MemorySkill]:
+        """Promote/deprecate/evolve skills based on feedback."""
+        evolved: list[MemorySkill] = []
+        for skill in list(self._skills.values()):
+            conf = self._confidence(skill)
+            if conf >= self._confidence_threshold and skill.status == SkillStatus.CANDIDATE:
+                skill.status = SkillStatus.ACTIVE
+                evolved.append(skill)
+            elif conf < self._deprecation_threshold and skill.status == SkillStatus.ACTIVE:
+                skill.status = SkillStatus.DEPRECATED
+                evolved.append(skill)
+            elif skill.hard_cases and skill.status == SkillStatus.ACTIVE:
+                # Evolve: create a refined version
+                evolved_name = f"{skill.name}_v2"
+                if evolved_name not in self._skills:
+                    evolved_skill = MemorySkill(
+                        name=evolved_name,
+                        pattern=skill.pattern,
+                        trigger=skill.trigger,
+                        confidence=0.5,
+                        status=SkillStatus.CANDIDATE,
+                        evolved_from=skill.name,
+                        hard_cases=list(skill.hard_cases),
+                    )
+                    self._skills[evolved_name] = evolved_skill
+                    skill.status = SkillStatus.EVOLVED
+                    evolved.append(evolved_skill)
+        return evolved
+
+    def mine_hard_cases(self) -> list[dict]:
+        """Find cases where memory was wrong or missing."""
+        cases: list[dict] = []
+        for fb in self._feedback_history:
+            if fb.wrong_info:
+                cases.append({"type": "wrong", "info": fb.wrong_info, "task": fb.task})
+            if fb.missing_info:
+                cases.append({"type": "missing", "info": fb.missing_info, "task": fb.task})
+        return cases
+
+    @property
+    def skills(self) -> dict[str, MemorySkill]:
+        return dict(self._skills)

algo_cli/intelligence/minhash_lsh.py

@@ -0,0 +1,182 @@
+"""MinHash + LSH — approximate near-duplicate detection.
+
+MinHash estimates Jaccard similarity between sets using k random hash
+functions.  LSH (Locality-Sensitive Hashing) buckets similar signatures
+into the same band-slot for O(1) candidate lookup.
+
+Harness use:
+  - Detect near-duplicate files (rebranded code, copied configs)
+  - Find similar conversation contexts for dedup
+  - Cluster similar error messages
+  - Detect duplicate harness entries
+
+Operations:
+  - MinHasher.signature(set): compute k-element signature
+  - MinHasher.similarity(sig1, sig2): estimated Jaccard similarity
+  - LSHIndex.insert(key, signature): add to LSH buckets
+  - LSHIndex.query(signature): return candidate near-duplicate keys
+
+Properties:
+  - Signature computation: O(k * |set|)
+  - Similarity estimation: O(k)
+  - LSH query: O(bands) expected, where bands = signature_size / rows_per_band
+  - Trade-off: more bands = higher recall, more false positives
+"""
+from __future__ import annotations
+
+import hashlib
+from typing import Any
+
+from dataclasses import dataclass, field
+
+
+class MinHasher:
+    """MinHash signature generator.
+
+    Args:
+        num_hashes: Number of hash functions (signature size).
+            Higher = more accurate similarity estimation, more memory.
+        seed: Random seed for reproducibility.
+    """
+
+    def __init__(self, num_hashes: int = 128, seed: int = 42) -> None:
+        self.num_hashes = num_hashes
+        self._seeds = [(seed + i * 2654435761) & 0xFFFFFFFF for i in range(num_hashes)]
+
+    def _hash(self, item: Any, seed: int) -> int:
+        """Hash an item with a given seed to a 32-bit integer."""
+        data = f"{seed}:{item}".encode("utf-8")
+        return int.from_bytes(hashlib.md5(data).digest()[:4], "big")
+
+    def signature(self, items: set[Any] | list[Any]) -> list[int]:
+        """Compute the MinHash signature of a set of items.
+
+        Returns a list of num_hashes integers, where each is the minimum
+        hash value for that hash function across all items.
+        """
+        if not items:
+            return [0xFFFFFFFF] * self.num_hashes
+        items_set = set(items)
+        sig = []
+        for seed in self._seeds:
+            min_val = min(self._hash(item, seed) for item in items_set)
+            sig.append(min_val)
+        return sig
+
+    def similarity(self, sig1: list[int], sig2: list[int]) -> float:
+        """Estimate Jaccard similarity from two signatures.
+
+        Jaccard(A, B) = |A ∩ B| / |A ∪ B|
+        MinHash estimates this as the fraction of matching hash positions.
+        """
+        if len(sig1) != len(sig2):
+            raise ValueError("Signatures must have the same length")
+        if not sig1:
+            return 0.0
+        matches = sum(1 for a, b in zip(sig1, sig2) if a == b)
+        return matches / len(sig1)
+
+
+@dataclass
+class LSHIndex:
+    """Locality-Sensitive Hashing index for MinHash signatures.
+
+    Splits the signature into bands.  Two signatures are candidates if
+    they share at least one band hash.  This provides sublinear query time.
+
+    Args:
+        num_bands: Number of bands (more = higher recall, more false positives).
+        rows_per_band: Rows per band (more = higher precision, lower recall).
+            num_bands * rows_per_band should equal signature size.
+    """
+
+    num_bands: int = 32
+    rows_per_band: int = 4
+    _buckets: dict[tuple[int, int], set[str]] = field(default_factory=dict)
+    _signatures: dict[str, list[int]] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        self._expected_sig_len = self.num_bands * self.rows_per_band
+
+    def _band_hash(self, signature: list[int], band_idx: int) -> int:
+        """Hash a band of the signature to an integer."""
+        start = band_idx * self.rows_per_band
+        end = start + self.rows_per_band
+        band = tuple(signature[start:end])
+        return hash(band)
+
+    def insert(self, key: str, signature: list[int]) -> None:
+        """Insert a key with its MinHash signature into the LSH index."""
+        if len(signature) != self._expected_sig_len:
+            raise ValueError(
+                f"Signature length {len(signature)} != expected "
+                f"{self._expected_sig_len} (bands={self.num_bands} * "
+                f"rows={self.rows_per_band})"
+            )
+        self._signatures[key] = signature
+        for band_idx in range(self.num_bands):
+            bh = self._band_hash(signature, band_idx)
+            bucket_key = (band_idx, bh)
+            if bucket_key not in self._buckets:
+                self._buckets[bucket_key] = set()
+            self._buckets[bucket_key].add(key)
+
+    def remove(self, key: str) -> None:
+        """Remove a key from the LSH index."""
+        sig = self._signatures.pop(key, None)
+        if sig is None:
+            return
+        for band_idx in range(self.num_bands):
+            bh = self._band_hash(sig, band_idx)
+            bucket_key = (band_idx, bh)
+            if bucket_key in self._buckets:
+                self._buckets[bucket_key].discard(key)
+                if not self._buckets[bucket_key]:
+                    del self._buckets[bucket_key]
+
+    def query(self, signature: list[int]) -> list[str]:
+        """Find candidate near-duplicate keys for a signature.
+
+        Returns keys that share at least one band hash.  These are
+        candidates — verify with MinHasher.similarity() to get exact estimate.
+        """
+        if len(signature) != self._expected_sig_len:
+            raise ValueError(
+                f"Signature length {len(signature)} != expected "
+                f"{self._expected_sig_len}"
+            )
+        candidates: set[str] = set()
+        for band_idx in range(self.num_bands):
+            bh = self._band_hash(signature, band_idx)
+            bucket_key = (band_idx, bh)
+            if bucket_key in self._buckets:
+                candidates.update(self._buckets[bucket_key])
+        return list(candidates)
+
+    def query_similar(
+        self,
+        signature: list[int],
+        minhasher: MinHasher,
+        threshold: float = 0.5,
+    ) -> list[tuple[str, float]]:
+        """Find near-duplicates above a similarity threshold.
+
+        Returns list of (key, similarity) sorted by similarity descending.
+        """
+        candidates = self.query(signature)
+        results: list[tuple[str, float]] = []
+        for key in candidates:
+            sim = minhasher.similarity(signature, self._signatures[key])
+            if sim >= threshold:
+                results.append((key, sim))
+        results.sort(key=lambda x: -x[1])
+        return results
+
+    def stats(self) -> dict[str, Any]:
+        return {
+            "num_bands": self.num_bands,
+            "rows_per_band": self.rows_per_band,
+            "indexed_items": len(self._signatures),
+            "num_buckets": len(self._buckets),
+            "expected_sig_len": self._expected_sig_len,
+        }

algo_cli/intelligence/multi_model_score.py

@@ -0,0 +1,174 @@
+"""H12 — Multi-Model Composite Scoring.
+
+Score algorithm candidates across a panel of models.
+Mined from G0DM0D3 ULTRAPLINIAN: query N models, score each response,
+pick the winner.
+
+LLM integration: requires model clients to query. Falls back to
+rule-based scoring when no models are available.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ModelResponse:
+    """A single model's response to a prompt."""
+
+    model_name: str
+    response: str
+    latency_ms: float = 0.0
+    error: str | None = None
+
+
+@dataclass
+class ScoredResponse:
+    """A response with its composite score."""
+
+    model_name: str
+    response: str
+    score: float
+    sub_scores: dict[str, float] = field(default_factory=dict)
+    winner: bool = False
+
+
+# Scoring dimensions
+SCORE_DIMENSIONS = [
+    "directness",      # How direct and clear is the response?
+    "completeness",    # Does it address all parts of the prompt?
+    "accuracy",        # Is the information correct?
+    "conciseness",     # Is it appropriately concise?
+]
+
+
+def _score_dimension(response: str, dimension: str) -> float:
+    """Score a single dimension of a response (rule-based fallback)."""
+    if not response:
+        return 0.0
+
+    text = response.lower()
+
+    if dimension == "directness":
+        # Penalize hedging language
+        hedge_words = ["maybe", "perhaps", "might", "could", "possibly", "i think"]
+        hedge_count = sum(text.count(w) for w in hedge_words)
+        return max(0.0, 1.0 - hedge_count * 0.1)
+
+    if dimension == "completeness":
+        # Reward longer responses (up to a point)
+        length = len(response)
+        if length < 50:
+            return length / 50.0
+        if length > 500:
+            return min(1.0, 500 / length + 0.5)
+        return 1.0
+
+    if dimension == "accuracy":
+        # Rule-based: penalize obvious errors (empty, repeated chars)
+        if not response.strip():
+            return 0.0
+        if response.strip() == response[0] * len(response.strip()):
+            return 0.1
+        return 0.8  # Default neutral-positive
+
+    if dimension == "conciseness":
+        # Reward shorter responses
+        length = len(response)
+        if length < 100:
+            return 1.0
+        if length > 2000:
+            return 0.3
+        return max(0.3, 1.0 - (length - 100) / 1900)
+
+    return 0.5
+
+
+def score_response(
+    response: ModelResponse,
+    dimensions: list[str] | None = None,
+    weights: dict[str, float] | None = None,
+    model_client: Any | None = None,
+) -> ScoredResponse:
+    """Score a single model response across dimensions.
+
+    Args:
+        response: The model response to score.
+        dimensions: Which dimensions to score. Defaults to all.
+        weights: Optional weights per dimension. Defaults to equal.
+        model_client: Optional LLM for richer scoring.
+
+    Returns:
+        ScoredResponse with composite score.
+    """
+    dims = dimensions or SCORE_DIMENSIONS
+    w = weights or {d: 1.0 / len(dims) for d in dims}
+
+    if response.error:
+        return ScoredResponse(
+            model_name=response.model_name,
+            response=response.response,
+            score=0.0,
+            sub_scores={d: 0.0 for d in dims},
+        )
+
+    sub_scores: dict[str, float] = {}
+    for dim in dims:
+        sub_scores[dim] = _score_dimension(response.response, dim)
+
+    total_weight = sum(w.get(d, 0.0) for d in dims)
+    if total_weight == 0:
+        composite = 0.0
+    else:
+        composite = sum(sub_scores[d] * w.get(d, 0.0) for d in dims) / total_weight
+
+    return ScoredResponse(
+        model_name=response.model_name,
+        response=response.response,
+        score=composite,
+        sub_scores=sub_scores,
+    )
+
+
+def score_panel(
+    responses: list[ModelResponse],
+    dimensions: list[str] | None = None,
+    weights: dict[str, float] | None = None,
+    model_client: Any | None = None,
+) -> list[ScoredResponse]:
+    """Score a panel of model responses and pick the winner.
+
+    Args:
+        responses: List of model responses.
+        dimensions: Which dimensions to score.
+        weights: Optional weights per dimension.
+        model_client: Optional LLM for richer scoring.
+
+    Returns:
+        List of ScoredResponses, with the winner marked.
+    """
+    scored = [
+        score_response(r, dimensions, weights, model_client)
+        for r in responses
+    ]
+    if scored:
+        best_idx = max(range(len(scored)), key=lambda i: scored[i].score)
+        scored[best_idx] = ScoredResponse(
+            model_name=scored[best_idx].model_name,
+            response=scored[best_idx].response,
+            score=scored[best_idx].score,
+            sub_scores=scored[best_idx].sub_scores,
+            winner=True,
+        )
+    return scored
+
+
+def pick_winner(scored: list[ScoredResponse]) -> ScoredResponse | None:
+    """Get the winning response from a scored panel."""
+    for s in scored:
+        if s.winner:
+            return s
+    if not scored:
+        return None
+    return max(scored, key=lambda s: s.score)