stratonext-core 0.0.1__py3-none-any.whl

stratonext_core/agents/__init__.py

@@ -0,0 +1,3 @@
+from .skill import AgentsSkill
+
+__all__ = ["AgentsSkill"]

stratonext_core/agents/skill.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from types import TracebackType
+
+from stratonext_sdk import Client
+from stratonext_sdk.get_agent import GetAgentAgent
+from stratonext_sdk.get_agents import GetAgentsAgentsNodes
+from stratonext_sdk.input_types import CreateAgentInput, UpdateAgentInput
+
+from ..client import build_client
+from ..config import ArtemisConfig
+
+
+class AgentsSkill:
+    """Read and manage Artemis agents via the platform GraphQL API."""
+
+    def __init__(self, client: Client | None = None, config: ArtemisConfig | None = None) -> None:
+        self._client = client or build_client(config)
+
+    async def __aenter__(self) -> AgentsSkill:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self._client.__aexit__(exc_type, exc, tb)
+
+    async def list_agents(
+        self, workspace_id: str, after: str | None = None
+    ) -> list[GetAgentsAgentsNodes]:
+        """List agents in a workspace, paginated 50 at a time."""
+        result = await self._client.get_agents(workspace_id=workspace_id, after=after)
+        if result.agents is None:
+            return []
+        return result.agents.nodes or []
+
+    async def get_agent(self, agent_id: str) -> GetAgentAgent | None:
+        """Fetch a single agent by ID, or None if it doesn't exist."""
+        result = await self._client.get_agent(agent_id=agent_id)
+        return result.agent
+
+    async def create_agent(
+        self,
+        workspace_id: str,
+        name: str,
+        project_id: str | None = None,
+    ) -> str:
+        """Register an agent in a workspace, returning its ID. project_id is
+        required for Workers and must be omitted for Lead-Agents."""
+        result = await self._client.create_agent(
+            input=CreateAgentInput(
+                workspace_id=workspace_id,
+                name=name,
+                project_id=project_id,
+            )
+        )
+        return result.create_agent.id
+
+    async def update_agent(self, agent_id: str, name: str) -> str:
+        """Rename an agent, returning its ID."""
+        result = await self._client.update_agent(
+            agent_id=agent_id, input=UpdateAgentInput(name=name)
+        )
+        return result.update_agent.id
+
+    async def deactivate_agent(self, agent_id: str) -> str:
+        """Deactivate an agent, returning its ID."""
+        result = await self._client.deactivate_agent(agent_id=agent_id)
+        return result.deactivate_agent.id
+
+    async def delete_agent(self, agent_id: str) -> None:
+        """Delete an agent."""
+        await self._client.delete_agent(agent_id=agent_id)

stratonext_core/approvals/__init__.py

@@ -0,0 +1,3 @@
+from .skill import ApprovalsSkill
+
+__all__ = ["ApprovalsSkill"]

