synth-ai 0.4.1__py3-none-any.whl → 0.4.4__py3-none-any.whl

synth_ai/sdk/research_agent/container_spec.py

@@ -1,198 +0,0 @@
-from __future__ import annotations
-
-import io
-import textwrap
-import time
-from dataclasses import dataclass, field
-from importlib import import_module
-from pathlib import Path
-from typing import Dict, Iterable, List, Optional
-
-from synth_ai.sdk.research_agent.defaults import (
-    DEFAULT_BACKEND,
-    DEFAULT_BASE_IMAGE,
-    DEFAULT_INSTRUCTIONS,
-    DEFAULT_PACKAGES,
-    DEFAULT_PYTHON_VERSION,
-    DEFAULT_RESULT_PATTERNS,
-    DEFAULT_SYNTH_PIP_SPEC,
-)
-
-
-def _load_box_bootstrap() -> str:
-    """Load the canonical box_bootstrap.sh content from regenerate_bootstrap."""
-    try:
-        mod = import_module("scripts.regenerate_bootstrap")
-        content = getattr(mod, "bootstrap_content", None)
-        if content:
-            return content
-    except Exception:
-        pass
-    return "#!/bin/bash\nset -euo pipefail\necho 'box_bootstrap.sh missing; ensure regenerate_bootstrap.py is available.'\nexit 1\n"
-
-
-@dataclass
-class ContainerSpec:
-    """Declarative container configuration for running the research agent."""
-
-    repo_url: str
-    repo_branch: str = "main"
-    repo_commit: Optional[str] = None
-
-    agent_instructions: str = DEFAULT_INSTRUCTIONS
-    base_image: str = DEFAULT_BASE_IMAGE
-    python_version: str = DEFAULT_PYTHON_VERSION
-    apt_packages: List[str] = field(default_factory=lambda: list(DEFAULT_PACKAGES))
-
-    env_vars: Dict[str, str] = field(default_factory=dict)
-    secrets: Dict[str, str] = field(default_factory=dict)
-    files: Dict[str, str | bytes] = field(default_factory=dict)
-    preflight_script: Optional[str] = None
-    postflight_script: Optional[str] = None
-
-    artifacts_dir: Path = Path("/app/artifacts")
-    result_patterns: List[str] = field(default_factory=lambda: list(DEFAULT_RESULT_PATTERNS))
-    workdir: Path = Path("/app/repo")
-
-    backend: str = DEFAULT_BACKEND
-    overlay_dir: Optional[Path] = None
-    bootstrap_content: str = field(default_factory=_load_box_bootstrap)
-    synth_pip_spec: str = DEFAULT_SYNTH_PIP_SPEC
-
-    def validate(self) -> None:
-        """Lightweight validation before provisioning."""
-        if not self.repo_url:
-            raise ValueError("repo_url is required")
-        if not self.agent_instructions:
-            raise ValueError("agent_instructions is required")
-        if not self.base_image:
-            raise ValueError("base_image is required")
-        if not self.artifacts_dir.is_absolute():
-            raise ValueError("artifacts_dir must be absolute")
-
-    @property
-    def build_args(self) -> Dict[str, str]:
-        """Build args passed to Docker/Modal image creation."""
-        return {
-            "GIT_URL": self.repo_url,
-            "GIT_BRANCH": self.repo_branch,
-            "GIT_COMMIT": self.repo_commit or "",
-            "PYTHON_VERSION": self.python_version,
-            "SYNTH_PIP_SPEC": self.synth_pip_spec or "",
-        }
-
-    def to_dockerfile(self) -> str:
-        """Render a Dockerfile that mirrors the existing OneShot bootstrap."""
-        package_line = " ".join(sorted(set(self.apt_packages)))
-        return textwrap.dedent(
-            f"""
-            FROM {self.base_image}
-
-            ARG GIT_URL
-            ARG GIT_BRANCH
-            ARG GIT_COMMIT
-            ARG PYTHON_VERSION="{self.python_version}"
-
-            ENV DEBIAN_FRONTEND=noninteractive
-            ENV PIP_DISABLE_PIP_VERSION_CHECK=1
-            ENV PIP_NO_PYTHON_VERSION_WARNING=1
-            ENV PIP_BREAK_SYSTEM_PACKAGES=1
-            ENV PYTHONWARNINGS=ignore
-
-            RUN apt-get update && \\
-                apt-get install -y --no-install-recommends {package_line} && \\
-                ln -sf /usr/bin/python3 /usr/bin/python && \\
-                mkdir -p {self.artifacts_dir} /app/overlay_files && \\
-                apt-get clean
-
-            # Install uv for fast Python installs
-            RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \\
-                ln -sf /root/.local/bin/uv /usr/local/bin/uv || true
-
-            WORKDIR /app
-            RUN git clone --branch "$GIT_BRANCH" "$GIT_URL" repo && \\
-                cd repo && if [ -n "$GIT_COMMIT" ]; then git checkout "$GIT_COMMIT"; fi && \\
-                python3 -m venv /app/repo/.venv && \\
-                . /app/repo/.venv/bin/activate && \\
-                pip install --no-cache-dir --upgrade pip && \\
-                if [ -n "$SYNTH_PIP_SPEC" ]; then \\
-                  pip install --no-cache-dir "$SYNTH_PIP_SPEC"; \\
-                else \\
-                  pip install --no-cache-dir -e .; \\
-                fi
-            ENV VIRTUAL_ENV="/app/repo/.venv"
-            ENV PATH="/app/repo/.venv/bin:${{PATH}}"
-
-            COPY overlay_files/ /app/
-
-            WORKDIR {self.workdir}
-            """
-        ).strip() + "\n"
-
-    def rendered_overlay_files(self) -> Dict[str, bytes]:
-        """Overlay files placed into the build context / runtime container."""
-        files: Dict[str, bytes] = {}
-
-        if self.overlay_dir and self.overlay_dir.exists():
-            for path in self.overlay_dir.rglob("*"):
-                if path.is_dir():
-                    continue
-                rel_path = path.relative_to(self.overlay_dir)
-                files.setdefault(str(rel_path), path.read_bytes())
-
-        if self.agent_instructions:
-            files["LM_INSTRUCTIONS.md"] = self.agent_instructions.encode()
-
-        if self.preflight_script:
-            files["overlay_hidden_pre/preflight.sh"] = self.preflight_script.encode()
-            files["pre_flight.sh"] = self.preflight_script.encode()
-        if self.postflight_script:
-            files["overlay_hidden_post/postflight.sh"] = self.postflight_script.encode()
-
-        for relative_path, content in self.files.items():
-            data = content.encode() if isinstance(content, str) else content
-            files[str(relative_path)] = data
-
-        files.setdefault("box_bootstrap.sh", self.bootstrap_content.encode())
-
-        return files
-
-    def build_context(self) -> bytes:
-        """Create a tar build context for Docker builds."""
-        import tarfile
-
-        buf = io.BytesIO()
-        with tarfile.open(fileobj=buf, mode="w") as tar:
-            dockerfile_bytes = self.to_dockerfile().encode()
-            dockerfile_info = tarfile.TarInfo("Dockerfile")
-            dockerfile_info.size = len(dockerfile_bytes)
-            dockerfile_info.mtime = int(time.time())
-            tar.addfile(dockerfile_info, io.BytesIO(dockerfile_bytes))
-
-            for rel_path, content in self.rendered_overlay_files().items():
-                overlay_path = Path("overlay_files") / rel_path
-                executable = overlay_path.name.endswith(".sh")
-                info = tarfile.TarInfo(str(overlay_path))
-                info.size = len(content)
-                info.mtime = int(time.time())
-                if executable:
-                    info.mode = 0o755
-                tar.addfile(info, io.BytesIO(content))
-
-            for rel_path, content in self.files.items():
-                if str(rel_path).startswith("/"):
-                    data = content.encode() if isinstance(content, str) else content
-                    target = Path(str(rel_path).lstrip("/"))
-                    info = tarfile.TarInfo(str(target))
-                    info.size = len(data)
-                    info.mtime = int(time.time())
-                    if target.name.endswith(".sh"):
-                        info.mode = 0o755
-                    tar.addfile(info, io.BytesIO(data))
-
-        buf.seek(0)
-        return buf.read()
-
-    def result_matchers(self) -> Iterable[str]:
-        """Expose patterns for callers that only need read-only access."""
-        return tuple(self.result_patterns)

