vystak 0.1.0__tar.gz

vystak-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+.pytest_cache/
+.ruff_cache/
+.pyright/
+
+# TypeScript
+node_modules/
+*.tsbuildinfo
+coverage/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Vystak generated output (was .agentstack/ before rename)
+.vystak/
+.agentstack/
+
+# Tooling workspaces (brainstorm sessions, local agent state)
+.superpowers/

vystak-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: vystak
+Version: 0.1.0
+Summary: Vystak core SDK — declarative AI agent orchestration
+Project-URL: Homepage, https://vystak.dev
+Project-URL: Documentation, https://vystak.dev/docs
+Project-URL: Repository, https://github.com/vystak/vystak
+Project-URL: Issues, https://github.com/vystak/vystak/issues
+Author-email: Anatoliy Kolodkin <11351966+akolodkin@users.noreply.github.com>
+License-Expression: Apache-2.0
+Keywords: agent,ai,declarative,infrastructure,langchain,langgraph,orchestration
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: aiosqlite>=0.20
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# vystak
+
+Core SDK for Vystak — declarative, platform-agnostic orchestration for AI agents.
+
+This package provides the foundational schema, hashing engine, provisioning graph, and provider base classes that the rest of the Vystak ecosystem builds on. You typically don't install this directly — use [`vystak-cli`](https://pypi.org/project/vystak-cli/) instead, which pulls it in.
+
+## Install
+
+```bash
+pip install vystak
+```
+
+## What's in this package
+
+- **`vystak.schema`** — Pydantic models for `Agent`, `Model`, `Provider`, `Platform`, `Channel`, `Service`, `Skill`, `Workspace`, `Secret`, `Mcp`. This is the contract adapters and providers consume.
+- **`vystak.hash`** — content-addressable hashing (`AgentHashTree`) for stateless change detection.
+- **`vystak.provisioning`** — `ProvisionGraph`, a DAG of `Provisionable` nodes for topological resource rollout with health checks.
+- **`vystak.providers`** — `PlatformProvider`, `FrameworkAdapter`, `ChannelAdapter` ABCs.
+- **`vystak.stores`** — async SQLite-backed key-value store for long-term memory.
+
+## Example
+
+```python
+import vystak as ast
+
+anthropic = ast.Provider(name="anthropic", type="anthropic")
+model = ast.Model(name="claude", provider=anthropic, model_name="claude-sonnet-4-20250514")
+agent = ast.Agent(name="support-bot", model=model)
+```
+
+See the [main repository](https://github.com/vystak/vystak) for the full CLI, adapters, and providers.
+
+## License
+
+Apache-2.0

vystak-0.1.0/README.md

@@ -0,0 +1,35 @@
+# vystak
+
+Core SDK for Vystak — declarative, platform-agnostic orchestration for AI agents.
+
+This package provides the foundational schema, hashing engine, provisioning graph, and provider base classes that the rest of the Vystak ecosystem builds on. You typically don't install this directly — use [`vystak-cli`](https://pypi.org/project/vystak-cli/) instead, which pulls it in.
+
+## Install
+
+```bash
+pip install vystak
+```
+
+## What's in this package
+
+- **`vystak.schema`** — Pydantic models for `Agent`, `Model`, `Provider`, `Platform`, `Channel`, `Service`, `Skill`, `Workspace`, `Secret`, `Mcp`. This is the contract adapters and providers consume.
+- **`vystak.hash`** — content-addressable hashing (`AgentHashTree`) for stateless change detection.
+- **`vystak.provisioning`** — `ProvisionGraph`, a DAG of `Provisionable` nodes for topological resource rollout with health checks.
+- **`vystak.providers`** — `PlatformProvider`, `FrameworkAdapter`, `ChannelAdapter` ABCs.
+- **`vystak.stores`** — async SQLite-backed key-value store for long-term memory.
+
+## Example
+
+```python
+import vystak as ast
+
+anthropic = ast.Provider(name="anthropic", type="anthropic")
+model = ast.Model(name="claude", provider=anthropic, model_name="claude-sonnet-4-20250514")
+agent = ast.Agent(name="support-bot", model=model)
+```
+
+See the [main repository](https://github.com/vystak/vystak) for the full CLI, adapters, and providers.
+
+## License
+
+Apache-2.0

vystak-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "vystak"
+version = "0.1.0"
+description = "Vystak core SDK — declarative AI agent orchestration"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+authors = [
+    { name = "Anatoliy Kolodkin", email = "11351966+akolodkin@users.noreply.github.com" },
+]
+keywords = [
+    "ai",
+    "agent",
+    "orchestration",
+    "langchain",
+    "langgraph",
+    "infrastructure",
+    "declarative",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Systems Administration",
+    "Typing :: Typed",
+]
+dependencies = [
+    "pydantic>=2.0",
+    "pyyaml>=6.0",
+    "aiosqlite>=0.20",
+]
+
+[project.urls]
+Homepage = "https://vystak.dev"
+Documentation = "https://vystak.dev/docs"
+Repository = "https://github.com/vystak/vystak"
+Issues = "https://github.com/vystak/vystak/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/vystak"]

vystak-0.1.0/src/vystak/__init__.py

@@ -0,0 +1,126 @@
+"""Vystak — declarative AI agent orchestration."""
+
+__version__ = "0.1.0"
+
+# Schema models
+# Hash engine
+from vystak.hash import AgentHashTree, hash_agent, hash_dict, hash_model
+
+# Provider ABCs and supporting types
+from vystak.providers import (
+    AgentStatus,
+    ChannelAdapter,
+    DeployPlan,
+    DeployResult,
+    FrameworkAdapter,
+    GeneratedCode,
+    PlatformProvider,
+    ValidationError,
+)
+
+# Provisioning engine
+from vystak.provisioning import (
+    CommandHealthCheck,
+    CycleError,
+    HealthCheck,
+    HttpHealthCheck,
+    NoopHealthCheck,
+    Provisionable,
+    ProvisionError,
+    ProvisionGraph,
+    ProvisionResult,
+    TcpHealthCheck,
+)
+from vystak.schema import (
+    Agent,
+    Cache,
+    Channel,
+    ChannelProvider,
+    ChannelType,
+    Database,
+    Embedding,
+    Gateway,
+    McpServer,
+    McpTransport,
+    Model,
+    NamedModel,
+    ObjectStore,
+    Platform,
+    Postgres,
+    Provider,
+    Qdrant,
+    Queue,
+    Redis,
+    Resource,
+    Secret,
+    Service,
+    SessionStore,
+    Skill,
+    SkillRequirements,
+    SlackChannel,
+    Sqlite,
+    VectorStore,
+    Workspace,
+    WorkspaceType,
+)
+
+# Loader
+from vystak.schema.loader import dump_agent, load_agent
+
+__all__ = [
+    "__version__",
+    "Agent",
+    "Cache",
+    "Channel",
+    "ChannelProvider",
+    "ChannelType",
+    "Database",
+    "Embedding",
+    "Gateway",
+    "McpServer",
+    "McpTransport",
+    "Model",
+    "NamedModel",
+    "ObjectStore",
+    "Platform",
+    "Postgres",
+    "Provider",
+    "Qdrant",
+    "Queue",
+    "Redis",
+    "Resource",
+    "Secret",
+    "Service",
+    "SessionStore",
+    "Skill",
+    "SkillRequirements",
+    "SlackChannel",
+    "Sqlite",
+    "VectorStore",
+    "Workspace",
+    "WorkspaceType",
+    "AgentHashTree",
+    "hash_agent",
+    "hash_dict",
+    "hash_model",
+    "dump_agent",
+    "load_agent",
+    "AgentStatus",
+    "ChannelAdapter",
+    "DeployPlan",
+    "DeployResult",
+    "FrameworkAdapter",
+    "GeneratedCode",
+    "PlatformProvider",
+    "ValidationError",
+    "CommandHealthCheck",
+    "CycleError",
+    "HealthCheck",
+    "HttpHealthCheck",
+    "NoopHealthCheck",
+    "Provisionable",
+    "ProvisionError",
+    "ProvisionGraph",
+    "ProvisionResult",
+    "TcpHealthCheck",
+]

vystak-0.1.0/src/vystak/hash/__init__.py

@@ -0,0 +1,6 @@
+"""Content-addressable hash engine for stateless change detection."""
+
+from vystak.hash.hasher import hash_dict, hash_model
+from vystak.hash.tree import AgentHashTree, hash_agent
+
+__all__ = ["AgentHashTree", "hash_agent", "hash_dict", "hash_model"]

vystak-0.1.0/src/vystak/hash/hasher.py

@@ -0,0 +1,18 @@
+"""Leaf-level hashing for Pydantic models and dicts."""
+
+import hashlib
+import json
+
+from pydantic import BaseModel
+
+
+def hash_model(model: BaseModel) -> str:
+    """SHA-256 of canonical JSON representation of a Pydantic model."""
+    canonical = json.dumps(model.model_dump(mode="python"), sort_keys=True, default=str)
+    return hashlib.sha256(canonical.encode()).hexdigest()
+
+
+def hash_dict(data: dict) -> str:
+    """SHA-256 of canonical JSON representation of a dict."""
+    canonical = json.dumps(data, sort_keys=True, default=str)
+    return hashlib.sha256(canonical.encode()).hexdigest()

vystak-0.1.0/src/vystak/hash/tree.py

@@ -0,0 +1,82 @@
+"""Hash tree composition for agent definitions."""
+
+import hashlib
+from dataclasses import dataclass
+
+from vystak.hash.hasher import hash_model
+from vystak.schema.agent import Agent
+
+
+@dataclass
+class AgentHashTree:
+    """Per-section hashes for an agent, enabling partial deploy detection."""
+
+    brain: str
+    skills: str
+    mcp_servers: str
+    channels: str
+    workspace: str
+    resources: str
+    secrets: str
+    sessions: str
+    memory: str
+    services: str
+    root: str
+
+
+def _hash_list(items: list) -> str:
+    if not items:
+        return hashlib.sha256(b"[]").hexdigest()
+    individual = sorted(hash_model(item) for item in items)
+    combined = "|".join(individual)
+    return hashlib.sha256(combined.encode()).hexdigest()
+
+
+def _hash_optional(item) -> str:
+    if item is None:
+        return hashlib.sha256(b"null").hexdigest()
+    return hash_model(item)
+
+
+def hash_agent(agent: Agent) -> AgentHashTree:
+    """Compute the full hash tree for an agent definition."""
+    brain = hash_model(agent.model)
+    skills = _hash_list(agent.skills)
+    mcp_servers = _hash_list(agent.mcp_servers)
+    channels = _hash_list(agent.channels)
+    workspace = _hash_optional(agent.workspace)
+    resources = _hash_list(agent.resources)
+    secrets = _hash_list(agent.secrets)
+    sessions = _hash_optional(agent.sessions)
+    memory = _hash_optional(agent.memory)
+    services = _hash_list(agent.services)
+
+    sections = "|".join(
+        [
+            brain,
+            skills,
+            mcp_servers,
+            channels,
+            workspace,
+            resources,
+            secrets,
+            sessions,
+            memory,
+            services,
+        ]
+    )
+    root = hashlib.sha256(sections.encode()).hexdigest()
+
+    return AgentHashTree(
+        brain=brain,
+        skills=skills,
+        mcp_servers=mcp_servers,
+        channels=channels,
+        workspace=workspace,
+        resources=resources,
+        secrets=secrets,
+        sessions=sessions,
+        memory=memory,
+        services=services,
+        root=root,
+    )

vystak-0.1.0/src/vystak/ir/__init__.py

@@ -0,0 +1 @@
+"""Intermediate representation consumed by framework adapters."""

vystak-0.1.0/src/vystak/providers/__init__.py

@@ -0,0 +1,23 @@
+"""Provider base classes for platform and resource provisioning."""
+
+from vystak.providers.base import (
+    AgentStatus,
+    ChannelAdapter,
+    DeployPlan,
+    DeployResult,
+    FrameworkAdapter,
+    GeneratedCode,
+    PlatformProvider,
+    ValidationError,
+)
+
+__all__ = [
+    "AgentStatus",
+    "ChannelAdapter",
+    "DeployPlan",
+    "DeployResult",
+    "FrameworkAdapter",
+    "GeneratedCode",
+    "PlatformProvider",
+    "ValidationError",
+]

vystak-0.1.0/src/vystak/providers/base.py

@@ -0,0 +1,77 @@
+"""Abstract base classes for framework adapters, platform providers, and channel adapters."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+
+from vystak.schema.agent import Agent
+from vystak.schema.channel import Channel
+
+
+@dataclass
+class GeneratedCode:
+    files: dict[str, str]
+    entrypoint: str
+
+
+@dataclass
+class DeployPlan:
+    agent_name: str
+    actions: list[str]
+    current_hash: str | None
+    target_hash: str
+    changes: dict[str, tuple[str | None, str]]
+
+
+@dataclass
+class DeployResult:
+    agent_name: str
+    success: bool
+    hash: str
+    message: str
+
+
+@dataclass
+class AgentStatus:
+    agent_name: str
+    running: bool
+    hash: str | None
+    info: dict = field(default_factory=dict)
+
+
+@dataclass
+class ValidationError:
+    field: str
+    message: str
+
+
+class FrameworkAdapter(ABC):
+    @abstractmethod
+    def generate(self, agent: Agent) -> GeneratedCode: ...
+
+    @abstractmethod
+    def validate(self, agent: Agent) -> list[ValidationError]: ...
+
+
+class PlatformProvider(ABC):
+    @abstractmethod
+    def plan(self, agent: Agent, current_hash: str | None) -> DeployPlan: ...
+
+    @abstractmethod
+    def apply(self, plan: DeployPlan) -> DeployResult: ...
+
+    @abstractmethod
+    def destroy(self, agent_name: str) -> None: ...
+
+    @abstractmethod
+    def status(self, agent_name: str) -> AgentStatus: ...
+
+    @abstractmethod
+    def get_hash(self, agent_name: str) -> str | None: ...
+
+
+class ChannelAdapter(ABC):
+    @abstractmethod
+    def setup(self, agent: Agent, channel: Channel) -> None: ...
+
+    @abstractmethod
+    def teardown(self, channel: Channel) -> None: ...

vystak-0.1.0/src/vystak/provisioning/__init__.py

@@ -0,0 +1,37 @@
+"""Provisioning engine — dependency graph, health checks, and provisionable protocol."""
+
+from vystak.provisioning.graph import CycleError, ProvisionError, ProvisionGraph
+from vystak.provisioning.grouping import group_agents_by_platform, platform_fingerprint
+from vystak.provisioning.health import (
+    CommandHealthCheck,
+    HealthCheck,
+    HttpHealthCheck,
+    NoopHealthCheck,
+    TcpHealthCheck,
+)
+from vystak.provisioning.listener import (
+    NullListener,
+    PrintListener,
+    ProvisionEvent,
+    ProvisionListener,
+)
+from vystak.provisioning.node import Provisionable, ProvisionResult
+
+__all__ = [
+    "CommandHealthCheck",
+    "CycleError",
+    "group_agents_by_platform",
+    "HealthCheck",
+    "HttpHealthCheck",
+    "NoopHealthCheck",
+    "NullListener",
+    "platform_fingerprint",
+    "PrintListener",
+    "Provisionable",
+    "ProvisionError",
+    "ProvisionEvent",
+    "ProvisionGraph",
+    "ProvisionListener",
+    "ProvisionResult",
+    "TcpHealthCheck",
+]

vystak-0.1.0/src/vystak/provisioning/graph.py

@@ -0,0 +1,122 @@
+"""Dependency graph for provisioning resources."""
+
+from dataclasses import dataclass, field
+
+from vystak.provisioning.listener import NullListener, ProvisionEvent, ProvisionListener
+from vystak.provisioning.node import Provisionable, ProvisionResult
+
+
+class CycleError(Exception):
+    pass
+
+
+class ProvisionError(Exception):
+    pass
+
+
+@dataclass
+class ProvisionGraph:
+    _nodes: dict[str, Provisionable] = field(default_factory=dict)
+    _implicit_deps: dict[str, list[str]] = field(default_factory=dict)
+    _listener: ProvisionListener = field(default_factory=NullListener)
+
+    def set_listener(self, listener: ProvisionListener) -> None:
+        """Set the event listener for provision progress."""
+        self._listener = listener
+
+    def add(self, node: Provisionable) -> None:
+        self._nodes[node.name] = node
+
+    def add_dependency(self, name: str, depends_on: str) -> None:
+        self._implicit_deps.setdefault(name, []).append(depends_on)
+
+    def _all_deps(self, name: str) -> list[str]:
+        node = self._nodes[name]
+        all_deps = list(node.depends_on)
+        all_deps.extend(self._implicit_deps.get(name, []))
+        return [d for d in all_deps if d in self._nodes]
+
+    def _resolve_order(self) -> list[str]:
+        reverse: dict[str, list[str]] = {name: [] for name in self._nodes}
+        in_degree: dict[str, int] = {name: 0 for name in self._nodes}
+
+        for name in self._nodes:
+            deps = self._all_deps(name)
+            in_degree[name] = len(deps)
+            for dep in deps:
+                reverse[dep].append(name)
+
+        queue = [n for n, d in in_degree.items() if d == 0]
+        order: list[str] = []
+
+        while queue:
+            node = queue.pop(0)
+            order.append(node)
+            for dependent in reverse[node]:
+                in_degree[dependent] -= 1
+                if in_degree[dependent] == 0:
+                    queue.append(dependent)
+
+        if len(order) != len(self._nodes):
+            raise CycleError("Dependency cycle detected in provision graph")
+
+        return order
+
+    def execute(self) -> dict[str, ProvisionResult]:
+        order = self._resolve_order()
+        results: dict[str, ProvisionResult] = {}
+
+        for name in order:
+            node = self._nodes[name]
+
+            self._listener.on_start(
+                ProvisionEvent(
+                    node_name=name,
+                    event_type="start",
+                    message=name,
+                )
+            )
+
+            # Pass listener to node if it supports it
+            if hasattr(node, "set_listener"):
+                node.set_listener(self._listener)
+
+            result = node.provision(context=results)
+            results[name] = result
+
+            if not result.success:
+                self._listener.on_error(
+                    ProvisionEvent(
+                        node_name=name,
+                        event_type="error",
+                        message=name,
+                        detail=result.error or "",
+                    )
+                )
+                raise ProvisionError(f"Failed to provision {name}: {result.error}")
+
+            self._listener.on_complete(
+                ProvisionEvent(
+                    node_name=name,
+                    event_type="complete",
+                    message=name,
+                    detail=result.info.get("detail", ""),
+                )
+            )
+
+            check = node.health_check()
+            self._listener.on_health_check(
+                ProvisionEvent(
+                    node_name=name,
+                    event_type="health_check",
+                    message=f"Waiting for {name}",
+                )
+            )
+            check.wait()
+
+        return results
+
+    def destroy_all(self) -> None:
+        order = self._resolve_order()
+        for name in reversed(order):
+            self._nodes[name].destroy()