stratonext_core/approvals/skill.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from types import TracebackType
+
+from stratonext_sdk import Client
+from stratonext_sdk.enums import ApprovalDecision, ApprovalRequestType
+from stratonext_sdk.get_approval import GetApprovalApproval
+from stratonext_sdk.get_approvals import GetApprovalsApprovalsNodes
+from stratonext_sdk.input_types import (
+    ArtemisApprovalFilterInput,
+    ArtemisApprovalSortInput,
+    ResolveApprovalInput,
+    SubmitApprovalInput,
+)
+
+from ..client import build_client
+from ..config import ArtemisConfig
+
+
+class ApprovalsSkill:
+    """Read and manage Artemis approvals via the platform GraphQL API."""
+
+    def __init__(self, client: Client | None = None, config: ArtemisConfig | None = None) -> None:
+        self._client = client or build_client(config)
+
+    async def __aenter__(self) -> ApprovalsSkill:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self._client.__aexit__(exc_type, exc, tb)
+
+    async def list_approvals(
+        self,
+        workspace_id: str,
+        after: str | None = None,
+        where: ArtemisApprovalFilterInput | None = None,
+        order: list[ArtemisApprovalSortInput] | None = None,
+    ) -> list[GetApprovalsApprovalsNodes]:
+        """List approvals in a workspace, paginated 50 at a time. Optionally filter/sort server-side."""
+        result = await self._client.get_approvals(
+            workspace_id=workspace_id,
+            after=after,
+            where=where,
+            order=order,
+        )
+        if result.approvals is None:
+            return []
+        return result.approvals.nodes or []
+
+    async def get_approval(self, approval_id: str) -> GetApprovalApproval | None:
+        """Fetch a single approval by ID, or None if not found."""
+        result = await self._client.get_approval(approval_id=approval_id)
+        return result.approval
+
+    async def submit_approval(
+        self,
+        task_id: str,
+        agent_id: str,
+        environment_id: str,
+        workspace_id: str,
+        request_type: ApprovalRequestType,
+        name: str,
+        action_description: str,
+        payload_ref: str,
+    ) -> str:
+        """Submit an approval request, returning the approval ID.
+
+        action_description should be a detailed, human-readable description of what the agent
+        intends to do, including affected resource IDs and mutation intent. The platform evaluates
+        risk automatically using an LLM — the more detail provided, the more accurate the result.
+
+        If the environment's automation policy permits it, the approval is resolved immediately
+        (status APPROVED) and the task remains dispatchable. Otherwise the task is transitioned
+        to APPROVAL_REQUIRED and the approval ID should be surfaced to human approvers.
+        """
+        result = await self._client.submit_approval(
+            input=SubmitApprovalInput(
+                task_id=task_id,
+                agent_id=agent_id,
+                environment_id=environment_id,
+                workspace_id=workspace_id,
+                request_type=request_type,
+                name=name,
+                action_description=action_description,
+                payload_ref=payload_ref,
+            )
+        )
+        return result.submit_approval.id
+
+    async def approve(self, approval_id: str, notes: str | None = None) -> str:
+        """Approve a pending approval, returning the approval ID."""
+        result = await self._client.resolve_approval(
+            approval_id=approval_id,
+            input=ResolveApprovalInput(decision=ApprovalDecision.APPROVED, notes=notes),
+        )
+        return result.resolve_approval.id
+
+    async def reject(self, approval_id: str, notes: str | None = None) -> str:
+        """Reject a pending approval, returning the approval ID."""
+        result = await self._client.resolve_approval(
+            approval_id=approval_id,
+            input=ResolveApprovalInput(decision=ApprovalDecision.REJECTED, notes=notes),
+        )
+        return result.resolve_approval.id

stratonext_core/assets/__init__.py

@@ -0,0 +1,3 @@
+from .skill import AssetsSkill
+
+__all__ = ["AssetsSkill"]