synth_ai/sdk/research_agent/defaults.py

@@ -1,34 +0,0 @@
-"""Defaults and shared constants for the research agent (library side)."""
-
-from __future__ import annotations
-
-DEFAULT_INSTRUCTIONS = "Run baseline, then optimize prompt with configured optimizer."
-DEFAULT_MODEL = "gpt-4o-mini"
-DEFAULT_REASONING_EFFORT = "medium"
-
-DEFAULT_BACKEND = "docker"
-DEFAULT_BASE_IMAGE = "ubuntu:24.04"
-DEFAULT_PYTHON_VERSION = "3.11"
-DEFAULT_PACKAGES = (
-    "git",
-    "curl",
-    "build-essential",
-    "cmake",
-    "ninja-build",
-    "pkg-config",
-    "python3",
-    "python3-venv",
-    "python3-pip",
-    "ca-certificates",
-    "jq",
-)
-
-DEFAULT_RESULT_PATTERNS = (
-    "*.json",
-    "*.log",
-    "*.md",
-    "*.toml",
-    "diff.patch",
-)
-
-DEFAULT_SYNTH_PIP_SPEC = "synth-ai==0.2.26.dev1"

synth_ai/sdk/research_agent/results_collector.py

@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-import json
-from datetime import UTC, datetime
-from pathlib import Path
-from typing import Dict, Iterable
-
-from synth_ai.sdk.research_agent.container_builder import ContainerBackend
-
-
-class ResultsCollector:
-    """Collect and persist artifacts from a container run."""
-
-    def __init__(self, output_dir: Path):
-        self.output_dir = output_dir
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-
-    async def collect_from_container(
-        self,
-        backend: ContainerBackend,
-        container_id: str,
-        patterns: Iterable[str],
-    ) -> Dict[str, Path]:
-        """Fetch artifacts via the backend and write them to disk."""
-        artifacts = await backend.collect_artifacts(container_id, patterns)
-        saved: Dict[str, Path] = {}
-        for name, content in artifacts.items():
-            path = self.output_dir / Path(name).name
-            path.write_bytes(content)
-            saved[name] = path
-        return saved
-
-    def create_manifest(self, saved_files: Dict[str, Path]) -> Path:
-        """Create a manifest describing collected artifacts."""
-        manifest = {
-            "files": [
-                {
-                    "name": name,
-                    "path": str(path.relative_to(self.output_dir)),
-                    "size_bytes": path.stat().st_size,
-                    "type": self._classify_file(name),
-                }
-                for name, path in saved_files.items()
-            ],
-            "collected_at": datetime.now(UTC).isoformat(),
-            "total_size_bytes": sum(path.stat().st_size for path in saved_files.values()),
-        }
-        manifest_path = self.output_dir / "manifest.json"
-        manifest_path.write_text(json.dumps(manifest, indent=2))
-        return manifest_path
-
-    def _classify_file(self, filename: str) -> str:
-        """Coarse file typing to make downstream filtering simpler."""
-        lowered = filename.lower()
-        if lowered.endswith(".json"):
-            if "result" in lowered or "metric" in lowered:
-                return "metrics"
-            if "config" in lowered:
-                return "config"
-            return "data"
-        if lowered.endswith(".log"):
-            return "logs"
-        if lowered.endswith(".md"):
-            return "documentation"
-        if lowered.endswith((".toml", ".yaml", ".yml")):
-            return "config"
-        if lowered == "diff.patch":
-            return "code_changes"
-        return "other"

