the-grid-cc 1.1.0

package/core/cluster.py

@@ -0,0 +1,228 @@
+"""
+Cluster - Collection of related Blocks.
+
+"Clusters organize the computational landscape of The Grid."
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+from enum import Enum
+import uuid
+
+from .block import Block, BlockStatus
+from .energy import EnergyPool
+
+
+class ClusterStatus(Enum):
+    """Status of a Cluster."""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    DEREZZED = "derezzed"
+
+
+class Cluster:
+    """
+    Cluster - Collection of related Blocks (feature/domain group).
+
+    Clusters represent a major feature or domain area.
+    They contain Blocks that work together toward a shared goal.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        purpose: str,
+        description: str = "",
+    ):
+        self.id = str(uuid.uuid4())[:8]
+        self.name = name
+        self.purpose = purpose
+        self.description = description
+
+        self.status = ClusterStatus.PENDING
+        self.created_at = datetime.now()
+        self.started_at: Optional[datetime] = None
+        self.completed_at: Optional[datetime] = None
+
+        # Blocks in this Cluster
+        self.blocks: dict[str, Block] = {}
+        self.block_order: list[str] = []  # Execution order
+
+        # Energy
+        self.energy_pool: Optional[EnergyPool] = None
+
+        # I/O Tower checkpoints
+        self.io_tower_checkpoints: list[str] = []
+
+    def add_block(
+        self,
+        name: str,
+        purpose: str,
+        blocked_by: list[str] = None,
+    ) -> Block:
+        """Add a new Block to this Cluster."""
+        block = Block(
+            name=name,
+            purpose=purpose,
+            cluster_id=self.id,
+            blocked_by=blocked_by,
+        )
+        self.blocks[block.id] = block
+        self.block_order.append(block.id)
+        return block
+
+    def get_block(self, block_id: str) -> Optional[Block]:
+        """Get a Block by ID."""
+        return self.blocks.get(block_id)
+
+    def get_block_by_name(self, name: str) -> Optional[Block]:
+        """Get a Block by name."""
+        for block in self.blocks.values():
+            if block.name == name:
+                return block
+        return None
+
+    def start(self) -> None:
+        """Start Cluster execution."""
+        self.status = ClusterStatus.RUNNING
+        self.started_at = datetime.now()
+
+    def get_runnable_blocks(self) -> list[Block]:
+        """Get Blocks that can start (not blocked by other Blocks)."""
+        completed = {
+            b.name for b in self.blocks.values()
+            if b.status == BlockStatus.COMPLETED
+        }
+        return [
+            b for b in self.blocks.values()
+            if b.status == BlockStatus.PENDING and b.can_start(completed)
+        ]
+
+    def get_running_blocks(self) -> list[Block]:
+        """Get currently running Blocks."""
+        return [
+            b for b in self.blocks.values()
+            if b.status == BlockStatus.RUNNING
+        ]
+
+    def get_completed_blocks(self) -> list[Block]:
+        """Get completed Blocks."""
+        return [
+            b for b in self.blocks.values()
+            if b.status == BlockStatus.COMPLETED
+        ]
+
+    def all_blocks_completed(self) -> bool:
+        """Check if all Blocks are completed."""
+        return all(
+            b.status in (BlockStatus.COMPLETED, BlockStatus.DEREZZED)
+            for b in self.blocks.values()
+        )
+
+    def any_block_failed(self) -> bool:
+        """Check if any Block failed."""
+        return any(
+            b.status == BlockStatus.FAILED
+            for b in self.blocks.values()
+        )
+
+    def complete(self) -> None:
+        """Mark Cluster as completed."""
+        self.status = ClusterStatus.COMPLETED
+        self.completed_at = datetime.now()
+        # Return unused energy
+        if self.energy_pool:
+            self.energy_pool.return_unused()
+
+    def fail(self) -> None:
+        """Mark Cluster as failed."""
+        self.status = ClusterStatus.FAILED
+        self.completed_at = datetime.now()
+
+    def derez(self) -> None:
+        """Mark Cluster as derezzed."""
+        self.status = ClusterStatus.DEREZZED
+        for block in self.blocks.values():
+            block.derez()
+
+    def progress(self) -> float:
+        """Get overall Cluster progress (0-100)."""
+        if not self.blocks:
+            return 0.0
+        total_progress = sum(b.progress() for b in self.blocks.values())
+        return total_progress / len(self.blocks)
+
+    def total_threads(self) -> int:
+        """Get total number of Threads across all Blocks."""
+        return sum(len(b.threads) for b in self.blocks.values())
+
+    def completed_threads(self) -> int:
+        """Get number of completed Threads."""
+        return sum(len(b.get_completed_threads()) for b in self.blocks.values())
+
+    def energy_consumed(self) -> int:
+        """Get total energy consumed by this Cluster."""
+        return sum(b.energy_consumed() for b in self.blocks.values())
+
+    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 add_io_checkpoint(self, reason: str) -> None:
+        """Add an I/O Tower checkpoint."""
+        self.io_tower_checkpoints.append(reason)
+
+    def display_full(self) -> str:
+        """Get full display for status views."""
+        energy_display = ""
+        if self.energy_pool:
+            energy_display = f"Energy: {self.energy_pool.remaining}"
+
+        lines = [
+            "╔" + "═" * 77 + "╗",
+            f"║  CLUSTER: {self.name:<50} {energy_display:>15}  ║",
+            "╠" + "═" * 77 + "╣",
+            "║" + " " * 77 + "║",
+        ]
+
+        for block_id in self.block_order:
+            block = self.blocks[block_id]
+            for line in block.display_box().split("\n"):
+                lines.append(f"║  {line:<75}║")
+            lines.append("║" + " " * 77 + "║")
+
+        # I/O Tower checkpoints
+        for checkpoint in self.io_tower_checkpoints:
+            lines.append(f"║  ⛯ I/O TOWER: {checkpoint:<61}║")
+
+        lines.append("║" + " " * 77 + "║")
+        lines.append("╚" + "═" * 77 + "╝")
+
+        return "\n".join(lines)
+
+    def to_dict(self) -> dict:
+        """Serialize Cluster to dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "purpose": self.purpose,
+            "description": self.description,
+            "status": self.status.value,
+            "progress": self.progress(),
+            "blocks": [b.to_dict() for b in self.blocks.values()],
+            "io_tower_checkpoints": self.io_tower_checkpoints,
+            "total_threads": self.total_threads(),
+            "completed_threads": self.completed_threads(),
+            "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"Cluster(id={self.id}, name={self.name}, blocks={len(self.blocks)})"

package/core/disc.py

@@ -0,0 +1,254 @@
+"""
+Identity Disc - Carries a Program's memory and decisions.
+
+"Everything you do or learn will be imprinted on this disc."
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional, Any
+from enum import Enum
+import json
+import uuid
+
+
+class DiscStatus(Enum):
+    """Status of an Identity Disc."""
+    ACTIVE = "active"
+    ARCHIVED = "archived"
+    DEREZZED = "derezzed"
+
+
+@dataclass
+class Decision:
+    """A recorded decision made by a Program."""
+    timestamp: datetime
+    choice: str
+    reasoning: str
+    alternatives: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "timestamp": self.timestamp.isoformat(),
+            "choice": self.choice,
+            "reasoning": self.reasoning,
+            "alternatives": self.alternatives,
+        }
+
+
+@dataclass
+class Discovery:
+    """Something learned during execution."""
+    timestamp: datetime
+    finding: str
+    source: str
+    relevance: str = "medium"  # low, medium, high, critical
+
+    def to_dict(self) -> dict:
+        return {
+            "timestamp": self.timestamp.isoformat(),
+            "finding": self.finding,
+            "source": self.source,
+            "relevance": self.relevance,
+        }
+
+
+@dataclass
+class Artifact:
+    """A file or resource created/modified by a Program."""
+    path: str
+    action: str  # created, modified, deleted
+    timestamp: datetime
+    description: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "path": self.path,
+            "action": self.action,
+            "timestamp": self.timestamp.isoformat(),
+            "description": self.description,
+        }
+
+
+class IdentityDisc:
+    """
+    The Identity Disc - carries a Program's memory and decisions.
+
+    Each Program on The Grid carries an Identity Disc containing:
+    - Purpose: What the Program is trying to accomplish
+    - Constraints: Boundaries it must respect
+    - Decisions: Choices made and why
+    - Discoveries: Things learned during execution
+    - Artifacts: Files created/modified
+    - Lineage: Parent/child relationships for fission
+    """
+
+    def __init__(
+        self,
+        program_id: str,
+        purpose: str = "",
+        parent_disc: Optional["IdentityDisc"] = None,
+    ):
+        self.id = str(uuid.uuid4())[:8]
+        self.program_id = program_id
+        self.created_at = datetime.now()
+        self.status = DiscStatus.ACTIVE
+
+        # Core identity
+        self.purpose = purpose
+        self.constraints: list[str] = []
+
+        # Memory
+        self.decisions: list[Decision] = []
+        self.discoveries: list[Discovery] = []
+        self.artifacts: list[Artifact] = []
+
+        # Lineage (for fission)
+        self.parent_disc = parent_disc
+        self.child_discs: list["IdentityDisc"] = []
+        self.depth = 0 if parent_disc is None else parent_disc.depth + 1
+
+        # Energy tracking
+        self.energy_allocated = 0
+        self.energy_consumed = 0
+
+        # Inherit relevant context from parent
+        if parent_disc:
+            self._inherit_from_parent(parent_disc)
+
+    def _inherit_from_parent(self, parent: "IdentityDisc") -> None:
+        """Inherit relevant context from parent disc."""
+        # Inherit constraints
+        self.constraints = parent.constraints.copy()
+
+        # Inherit high-relevance discoveries
+        for discovery in parent.discoveries:
+            if discovery.relevance in ("high", "critical"):
+                self.discoveries.append(discovery)
+
+        # Register as child of parent
+        parent.child_discs.append(self)
+
+    def record_decision(
+        self,
+        choice: str,
+        reasoning: str,
+        alternatives: list[str] = None,
+    ) -> Decision:
+        """Record a decision made by the Program."""
+        decision = Decision(
+            timestamp=datetime.now(),
+            choice=choice,
+            reasoning=reasoning,
+            alternatives=alternatives or [],
+        )
+        self.decisions.append(decision)
+        return decision
+
+    def record_discovery(
+        self,
+        finding: str,
+        source: str,
+        relevance: str = "medium",
+    ) -> Discovery:
+        """Record something learned during execution."""
+        discovery = Discovery(
+            timestamp=datetime.now(),
+            finding=finding,
+            source=source,
+            relevance=relevance,
+        )
+        self.discoveries.append(discovery)
+        return discovery
+
+    def record_artifact(
+        self,
+        path: str,
+        action: str,
+        description: str = "",
+    ) -> Artifact:
+        """Record a file/resource created or modified."""
+        artifact = Artifact(
+            path=path,
+            action=action,
+            timestamp=datetime.now(),
+            description=description,
+        )
+        self.artifacts.append(artifact)
+        return artifact
+
+    def add_constraint(self, constraint: str) -> None:
+        """Add a constraint the Program must respect."""
+        if constraint not in self.constraints:
+            self.constraints.append(constraint)
+
+    def consume_energy(self, amount: int) -> bool:
+        """Consume energy. Returns False if insufficient energy."""
+        if self.energy_consumed + amount > self.energy_allocated:
+            return False
+        self.energy_consumed += amount
+        return True
+
+    def energy_remaining(self) -> int:
+        """Get remaining energy."""
+        return self.energy_allocated - self.energy_consumed
+
+    def energy_percentage(self) -> float:
+        """Get energy as percentage of allocated."""
+        if self.energy_allocated == 0:
+            return 0.0
+        return (self.energy_remaining() / self.energy_allocated) * 100
+
+    def derez(self) -> None:
+        """Mark disc as derezzed (completed/archived)."""
+        self.status = DiscStatus.DEREZZED
+
+    def get_lineage(self) -> list[str]:
+        """Get the lineage chain of program IDs."""
+        lineage = [self.program_id]
+        current = self.parent_disc
+        while current:
+            lineage.insert(0, current.program_id)
+            current = current.parent_disc
+        return lineage
+
+    def to_dict(self) -> dict:
+        """Serialize disc to dictionary."""
+        return {
+            "id": self.id,
+            "program_id": self.program_id,
+            "created_at": self.created_at.isoformat(),
+            "status": self.status.value,
+            "purpose": self.purpose,
+            "constraints": self.constraints,
+            "decisions": [d.to_dict() for d in self.decisions],
+            "discoveries": [d.to_dict() for d in self.discoveries],
+            "artifacts": [a.to_dict() for a in self.artifacts],
+            "depth": self.depth,
+            "lineage": self.get_lineage(),
+            "energy_allocated": self.energy_allocated,
+            "energy_consumed": self.energy_consumed,
+            "child_count": len(self.child_discs),
+        }
+
+    def to_json(self) -> str:
+        """Serialize disc to JSON."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def summary(self) -> str:
+        """Get a brief summary of the disc contents."""
+        lines = [
+            f"Identity Disc [{self.id}]",
+            f"  Program: {self.program_id}",
+            f"  Purpose: {self.purpose}",
+            f"  Depth: {self.depth}",
+            f"  Energy: {self.energy_remaining()}/{self.energy_allocated}",
+            f"  Decisions: {len(self.decisions)}",
+            f"  Discoveries: {len(self.discoveries)}",
+            f"  Artifacts: {len(self.artifacts)}",
+            f"  Children: {len(self.child_discs)}",
+        ]
+        return "\n".join(lines)
+
+    def __repr__(self) -> str:
+        return f"IdentityDisc(id={self.id}, program={self.program_id}, depth={self.depth})"