@oswaldzsh/devhive 0.1.0

package/protocol/schemas.py

@@ -0,0 +1,222 @@
+"""DevHive Protocol Schemas
+
+All inter-agent communication is fully typed via Pydantic models.
+No natural-language handoffs — every message is machine-verifiable.
+"""
+
+from pydantic import BaseModel, Field
+from enum import Enum
+from datetime import datetime, timezone
+from typing import Optional
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc).replace(tzinfo=None)
+
+
+# ── Enums ────────────────────────────────────────────────────
+
+class ChangeType(str, Enum):
+    LOGIC_FIX = "logic_fix"
+    NEW_FEATURE = "new_feature"
+    REFACTOR = "refactor"
+    CONFIG = "config"
+    DEPENDENCY = "dependency"
+    DOCS = "docs"
+
+
+class Severity(str, Enum):
+    CRITICAL = "CRITICAL"
+    HIGH = "HIGH"
+    MEDIUM = "MEDIUM"
+    LOW = "LOW"
+    INFO = "INFO"
+
+
+class Priority(str, Enum):
+    CRITICAL = "CRITICAL"
+    HIGH = "HIGH"
+    MEDIUM = "MEDIUM"
+    LOW = "LOW"
+
+
+class VerdictOverall(str, Enum):
+    PASS = "PASS"
+    WARN = "WARN"
+    FAIL = "FAIL"
+    CONFLICT = "CONFLICT"
+
+
+class VerifierType(str, Enum):
+    STATIC = "static"
+    DYNAMIC = "dynamic"
+    SEMANTIC = "semantic"
+
+
+class ConflictType(str, Enum):
+    FACT = "fact"
+    INTERPRETATION = "interpretation"
+    SPEC_AMBIGUITY = "spec_ambiguity"
+
+
+class ConcurrencyAction(str, Enum):
+    PASS = "PASS"
+    FIX = "FIX"
+    ESCALATE = "ESCALATE"
+    CONFLICT = "CONFLICT"
+
+
+class Alignment(str, Enum):
+    ALIGNED = "ALIGNED"
+    ENHANCED = "ENHANCED"
+    DEVIATED = "DEVIATED"
+    CONFLICT = "CONFLICT"
+
+
+class SuggestedAction(str, Enum):
+    ROLLBACK = "ROLLBACK"
+    FIX = "FIX"
+    RETEST = "RETEST"
+    ESCALATE = "ESCALATE"
+    IGNORE = "IGNORE"
+
+
+# ── Task / Spec ──────────────────────────────────────────────
+
+class TaskSpec(BaseModel):
+    """Human-provided target-state description."""
+    title: str
+    description: str
+    acceptance_criteria: list[str] = Field(default_factory=list)
+    scope_constraints: list[str] = Field(default_factory=list)
+    sensitive_modules: list[str] = Field(default_factory=list)
+    priority: Priority = Priority.MEDIUM
+
+
+class Task(BaseModel):
+    id: str
+    spec: TaskSpec
+    branch: str
+    base_commit: str
+    created_at: datetime = Field(default_factory=_utcnow)
+    current_stage: str = "SPECIFY"
+
+
+# ── Handoff ──────────────────────────────────────────────────
+
+class RiskAssessment(BaseModel):
+    risk: str
+    severity: Severity
+
+
+class FileChange(BaseModel):
+    file: str
+    diff_range: dict  # {"start_line": int, "end_line": int}
+    change_type: ChangeType
+    summary: str
+    risk_self_assessment: list[RiskAssessment] = Field(default_factory=list)
+
+
+class VerificationFocus(BaseModel):
+    what: str
+    how_to_verify: str
+    priority: Priority
+
+
+class EnvChanges(BaseModel):
+    new_dependencies: list[str] = Field(default_factory=list)
+    config_changes: list[str] = Field(default_factory=list)
+    migration_needed: bool = False
+
+
+class ExecutionTrace(BaseModel):
+    commands_run: list[str] = Field(default_factory=list)
+    self_check_passed: bool = False
+    self_check_output_hash: Optional[str] = None
+
+
+class ExecutionHandoff(BaseModel):
+    """Emitted by Execute Agent after producing code changes."""
+    handoff_version: str = "1.0"
+    source: str
+    task_id: str
+    timestamp: datetime = Field(default_factory=_utcnow)
+    intent: str
+    changes: list[FileChange]
+    verification_focus: list[VerificationFocus]
+    env_changes: EnvChanges = Field(default_factory=EnvChanges)
+    execution_trace: ExecutionTrace
+
+
+# ── Verdict ──────────────────────────────────────────────────
+
+class FindingEvidence(BaseModel):
+    type: str  # diff | log | metric | ast | trace
+    data: str
+
+
+class Finding(BaseModel):
+    id: str = Field(default_factory=lambda: f"F-{_utcnow().timestamp()}")
+    severity: Severity
+    category: str
+    title: str
+    detail: str
+    evidence: FindingEvidence
+    matched_signature: Optional[str] = None
+    suggested_action: SuggestedAction = SuggestedAction.ESCALATE
+
+
+class Verdict(BaseModel):
+    """Output from any Verifier Agent."""
+    verdict_version: str = "1.0"
+    verifier_type: VerifierType
+    task_id: str
+    timestamp: datetime = Field(default_factory=_utcnow)
+    overall: VerdictOverall
+    findings: list[Finding] = Field(default_factory=list)
+
+
+# ── Semiconductor Verdict ────────────────────────────────────
+
+class SemanticVerdict(BaseModel):
+    """Specialized verdict for semantic verification."""
+    verdict_version: str = "1.0"
+    verifier_type: str = "semantic"
+    task_id: str
+    timestamp: datetime = Field(default_factory=_utcnow)
+    alignment: Alignment
+    reasoning: str
+    concerns: list[str] = Field(default_factory=list)
+    overall: VerdictOverall = VerdictOverall.PASS
+
+
+# ── Convergence ──────────────────────────────────────────────
+
+class ConvergenceDecision(BaseModel):
+    action: ConcurrencyAction
+    reason: str
+    fix_strategy: Optional[str] = None
+    escalation: Optional['EscalationReport'] = None
+
+
+# ── Escalation ────────────────────────────────────────────────
+
+class EscalationReport(BaseModel):
+    escalation_id: str
+    task_id: str
+    triggered_by: str
+    current_state: dict
+    history: list[dict] = Field(default_factory=list)
+    what_agent_tried: list[str] = Field(default_factory=list)
+    blocking_finding: Optional[dict] = None
+    suggested_human_action: str = ""
+
+
+# ── Events ───────────────────────────────────────────────────
+
+class DevHiveEvent(BaseModel):
+    """Base event type for the event bus."""
+    event_type: str
+    task_id: str
+    timestamp: datetime = Field(default_factory=_utcnow)
+    payload: dict = Field(default_factory=dict)