stratonext_core/assets/skill.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import mimetypes
+from pathlib import Path
+from types import TracebackType
+
+import httpx
+from stratonext_sdk import Client
+from stratonext_sdk.confirm_asset import ConfirmAssetConfirmAsset
+from stratonext_sdk.enums import AssetCategory, ParentType
+from stratonext_sdk.input_types import RegisterAssetInput
+from stratonext_sdk.register_asset import RegisterAssetRegisterAsset
+
+from ..client import build_client
+from ..config import ArtemisConfig
+
+
+class AssetsSkill:
+    """Register, confirm, and fetch download URLs for Artemis assets.
+
+    ``upload_file``/``download_file`` are the preferred entry points: the raw
+    register/confirm calls below leave a stale PENDING asset row (and staging
+    object) behind if the caller uploads the bytes and forgets to confirm, or
+    crashes in between. A single call removes that window entirely.
+    """
+
+    def __init__(self, client: Client | None = None, config: ArtemisConfig | None = None) -> None:
+        self._client = client or build_client(config)
+
+    async def __aenter__(self) -> AssetsSkill:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self._client.__aexit__(exc_type, exc, tb)
+
+    async def register_asset(
+        self,
+        name: str,
+        description: str,
+        media_type: str,
+        category: AssetCategory,
+        filename: str,
+        parent_id: str,
+        parent_type: ParentType,
+        workspace_id: str,
+    ) -> RegisterAssetRegisterAsset:
+        """Register a new asset, returning its record and a presigned upload URL."""
+        result = await self._client.register_asset(
+            input=RegisterAssetInput(
+                name=name,
+                description=description,
+                media_type=media_type,
+                category=category,
+                filename=filename,
+                parent_id=parent_id,
+                parent_type=parent_type,
+                workspace_id=workspace_id,
+            )
+        )
+        return result.register_asset
+
+    async def confirm_asset(self, asset_id: str) -> ConfirmAssetConfirmAsset:
+        """Confirm an asset after its bytes have been uploaded to the presigned URL."""
+        result = await self._client.confirm_asset(asset_id=asset_id)
+        return result.confirm_asset
+
+    async def get_download_url(self, asset_id: str) -> str | None:
+        """Get a presigned download URL for an existing asset, or None if it doesn't exist."""
+        result = await self._client.get_asset_download_url(asset_id=asset_id)
+        return result.asset_download_url
+
+    async def upload_file(
+        self,
+        path: str | Path,
+        parent_id: str,
+        parent_type: ParentType,
+        workspace_id: str,
+        name: str | None = None,
+        description: str = "",
+        category: AssetCategory = AssetCategory.GENERIC,
+        media_type: str | None = None,
+    ) -> ConfirmAssetConfirmAsset:
+        """Register, upload, and confirm a local file as one call.
+
+        Reads ``path`` from disk and uploads it to the presigned staging URL.
+        If the upload or confirm step fails, the just-registered asset is
+        deleted so no PENDING row is left behind — callers never have to
+        handle the register/confirm gap themselves.
+        """
+        path = Path(path)
+        media_type = media_type or mimetypes.guess_type(path.name)[0] or "application/octet-stream"
+        registered = await self.register_asset(
+            name=name or path.name,
+            description=description,
+            media_type=media_type,
+            category=category,
+            filename=path.name,
+            parent_id=parent_id,
+            parent_type=parent_type,
+            workspace_id=workspace_id,
+        )
+        try:
+            # Presigned POST: form fields first, file part last. The signed policy
+            # enforces the size cap, so S3 rejects an oversized file here (4xx).
+            fields = {f.name: f.value for f in registered.upload.fields}
+            async with httpx.AsyncClient() as http_client:
+                response = await http_client.post(
+                    registered.upload.url,
+                    data=fields,
+                    files={"file": (path.name, path.read_bytes(), media_type)},
+                )
+                response.raise_for_status()
+            return await self.confirm_asset(registered.asset.id)
+        except Exception:
+            await self._client.delete_asset(asset_id=registered.asset.id)
+            raise
+
+    async def download_file(self, asset_id: str, dest: str | Path) -> Path:
+        """Download an asset's content to ``dest`` as one call.
+
+        Raises ``ValueError`` if the asset doesn't exist or has no download URL.
+        """
+        url = await self.get_download_url(asset_id)
+        if not url:
+            raise ValueError(f"Asset {asset_id!r} not found or has no download URL")
+
+        dest = Path(dest)
+        async with httpx.AsyncClient(follow_redirects=True) as http_client:
+            response = await http_client.get(url)
+            response.raise_for_status()
+        dest.write_bytes(response.content)
+        return dest
+
+    async def delete_asset(self, asset_id: str) -> bool:
+        """Delete an asset by ID, returning the platform's deletion result."""
+        return (await self._client.delete_asset(asset_id=asset_id)).delete_asset

stratonext_core/client.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from stratonext_sdk import Client
+
+from .config import ArtemisConfig
+
+
+def build_client(config: ArtemisConfig | None = None) -> Client:
+    """Construct a Client for the Artemis platform GraphQL API.
+
+    Reads connection settings from the environment via ArtemisConfig.from_env()
+    unless an explicit config is passed.
+    """
+    config = config or ArtemisConfig.from_env()
+    return Client(url=config.endpoint, headers=config.headers)

stratonext_core/config.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ArtemisConfig:
+    """Connection settings for the Artemis platform GraphQL API, read from the environment.
+
+    - ARTEMIS_API_URL: GraphQL endpoint URL. Defaults to the local dev API.
+    - ARTEMIS_AUTH_API_TOKEN: bearer token sent as `Authorization: Bearer <token>`. Optional
+      for local dev deployments running without auth.
+    """
+
+    endpoint: str
+    api_token: str | None = None
+
+    @property
+    def headers(self) -> dict[str, str]:
+        if not self.api_token:
+            return {}
+        return {"Authorization": f"Bearer {self.api_token}"}
+
+    @classmethod
+    def from_env(cls) -> ArtemisConfig:
+        return cls(
+            endpoint=os.environ.get("ARTEMIS_API_URL", "http://localhost:5555/v1/graphql"),
+            api_token=os.environ.get("ARTEMIS_AUTH_API_TOKEN"),
+        )

stratonext_core/dossiers/__init__.py

@@ -0,0 +1,3 @@
+from .skill import DossiersSkill
+
+__all__ = ["DossiersSkill"]