synth_ai/sdk/specs/__init__.py

@@ -1,46 +0,0 @@
-"""System specification abstractions for synth-ai.
-
-Provides hierarchical specification format inspired by Sean Grove's "spec as code" pattern.
-Specs encode intent, policies, and rules as versioned, testable artifacts.
-"""
-
-from synth_ai.sdk.specs.dataclasses import (
-    Constraints,
-    Example,
-    GlossaryItem,
-    Interfaces,
-    Metadata,
-    Principle,
-    Rule,
-    Spec,
-    TestCase,
-)
-from synth_ai.sdk.specs.loader import load_spec_from_dict, load_spec_from_file
-from synth_ai.sdk.specs.serializer import spec_to_compact_context, spec_to_prompt_context
-from synth_ai.sdk.specs.validation import (
-    SpecValidationError,
-    SpecValidator,
-    validate_spec_dict,
-    validate_spec_file,
-)
-
-__all__ = [
-    "Spec",
-    "Metadata",
-    "Principle",
-    "Rule",
-    "Constraints",
-    "Example",
-    "TestCase",
-    "Interfaces",
-    "GlossaryItem",
-    "load_spec_from_file",
-    "load_spec_from_dict",
-    "spec_to_prompt_context",
-    "spec_to_compact_context",
-    "SpecValidator",
-    "SpecValidationError",
-    "validate_spec_dict",
-    "validate_spec_file",
-]
-

