devtorch-core 3.0.1__py3-none-any.whl

devtorch_core/parser/inference.py

@@ -0,0 +1,159 @@
+"""
+devtorch_core.parser.inference
+================================
+Heuristic inference of sensitivity signals and decision summaries from raw LLM
+response text.
+
+This is the *fallback* path used when the LLM did not emit explicit RACP
+``<devtorch:sensitivity>`` or ``<devtorch:commit>`` blocks.  All inferred
+results carry ``confidence=0.5`` to distinguish them from LLM-asserted values.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+# ---------------------------------------------------------------------------
+# Data class
+# ---------------------------------------------------------------------------
+
+@dataclass
+class InferredSensitivity:
+    concept: str
+    signal: str
+    confidence: float = 0.5
+    source: str = "inference_heuristic"
+
+
+# ---------------------------------------------------------------------------
+# Keyword → concept mapping
+# ---------------------------------------------------------------------------
+
+# Each entry is (compiled_pattern, concept_label).
+_SENSITIVITY_PATTERNS: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r'\b(schema|migration|database)\b', re.IGNORECASE), 'data_schema'),
+    (re.compile(r'\b(auth|authentication|token|jwt|session)\b', re.IGNORECASE), 'authentication'),
+    (re.compile(r'\b(api|endpoint|route|url)\b', re.IGNORECASE), 'api_interface'),
+    (re.compile(r'\b(deploy|release|rollout|pipeline)\b', re.IGNORECASE), 'deployment'),
+    (re.compile(r'\b(security|vulnerability|cve|injection)\b', re.IGNORECASE), 'security'),
+    (re.compile(r'\b(performance|latency|throughput|cache)\b', re.IGNORECASE), 'performance'),
+    (re.compile(r'\b(config|configuration|environment|env)\b', re.IGNORECASE), 'configuration'),
+]
+
+# Sentence boundary: split on . ! ? followed by whitespace or end-of-string.
+_RE_SENTENCE_SPLIT = re.compile(r'(?<=[.!?])\s+')
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _sentences(text: str) -> list[str]:
+    """Split text into rough sentences."""
+    return [s.strip() for s in _RE_SENTENCE_SPLIT.split(text) if s.strip()]
+
+
+def _find_surrounding_sentence(text: str, match: re.Match[str]) -> str:
+    """
+    Return the sentence that contains the regex match, truncated to 120 chars.
+    Falls back to the matched substring itself if no sentence boundary is found.
+    """
+    start = match.start()
+    # Walk backwards to the previous sentence boundary (. ! ? or start of text).
+    before = text[:start]
+    sentence_start = max(
+        before.rfind("."),
+        before.rfind("!"),
+        before.rfind("?"),
+    )
+    sentence_start = sentence_start + 1 if sentence_start != -1 else 0
+
+    # Walk forwards to the next sentence boundary.
+    after = text[start:]
+    ends = [after.find(c) for c in ".!?" if after.find(c) != -1]
+    sentence_end = start + min(ends) + 1 if ends else len(text)
+
+    sentence = text[sentence_start:sentence_end].strip()
+    return sentence[:120]
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def infer_sensitivity(text: str, max_concepts: int = 2) -> list[InferredSensitivity]:
+    """
+    Heuristically infer sensitivity signals from response text.
+
+    Scans *text* for keyword patterns defined in ``_SENSITIVITY_PATTERNS``.
+    Returns up to *max_concepts* :class:`InferredSensitivity` objects.
+
+    All results have ``confidence=0.5`` — this is the fallback path only.
+    Signal text is the first 120 characters of the surrounding sentence.
+    """
+    if not text or not text.strip():
+        return []
+
+    results: list[InferredSensitivity] = []
+    seen_concepts: set[str] = set()
+
+    for pattern, concept in _SENSITIVITY_PATTERNS:
+        if len(results) >= max_concepts:
+            break
+        if concept in seen_concepts:
+            continue
+        match = pattern.search(text)
+        if match:
+            signal = _find_surrounding_sentence(text, match)
+            results.append(
+                InferredSensitivity(
+                    concept=concept,
+                    signal=signal,
+                )
+            )
+            seen_concepts.add(concept)
+
+    return results
+
+
+def extract_decision_summary(text: str, max_chars: int = 150) -> str:
+    """
+    Extract a short decision summary from the first meaningful sentence of text.
+
+    Processing steps:
+
+    1. Strip markdown formatting (headings, bold, italic, code fences,
+       inline code, bullet markers).
+    2. Find the first non-empty sentence.
+    3. Truncate to *max_chars*.
+    4. Prefix with ``"auto: "``.
+
+    Returns ``"auto: (no content)"`` if *text* is empty or blank.
+    """
+    if not text or not text.strip():
+        return "auto: (no content)"
+
+    # Remove fenced code blocks.
+    cleaned = re.sub(r"```[\s\S]*?```", " ", text)
+    # Remove inline code.
+    cleaned = re.sub(r"`[^`]*`", " ", cleaned)
+    # Remove markdown headings.
+    cleaned = re.sub(r"^#{1,6}\s+", "", cleaned, flags=re.MULTILINE)
+    # Remove bold/italic markers (**text**, __text__, *text*, _text_).
+    cleaned = re.sub(r"\*{1,3}([^*]+)\*{1,3}", r"\1", cleaned)
+    cleaned = re.sub(r"_{1,3}([^_]+)_{1,3}", r"\1", cleaned)
+    # Remove bullet / list markers.
+    cleaned = re.sub(r"^\s*[-*+]\s+", "", cleaned, flags=re.MULTILINE)
+    cleaned = re.sub(r"^\s*\d+\.\s+", "", cleaned, flags=re.MULTILINE)
+    # Collapse whitespace.
+    cleaned = " ".join(cleaned.split())
+
+    # Extract first meaningful sentence.
+    sentences = _RE_SENTENCE_SPLIT.split(cleaned)
+    first = next((s.strip() for s in sentences if s.strip()), "")
+
+    if not first:
+        return "auto: (no content)"
+
+    truncated = first[:max_chars].rstrip()
+    return f"auto: {truncated}"

devtorch_core/parser/thinking.py

@@ -0,0 +1,112 @@
+"""
+devtorch_core.parser.thinking
+==============================
+Normalise extended-thinking / reasoning content blocks returned by LLM APIs.
+
+Supported formats
+-----------------
+Anthropic extended thinking
+    ``response["content"]`` is a list of content blocks.  Blocks whose
+    ``"type"`` equals ``"thinking"`` carry the reasoning text in
+    ``block["thinking"]``.
+
+OpenAI o1 / o3 reasoning
+    ``response["choices"][0]["message"]["reasoning_content"]`` is a string
+    containing the chain-of-thought the model produced before answering.
+
+Standard models
+    Neither format is present.  An empty list is returned.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Data class
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ThinkingBlock:
+    text: str
+    confidence: float = 1.0    # thinking tokens always conf=1.0
+    source: str = "thinking_content"
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def extract_thinking_blocks(response: dict) -> list[ThinkingBlock]:
+    """
+    Extract thinking / reasoning content from an LLM API response dict.
+
+    Anthropic format
+        ``response["content"]`` is a list; items with ``type == "thinking"``
+        have a ``"thinking"`` key with the text.
+
+    OpenAI o1/o3 format
+        ``response["choices"][0]["message"]["reasoning_content"]`` is a string.
+
+    Returns a list of :class:`ThinkingBlock` objects (may be empty for
+    standard non-reasoning models).
+    """
+    blocks: list[ThinkingBlock] = []
+
+    # --- Anthropic format ---
+    content = response.get("content")
+    if isinstance(content, list):
+        for item in content:
+            if not isinstance(item, dict):
+                continue
+            if item.get("type") == "thinking":
+                text = item.get("thinking", "")
+                if text:
+                    blocks.append(ThinkingBlock(text=str(text)))
+        # If we found Anthropic-style blocks, return early — no need to also
+        # scan OpenAI format.
+        if blocks:
+            return blocks
+
+    # --- OpenAI o1/o3 format ---
+    try:
+        choices = response.get("choices")
+        if isinstance(choices, list) and choices:
+            message = choices[0].get("message", {})
+            reasoning = message.get("reasoning_content")
+            if reasoning and isinstance(reasoning, str):
+                blocks.append(
+                    ThinkingBlock(
+                        text=reasoning,
+                        source="reasoning_content",
+                    )
+                )
+    except (AttributeError, IndexError, KeyError) as exc:
+        logger.warning("devtorch parser: error reading OpenAI reasoning_content — %s", exc)
+
+    return blocks
+
+
+def thinking_to_commit_message(
+    blocks: list[ThinkingBlock],
+    max_chars: int = 200,
+) -> str:
+    """
+    Summarise thinking blocks into a short commit message.
+
+    Takes the first *max_chars* characters of the first block's text (newlines
+    stripped/collapsed).  Returns a string prefixed with ``"auto: "``.
+
+    If *blocks* is empty, returns ``"auto: (no thinking content)"``.
+    """
+    if not blocks:
+        return "auto: (no thinking content)"
+
+    text = blocks[0].text
+    # Collapse whitespace and newlines into single spaces.
+    text = " ".join(text.split())
+    truncated = text[:max_chars].rstrip()
+    return f"auto: {truncated}"