stratonext_core/dossiers/skill.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from types import TracebackType
+
+from stratonext_sdk import Client
+from stratonext_sdk.enums import DossierStatus, DossierType
+from stratonext_sdk.get_dossier import GetDossierDossier
+from stratonext_sdk.get_dossiers import GetDossiersDossiersNodes
+from stratonext_sdk.input_types import CreateDossierInput, UpdateDossierInput
+
+from ..client import build_client
+from ..config import ArtemisConfig
+
+
+class DossiersSkill:
+    """Read and manage Artemis dossiers via the platform GraphQL API."""
+
+    def __init__(self, client: Client | None = None, config: ArtemisConfig | None = None) -> None:
+        self._client = client or build_client(config)
+
+    async def __aenter__(self) -> DossiersSkill:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self._client.__aexit__(exc_type, exc, tb)
+
+    async def list_dossiers(
+        self, workspace_id: str, after: str | None = None
+    ) -> list[GetDossiersDossiersNodes]:
+        """List dossiers in a workspace, paginated 50 at a time."""
+        result = await self._client.get_dossiers(workspace_id=workspace_id, after=after)
+        if result.dossiers is None:
+            return []
+        return result.dossiers.nodes or []
+
+    async def get_dossier(self, dossier_id: str) -> GetDossierDossier | None:
+        """Fetch a single dossier by ID, or None if it doesn't exist."""
+        result = await self._client.get_dossier(dossier_id=dossier_id)
+        return result.dossier
+
+    async def create_dossier(
+        self,
+        workspace_id: str,
+        title: str,
+        type: DossierType = DossierType.GENERIC,
+        body: str | None = None,
+        owner_id: str | None = None,
+    ) -> str:
+        """Create a dossier in a workspace, returning its ID."""
+        result = await self._client.create_dossier(
+            input=CreateDossierInput(
+                workspace_id=workspace_id,
+                title=title,
+                type_=type,
+                body=body,
+                owner_id=owner_id,
+            )
+        )
+        return result.create_dossier.id
+
+    async def update_dossier(
+        self,
+        dossier_id: str,
+        title: str | None = None,
+        body: str | None = None,
+        owner_id: str | None = None,
+        status: DossierStatus | None = None,
+        project_ids: list[str] | None = None,
+    ) -> str:
+        """Update a dossier's fields, returning its ID."""
+        result = await self._client.update_dossier(
+            dossier_id=dossier_id,
+            input=UpdateDossierInput(
+                title=title,
+                body=body,
+                owner_id=owner_id,
+                status=status,
+                project_ids=project_ids,
+            ),
+        )
+        return result.update_dossier.id
+
+    async def delete_dossier(self, dossier_id: str) -> None:
+        """Delete a dossier."""
+        await self._client.delete_dossier(dossier_id=dossier_id)

stratonext_core/environments/__init__.py

@@ -0,0 +1,3 @@
+from .skill import EnvironmentsSkill
+
+__all__ = ["EnvironmentsSkill"]