synth_ai/sdk/specs/dataclasses.py

@@ -1,149 +0,0 @@
-"""Dataclasses for hierarchical system specifications.
-
-Based on Sean Grove's "spec as code" pattern from AI Engineer World's Fair.
-Specs are the source of truth that encode intent, policies, and rules.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-
-@dataclass
-class Principle:
-    """A high-level principle or value that guides behavior."""
-
-    id: str
-    text: str
-    rationale: Optional[str] = None
-
-
-@dataclass
-class Example:
-    """An example demonstrating good or bad behavior."""
-
-    kind: str  # "good" | "bad"
-    prompt: str
-    response: str
-    description: Optional[str] = None
-
-
-@dataclass
-class TestCase:
-    """A test case to verify adherence to a rule."""
-
-    id: str
-    challenge: str
-    asserts: List[str] = field(default_factory=list)
-    expected_behavior: Optional[str] = None
-
-
-@dataclass
-class Constraints:
-    """Positive and negative constraints for a rule."""
-
-    must: List[str] = field(default_factory=list)
-    must_not: List[str] = field(default_factory=list)
-    should: List[str] = field(default_factory=list)
-    should_not: List[str] = field(default_factory=list)
-
-
-@dataclass
-class Rule:
-    """A specific policy or rule with constraints, examples, and tests."""
-
-    id: str
-    title: str
-    rationale: Optional[str] = None
-    constraints: Constraints = field(default_factory=Constraints)
-    examples: List[Example] = field(default_factory=list)
-    tests: List[TestCase] = field(default_factory=list)
-    priority: Optional[int] = None  # Higher = more important
-
-
-@dataclass
-class Metadata:
-    """Metadata about the specification."""
-
-    id: str
-    title: str
-    version: str
-    owner: Optional[str] = None
-    created_at: Optional[str] = None
-    updated_at: Optional[str] = None
-    imports: List[str] = field(default_factory=list)
-    scope: Optional[str] = None
-    description: Optional[str] = None
-
-
-@dataclass
-class Interfaces:
-    """Interface definitions for the system."""
-
-    io_modes: List[str] = field(default_factory=list)
-    capabilities: List[str] = field(default_factory=list)
-    constraints: Optional[Dict[str, Any]] = None
-
-
-@dataclass
-class GlossaryItem:
-    """A term definition in the glossary."""
-
-    term: str
-    definition: str
-    aliases: List[str] = field(default_factory=list)
-
-
-@dataclass
-class Spec:
-    """A complete system specification.
-    
-    Hierarchical structure:
-    - Metadata (versioning, ownership, imports)
-    - Principles (high-level values)
-    - Rules (specific policies with constraints, examples, tests)
-    - Interfaces (capabilities, modes)
-    - Glossary (domain terminology)
-    - Changelog (version history)
-    """
-
-    metadata: Metadata
-    principles: List[Principle] = field(default_factory=list)
-    rules: List[Rule] = field(default_factory=list)
-    interfaces: Interfaces = field(default_factory=Interfaces)
-    glossary: List[GlossaryItem] = field(default_factory=list)
-    changelog: List[Dict[str, Any]] = field(default_factory=list)
-
-    def get_rule(self, rule_id: str) -> Optional[Rule]:
-        """Get a rule by ID."""
-        for rule in self.rules:
-            if rule.id == rule_id:
-                return rule
-        return None
-
-    def get_principle(self, principle_id: str) -> Optional[Principle]:
-        """Get a principle by ID."""
-        for principle in self.principles:
-            if principle.id == principle_id:
-                return principle
-        return None
-
-    def get_glossary_term(self, term: str) -> Optional[GlossaryItem]:
-        """Get a glossary item by term or alias."""
-        term_lower = term.lower()
-        for item in self.glossary:
-            if item.term.lower() == term_lower:
-                return item
-            if any(alias.lower() == term_lower for alias in item.aliases):
-                return item
-        return None
-
-    def get_high_priority_rules(self, min_priority: int = 8) -> List[Rule]:
-        """Get rules with priority >= min_priority."""
-        return [
-            rule for rule in self.rules
-            if rule.priority is not None and rule.priority >= min_priority
-        ]
-
-

synth_ai/sdk/specs/loader.py

@@ -1,144 +0,0 @@
-"""Loaders for system specifications from JSON files."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any, Dict
-
-from synth_ai.sdk.specs.dataclasses import (
-    Constraints,
-    Example,
-    GlossaryItem,
-    Interfaces,
-    Metadata,
-    Principle,
-    Rule,
-    Spec,
-    TestCase,
-)
-
-
-def load_spec_from_dict(data: Dict[str, Any]) -> Spec:
-    """Load a Spec from a dictionary.
-    
-    Args:
-        data: Dictionary representation of a spec
-        
-    Returns:
-        Spec instance
-    """
-    # Load metadata
-    metadata_dict = data["metadata"]
-    md = Metadata(
-        id=metadata_dict["id"],
-        title=metadata_dict["title"],
-        version=metadata_dict["version"],
-        owner=metadata_dict.get("owner"),
-        created_at=metadata_dict.get("created_at"),
-        updated_at=metadata_dict.get("updated_at"),
-        imports=metadata_dict.get("imports", []),
-        scope=metadata_dict.get("scope"),
-        description=metadata_dict.get("description"),
-    )
-    
-    # Load principles
-    principles = [
-        Principle(
-            id=p["id"],
-            text=p["text"],
-            rationale=p.get("rationale"),
-        )
-        for p in data.get("principles", [])
-    ]
-    
-    # Load rules
-    def load_rule(r: Dict[str, Any]) -> Rule:
-        constraints_data = r.get("constraints", {})
-        constraints = Constraints(**constraints_data)
-        
-        examples_data = r.get("examples", [])
-        examples = [
-            Example(
-                kind=e["kind"],
-                prompt=e["prompt"],
-                response=e["response"],
-                description=e.get("description"),
-            )
-            for e in examples_data
-        ]
-        
-        tests_data = r.get("tests", [])
-        tests = [
-            TestCase(
-                id=t["id"],
-                challenge=t["challenge"],
-                asserts=t.get("asserts", []),
-                expected_behavior=t.get("expected_behavior"),
-            )
-            for t in tests_data
-        ]
-        
-        return Rule(
-            id=r["id"],
-            title=r["title"],
-            rationale=r.get("rationale"),
-            constraints=constraints,
-            examples=examples,
-            tests=tests,
-            priority=r.get("priority"),
-        )
-    
-    rules = [load_rule(r) for r in data.get("rules", [])]
-    
-    # Load interfaces
-    interfaces_data = data.get("interfaces", {})
-    interfaces = Interfaces(**interfaces_data)
-    
-    # Load glossary
-    glossary = [
-        GlossaryItem(
-            term=g["term"],
-            definition=g["definition"],
-            aliases=g.get("aliases", []),
-        )
-        for g in data.get("glossary", [])
-    ]
-    
-    # Load changelog
-    changelog = data.get("changelog", [])
-    
-    return Spec(
-        metadata=md,
-        principles=principles,
-        rules=rules,
-        interfaces=interfaces,
-        glossary=glossary,
-        changelog=changelog,
-    )
-
-
-def load_spec_from_file(path: str | Path) -> Spec:
-    """Load a Spec from a JSON file.
-    
-    Args:
-        path: Path to JSON file
-        
-    Returns:
-        Spec instance
-        
-    Raises:
-        FileNotFoundError: If file doesn't exist
-        json.JSONDecodeError: If file is not valid JSON
-    """
-    path = Path(path)
-    
-    if not path.exists():
-        raise FileNotFoundError(f"Spec file not found: {path}")
-    
-    with open(path, encoding="utf-8") as f:
-        data = json.load(f)
-    
-    return load_spec_from_dict(data)
-
-