strot-ai 0.1.1__tar.gz

strot_ai-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 STROT AI
+
+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.

strot_ai-0.1.1/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: strot-ai
+Version: 0.1.1
+Summary: Build tools, agents, and pipelines for your STROT instance
+License: MIT
+License-File: LICENSE
+Keywords: strot,ai,agents,pipelines
+Author: STROT AI
+Author-email: dev@strot.ai
+Requires-Python: >=3.9,<4.0
+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.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: click (>=8.0)
+Requires-Dist: pyyaml (>=6.0)
+Requires-Dist: requests (>=2.28)
+Requires-Dist: rich (>=13.0)
+Project-URL: Homepage, https://strot.ai
+Project-URL: Repository, https://github.com/strot-ai/strot-sdk
+Description-Content-Type: text/markdown
+
+# STROT
+
+Build tools, agents, pipelines, and dashboards for your [STROT](https://strot.ai) instance — in Python.
+
+## Installation
+
+```bash
+pip install strot-ai
+```
+
+## Quick Start
+
+```bash
+strot login                         # Authenticate
+strot init tool my-calculator       # Scaffold a project
+cd my-calculator                    # Edit main.py with any editor
+strot test                          # Validate locally
+strot deploy                        # Ship to your STROT instance
+```
+
+## SDK Reference
+
+### Tools (`@function`)
+
+```python
+from strot_sdk import function, llm
+
+@function(
+    name='calculate_roi',
+    description='Calculate return on investment',
+    category='finance',
+    parameters=[
+        {'name': 'cost', 'type': 'number', 'description': 'Total cost'},
+        {'name': 'revenue', 'type': 'number', 'description': 'Total revenue'},
+    ],
+    returns={'type': 'number', 'description': 'ROI percentage'}
+)
+class CalculateROI:
+    def run(self, cost: float, revenue: float) -> float:
+        return ((revenue - cost) / cost) * 100
+```
+
+### Agents (`@agent`)
+
+```python
+from strot_sdk import agent
+
+@agent(
+    name='sales_analyst',
+    description='Analyzes sales data and provides insights',
+    tools=['calculate_roi', 'top_n'],
+    model='gpt-4o',
+    temperature=0.1,
+)
+class SalesAnalyst:
+    system_prompt = """You are a sales analyst.
+    Analyze data and provide actionable recommendations."""
+```
+
+### Cortex Pipelines (`@cortex`)
+
+```python
+from strot_sdk import cortex
+from strot_sdk.cortex import Flow
+
+@cortex(name='daily_etl', description='Daily ETL pipeline')
+class DailyETL:
+    def build(self, flow: Flow):
+        data = flow.data_connector('load_sales', query_id=42)
+        cleaned = flow.transform(data, prompt='Clean and normalize the data')
+        flow.publish(cleaned, name='daily_report', destination='slack', channel='#data')
+```
+
+### Pages / Dashboards (`@page`)
+
+```python
+from strot_sdk import page
+from strot_sdk.pages import Dashboard, Row, KPI, Chart, Table
+
+@page(name='sales_dashboard', description='Sales overview', type='dashboard')
+class SalesDashboard:
+    def layout(self):
+        return Dashboard(
+            Row(
+                KPI(query_id=1, label='Revenue', format='currency'),
+                KPI(query_id=2, label='Orders'),
+                KPI(query_id=3, label='Customers'),
+            ),
+            Row(
+                Chart(query_id=5, type='line', title='Revenue Trend', span=8),
+                Chart(query_id=6, type='donut', title='By Region', span=4),
+            ),
+            Row(
+                Table(query_id=7, title='Recent Orders', sortable=True),
+            ),
+        )
+```
+
+### LLM
+
+All LLM calls go through your STROT instance — no API keys needed in your code.
+
+```python
+from strot_sdk import llm
+
+result = llm.complete("Summarize this: " + text)
+result = llm.chat([{"role": "user", "content": "What is 2+2?"}])
+category = llm.classify("Great product!", ["positive", "negative", "neutral"])
+data = llm.extract("John is 30 years old", {"name": "string", "age": "number"})
+```
+
+### Data Access
+
+```python
+from strot_sdk import strot, query, query_one
+
+rows = strot.queries['monthly_sales'].execute()
+rows = query("SELECT * FROM users", data_source_id=1)
+row = query_one("SELECT * FROM users WHERE id = 1", data_source_id=1)
+```
+
+### Destinations
+
+```python
+from strot_sdk import email, slack, webhook
+
+email.send(to="team@example.com", subject="Report Ready", body="Done.")
+slack.send(channel="#alerts", message="New alert!")
+webhook.post(url="https://api.example.com/hook", data={"event": "deploy"})
+```
+
+## CLI Reference
+
+```bash
+strot login                              # Authenticate
+strot login --token sk_live_abc123       # Direct API key
+strot whoami                             # Show current user/org
+strot logout                             # Clear credentials
+
+strot init tool my-calculator            # Scaffold tool
+strot init agent my-analyst              # Scaffold agent
+strot init cortex my-pipeline            # Scaffold pipeline
+strot init page my-dashboard             # Scaffold dashboard
+
+strot test                               # Validate locally
+strot deploy                             # Deploy to STROT
+strot deploy --dry-run                   # Validate without deploying
+
+strot resources                          # List all resources
+strot resources queries                  # List saved queries
+strot resources datasources              # List data sources
+```
+
+## Configuration
+
+Credentials stored in `~/.strot/credentials`:
+
+```yaml
+version: 1
+current_profile: default
+profiles:
+  default:
+    url: https://app.strot.ai
+    api_key: sk_live_abc123
+    org: 98bf9a0a-c9cd-42a8-9ea4-4f7fee9a4535
+```
+
+**Priority:** Constructor args > Environment variables (`STROT_URL`, `STROT_API_KEY`) > Credentials file
+
+## License
+
+MIT
+

strot_ai-0.1.1/README.md

@@ -0,0 +1,172 @@
+# STROT
+
+Build tools, agents, pipelines, and dashboards for your [STROT](https://strot.ai) instance — in Python.
+
+## Installation
+
+```bash
+pip install strot-ai
+```
+
+## Quick Start
+
+```bash
+strot login                         # Authenticate
+strot init tool my-calculator       # Scaffold a project
+cd my-calculator                    # Edit main.py with any editor
+strot test                          # Validate locally
+strot deploy                        # Ship to your STROT instance
+```
+
+## SDK Reference
+
+### Tools (`@function`)
+
+```python
+from strot_sdk import function, llm
+
+@function(
+    name='calculate_roi',
+    description='Calculate return on investment',
+    category='finance',
+    parameters=[
+        {'name': 'cost', 'type': 'number', 'description': 'Total cost'},
+        {'name': 'revenue', 'type': 'number', 'description': 'Total revenue'},
+    ],
+    returns={'type': 'number', 'description': 'ROI percentage'}
+)
+class CalculateROI:
+    def run(self, cost: float, revenue: float) -> float:
+        return ((revenue - cost) / cost) * 100
+```
+
+### Agents (`@agent`)
+
+```python
+from strot_sdk import agent
+
+@agent(
+    name='sales_analyst',
+    description='Analyzes sales data and provides insights',
+    tools=['calculate_roi', 'top_n'],
+    model='gpt-4o',
+    temperature=0.1,
+)
+class SalesAnalyst:
+    system_prompt = """You are a sales analyst.
+    Analyze data and provide actionable recommendations."""
+```
+
+### Cortex Pipelines (`@cortex`)
+
+```python
+from strot_sdk import cortex
+from strot_sdk.cortex import Flow
+
+@cortex(name='daily_etl', description='Daily ETL pipeline')
+class DailyETL:
+    def build(self, flow: Flow):
+        data = flow.data_connector('load_sales', query_id=42)
+        cleaned = flow.transform(data, prompt='Clean and normalize the data')
+        flow.publish(cleaned, name='daily_report', destination='slack', channel='#data')
+```
+
+### Pages / Dashboards (`@page`)
+
+```python
+from strot_sdk import page
+from strot_sdk.pages import Dashboard, Row, KPI, Chart, Table
+
+@page(name='sales_dashboard', description='Sales overview', type='dashboard')
+class SalesDashboard:
+    def layout(self):
+        return Dashboard(
+            Row(
+                KPI(query_id=1, label='Revenue', format='currency'),
+                KPI(query_id=2, label='Orders'),
+                KPI(query_id=3, label='Customers'),
+            ),
+            Row(
+                Chart(query_id=5, type='line', title='Revenue Trend', span=8),
+                Chart(query_id=6, type='donut', title='By Region', span=4),
+            ),
+            Row(
+                Table(query_id=7, title='Recent Orders', sortable=True),
+            ),
+        )
+```
+
+### LLM
+
+All LLM calls go through your STROT instance — no API keys needed in your code.
+
+```python
+from strot_sdk import llm
+
+result = llm.complete("Summarize this: " + text)
+result = llm.chat([{"role": "user", "content": "What is 2+2?"}])
+category = llm.classify("Great product!", ["positive", "negative", "neutral"])
+data = llm.extract("John is 30 years old", {"name": "string", "age": "number"})
+```
+
+### Data Access
+
+```python
+from strot_sdk import strot, query, query_one
+
+rows = strot.queries['monthly_sales'].execute()
+rows = query("SELECT * FROM users", data_source_id=1)
+row = query_one("SELECT * FROM users WHERE id = 1", data_source_id=1)
+```
+
+### Destinations
+
+```python
+from strot_sdk import email, slack, webhook
+
+email.send(to="team@example.com", subject="Report Ready", body="Done.")
+slack.send(channel="#alerts", message="New alert!")
+webhook.post(url="https://api.example.com/hook", data={"event": "deploy"})
+```
+
+## CLI Reference
+
+```bash
+strot login                              # Authenticate
+strot login --token sk_live_abc123       # Direct API key
+strot whoami                             # Show current user/org
+strot logout                             # Clear credentials
+
+strot init tool my-calculator            # Scaffold tool
+strot init agent my-analyst              # Scaffold agent
+strot init cortex my-pipeline            # Scaffold pipeline
+strot init page my-dashboard             # Scaffold dashboard
+
+strot test                               # Validate locally
+strot deploy                             # Deploy to STROT
+strot deploy --dry-run                   # Validate without deploying
+
+strot resources                          # List all resources
+strot resources queries                  # List saved queries
+strot resources datasources              # List data sources
+```
+
+## Configuration
+
+Credentials stored in `~/.strot/credentials`:
+
+```yaml
+version: 1
+current_profile: default
+profiles:
+  default:
+    url: https://app.strot.ai
+    api_key: sk_live_abc123
+    org: 98bf9a0a-c9cd-42a8-9ea4-4f7fee9a4535
+```
+
+**Priority:** Constructor args > Environment variables (`STROT_URL`, `STROT_API_KEY`) > Credentials file
+
+## License
+
+MIT

strot_ai-0.1.1/pyproject.toml

@@ -0,0 +1,42 @@
+[tool.poetry]
+name = "strot-ai"
+version = "0.1.1"
+description = "Build tools, agents, and pipelines for your STROT instance"
+authors = ["STROT AI <dev@strot.ai>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://strot.ai"
+repository = "https://github.com/strot-ai/strot-sdk"
+keywords = ["strot", "ai", "agents", "pipelines"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries",
+    "Programming Language :: Python :: 3",
+]
+packages = [
+    { include = "strot_sdk", from = "src" },
+    { include = "strot_cli", from = "src" },
+]
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+requests = ">=2.28"
+pyyaml = ">=6.0"
+click = ">=8.0"
+rich = ">=13.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=7.0"
+pytest-cov = "*"
+responses = ">=0.23"
+
+[tool.poetry.scripts]
+strot = "strot_cli.main:cli"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

strot_ai-0.1.1/src/strot_cli/__init__.py

@@ -0,0 +1 @@
+"""STROT CLI — Command-line interface for the STROT SDK."""

strot_ai-0.1.1/src/strot_cli/auth.py

@@ -0,0 +1,36 @@
+"""
+STROT CLI — Browser-Based Authentication (Org-Scoped)
+
+Flow:
+1. CLI opens browser to /<org_id>/cli/auth
+2. User logs in if needed, clicks "Authorize CLI"
+3. Browser shows the generated API key
+4. User copies and pastes into the CLI prompt
+5. CLI validates and saves to ~/.strot/credentials
+"""
+import secrets
+import webbrowser
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def generate_auth_code() -> str:
+    """Generate a random code (used as a nonce in the auth URL)."""
+    return secrets.token_urlsafe(16)
+
+
+def get_auth_url(instance_url: str, org_id: str, code: str) -> str:
+    """Build the org-scoped browser auth URL."""
+    base = instance_url.rstrip("/")
+    return f"{base}/{org_id}/cli/auth?code={code}"
+
+
+def open_browser_auth(instance_url: str, org_id: str, code: str) -> str:
+    """Open the browser to the auth URL. Returns the URL."""
+    url = get_auth_url(instance_url, org_id, code)
+    try:
+        webbrowser.open(url)
+    except Exception:
+        pass  # Browser open may fail in headless environments
+    return url

strot_ai-0.1.1/src/strot_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""STROT CLI commands."""

strot_ai-0.1.1/src/strot_cli/commands/deploy.py

@@ -0,0 +1,219 @@
+"""strot deploy — Deploy project to a STROT instance."""
+import click
+from pathlib import Path
+from rich.console import Console
+
+console = Console()
+
+
+@click.command()
+@click.option("--dry-run", is_flag=True, help="Validate without deploying")
+def deploy(dry_run):
+    """Deploy the current project to your STROT instance.
+
+    Reads strot.yaml, bundles files, and deploys to the connected instance.
+    """
+    from strot_cli.project import find_project_root, load_project_config, read_project_files
+
+    root = find_project_root()
+    if not root:
+        console.print("[red]No strot.yaml found.[/red] Run 'strot init' to create a project.")
+        raise SystemExit(1)
+
+    config = load_project_config(root)
+    project_type = config["type"]
+
+    console.print(f"[bold]Deploying:[/bold] {config['name']} ({project_type})")
+
+    if project_type in ("cortex", "page"):
+        _deploy_compiled(root, config, dry_run)
+    else:
+        _deploy_function(root, config, dry_run)
+
+
+def _deploy_function(root, config, dry_run):
+    """Deploy a tool or agent (code-based)."""
+    from strot_cli.project import read_project_files
+
+    files = read_project_files(root)
+    console.print(f"[dim]Files: {', '.join(files.keys())}[/dim]")
+
+    if not files:
+        console.print("[red]No files to deploy.[/red]")
+        raise SystemExit(1)
+
+    entry = config["entry"]
+    if entry not in files:
+        console.print(f"[red]Entry file '{entry}' not found.[/red]")
+        raise SystemExit(1)
+
+    code = files.pop(entry)
+
+    if dry_run:
+        console.print()
+        console.print("[green]Dry run passed.[/green] Project is valid for deployment.")
+        console.print(f"  Name: {config['name']}")
+        console.print(f"  Type: {config['type']}")
+        console.print(f"  Entry: {entry} ({len(code)} chars)")
+        if files:
+            console.print(f"  Additional files: {', '.join(files.keys())}")
+        return
+
+    try:
+        from strot_sdk.client import StrotClient
+        client = StrotClient()
+
+        result = client.deploy_function(
+            name=config["name"],
+            code=code,
+            function_type=config["type"],
+            description=config.get("description", ""),
+            category=config.get("category", "custom"),
+            language=config.get("language", "python"),
+            file_contents=files if files else None,
+            config={
+                "version": config.get("version", "1.0.0"),
+            },
+        )
+
+        if result.success:
+            console.print()
+            console.print(f"[green]Deployed successfully![/green] ({result.action})")
+            if result.url:
+                console.print(f"[dim]URL: {result.url}[/dim]")
+            if result.id:
+                console.print(f"[dim]ID: {result.id}[/dim]")
+        else:
+            console.print(f"[red]Deploy failed:[/red] {result.error}")
+            raise SystemExit(1)
+
+    except SystemExit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Deploy failed:[/red] {e}")
+        raise SystemExit(1)
+
+
+def _deploy_compiled(root, config, dry_run):
+    """Deploy a cortex pipeline or page (compiled to JSON DSL)."""
+    import sys
+    import importlib.util
+
+    entry = config["entry"]
+    entry_file = root / entry
+
+    if not entry_file.exists():
+        console.print(f"[red]Entry file '{entry}' not found.[/red]")
+        raise SystemExit(1)
+
+    # Import the entry module to find decorated classes
+    sys.path.insert(0, str(root))
+    try:
+        spec = importlib.util.spec_from_file_location("__strot_deploy__", entry_file)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        project_type = config["type"]
+
+        if project_type == "cortex":
+            dsl = _compile_cortex(module, config)
+        else:
+            dsl = _compile_page(module, config)
+
+        if dry_run:
+            import json
+            console.print()
+            console.print("[green]Dry run passed.[/green] Compiled successfully.")
+            console.print(f"  Name: {config['name']}")
+            console.print(f"  Type: {project_type}")
+            console.print()
+            console.print("[dim]Compiled DSL:[/dim]")
+            console.print(json.dumps(dsl, indent=2))
+            return
+
+        # Deploy to STROT instance
+        from strot_sdk.client import StrotClient
+        client = StrotClient()
+
+        if project_type == "cortex":
+            result = client.deploy_orchestration(
+                name=config["name"],
+                dsl=dsl,
+                description=config.get("description", ""),
+            )
+        else:
+            result = client.deploy_page(
+                name=config["name"],
+                layout=dsl,
+                description=config.get("description", ""),
+            )
+
+        if result.success:
+            console.print()
+            console.print(f"[green]Deployed successfully![/green] ({result.action})")
+            if result.url:
+                console.print(f"[dim]URL: {result.url}[/dim]")
+            if result.id:
+                console.print(f"[dim]ID: {result.id}[/dim]")
+        else:
+            console.print(f"[red]Deploy failed:[/red] {result.error}")
+            raise SystemExit(1)
+
+    except SystemExit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Deploy failed:[/red] {e}")
+        import traceback
+        traceback.print_exc()
+        raise SystemExit(1)
+    finally:
+        sys.path.pop(0)
+
+
+def _compile_cortex(module, config):
+    """Compile a @cortex decorated class to DSL."""
+    from strot_sdk.decorators import get_registry
+    from strot_sdk.cortex import build_pipeline
+
+    registry = get_registry()
+    cortex_items = registry.get("cortex", {})
+
+    if not cortex_items:
+        raise ValueError("No @cortex decorated class found in entry file.")
+
+    # Use the first (or matching) cortex class
+    target_name = config["name"]
+    cls = None
+    for name, entry in cortex_items.items():
+        if name == target_name:
+            cls = entry["class"]
+            break
+    if cls is None:
+        cls = next(iter(cortex_items.values()))["class"]
+
+    console.print(f"[dim]Compiling pipeline: {target_name}[/dim]")
+    return build_pipeline(cls)
+
+
+def _compile_page(module, config):
+    """Compile a @page decorated class to layout JSON."""
+    from strot_sdk.decorators import get_registry
+    from strot_sdk.pages import build_page
+
+    registry = get_registry()
+    page_items = registry.get("page", {})
+
+    if not page_items:
+        raise ValueError("No @page decorated class found in entry file.")
+
+    target_name = config["name"]
+    cls = None
+    for name, entry in page_items.items():
+        if name == target_name:
+            cls = entry["class"]
+            break
+    if cls is None:
+        cls = next(iter(page_items.values()))["class"]
+
+    console.print(f"[dim]Compiling page layout: {target_name}[/dim]")
+    return build_page(cls)