stratonext_core/environments/skill.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from types import TracebackType
+
+from stratonext_sdk import Client
+from stratonext_sdk.enums import (
+    EnvironmentAutomationPolicy,
+    EnvironmentClassification,
+    EnvironmentProvider,
+)
+from stratonext_sdk.get_environment import GetEnvironmentEnvironment
+from stratonext_sdk.get_environments import GetEnvironmentsEnvironmentsNodes
+from stratonext_sdk.input_types import (
+    CreateEnvironmentInput,
+    MetadataKvInput,
+    UpdateEnvironmentInput,
+)
+
+from ..client import build_client
+from ..config import ArtemisConfig
+
+
+class EnvironmentsSkill:
+    """Read and manage Artemis environments via the platform GraphQL API."""
+
+    def __init__(self, client: Client | None = None, config: ArtemisConfig | None = None) -> None:
+        self._client = client or build_client(config)
+
+    async def __aenter__(self) -> EnvironmentsSkill:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self._client.__aexit__(exc_type, exc, tb)
+
+    async def list_environments(
+        self, workspace_id: str, after: str | None = None
+    ) -> list[GetEnvironmentsEnvironmentsNodes]:
+        """List environments in a workspace, paginated 50 at a time."""
+        result = await self._client.get_environments(workspace_id=workspace_id, after=after)
+        if result.environments is None:
+            return []
+        return result.environments.nodes or []
+
+    async def get_environment(self, environment_id: str) -> GetEnvironmentEnvironment | None:
+        """Fetch a single environment by ID, or None if it doesn't exist."""
+        result = await self._client.get_environment(environment_id=environment_id)
+        return result.environment
+
+    async def create_environment(
+        self,
+        workspace_id: str,
+        name: str,
+        provider: EnvironmentProvider,
+        classification: EnvironmentClassification | None = None,
+        automation_policy: EnvironmentAutomationPolicy | None = None,
+        metadata: list[MetadataKvInput] | None = None,
+    ) -> str:
+        """Register a new environment in a workspace, returning its ID."""
+        result = await self._client.create_environment(
+            input=CreateEnvironmentInput(
+                workspace_id=workspace_id,
+                name=name,
+                provider=provider,
+                classification=classification,
+                automation_policy=automation_policy,
+                metadata=metadata,
+            )
+        )
+        return result.create_environment.id
+
+    async def update_environment(
+        self,
+        environment_id: str,
+        name: str | None = None,
+        classification: EnvironmentClassification | None = None,
+        automation_policy: EnvironmentAutomationPolicy | None = None,
+        metadata: list[MetadataKvInput] | None = None,
+    ) -> str:
+        """Update an environment's fields, returning its ID."""
+        result = await self._client.update_environment(
+            environment_id=environment_id,
+            input=UpdateEnvironmentInput(
+                name=name,
+                classification=classification,
+                automation_policy=automation_policy,
+                metadata=metadata,
+            ),
+        )
+        return result.update_environment.id
+
+    async def delete_environment(self, environment_id: str) -> None:
+        """Delete an environment."""
+        await self._client.delete_environment(environment_id=environment_id)

stratonext_core/jobs/__init__.py

@@ -0,0 +1,3 @@
+from .skill import JobsSkill
+
+__all__ = ["JobsSkill"]

stratonext_core/jobs/skill.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from types import TracebackType
+
+from stratonext_sdk import Client
+from stratonext_sdk.get_job import GetJobJob
+from stratonext_sdk.get_job_run import GetJobRunJobRun
+from stratonext_sdk.get_job_runs import GetJobRunsJobRunsNodes
+from stratonext_sdk.get_jobs import GetJobsJobsNodes
+from stratonext_sdk.input_types import CreateJobInput, UpdateJobInput
+from stratonext_sdk.trigger_job_run import TriggerJobRunTriggerJobRun
+
+from ..client import build_client
+from ..config import ArtemisConfig
+
+
+class JobsSkill:
+    """Read and manage Artemis jobs and job runs via the platform GraphQL API."""
+
+    def __init__(self, client: Client | None = None, config: ArtemisConfig | None = None) -> None:
+        self._client = client or build_client(config)
+
+    async def __aenter__(self) -> JobsSkill:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self._client.__aexit__(exc_type, exc, tb)
+
+    async def list_jobs(self, project_id: str, after: str | None = None) -> list[GetJobsJobsNodes]:
+        """List jobs in a project, paginated 50 at a time."""
+        result = await self._client.get_jobs(project_id=project_id, after=after)
+        if result.jobs is None:
+            return []
+        return result.jobs.nodes or []
+
+    async def get_job(self, job_id: str) -> GetJobJob | None:
+        """Fetch a single job by ID, or None if it doesn't exist."""
+        result = await self._client.get_job(job_id=job_id)
+        return result.job
+
+    async def create_job(
+        self,
+        workspace_id: str,
+        project_id: str,
+        name: str,
+        agent_id: str,
+        schedule: str,
+        description: str | None = None,
+        instructions: str | None = None,
+        deployment_ids: list[str] | None = None,
+        max_queue_depth: int | None = None,
+    ) -> str:
+        """Create a job in a project, returning its ID."""
+        result = await self._client.create_job(
+            input=CreateJobInput(
+                workspace_id=workspace_id,
+                project_id=project_id,
+                name=name,
+                agent_id=agent_id,
+                schedule=schedule,
+                description=description,
+                instructions=instructions,
+                deployment_ids=deployment_ids,
+                max_queue_depth=max_queue_depth,
+            )
+        )
+        return result.create_job.id
+
+    async def update_job(
+        self,
+        job_id: str,
+        name: str | None = None,
+        description: str | None = None,
+        schedule: str | None = None,
+        max_queue_depth: int | None = None,
+    ) -> str:
+        """Update a job's fields, returning its ID."""
+        result = await self._client.update_job(
+            job_id=job_id,
+            input=UpdateJobInput(
+                name=name,
+                description=description,
+                schedule=schedule,
+                max_queue_depth=max_queue_depth,
+            ),
+        )
+        return result.update_job.id
+
+    async def pause_job(self, job_id: str) -> str:
+        """Pause a job's schedule, returning its ID."""
+        result = await self._client.pause_job(job_id=job_id)
+        return result.pause_job.id
+
+    async def resume_job(self, job_id: str) -> str:
+        """Resume a paused job's schedule, returning its ID."""
+        result = await self._client.resume_job(job_id=job_id)
+        return result.resume_job.id
+
+    async def disable_job(self, job_id: str) -> str:
+        """Permanently disable a job and delete its schedule, returning its ID."""
+        result = await self._client.disable_job(job_id=job_id)
+        return result.disable_job.id
+
+    async def trigger_job_run(self, job_id: str) -> TriggerJobRunTriggerJobRun:
+        """Manually trigger one job run, bypassing the schedule."""
+        result = await self._client.trigger_job_run(job_id=job_id)
+        return result.trigger_job_run
+
+    async def list_job_runs(
+        self, job_id: str, after: str | None = None
+    ) -> list[GetJobRunsJobRunsNodes]:
+        """List runs for a job, paginated 50 at a time."""
+        result = await self._client.get_job_runs(job_id=job_id, after=after)
+        if result.job_runs is None:
+            return []
+        return result.job_runs.nodes or []
+
+    async def get_job_run(self, job_run_id: str) -> GetJobRunJobRun | None:
+        """Fetch a single job run by ID, or None if it doesn't exist."""
+        result = await self._client.get_job_run(job_run_id=job_run_id)
+        return result.job_run

