devtorch-core 3.0.1__py3-none-any.whl

devtorch_core/query/semantic.py

@@ -0,0 +1,157 @@
+"""Optional semantic search over .GCC/ events and concepts.
+
+The import of `sentence-transformers` is delayed and optional.  If the package
+is not installed, the backend falls back to keyword search so that `devtorch ask`
+still works without extra dependencies.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+
+@dataclass(frozen=False)
+class SemanticResult:
+    path: Path
+    line: int
+    snippet: str
+    score: float
+
+    def to_dict(self) -> dict:
+        return {
+            "path": str(self.path),
+            "line": self.line,
+            "snippet": self.snippet,
+            "score": self.score,
+        }
+
+
+class SemanticBackend:
+    """Encapsulates the optional embedding model."""
+
+    def __init__(self, model_name: str | None = None):
+        self.model_name = model_name
+        self._model = None
+        self._tokenizer = None
+
+    def available(self) -> bool:
+        try:
+            import sentence_transformers  # type: ignore
+        except Exception:
+            return False
+        return True
+
+    def _load(self):
+        if self._model is not None:
+            return self._model
+        from sentence_transformers import SentenceTransformer  # type: ignore
+        name = self.model_name or "all-MiniLM-L6-v2"
+        self._model = SentenceTransformer(name)
+        return self._model
+
+    def encode(self, texts: list[str]) -> list[list[float]]:
+        if not texts:
+            return []
+        model = self._load()
+        embeddings = model.encode(texts, convert_to_numpy=True, show_progress_bar=False)
+        return embeddings.tolist()
+
+
+def _cosine(a: list[float], b: list[float]) -> float:
+    dot = sum(x * y for x, y in zip(a, b))
+    norm_a = math.sqrt(sum(x * x for x in a))
+    norm_b = math.sqrt(sum(x * x for x in b))
+    if norm_a == 0 or norm_b == 0:
+        return 0.0
+    return max(0.0, min(1.0, dot / (norm_a * norm_b)))
+
+
+def _keyword_score(query: str, text: str) -> float:
+    """Fallback keyword overlap used when no embedding model is available."""
+    query_terms = set(query.lower().split())
+    text_lower = text.lower()
+    if not query_terms:
+        return 0.0
+    matches = sum(1 for term in query_terms if term in text_lower)
+    return matches / len(query_terms)
+
+
+def _collect_documents(gcc_dir: Path) -> list[tuple[Path, int, str]]:
+    """Collect (path, line, text) documents from .GCC/ events and concepts."""
+    docs: list[tuple[Path, int, str]] = []
+    events_path = gcc_dir / "events.log.jsonl"
+    if events_path.exists():
+        try:
+            for line_no, raw in enumerate(events_path.read_text(encoding="utf-8", errors="replace").splitlines(), start=1):
+                try:
+                    payload = json.loads(raw)
+                except Exception:
+                    continue
+                text = json.dumps(payload, ensure_ascii=False, separators=(", ", ": "))
+                docs.append((events_path, line_no, text))
+        except Exception:
+            pass
+
+    for subdir in ("concepts", "sensitivities"):
+        sub = gcc_dir / subdir
+        if not sub.exists():
+            continue
+        for path in sub.rglob("*"):
+            if not path.is_file() or path.suffix not in (".md", ".json", ".txt"):
+                continue
+            try:
+                text = path.read_text(encoding="utf-8", errors="replace")
+            except Exception:
+                continue
+            for line_no, line in enumerate(text.splitlines(), start=1):
+                if line.strip():
+                    docs.append((path, line_no, line.strip()))
+    return docs
+
+
+def semantic_search(
+    query: str,
+    project_root: Path,
+    top_n: int = 5,
+    backend: SemanticBackend | None = None,
+) -> list[SemanticResult]:
+    """Run semantic search over .GCC/ events and concepts.
+
+    If `sentence-transformers` is unavailable, fall back to keyword overlap.
+    """
+    gcc_dir = project_root / ".GCC"
+    if not gcc_dir.exists():
+        return []
+
+    docs = _collect_documents(gcc_dir)
+    if not docs:
+        return []
+
+    backend = backend or SemanticBackend()
+
+    if not backend.available():
+        # Keyword fallback
+        scored: list[tuple[float, SemanticResult]] = []
+        for path, line, text in docs:
+            score = _keyword_score(query, text)
+            if score > 0:
+                scored.append((score, SemanticResult(path, line, text[:240], score)))
+        scored.sort(key=lambda t: t[0], reverse=True)
+        return [r for _, r in scored[:top_n]]
+
+    query_embedding = backend.encode([query])[0]
+    doc_texts = [text for _, _, text in docs]
+    doc_embeddings = backend.encode(doc_texts)
+
+    results: list[SemanticResult] = []
+    for (path, line, text), embedding in zip(docs, doc_embeddings):
+        score = _cosine(query_embedding, embedding)
+        if score > 0.0:
+            results.append(SemanticResult(path, line, text[:240], score))
+
+    results.sort(key=lambda r: r.score, reverse=True)
+    return results[:top_n]

devtorch_core/rdp.py

@@ -0,0 +1,105 @@
+"""
+Sprint 5 – A4: RDP (Rényi Differential Privacy) accountant.
+
+Per-round spend checks; PRIVACY_BUDGET_EXHAUSTED when budget exceeded; read-only mode.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Tuple
+
+RDP_DIR_NAME = "rdp"
+RDP_STATE_NAME = "rdp_state.json"
+PRIVACY_BUDGET_EXHAUSTED_EVENT = "PRIVACY_BUDGET_EXHAUSTED"
+
+# Default epsilon budget (total)
+DEFAULT_EPSILON_BUDGET = 1.0
+DEFAULT_ALPHA = 1.5  # Rényi order for composition
+
+
+@dataclass
+class RDPState:
+    """RDP accountant state: remaining budget and spend history."""
+    epsilon_budget: float
+    epsilon_spent: float
+    alpha: float
+    round_ids: list  # rounds that consumed budget
+    read_only: bool  # True after PRIVACY_BUDGET_EXHAUSTED
+
+    def remaining(self) -> float:
+        return max(0.0, self.epsilon_budget - self.epsilon_spent)
+
+    def to_dict(self) -> dict:
+        return {
+            "epsilon_budget": self.epsilon_budget,
+            "epsilon_spent": self.epsilon_spent,
+            "alpha": self.alpha,
+            "round_ids": list(self.round_ids),
+            "read_only": self.read_only,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "RDPState":
+        return cls(
+            epsilon_budget=float(d.get("epsilon_budget", DEFAULT_EPSILON_BUDGET)),
+            epsilon_spent=float(d.get("epsilon_spent", 0)),
+            alpha=float(d.get("alpha", DEFAULT_ALPHA)),
+            round_ids=list(d.get("round_ids", [])),
+            read_only=bool(d.get("read_only", False)),
+        )
+
+
+def rdp_compose(epsilon_per_round: float, alpha: float, k_rounds: int) -> float:
+    """Simple RDP composition: k rounds of (epsilon_per_round, alpha) -> total epsilon (approx)."""
+    # RDP composition: (alpha, eps) * k -> (alpha, k*eps) for same alpha
+    return k_rounds * epsilon_per_round
+
+
+class RDPAccountant:
+    """Persist RDP state and enforce per-round spend."""
+    def __init__(self, gcc_dir: Path) -> None:
+        self.rdp_dir = gcc_dir / RDP_DIR_NAME
+        self.state_path = self.rdp_dir / RDP_STATE_NAME
+
+    def ensure_dir(self) -> None:
+        self.rdp_dir.mkdir(parents=True, exist_ok=True)
+
+    def load_state(self) -> RDPState:
+        if not self.state_path.exists():
+            return RDPState(
+                epsilon_budget=DEFAULT_EPSILON_BUDGET,
+                epsilon_spent=0.0,
+                alpha=DEFAULT_ALPHA,
+                round_ids=[],
+                read_only=False,
+            )
+        return RDPState.from_dict(json.loads(self.state_path.read_text(encoding="utf-8")))
+
+    def save_state(self, state: RDPState) -> None:
+        self.ensure_dir()
+        self.state_path.write_text(json.dumps(state.to_dict(), indent=2) + "\n", encoding="utf-8")
+
+    def spend(self, round_id: int, epsilon_cost: float) -> Tuple[bool, str]:
+        """
+        Attempt to spend epsilon_cost for round_id. Returns (allowed, event_or_empty).
+        If allowed: state updated, return (True, "").
+        If budget exceeded: state set read_only, return (False, PRIVACY_BUDGET_EXHAUSTED_EVENT).
+        """
+        state = self.load_state()
+        if state.read_only:
+            return False, PRIVACY_BUDGET_EXHAUSTED_EVENT
+        if state.remaining() < epsilon_cost:
+            state.read_only = True
+            state.epsilon_spent = state.epsilon_budget
+            self.save_state(state)
+            return False, PRIVACY_BUDGET_EXHAUSTED_EVENT
+        state.epsilon_spent += epsilon_cost
+        state.round_ids.append(round_id)
+        self.save_state(state)
+        return True, ""
+
+    def is_read_only(self) -> bool:
+        return self.load_state().read_only

devtorch_core/reasoning/__init__.py

@@ -0,0 +1,4 @@
+from .entry import ReasoningEntry
+from .store import ReasoningStore
+
+__all__ = ["ReasoningEntry", "ReasoningStore"]

devtorch_core/reasoning/entry.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+
+@dataclasses.dataclass
+class ReasoningEntry:
+    """
+    A single cross-agent-queryable reasoning record.
+
+    Combines a SensitivityEvent (the why) with its associated commit message
+    (the decision), token-budgeted and structured for Agent B to consume.
+    """
+
+    entry_id: str
+    agent_id: str
+    concept: str
+    reasoning_text: str   # counterfactuals / why text from SensitivityEvent
+    decision_text: str    # commit message from nearest preceding commit
+    confidence: float
+    disclosure_level: str
+    session_id: Optional[str]
+    branch: str
+    timestamp: str
+    source_type: str  # "sensitivity" | "commit"
+
+    def approx_tokens(self) -> int:
+        """Rough token estimate: 4 chars ≈ 1 token."""
+        text = self.reasoning_text + " " + self.decision_text
+        return max(1, len(text) // 4)

devtorch_core/reasoning/store.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import List, Optional
+
+from .entry import ReasoningEntry
+
+_SENSITIVITIES_FILE = "sensitivities/events.jsonl"
+_COMMITS_DIR = "commits"
+
+
+class ReasoningStore:
+    """
+    Query Agent reasoning from the .GCC/ event store.
+
+    Combines SensitivityEvents (the why) with the nearest commit on the same
+    branch (the decision), filtered by agent_id and concept, token-budgeted.
+    """
+
+    def __init__(self, repo) -> None:
+        self._repo = repo
+        self._gcc_dir = repo.gcc_dir
+
+    def query(
+        self,
+        concept: str,
+        agent_id: Optional[str] = None,
+        scope: str = "branch",
+        k_tokens: int = 4000,
+    ) -> List[ReasoningEntry]:
+        """
+        Return reasoning entries for the given concept, optionally filtered by agent_id.
+
+        Falls back to source_node as agent_id for events without an explicit agent_id
+        (backward compatibility with pre-S18 events).
+        """
+        events = self._load_sensitivity_events(concept)
+        commits = self._load_commits_index()
+
+        entries: List[ReasoningEntry] = []
+        for ev in events:
+            effective_agent = ev.get("agent_id") or ev.get("source_node", "unknown")
+            if agent_id is not None and effective_agent != agent_id:
+                continue
+
+            decision_text = self._nearest_commit_message(
+                ev.get("created_at", ""), ev.get("branch", "main"), commits
+            )
+
+            entry = ReasoningEntry(
+                entry_id=ev.get("event_id", ""),
+                agent_id=effective_agent,
+                concept=concept,
+                reasoning_text=ev.get("counterfactuals", "") or ev.get("message", ""),
+                decision_text=decision_text,
+                confidence=float(ev.get("confidence", 0.0)),
+                disclosure_level=ev.get("disclosure_level", "PROTECTED"),
+                session_id=ev.get("session_id"),
+                branch=ev.get("branch", "main"),
+                timestamp=ev.get("created_at", ""),
+                source_type="sensitivity",
+            )
+            entries.append(entry)
+
+        # Sort by timestamp descending (most recent first), then apply token budget
+        entries.sort(key=lambda e: e.timestamp, reverse=True)
+        return self._apply_token_budget(entries, k_tokens)
+
+    def _load_sensitivity_events(self, concept: str) -> List[dict]:
+        path = self._gcc_dir / _SENSITIVITIES_FILE
+        if not path.exists():
+            return []
+        results = []
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                d = json.loads(line)
+                if d.get("target_concept") == concept:
+                    results.append(d)
+            except json.JSONDecodeError:
+                continue
+        return results
+
+    def _load_commits_index(self) -> List[dict]:
+        commits_dir = self._gcc_dir / _COMMITS_DIR
+        if not commits_dir.exists():
+            return []
+        commits = []
+        for f in sorted(commits_dir.glob("*.json")):
+            try:
+                commits.append(json.loads(f.read_text(encoding="utf-8")))
+            except (json.JSONDecodeError, OSError):
+                continue
+        return sorted(commits, key=lambda c: c.get("timestamp", ""))
+
+    def _nearest_commit_message(
+        self, event_ts: str, branch: str, commits: List[dict]
+    ) -> str:
+        """Find the commit message from the latest commit at or before event_ts on branch."""
+        branch_commits = [c for c in commits if c.get("branch") == branch]
+        before = [c for c in branch_commits if c.get("timestamp", "") <= event_ts]
+        if before:
+            return before[-1].get("message", "")
+        # Fall back to nearest commit regardless of branch
+        if commits:
+            return commits[-1].get("message", "")
+        return ""
+
+    @staticmethod
+    def _apply_token_budget(entries: List[ReasoningEntry], k_tokens: int) -> List[ReasoningEntry]:
+        result = []
+        used = 0
+        for e in entries:
+            t = e.approx_tokens()
+            if used + t > k_tokens:
+                break
+            result.append(e)
+            used += t
+        return result

devtorch_core/reasoning_plus/__init__.py

@@ -0,0 +1,70 @@
+"""
+devtorch_core.reasoning_plus
+============================
+Reasoning Plus: smart workspace context + inline reasoning capture.
+
+Public API:
+    ReasoningPlusAugmenter  — orchestrates context, prompt, and capture
+    ReasoningPlusConfig     — dataclass for settings
+    SettingsStore           — read/write project and global settings
+    load_config             — convenience loader
+    is_enabled              — quick enablement check
+    gather_smart_context    — extract keywords, search repo, read files
+    build_reasoning_plus_system_prompt  — prompt builder
+    extract_inline_thinking, strip_inline_thinking, commit_reasoning
+"""
+from __future__ import annotations
+
+from devtorch_core.reasoning_plus.augmenter import (
+    ReasoningPlusAugmenter,
+    is_enabled,
+)
+from devtorch_core.reasoning_plus.capture import (
+    commit_reasoning,
+    extract_inline_thinking,
+    strip_inline_thinking,
+)
+from devtorch_core.reasoning_plus.config import (
+    ReasoningPlusConfig,
+    SettingsStore,
+    load_config,
+)
+from devtorch_core.reasoning_plus.context import (
+    extract_keywords,
+    gather_smart_context,
+    read_files_at_commit,
+    search_repo,
+)
+from devtorch_core.reasoning_plus.learning import (
+    Learning,
+    PromptComposer,
+    ReasoningCall,
+    ReasoningPlusLearning,
+)
+from devtorch_core.reasoning_plus.prompt import (
+    DEFAULT_REASONING_DIRECTIVE,
+    PATCH_REASONING_DIRECTIVE,
+    build_reasoning_plus_system_prompt,
+)
+
+__all__ = [
+    "ReasoningPlusAugmenter",
+    "ReasoningPlusConfig",
+    "SettingsStore",
+    "load_config",
+    "is_enabled",
+    "extract_keywords",
+    "search_repo",
+    "read_files_at_commit",
+    "gather_smart_context",
+    "build_reasoning_plus_system_prompt",
+    "DEFAULT_REASONING_DIRECTIVE",
+    "PATCH_REASONING_DIRECTIVE",
+    "extract_inline_thinking",
+    "strip_inline_thinking",
+    "commit_reasoning",
+    "ReasoningPlusLearning",
+    "ReasoningCall",
+    "Learning",
+    "PromptComposer",
+]