the-grid-cc 1.1.0

package/core/recognizer.py

@@ -0,0 +1,294 @@
+"""
+Recognizer - Validation Programs that scan for anomalies.
+
+"Recognizers patrol The Grid, ensuring order and quality."
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional, Any
+from enum import Enum
+import uuid
+
+from .program import Program, ProgramType, ProgramStatus
+
+
+class ValidationResult(Enum):
+    """Result of a Recognizer scan."""
+    VALID = "valid"           # All checks passed
+    RECTIFY_NEEDED = "rectify_needed"  # Issues found, can be fixed
+    DEREZ = "derez"           # Critical failure, reject
+
+
+class RecognizerType(Enum):
+    """Type of Recognizer."""
+    CODE = "code"              # Code quality validation
+    ARCHITECTURE = "architecture"  # Design validation
+    SECURITY = "security"      # Security scanning
+    CONSISTENCY = "consistency"  # Artifact alignment
+
+
+@dataclass
+class ValidationIssue:
+    """An issue found during validation."""
+    severity: str  # low, medium, high, critical
+    category: str
+    message: str
+    location: Optional[str] = None
+    suggestion: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        return {
+            "severity": self.severity,
+            "category": self.category,
+            "message": self.message,
+            "location": self.location,
+            "suggestion": self.suggestion,
+        }
+
+
+@dataclass
+class ScanResult:
+    """Result of a Recognizer scan."""
+    result: ValidationResult
+    issues: list[ValidationIssue] = field(default_factory=list)
+    passed_checks: int = 0
+    total_checks: int = 0
+    scan_duration: float = 0.0
+    details: dict = field(default_factory=dict)
+
+    @property
+    def passed(self) -> bool:
+        return self.result == ValidationResult.VALID
+
+    @property
+    def pass_rate(self) -> float:
+        if self.total_checks == 0:
+            return 0.0
+        return (self.passed_checks / self.total_checks) * 100
+
+    def summary(self) -> str:
+        status = "✓ VALID" if self.passed else "✗ ISSUES FOUND"
+        return (
+            f"{status}\n"
+            f"  Checks: {self.passed_checks}/{self.total_checks} passed ({self.pass_rate:.0f}%)\n"
+            f"  Issues: {len(self.issues)}\n"
+            f"  Duration: {self.scan_duration:.2f}s"
+        )
+
+
+class Recognizer(Program):
+    """
+    Recognizer - Validation Program that scans for anomalies.
+
+    Recognizers are special Programs that validate work before
+    it can proceed. They ensure quality and consistency.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        target: str,
+        recognizer_type: RecognizerType,
+        criteria: list[str] = None,
+        parent: Optional[Program] = None,
+        energy_budget: int = 50,
+    ):
+        super().__init__(
+            name=name,
+            purpose=f"Validate {target}",
+            parent=parent,
+            energy_budget=energy_budget,
+            program_type=ProgramType.RECOGNIZER,
+        )
+
+        self.target = target
+        self.recognizer_type = recognizer_type
+        self.criteria = criteria or []
+
+        # Scan results
+        self.scan_result: Optional[ScanResult] = None
+        self.issues: list[ValidationIssue] = []
+
+    def add_criterion(self, criterion: str) -> None:
+        """Add a validation criterion."""
+        if criterion not in self.criteria:
+            self.criteria.append(criterion)
+
+    def scan(self, artifacts: list[Any] = None) -> ScanResult:
+        """
+        Perform validation scan.
+
+        This is a template method - actual validation logic would
+        be implemented by specific Recognizer subclasses or external
+        validation functions.
+        """
+        self.start()
+        start_time = datetime.now()
+
+        issues = []
+        passed = 0
+        total = len(self.criteria)
+
+        # Placeholder validation logic
+        # In real implementation, this would check actual artifacts
+        for criterion in self.criteria:
+            # Each criterion is checked
+            # For now, all pass (placeholder)
+            passed += 1
+
+        duration = (datetime.now() - start_time).total_seconds()
+
+        # Determine result
+        if not issues:
+            result = ValidationResult.VALID
+        elif any(i.severity == "critical" for i in issues):
+            result = ValidationResult.DEREZ
+        else:
+            result = ValidationResult.RECTIFY_NEEDED
+
+        self.scan_result = ScanResult(
+            result=result,
+            issues=issues,
+            passed_checks=passed,
+            total_checks=total,
+            scan_duration=duration,
+        )
+
+        self.issues = issues
+
+        if result == ValidationResult.VALID:
+            self.complete(self.scan_result)
+        else:
+            self.fail(f"Validation failed: {len(issues)} issues found")
+
+        return self.scan_result
+
+    def add_issue(
+        self,
+        severity: str,
+        category: str,
+        message: str,
+        location: str = None,
+        suggestion: str = None,
+    ) -> ValidationIssue:
+        """Add a validation issue."""
+        issue = ValidationIssue(
+            severity=severity,
+            category=category,
+            message=message,
+            location=location,
+            suggestion=suggestion,
+        )
+        self.issues.append(issue)
+        return issue
+
+    def summary(self) -> str:
+        """Get Recognizer summary."""
+        lines = [
+            f"Recognizer: {self.name} [{self.id}]",
+            f"  Type: {self.recognizer_type.value}",
+            f"  Target: {self.target}",
+            f"  Criteria: {len(self.criteria)}",
+            f"  Status: {self.status.value}",
+        ]
+        if self.scan_result:
+            lines.append(f"  Result: {self.scan_result.result.value}")
+            lines.append(f"  Issues: {len(self.issues)}")
+        return "\n".join(lines)
+
+    def to_dict(self) -> dict:
+        """Serialize Recognizer to dictionary."""
+        base = super().to_dict()
+        base.update({
+            "recognizer_type": self.recognizer_type.value,
+            "target": self.target,
+            "criteria": self.criteria,
+            "issues": [i.to_dict() for i in self.issues],
+            "scan_result": {
+                "result": self.scan_result.result.value,
+                "passed_checks": self.scan_result.passed_checks,
+                "total_checks": self.scan_result.total_checks,
+                "pass_rate": self.scan_result.pass_rate,
+            } if self.scan_result else None,
+        })
+        return base
+
+
+# Factory functions for common Recognizer types
+
+def create_code_recognizer(
+    target: str,
+    criteria: list[str] = None,
+) -> Recognizer:
+    """Create a code quality Recognizer."""
+    default_criteria = [
+        "No syntax errors",
+        "Tests pass",
+        "No linting errors",
+        "Type checks pass",
+    ]
+    return Recognizer(
+        name=f"code-validator-{target}",
+        target=target,
+        recognizer_type=RecognizerType.CODE,
+        criteria=criteria or default_criteria,
+    )
+
+
+def create_security_recognizer(
+    target: str,
+    criteria: list[str] = None,
+) -> Recognizer:
+    """Create a security Recognizer."""
+    default_criteria = [
+        "No hardcoded secrets",
+        "No SQL injection vulnerabilities",
+        "No XSS vulnerabilities",
+        "Input validation present",
+        "Authentication required for protected routes",
+    ]
+    return Recognizer(
+        name=f"security-scanner-{target}",
+        target=target,
+        recognizer_type=RecognizerType.SECURITY,
+        criteria=criteria or default_criteria,
+    )
+
+
+def create_architecture_recognizer(
+    target: str,
+    criteria: list[str] = None,
+) -> Recognizer:
+    """Create an architecture Recognizer."""
+    default_criteria = [
+        "Follows established patterns",
+        "Separation of concerns",
+        "No circular dependencies",
+        "Consistent naming conventions",
+    ]
+    return Recognizer(
+        name=f"architecture-validator-{target}",
+        target=target,
+        recognizer_type=RecognizerType.ARCHITECTURE,
+        criteria=criteria or default_criteria,
+    )
+
+
+def create_consistency_recognizer(
+    target: str,
+    criteria: list[str] = None,
+) -> Recognizer:
+    """Create a consistency Recognizer."""
+    default_criteria = [
+        "All artifacts aligned",
+        "Documentation matches implementation",
+        "API contracts satisfied",
+        "Schema consistency",
+    ]
+    return Recognizer(
+        name=f"consistency-checker-{target}",
+        target=target,
+        recognizer_type=RecognizerType.CONSISTENCY,
+        criteria=criteria or default_criteria,
+    )