stratonext_core/projects/__init__.py

@@ -0,0 +1,3 @@
+from .skill import ProjectsSkill
+
+__all__ = ["ProjectsSkill"]

stratonext_core/projects/skill.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from types import TracebackType
+
+from stratonext_sdk import Client
+from stratonext_sdk.enums import ProjectStatus, ProjectType
+from stratonext_sdk.get_project import GetProjectProject
+from stratonext_sdk.get_projects import GetProjectsProjectsNodes
+from stratonext_sdk.input_types import CreateProjectInput, ResourceLinkInput, UpdateProjectInput
+
+from ..client import build_client
+from ..config import ArtemisConfig
+
+
+class ProjectsSkill:
+    """Read and manage Artemis projects via the platform GraphQL API."""
+
+    def __init__(self, client: Client | None = None, config: ArtemisConfig | None = None) -> None:
+        self._client = client or build_client(config)
+
+    async def __aenter__(self) -> ProjectsSkill:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self._client.__aexit__(exc_type, exc, tb)
+
+    async def list_projects(
+        self, workspace_id: str, after: str | None = None
+    ) -> list[GetProjectsProjectsNodes]:
+        """List projects in a workspace, paginated 50 at a time."""
+        result = await self._client.get_projects(workspace_id=workspace_id, after=after)
+        if result.projects is None:
+            return []
+        return result.projects.nodes or []
+
+    async def get_project(self, project_id: str) -> GetProjectProject | None:
+        """Fetch a single project by ID, or None if it doesn't exist."""
+        result = await self._client.get_project(project_id=project_id)
+        return result.project
+
+    async def create_project(
+        self,
+        workspace_id: str,
+        name: str,
+        description: str,
+        type: ProjectType | None = None,
+    ) -> str:
+        """Create a project in a workspace, returning its ID."""
+        result = await self._client.create_project(
+            input=CreateProjectInput(
+                workspace_id=workspace_id,
+                name=name,
+                description=description,
+                type_=type,
+            )
+        )
+        return result.create_project.id
+
+    async def update_project(
+        self,
+        project_id: str,
+        name: str | None = None,
+        description: str | None = None,
+        status: ProjectStatus | None = None,
+        instructions: str | None = None,
+        notes: list[str] | None = None,
+        links: list[ResourceLinkInput] | None = None,
+        type: ProjectType | None = None,
+    ) -> str:
+        """Update a project's fields, returning its ID."""
+        result = await self._client.update_project(
+            project_id=project_id,
+            input=UpdateProjectInput(
+                name=name,
+                description=description,
+                status=status,
+                instructions=instructions,
+                notes=notes,
+                links=links,
+                type_=type,
+            ),
+        )
+        return result.update_project.id
+
+    async def delete_project(self, project_id: str) -> None:
+        """Delete a project."""
+        await self._client.delete_project(project_id=project_id)

