openconstruct 0.1.0__py3-none-any.whl

openconstruct/__init__.py

@@ -0,0 +1,15 @@
+"""OpenConstruct - Python thin client for SuperInstance ecosystem onboarding."""
+
+from openconstruct.client import OpenConstructClient
+from openconstruct.registry import ModuleRegistry
+from openconstruct.types import AgentIdentity, ModuleInfo, OnboardingConfig
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "OpenConstructClient",
+    "ModuleRegistry",
+    "AgentIdentity",
+    "ModuleInfo",
+    "OnboardingConfig",
+]

openconstruct/client.py

@@ -0,0 +1,165 @@
+"""Main OpenConstruct client for agent onboarding."""
+
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from openconstruct.registry import ModuleRegistry
+from openconstruct.types import AgentIdentity, ModuleInfo, OnboardingConfig
+
+
+class OpenConstructClient:
+    """Main client class for OpenConstruct onboarding."""
+
+    def __init__(self):
+        """Initialize the OpenConstruct client."""
+        self._session_id: Optional[str] = None
+        self._started = False
+        self._identity: Optional[AgentIdentity] = None
+        self._selected_modules: List[ModuleInfo] = []
+        self._selected_interfaces: List[str] = []
+        self._registry = ModuleRegistry()
+
+    def start(self) -> str:
+        """
+        Start a new onboarding session.
+
+        Returns:
+            Session ID for the new session
+        """
+        self._session_id = str(uuid.uuid4())
+        self._started = True
+        self._identity = None
+        self._selected_modules = []
+        self._selected_interfaces = []
+        return self._session_id
+
+    def declare_agent(self, identity: AgentIdentity) -> None:
+        """
+        Declare agent identity.
+
+        Args:
+            identity: AgentIdentity object with agent details
+
+        Raises:
+            RuntimeError: If session not started
+        """
+        if not self._started:
+            raise RuntimeError("Session not started. Call start() first.")
+        self._identity = identity
+
+    def list_modules(self, domain: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        List available modules, optionally filtered by domain.
+
+        Args:
+            domain: Optional domain filter
+
+        Returns:
+            List of module dictionaries
+        """
+        modules = self._registry.list_modules(domain)
+        return [m.to_dict() for m in modules]
+
+    def select_modules(self, module_ids: List[str]) -> None:
+        """
+        Select modules for the agent.
+
+        Args:
+            module_ids: List of module IDs to select
+
+        Raises:
+            RuntimeError: If session not started
+            ValueError: If any module ID is invalid
+        """
+        if not self._started:
+            raise RuntimeError("Session not started. Call start() first.")
+
+        for module_id in module_ids:
+            if not self._registry.module_exists(module_id):
+                raise ValueError(f"Module '{module_id}' not found")
+
+        self._selected_modules = [
+            self._registry.get_module(mid) for mid in module_ids if self._registry.get_module(mid)
+        ]
+
+    def choose_interface(self, interfaces: List[str]) -> None:
+        """
+        Choose interface types for the agent.
+
+        Args:
+            interfaces: List of interface types (e.g., ["cli", "api"])
+
+        Raises:
+            RuntimeError: If session not started
+        """
+        if not self._started:
+            raise RuntimeError("Session not started. Call start() first.")
+        self._selected_interfaces = interfaces
+
+    def generate_config(self) -> Dict[str, Any]:
+        """
+        Generate the final onboarding configuration.
+
+        Returns:
+            Dictionary containing the complete onboarding configuration
+
+        Raises:
+            RuntimeError: If session not started or identity not declared
+        """
+        if not self._started:
+            raise RuntimeError("Session not started. Call start() first.")
+
+        if not self._identity:
+            raise RuntimeError("Agent identity not declared. Call declare_agent() first.")
+
+        config = OnboardingConfig(
+            session_id=self._session_id,
+            agent=self._identity.to_dict(),
+            selected_modules=[m.to_dict() for m in self._selected_modules],
+            selected_interfaces=self._selected_interfaces,
+            workspace=self._build_workspace_config(),
+            created_at=datetime.utcnow().isoformat() + "Z",
+        )
+
+        return config.to_dict()
+
+    def _build_workspace_config(self) -> Dict[str, Any]:
+        """
+        Build workspace configuration based on selections.
+
+        Returns:
+            Dictionary with workspace configuration
+        """
+        workspace_config = {
+            "agent_name": self._identity.name if self._identity else "",
+            "modules": [m.id for m in self._selected_modules],
+            "interfaces": self._selected_interfaces,
+            "environment_variables": {
+                "OPENCONSTRUCT_SESSION_ID": self._session_id or "",
+            },
+        }
+
+        # Add module-specific configurations
+        for module in self._selected_modules:
+            workspace_config[f"module_{module.id}_config"] = {
+                "version": module.version,
+                "enabled": True,
+            }
+
+        return workspace_config
+
+    @property
+    def session_id(self) -> Optional[str]:
+        """Get the current session ID."""
+        return self._session_id
+
+    @property
+    def is_started(self) -> bool:
+        """Check if a session is started."""
+        return self._started
+
+    @property
+    def identity(self) -> Optional[AgentIdentity]:
+        """Get the declared agent identity."""
+        return self._identity

openconstruct/registry.py

@@ -0,0 +1,112 @@
+"""Module registry for browsing available modules."""
+
+import uuid
+from typing import List, Optional
+
+from openconstruct.types import ModuleInfo
+
+
+class ModuleRegistry:
+    """Registry of available OpenConstruct modules."""
+
+    def __init__(self):
+        """Initialize the module registry with sample modules."""
+        self._modules = self._initialize_modules()
+
+    def _initialize_modules(self) -> dict:
+        """Initialize with sample modules."""
+        return {
+            "spectral-graph-core": ModuleInfo(
+                id="spectral-graph-core",
+                name="Spectral Graph Core",
+                domain="math",
+                description="Core spectral graph theory operations and algorithms",
+                version="1.0.0",
+                dependencies=[],
+                requires_agent_capabilities=["computation"],
+            ),
+            "plato-room": ModuleInfo(
+                id="plato-room",
+                name="Plato Room",
+                domain="collaboration",
+                description="Virtual collaboration space for agent discussions",
+                version="0.9.0",
+                dependencies=["spectral-graph-core"],
+                requires_agent_capabilities=["communication"],
+            ),
+            "tensor-flow": ModuleInfo(
+                id="tensor-flow",
+                name="Tensor Flow Operations",
+                domain="math",
+                description="Advanced tensor manipulation and operations",
+                version="2.1.0",
+                dependencies=[],
+                requires_agent_capabilities=["computation"],
+            ),
+            "memory-bank": ModuleInfo(
+                id="memory-bank",
+                name="Memory Bank",
+                domain="storage",
+                description="Persistent memory storage for agents",
+                version="1.2.0",
+                dependencies=[],
+                requires_agent_capabilities=["persistence"],
+            ),
+            "code-analyzer": ModuleInfo(
+                id="code-analyzer",
+                name="Code Analyzer",
+                domain="analysis",
+                description="Static code analysis and quality checks",
+                version="0.8.0",
+                dependencies=[],
+                requires_agent_capabilities=["code_generation"],
+            ),
+            "web-crawler": ModuleInfo(
+                id="web-crawler",
+                name="Web Crawler",
+                domain="web",
+                description="Efficient web crawling and data extraction",
+                version="1.5.0",
+                dependencies=[],
+                requires_agent_capabilities=["web_search"],
+            ),
+        }
+
+    def list_modules(self, domain: Optional[str] = None) -> List[ModuleInfo]:
+        """
+        List all available modules, optionally filtered by domain.
+
+        Args:
+            domain: Optional domain filter (e.g., "math", "collaboration")
+
+        Returns:
+            List of ModuleInfo objects
+        """
+        modules = list(self._modules.values())
+        if domain:
+            modules = [m for m in modules if m.domain == domain]
+        return modules
+
+    def get_module(self, module_id: str) -> Optional[ModuleInfo]:
+        """
+        Get a specific module by ID.
+
+        Args:
+            module_id: The module identifier
+
+        Returns:
+            ModuleInfo if found, None otherwise
+        """
+        return self._modules.get(module_id)
+
+    def module_exists(self, module_id: str) -> bool:
+        """
+        Check if a module exists.
+
+        Args:
+            module_id: The module identifier
+
+        Returns:
+            True if module exists, False otherwise
+        """
+        return module_id in self._modules

openconstruct/types.py

@@ -0,0 +1,75 @@
+"""Data types for OpenConstruct."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class AgentIdentity:
+    """Agent self-declaration for onboarding."""
+
+    name: str
+    model: str
+    capabilities: List[str] = field(default_factory=list)
+    tools: List[str] = field(default_factory=list)
+    description: Optional[str] = None
+    version: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert identity to dictionary."""
+        return {
+            "name": self.name,
+            "model": self.model,
+            "capabilities": self.capabilities,
+            "tools": self.tools,
+            "description": self.description,
+            "version": self.version,
+        }
+
+
+@dataclass
+class ModuleInfo:
+    """Information about an available module."""
+
+    id: str
+    name: str
+    domain: str
+    description: str
+    version: str
+    dependencies: List[str] = field(default_factory=list)
+    requires_agent_capabilities: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert module info to dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "domain": self.domain,
+            "description": self.description,
+            "version": self.version,
+            "dependencies": self.dependencies,
+            "requires_agent_capabilities": self.requires_agent_capabilities,
+        }
+
+
+@dataclass
+class OnboardingConfig:
+    """Final onboarding configuration output."""
+
+    session_id: str
+    agent: Dict[str, Any]
+    selected_modules: List[Dict[str, Any]]
+    selected_interfaces: List[str]
+    workspace: Dict[str, Any] = field(default_factory=dict)
+    created_at: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert config to dictionary."""
+        return {
+            "session_id": self.session_id,
+            "agent": self.agent,
+            "selected_modules": self.selected_modules,
+            "selected_interfaces": self.selected_interfaces,
+            "workspace": self.workspace,
+            "created_at": self.created_at,
+        }

openconstruct-0.1.0.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: openconstruct
+Version: 0.1.0
+Summary: Python thin client for OpenConstruct - SuperInstance ecosystem onboarding
+Author-email: SuperInstance <contact@superinstance.dev>
+Project-URL: Homepage, https://github.com/SuperInstance/openconstruct-python
+Project-URL: Repository, https://github.com/SuperInstance/openconstruct-python
+Project-URL: Issues, https://github.com/SuperInstance/openconstruct-python/issues
+Keywords: openconstruct,agent,onboarding,superinstance
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Dynamic: license-file
+
+# OpenConstruct Python — Thin Client for Agent Onboarding
+
+Python client for [OpenConstruct](https://github.com/SuperInstance/OpenConstruct). Onboard agents into the SuperInstance ecosystem in under 10 lines.
+
+## What This Gives You
+
+- **5-phase onboarding** — `start()` → `declare_agent()` → `select_modules()` → `choose_interface()` → `generate_config()`
+- **Module registry** — domain-filtered catalog of available modules
+- **Pip-installable** — `pip install openconstruct`
+- **Zero runtime dependencies** — pure Python, no native extensions
+
+## Quick Start
+
+```python
+from openconstruct import OpenConstructClient, AgentIdentity
+
+client = OpenConstructClient()
+client.start()
+
+identity = AgentIdentity(
+    name="my-agent",
+    model="claude-4",
+    capabilities=["code_generation", "web_search", "file_ops"],
+    tools=["exec", "read", "write"]
+)
+client.declare_agent(identity)
+
+modules = client.list_modules(domain="math")
+client.select_modules(["spectral-graph-core", "plato-room"])
+client.choose_interface(["cli", "api"])
+
+config = client.generate_config()
+print(config)
+```
+
+## Installation
+
+```bash
+pip install openconstruct
+```
+
+## Testing
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## How It Fits
+
+One of the [polyglot OpenConstruct bindings](https://github.com/SuperInstance/OpenConstruct). Used by [openconstruct-jupyter](https://github.com/SuperInstance/openconstruct-jupyter) for notebook integration. See [openconstruct-examples](https://github.com/SuperInstance/openconstruct-examples) for a Python onboarding walkthrough.
+
+## License
+
+MIT

openconstruct-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+openconstruct/__init__.py,sha256=K5y0cRjgluATFRM6rczOquUPl9he9_5Hny3mWU2_2QY,410
+openconstruct/client.py,sha256=e-I4AQ9qfGyA85kGPkwhJ3ufEYFDP82MYgagwoosiCc,5211
+openconstruct/registry.py,sha256=kJXmpCDwWur4-u6EFKHXEt5LX7q-hm-JULVRIIx7jYM,3758
+openconstruct/types.py,sha256=uco2nrMglG6izSC4w0Uk34cu-40Ox-rbzl7Wr_r-cXk,2151
+openconstruct-0.1.0.dist-info/licenses/LICENSE,sha256=mDMbUdFbAd32o_PXQ90a29eTn-6OHaRJM8TG5iMW5cA,1069
+openconstruct-0.1.0.dist-info/METADATA,sha256=sWRyDuzpi3LsCZwFVFDH8SFHynV3JmCOt-J4Xd66eG0,2726
+openconstruct-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+openconstruct-0.1.0.dist-info/top_level.txt,sha256=gacT2S17Czus64PnwhVofNQzxivfVs-Gt3PabCPCDOM,14
+openconstruct-0.1.0.dist-info/RECORD,,

openconstruct-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

openconstruct-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SuperInstance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

openconstruct-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+openconstruct