package/setup.py

@@ -0,0 +1,44 @@
+"""Setup script for the C signature matching extension."""
+
+from setuptools import setup, Extension
+import os
+
+matcher_ext = Extension(
+    "signature._matcher",
+    sources=[
+        os.path.join("signature", "src", "matcher.c"),
+    ],
+    include_dirs=[os.path.join("signature", "src")],
+    extra_compile_args=["-O3", "-march=native", "-ffast-math"],
+    extra_link_args=["-lm"],
+)
+
+setup(
+    name="devhive",
+    version="0.1.0",
+    description="DevHive — Multi-Agent Software Development System",
+    packages=[
+        "devhive",
+        "devhive.orchestrator",
+        "devhive.agents",
+        "devhive.protocol",
+        "devhive.verification",
+        "devhive.signature",
+        "devhive.storage",
+        "devhive.tools",
+        "devhive.control_plane",
+    ],
+    package_dir={"devhive": "."},
+    ext_modules=[matcher_ext],
+    install_requires=[
+        "httpx>=0.25.0",
+        "pydantic>=2.0.0",
+        "pyyaml>=6.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "devhive=devhive.control_plane.cli:main",
+        ],
+    },
+    python_requires=">=3.12",
+)

package/signature/engine.py

@@ -0,0 +1,211 @@
+"""Python wrapper for the C signature matching engine.
+
+Falls back to a pure-Python implementation if the C extension is not built.
+"""
+
+import ctypes
+import os
+from ctypes import c_int, c_double, c_char, c_uint64, POINTER, Structure
+from typing import Optional
+
+
+# ── C Types ────────────────────────────────────────────────
+
+class CFeatureVector(Structure):
+    _fields_ = [
+        ("error_type", c_char * 64),
+        ("error_message_hash", c_uint64),
+        ("location_pattern", c_char * 256),
+        ("stack_depth", c_int),
+        ("stack_hashes", c_uint64 * 10),
+        ("change_type", c_int),
+        ("distance_to_error", c_int),
+        ("is_new_in_diff", c_int),
+    ]
+
+
+class CMatchResult(Structure):
+    _fields_ = [
+        ("sig_id", c_char * 32),
+        ("similarity", c_double),
+        ("reliability", c_double),
+        ("match_count", c_int),
+        ("resolution_strategy", c_char * 32),
+        ("fix_template", c_char * 512),
+    ]
+
+
+class CMatcherConfig(Structure):
+    _fields_ = [
+        ("w_error_type", c_double),
+        ("w_error_message", c_double),
+        ("w_location", c_double),
+        ("w_stack_trace", c_double),
+        ("w_change_context", c_double),
+        ("w_temporal", c_double),
+        ("min_confidence", c_double),
+        ("top_k", c_int),
+    ]
+
+
+class SignatureEngine:
+    """High-performance signature matching engine.
+
+    Uses C extension if available, otherwise falls back to Python.
+    """
+
+    def __init__(self, db_path: str = None, config: dict = None):
+        self.db_path = db_path
+        self._lib = None
+        self._db = None
+        self._config = CMatcherConfig()
+        self._load_library()
+        self._init_config(config)
+
+    def _load_library(self):
+        """Try to load the C extension library."""
+        lib_path = os.path.join(os.path.dirname(__file__), "src", "libmatcher.so")
+        if not os.path.exists(lib_path):
+            # Try build directory
+            lib_path = os.path.join(os.path.dirname(__file__),
+                                    "src", "build", "libmatcher.so")
+        if not os.path.exists(lib_path):
+            return  # Will use Python fallback
+
+        try:
+            self._lib = ctypes.CDLL(lib_path)
+            # Set up function signatures
+            self._lib.db_create.argtypes = [c_int]
+            self._lib.db_create.restype = ctypes.c_void_p
+
+            self._lib.db_destroy.argtypes = [ctypes.c_void_p]
+            self._lib.db_destroy.restype = None
+
+            self._lib.config_default.restype = CMatcherConfig
+
+            self._lib.db_match.argtypes = [
+                ctypes.c_void_p, POINTER(CMatcherConfig),
+                POINTER(CFeatureVector), POINTER(CMatchResult), c_int]
+            self._lib.db_match.restype = c_int
+
+            self._db = self._lib.db_create(1024)
+        except Exception:
+            self._lib = None
+
+    def _init_config(self, config: dict = None):
+        cfg = config or {}
+        if self._lib:
+            self._config = self._lib.config_default()
+        else:
+            self._config = CMatcherConfig()
+        self._config.w_error_type = cfg.get("w_error_type", 0.30)
+        self._config.w_error_message = cfg.get("w_error_message", 0.15)
+        self._config.w_location = cfg.get("w_location", 0.25)
+        self._config.w_stack_trace = cfg.get("w_stack_trace", 0.15)
+        self._config.w_change_context = cfg.get("w_change_context", 0.10)
+        self._config.w_temporal = cfg.get("w_temporal", 0.05)
+        self._config.min_confidence = cfg.get("min_confidence", 0.65)
+        self._config.top_k = cfg.get("top_k", 3)
+
+    def match(self, query: dict, k: int = 3,
+              min_confidence: float = None) -> list[dict]:
+        """Match a query against the signature database.
+
+        Args:
+            query: Dict with keys: error_type, error_message, location_pattern,
+                   stack_hashes, change_type, distance_to_error, is_new_in_diff
+            k: Number of top results to return
+            min_confidence: Override minimum confidence threshold
+        Returns:
+            List of matched signatures with similarity scores
+        """
+        if min_confidence is not None:
+            self._config.min_confidence = min_confidence
+        self._config.top_k = k
+
+        fv = self._build_feature_vector(query)
+
+        if self._lib and self._db:
+            return self._match_c(fv, k)
+        else:
+            return self._match_python(query, k)
+
+    def _build_feature_vector(self, query: dict) -> CFeatureVector:
+        fv = CFeatureVector()
+        fv.error_type = (query.get("error_type", "") or "").encode()[:63]
+        fv.error_message_hash = hash(query.get("error_message", "")) & 0xFFFFFFFFFFFFFFFF
+        fv.location_pattern = (query.get("location_pattern", "") or "").encode()[:255]
+        fv.stack_depth = 0
+        fv.change_type = 0
+        fv.distance_to_error = 0
+        fv.is_new_in_diff = 1 if query.get("is_new_in_diff", True) else 0
+        return fv
+
+    def _match_c(self, fv: CFeatureVector, k: int) -> list[dict]:
+        results = (CMatchResult * k)()
+        n = self._lib.db_match(self._db, ctypes.byref(self._config),
+                               ctypes.byref(fv), results, k)
+        return [
+            {
+                "signature_id": results[i].sig_id.decode(),
+                "similarity": results[i].similarity,
+                "reliability": results[i].reliability,
+                "match_count": results[i].match_count,
+                "resolution_strategy": results[i].resolution_strategy.decode(),
+                "fix_template": results[i].fix_template.decode(),
+            }
+            for i in range(n)
+        ]
+
+    def _match_python(self, query: dict, k: int) -> list[dict]:
+        """Pure Python fallback matcher."""
+        # Simple keyword-based matching as fallback
+        results = []
+        error_type = query.get("error_type", "").lower()
+        location = query.get("location_pattern", "").lower()
+
+        # Load signatures from file if available
+        signatures = self._load_signatures()
+
+        for sig in signatures:
+            score = 0.0
+            fv = sig.get("feature_vector", {})
+
+            # Error type match
+            if error_type and error_type in fv.get("error_type", "").lower():
+                score += self._config.w_error_type
+
+            # Location match
+            sig_loc = fv.get("error_location_pattern", "").lower()
+            if location and sig_loc:
+                if location == sig_loc:
+                    score += self._config.w_location
+                elif os.path.commonprefix([location, sig_loc]):
+                    score += self._config.w_location * 0.5
+
+            if score >= self._config.min_confidence:
+                results.append({
+                    "signature_id": sig.get("signature_id", ""),
+                    "similarity": score,
+                    "reliability": sig.get("diagnosis", {}).get("reliability", 0.5),
+                    "match_count": sig.get("match_count", 0),
+                    "resolution_strategy": sig.get("resolution", {}).get("strategy", ""),
+                    "fix_template": sig.get("resolution", {}).get("fix_template", ""),
+                })
+
+        results.sort(key=lambda r: r["similarity"], reverse=True)
+        return results[:k]
+
+    def _load_signatures(self) -> list[dict]:
+        """Load signatures from the JSON database."""
+        import json
+        if self.db_path and os.path.exists(self.db_path):
+            with open(self.db_path) as f:
+                data = json.load(f)
+            return data.get("signatures", [])
+        return []
+
+    def close(self):
+        if self._lib and self._db:
+            self._lib.db_destroy(self._db)
+            self._db = None