stratonext_core/registry.py

@@ -0,0 +1,17 @@
+from .agents import AgentsSkill
+from .approvals import ApprovalsSkill
+from .assets import AssetsSkill
+from .dossiers import DossiersSkill
+from .environments import EnvironmentsSkill
+from .projects import ProjectsSkill
+from .tasks import TasksSkill
+
+SKILLS: dict[str, type] = {
+    "projects": ProjectsSkill,
+    "tasks": TasksSkill,
+    "environments": EnvironmentsSkill,
+    "agents": AgentsSkill,
+    "assets": AssetsSkill,
+    "approvals": ApprovalsSkill,
+    "dossiers": DossiersSkill,
+}

stratonext_core/tasks/__init__.py

@@ -0,0 +1,3 @@
+from .skill import TasksSkill
+
+__all__ = ["TasksSkill"]

stratonext_core/tasks/skill.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from types import TracebackType
+
+from stratonext_sdk import Client
+from stratonext_sdk.enums import AssigneeType, TaskStatus, VerificationStatus
+from stratonext_sdk.get_task import GetTaskTask
+from stratonext_sdk.get_tasks import GetTasksTasksNodes, GetTasksTasksPageInfo
+from stratonext_sdk.input_types import (
+    ArtemisTaskFilterInput,
+    ArtemisTaskSortInput,
+    CreateTaskInput,
+    ResourceLinkInput,
+    UpdateTaskInput,
+)
+
+from ..client import build_client
+from ..config import ArtemisConfig
+
+
+class TasksSkill:
+    """Read and manage Artemis tasks via the platform GraphQL API."""
+
+    def __init__(self, client: Client | None = None, config: ArtemisConfig | None = None) -> None:
+        self._client = client or build_client(config)
+
+    async def __aenter__(self) -> TasksSkill:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self._client.__aexit__(exc_type, exc, tb)
+
+    async def list_tasks(
+        self,
+        workspace_id: str,
+        after: str | None = None,
+        order: list[ArtemisTaskSortInput] | None = None,
+        where: ArtemisTaskFilterInput | None = None,
+    ) -> tuple[list[GetTasksTasksNodes], GetTasksTasksPageInfo | None]:
+        """Fetch one page of tasks (50). Returns (nodes, page_info); page_info.end_cursor is the next-page token."""
+        result = await self._client.get_tasks(
+            workspace_id=workspace_id, after=after, order=order, where=where
+        )
+        if result.tasks is None:
+            return [], None
+        return result.tasks.nodes or [], result.tasks.page_info
+
+    async def get_task(self, task_id: str) -> GetTaskTask | None:
+        """Fetch a single task by ID, or None if it doesn't exist."""
+        result = await self._client.get_task(task_id=task_id)
+        return result.task
+
+    async def create_task(
+        self,
+        workspace_id: str,
+        project_id: str,
+        name: str,
+        description: str,
+        instructions: str | None = None,
+        assignee_id: str | None = None,
+        assignee_type: AssigneeType | None = None,
+        verification_criteria: str | None = None,
+        verification_status: VerificationStatus | None = None,
+        verification_notes: str | None = None,
+    ) -> str:
+        """Create a task in a project, returning its ID."""
+        result = await self._client.create_task(
+            input=CreateTaskInput(
+                workspace_id=workspace_id,
+                project_id=project_id,
+                name=name,
+                description=description,
+                instructions=instructions,
+                assignee_id=assignee_id,
+                assignee_type=assignee_type,
+                verification_criteria=verification_criteria,
+                verification_status=verification_status,
+                verification_notes=verification_notes,
+            )
+        )
+        return result.create_task.id
+
+    async def update_task(
+        self,
+        task_id: str,
+        name: str | None = None,
+        description: str | None = None,
+        instructions: str | None = None,
+        assignee_id: str | None = None,
+        assignee_type: AssigneeType | None = None,
+        status: TaskStatus | None = None,
+        result: str | None = None,
+        verification_criteria: str | None = None,
+        verification_status: VerificationStatus | None = None,
+        verification_notes: str | None = None,
+        links: list[ResourceLinkInput] | None = None,
+    ) -> str:
+        """Update a task's fields, returning its ID.
+
+        ``links`` replaces the whole task links array — fetch the current links,
+        modify the list, and pass the full result (see the CLI add-link/remove-link).
+        """
+        response = await self._client.update_task(
+            task_id=task_id,
+            input=UpdateTaskInput(
+                name=name,
+                description=description,
+                instructions=instructions,
+                assignee_id=assignee_id,
+                assignee_type=assignee_type,
+                status=status,
+                result=result,
+                verification_criteria=verification_criteria,
+                verification_status=verification_status,
+                verification_notes=verification_notes,
+                links=links,
+            ),
+        )
+        return response.update_task.id
+
+    async def delete_task(self, task_id: str) -> None:
+        """Delete a task."""
+        await self._client.delete_task(task_id=task_id)