package/core/thread.py

@@ -0,0 +1,180 @@
+"""
+Thread - Single unit of execution on The Grid.
+
+"The smallest unit of computation on The Grid."
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional, Callable, Any
+from enum import Enum
+import uuid
+
+from .disc import IdentityDisc
+
+
+class ThreadStatus(Enum):
+    """Status of a Thread."""
+    PENDING = "pending"
+    RUNNING = "running"
+    BLOCKED = "blocked"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    DEREZZED = "derezzed"
+
+
+@dataclass
+class ThreadResult:
+    """Result of Thread execution."""
+    success: bool
+    output: Any = None
+    error: Optional[str] = None
+    cycles_used: int = 0
+    energy_consumed: int = 0
+
+
+class Thread:
+    """
+    Thread - Single unit of execution (atomic operation).
+
+    Threads are the smallest executable units on The Grid.
+    They perform a single, focused task.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        purpose: str,
+        block_id: str,
+        program_type: str = "program",  # program or recognizer
+        blocked_by: list[str] = None,
+    ):
+        self.id = str(uuid.uuid4())[:8]
+        self.name = name
+        self.purpose = purpose
+        self.block_id = block_id
+        self.program_type = program_type
+        self.blocked_by = blocked_by or []
+
+        self.status = ThreadStatus.PENDING
+        self.created_at = datetime.now()
+        self.started_at: Optional[datetime] = None
+        self.completed_at: Optional[datetime] = None
+
+        # Progress tracking
+        self.progress = 0.0  # 0-100
+        self.current_action = "Waiting"
+        self.cycles_completed = 0
+        self.max_cycles = 10
+
+        # Results
+        self.result: Optional[ThreadResult] = None
+
+        # Identity Disc
+        self.disc = IdentityDisc(
+            program_id=f"thread:{self.id}",
+            purpose=purpose,
+        )
+
+    def can_start(self, completed_threads: set[str]) -> bool:
+        """Check if all blocking threads are completed."""
+        if not self.blocked_by:
+            return True
+        return all(t in completed_threads for t in self.blocked_by)
+
+    def start(self) -> None:
+        """Start Thread execution."""
+        self.status = ThreadStatus.RUNNING
+        self.started_at = datetime.now()
+        self.current_action = "Starting..."
+
+    def update_progress(self, progress: float, action: str = None) -> None:
+        """Update Thread progress."""
+        self.progress = min(100.0, max(0.0, progress))
+        if action:
+            self.current_action = action
+        self.cycles_completed += 1
+
+    def complete(self, result: ThreadResult) -> None:
+        """Mark Thread as completed."""
+        self.status = ThreadStatus.COMPLETED
+        self.completed_at = datetime.now()
+        self.result = result
+        self.progress = 100.0
+        self.current_action = "Completed"
+
+    def fail(self, error: str) -> None:
+        """Mark Thread as failed."""
+        self.status = ThreadStatus.FAILED
+        self.completed_at = datetime.now()
+        self.result = ThreadResult(success=False, error=error)
+        self.current_action = f"Failed: {error}"
+
+    def derez(self) -> None:
+        """Mark Thread as derezzed."""
+        self.status = ThreadStatus.DEREZZED
+        self.disc.derez()
+
+    def duration(self) -> Optional[float]:
+        """Get execution duration in seconds."""
+        if not self.started_at:
+            return None
+        end = self.completed_at or datetime.now()
+        return (end - self.started_at).total_seconds()
+
+    def status_icon(self) -> str:
+        """Get status icon for display."""
+        icons = {
+            ThreadStatus.PENDING: "○",
+            ThreadStatus.RUNNING: "◐",
+            ThreadStatus.BLOCKED: "◌",
+            ThreadStatus.COMPLETED: "●",
+            ThreadStatus.FAILED: "✗",
+            ThreadStatus.DEREZZED: "◯",
+        }
+        return icons.get(self.status, "?")
+
+    def program_icon(self) -> str:
+        """Get program type icon."""
+        return "◈" if self.program_type == "recognizer" else "○"
+
+    def progress_bar(self, width: int = 10) -> str:
+        """Get visual progress bar."""
+        filled = int((self.progress / 100) * width)
+        empty = width - filled
+        return "█" * filled + "░" * empty
+
+    def display_line(self) -> str:
+        """Get single-line display for status views."""
+        icon = self.program_icon()
+        ptype = "Recognizer" if self.program_type == "recognizer" else "Program"
+
+        if self.status == ThreadStatus.BLOCKED:
+            action = f"Blocked by: {', '.join(self.blocked_by)}"
+        else:
+            action = self.current_action
+
+        progress = f"{self.status_icon()} {self.progress:.0f}%"
+
+        return f"  {icon} {self.name:<16} {ptype:<10} {action:<30} {progress}"
+
+    def to_dict(self) -> dict:
+        """Serialize Thread to dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "purpose": self.purpose,
+            "block_id": self.block_id,
+            "program_type": self.program_type,
+            "status": self.status.value,
+            "progress": self.progress,
+            "current_action": self.current_action,
+            "cycles_completed": self.cycles_completed,
+            "blocked_by": self.blocked_by,
+            "created_at": self.created_at.isoformat(),
+            "started_at": self.started_at.isoformat() if self.started_at else None,
+            "completed_at": self.completed_at.isoformat() if self.completed_at else None,
+        }
+
+    def __repr__(self) -> str:
+        return f"Thread(id={self.id}, name={self.name}, status={self.status.value})"

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "the-grid-cc",
+  "version": "1.1.0",
+  "description": "Agent orchestration for Claude Code. You talk to MCP. MCP handles the rest.",
+  "main": "index.js",
+  "bin": {
+    "the-grid-cc": "./bin/install.js",
+    "grid": "./bin/install.js"
+  },
+  "scripts": {
+    "start": "python3 cli/main.py",
+    "test": "python3 -c \"from core import Grid; print('OK')\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JamesWeatherhead/grid.git"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "orchestration",
+    "claude",
+    "claude-code",
+    "tron",
+    "natural-language",
+    "subagents"
+  ],
+  "author": "James Weatherhead & Claude",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/JamesWeatherhead/grid/issues"
+  },
+  "homepage": "https://github.com/JamesWeatherhead/grid#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/templates/__init__.py

@@ -0,0 +1,14 @@
+"""
+Templates - Visual display components for The Grid.
+
+Import functions directly from the modules:
+    from templates.welcome import render_welcome
+    from templates.status import render_cluster_status
+"""
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "welcome",
+    "status",
+]