package/signature/extractor.py

@@ -0,0 +1,156 @@
+"""Feature vector extractor — converts raw error data to structured vectors."""
+
+import hashlib
+import re
+from typing import Optional
+
+
+def extract_feature_vector(
+    error_output: str,
+    changed_files: list[str] = None,
+    change_types: list[str] = None,
+) -> dict:
+    """Extract a feature vector from raw error output.
+
+    Args:
+        error_output: Raw stderr/stdout from a failed test run
+        changed_files: List of files modified in this change
+        change_types: Types of changes (logic_fix, refactor, etc.)
+
+    Returns:
+        Dict with feature_vector, ready for signature matching
+    """
+    changed_files = changed_files or []
+    change_types = change_types or []
+
+    # 1. Parse error type
+    error_type = _parse_error_type(error_output)
+
+    # 2. Hash the normalized error message
+    normalized = _normalize_error_message(error_output)
+    error_message_hash = hashlib.sha256(normalized.encode()).hexdigest()[:16]
+
+    # 3. Extract location pattern
+    location_pattern = _extract_location(error_output, changed_files)
+
+    # 4. Extract stack trace hashes
+    stack_hashes = _extract_stack_signature(error_output)
+
+    # 5. Determine distance to error
+    distance = _compute_distance(location_pattern, changed_files)
+
+    return {
+        "feature_vector": {
+            "error_type": error_type,
+            "error_message_hash": error_message_hash,
+            "error_location_pattern": location_pattern,
+            "stack_trace_signature": stack_hashes[:5],
+            "change_context": {
+                "files_touched": changed_files,
+                "change_types": change_types,
+                "distance_to_error": distance,
+            },
+            "temporal": {
+                "is_new_in_this_diff": True,
+            },
+        },
+        "raw_normalized": normalized[:500],
+    }
+
+
+def _parse_error_type(error_output: str) -> str:
+    """Extract the error/exception type from output."""
+    # Common Python patterns
+    patterns = [
+        (r'(\w+Error)', None),               # ValueError, KeyError, etc.
+        (r'(\w+Exception)', None),            # RuntimeException, etc.
+        (r'(\w+Warning)', None),              # DeprecationWarning, etc.
+        (r'AssertionError', None),
+        (r'Traceback.*\n\s*(\w+)', None),     # First line after Traceback
+        (r'FAILED.*-.*Error:\s*(\w+)', None), # pytest output
+        (r'segmentation fault', 'Segfault'),
+        (r'timeout', 'TimeoutError'),
+        (r'out of memory', 'OutOfMemoryError'),
+        (r'connection refused', 'ConnectionRefused'),
+        (r'connection timeout', 'ConnectionTimeout'),
+        (r'permission denied', 'PermissionError'),
+        (r'file not found', 'FileNotFoundError'),
+        (r'module not found', 'ModuleNotFoundError'),
+        (r'import error', 'ImportError'),
+    ]
+
+    for pattern, fallback in patterns:
+        match = re.search(pattern, error_output, re.IGNORECASE)
+        if match:
+            return match.group(1) if fallback is None else fallback
+
+    return "UnknownError"
+
+
+def _normalize_error_message(error_output: str) -> str:
+    """Normalize error message for consistent hashing."""
+    # Remove file paths (variable between environments)
+    text = re.sub(r'/[^\s]+\.py:\d+', '<FILE>:<LINE>', error_output)
+    # Remove hex addresses
+    text = re.sub(r'0x[0-9a-fA-F]+', '<ADDR>', text)
+    # Remove timestamps
+    text = re.sub(r'\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[^\s]*', '<TIMESTAMP>', text)
+    # Remove numeric IDs (UUIDs, etc.)
+    text = re.sub(r'[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}',
+                  '<UUID>', text)
+    # Collapse whitespace
+    text = re.sub(r'\s+', ' ', text).strip().lower()
+    return text
+
+
+def _extract_location(error_output: str, changed_files: list[str]) -> str:
+    """Extract the file location most likely associated with the error."""
+    # Look for file:line patterns
+    file_pattern = r'File "([^"]+)", line (\d+)'
+    matches = re.findall(file_pattern, error_output)
+
+    for file_path, line in matches:
+        for changed in changed_files:
+            if changed in file_path or file_path.endswith(changed.split("/")[-1]):
+                return f"{file_path}:{line}"
+
+    if matches:
+        return f"{matches[0][0]}:{matches[0][1]}"
+    if changed_files:
+        return changed_files[0]
+
+    return "unknown"
+
+
+def _extract_stack_signature(error_output: str) -> list[str]:
+    """Extract stack trace as a list of location hashes."""
+    file_pattern = r'File "([^"]+)", line (\d+), in (\w+)'
+    matches = re.findall(file_pattern, error_output)
+
+    hashes = []
+    for file_path, line, func in matches:
+        # Create a short hash of each stack frame
+        frame = f"{file_path.split('/')[-1]}:{line}:{func}"
+        h = hashlib.sha256(frame.encode()).hexdigest()[:8]
+        hashes.append(h)
+
+    return hashes if hashes else [hashlib.sha256(error_output[:200].encode()).hexdigest()[:8]]
+
+
+def _compute_distance(location: str, changed_files: list[str]) -> str:
+    """Determine if the error is in a changed file, same module, or elsewhere."""
+    if not location or location == "unknown":
+        return "DIFFERENT_MODULE"
+
+    for f in changed_files:
+        if f in location or location.endswith(f.split("/")[-1]):
+            return "SAME_FILE"
+
+    # Check same directory/module
+    location_dir = "/".join(location.split("/")[:-1])
+    for f in changed_files:
+        f_dir = "/".join(f.split("/")[:-1])
+        if location_dir and f_dir and location_dir == f_dir:
+            return "SAME_MODULE"
+
+    return "DIFFERENT_MODULE"