stratonext_core-0.0.1.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: stratonext-core
+Version: 0.0.1
+Summary: StratoNext agent skills for interacting with the StratoNext platform API.
+Requires-Python: >=3.14
+Requires-Dist: httpx
+Requires-Dist: stratonext-sdk

stratonext_core-0.0.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+stratonext_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stratonext_core/client.py,sha256=5gpdf10sCDBfs3ONqpujv2mGRupua5GnHSLycwKwrZ0,477
+stratonext_core/config.py,sha256=iQzk0hq7qo5KbONfPqM3dKZDRFapOZSciFcXK_6-vwA,917
+stratonext_core/registry.py,sha256=YP-VtNB96JDpWHV4Z8kkBtgFoWzbG6lbt9-75A7dHV0,492
+stratonext_core/agents/__init__.py,sha256=BZGFmDkBoa6PDHPrI-08yykY-xWjMNtXKpmlya3gBKI,58
+stratonext_core/agents/skill.py,sha256=4PW04dXzvCJWtsWC2vBJ1yKACPbiU9mncqy2R29D6Lc,2706
+stratonext_core/approvals/__init__.py,sha256=Xx8jTRQeU3Gc_FHxw8sKl7TVm_RAL6rvGCL4mIzpyl4,64
+stratonext_core/approvals/skill.py,sha256=Zwd43Mss796raPAYY8_xVuxFr7nYNyEZXXp7MaExfwk,4160
+stratonext_core/assets/__init__.py,sha256=0227dc-e2OJbWXF7NiG_bRF--xrBBnckeSstkHlSrFA,58
+stratonext_core/assets/skill.py,sha256=9OB858w2N4XM5YxAzi3iQWMS_5_V85c1oo7v4xf5hk0,5507
+stratonext_core/dossiers/__init__.py,sha256=Flyxv_hSVaC1JieAOXD9oeVkGX0JXgNmC2xZ9CfEdG8,62
+stratonext_core/dossiers/skill.py,sha256=Mzs6yfrMzHS1h_n65WHzUz6U3jL2m-r2OzX6uLfr_SY,3075
+stratonext_core/environments/__init__.py,sha256=XjUOrgEtiYhwsFG91PAMjNWEZTZXaUQ-XdGUpQYb7nY,70
+stratonext_core/environments/skill.py,sha256=EzQ2s55WNel_qhmZcalaC821gDIk7Yg6sqR5VjugUsg,3581
+stratonext_core/jobs/__init__.py,sha256=pKI3pkaCsHvREwebju5C-6GEoY766H1lxS67p5rqzHU,54
+stratonext_core/jobs/skill.py,sha256=C_pjT2C4LR0snuh-Vc4WSISMxF9wi290q-4GYJkKTeE,4662
+stratonext_core/projects/__init__.py,sha256=vTdNpiLzpfgHbYlvTAQSxRCa6FXE3Jalva7rWiQz2-A,62
+stratonext_core/projects/skill.py,sha256=g6YRcMV19_t6sWjxd6ND8vX6eAn9sBXjn4lq3hBKFHA,3182
+stratonext_core/tasks/__init__.py,sha256=PssT4i0Rdg1Gls-BTMPf1GYIpezpYsqRUcYKvKPotw4,56
+stratonext_core/tasks/skill.py,sha256=qjun5wjdflW7r4N16YmTbwZ-WyKuYwYoouORypgzfTE,4655
+stratonext_core-0.0.1.dist-info/METADATA,sha256=Ii8aKmoVWEcAGozuHx5GWtd4ivurZEMMw-APsd2MmJ4,217
+stratonext_core-0.0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+stratonext_core-0.0.1.dist-info/RECORD,,

stratonext_core-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any