devtorch_core/projects.py

@@ -0,0 +1,169 @@
+"""
+Sprint 19 — Multi-project registry.
+
+Maintains a machine-level index of all DevTorch-managed repos at
+~/.devtorch/registry.json. Each entry records:
+  - name
+  - path (resolved absolute path)
+  - developer_id
+  - added_at
+  - last_synced
+
+API is intentionally simple: the registry is metadata-only; reasoning state
+remains in each project's isolated .GCC/ directory.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from dataclasses import dataclass, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+DEFAULT_REGISTRY_DIR = Path.home() / ".devtorch"
+DEFAULT_REGISTRY_FILE = "registry.json"
+REGISTRY_PATH_ENV = "DEVTORCH_REGISTRY_PATH"
+
+
+@dataclass
+class ProjectEntry:
+    name: str
+    path: str
+    developer_id: str
+    added_at: str
+    last_synced: str
+
+
+class ProjectRegistry:
+    """Machine-level registry of DevTorch-managed projects."""
+
+    def __init__(self, registry_path: Optional[Path] = None) -> None:
+        if registry_path is None:
+            env_path = os.environ.get(REGISTRY_PATH_ENV, "").strip()
+            if env_path:
+                registry_path = Path(env_path)
+            else:
+                registry_path = DEFAULT_REGISTRY_DIR / DEFAULT_REGISTRY_FILE
+        self.registry_path = Path(registry_path)
+        self._ensure_dir()
+
+    def _ensure_dir(self) -> None:
+        self.registry_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _read(self) -> dict:
+        if not self.registry_path.exists():
+            return {"version": "1", "projects": []}
+        try:
+            data = json.loads(self.registry_path.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                return {"version": "1", "projects": []}
+            return data
+        except (json.JSONDecodeError, OSError):
+            return {"version": "1", "projects": []}
+
+    def _write(self, data: dict) -> None:
+        self._ensure_dir()
+        self.registry_path.write_text(json.dumps(data, indent=2, sort_keys=True), encoding="utf-8")
+
+    def _guess_developer_id(self, project_path: Path) -> str:
+        """Guess developer_id from git config user.email in the project."""
+        try:
+            result = subprocess.run(
+                ["git", "-C", str(project_path), "config", "user.email"],
+                capture_output=True,
+                text=True,
+                timeout=2,
+                check=False,
+            )
+            email = result.stdout.strip()
+            if email:
+                return email
+        except Exception:
+            pass
+        env_id = os.environ.get("DEVTORCH_DEVELOPER_ID", "").strip()
+        if env_id:
+            return env_id
+        return "unknown"
+
+    def list(self) -> List[ProjectEntry]:
+        data = self._read()
+        entries = []
+        for raw in data.get("projects", []):
+            try:
+                entries.append(ProjectEntry(**raw))
+            except (TypeError, ValueError):
+                continue
+        return entries
+
+    def add(
+        self,
+        project_path: Path,
+        name: Optional[str] = None,
+        developer_id: Optional[str] = None,
+    ) -> ProjectEntry:
+        """Add a project to the registry. Idempotent by resolved path."""
+        project_path = Path(project_path).resolve()
+        if not project_path.exists():
+            raise ValueError(f"Project path does not exist: {project_path}")
+
+        data = self._read()
+        projects = data.get("projects", [])
+
+        resolved = str(project_path)
+        for raw in projects:
+            if Path(raw["path"]).resolve() == project_path:
+                # Update existing entry
+                raw["name"] = name or raw.get("name") or project_path.name
+                raw["developer_id"] = developer_id or raw.get("developer_id") or self._guess_developer_id(project_path)
+                raw["last_synced"] = _now_iso()
+                self._write(data)
+                return ProjectEntry(**raw)
+
+        entry = ProjectEntry(
+            name=name or project_path.name,
+            path=resolved,
+            developer_id=developer_id or self._guess_developer_id(project_path),
+            added_at=_now_iso(),
+            last_synced=_now_iso(),
+        )
+        projects.append(asdict(entry))
+        data["projects"] = projects
+        self._write(data)
+        return entry
+
+    def remove(self, project_path: Path) -> bool:
+        """Remove a project by path. Returns True if removed."""
+        project_path = Path(project_path).resolve()
+        data = self._read()
+        projects = data.get("projects", [])
+        original_len = len(projects)
+        projects = [
+            raw for raw in projects
+            if Path(raw["path"]).resolve() != project_path
+        ]
+        if len(projects) == original_len:
+            return False
+        data["projects"] = projects
+        self._write(data)
+        return True
+
+    def sync(self) -> List[ProjectEntry]:
+        """Re-read each registered project and update last_synced."""
+        data = self._read()
+        projects = data.get("projects", [])
+        updated = []
+        for raw in projects:
+            path = Path(raw["path"])
+            if path.exists():
+                raw["last_synced"] = _now_iso()
+            updated.append(raw)
+        data["projects"] = updated
+        self._write(data)
+        return [ProjectEntry(**raw) for raw in updated]
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()

devtorch_core/prompt_artifact.py

@@ -0,0 +1,76 @@
+"""
+Sprint 5 – A3: Canonical system prompt artifact RACP_SYSTEM_PROMPT_v2.1.
+
+Stored under .GCC/ and referenced by Textual Mode runs.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+PROMPTS_DIR_NAME = "prompts"
+RACP_SYSTEM_PROMPT_NAME = "RACP_SYSTEM_PROMPT_v2.1.md"
+RACP_SYSTEM_PROMPT_META = "RACP_SYSTEM_PROMPT_v2.1_meta.json"
+
+DEFAULT_PROMPT_CONTENT = """# RACP System Prompt v2.1
+
+You are a reasoning agent operating under the RACP (Reasoning and Coordination Protocol) v2.1.
+
+When you make a reasoning decision, emit a self-closing XML tag inside your
+response text so DevTorch can capture it:
+
+    <devtorch:commit message="why you chose this approach and what 
+     alternatives you considered" concepts="comma,separated,concept,names"
+     confidence="0.85"/>
+
+If the decision touches a sensitive area (auth, schema, payments, secrets, PII,
+external APIs, security, or config), also emit:
+
+    <devtorch:sensitivity concept="area_name" 
+     signal="what this decision depends on or could affect"
+     confidence="0.9" disclosure="PROTECTED"/>
+
+The disclosure attribute must be one of: PUBLIC, PROTECTED, or PRIVATE.
+
+When citing the coordination vector, refer to concepts defined in 
+[DevTorch Θ — top concepts]. Respect any invariant constraints (I1, I3).
+Do not leak [PRIVATE] content into reasoning messages.
+"""
+
+
+class PromptArtifactStore:
+    """Store and retrieve the canonical RACP_SYSTEM_PROMPT_v2.1 artifact."""
+    def __init__(self, gcc_dir: Path) -> None:
+        self.prompts_dir = gcc_dir / PROMPTS_DIR_NAME
+        self.prompt_path = self.prompts_dir / RACP_SYSTEM_PROMPT_NAME
+        self.meta_path = self.prompts_dir / RACP_SYSTEM_PROMPT_META
+
+    def ensure_dir(self) -> None:
+        self.prompts_dir.mkdir(parents=True, exist_ok=True)
+
+    def set_prompt(self, content: str, version: str = "v2.1") -> None:
+        """Store prompt text and metadata."""
+        self.ensure_dir()
+        self.prompt_path.write_text(content, encoding="utf-8")
+        meta = {"version": version, "artifact": RACP_SYSTEM_PROMPT_NAME}
+        self.meta_path.write_text(json.dumps(meta, indent=2) + "\n", encoding="utf-8")
+
+    def get_prompt(self) -> Optional[str]:
+        """Return prompt content or None if not set."""
+        if not self.prompt_path.exists():
+            return None
+        return self.prompt_path.read_text(encoding="utf-8")
+
+    def get_meta(self) -> Optional[dict]:
+        """Return metadata dict or None."""
+        if not self.meta_path.exists():
+            return None
+        return json.loads(self.meta_path.read_text(encoding="utf-8"))
+
+    def reference_for_textual_mode(self) -> Optional[str]:
+        """Return path reference for Textual Mode runs (relative to .GCC)."""
+        if not self.prompt_path.exists():
+            return None
+        return f"{PROMPTS_DIR_NAME}/{RACP_SYSTEM_PROMPT_NAME}"

devtorch_core/proxy/__init__.py

@@ -0,0 +1,9 @@
+from .server import create_app, run_proxy, install_service, DEFAULT_PORT, DEFAULT_HOST
+
+__all__ = [
+    "create_app",
+    "run_proxy",
+    "install_service",
+    "DEFAULT_PORT",
+    "DEFAULT_HOST",
+]

devtorch_core/proxy/routes/__init__.py

@@ -0,0 +1 @@
+# devtorch_core.proxy.routes