python-yama 0.1.0__py3-none-any.whl

yama/workspace.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_CASE_PATTERNS = [
+    "__evals__/cases/**/*.yaml",
+    "__evals__/cases/**/*.yml",
+]
+
+
+class ConfigurationError(ValueError):
+    pass
+
+
+@dataclass
+class WorkspaceConfig:
+    root: Path
+    config_path: Path | None = None
+    case_patterns: list[str] = field(
+        default_factory=lambda: list(DEFAULT_CASE_PATTERNS)
+    )
+    result_dir: str = ".yama/runs"
+    defaults: dict[str, Any] = field(
+        default_factory=lambda: {
+            "model": {"name": "gpt-5", "temperature": 0},
+            "execution": {
+                "timeout_seconds_per_step": 120,
+                "max_tool_rounds_per_step": 10,
+                "repeat": 1,
+            },
+        }
+    )
+    plugins: dict[str, dict[str, Any]] = field(default_factory=dict)
+
+
+def find_workspace_config(start: Path) -> Path | None:
+    current = start.resolve()
+    for directory in (current, *current.parents):
+        candidate = directory / "yama.toml"
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def load_workspace_config(start: Path) -> WorkspaceConfig:
+    path = find_workspace_config(start)
+    if path is None:
+        return WorkspaceConfig(root=start.resolve())
+    with path.open("rb") as handle:
+        raw = tomllib.load(handle)
+    workspace = raw.get("workspace", {})
+    defaults = raw.get("defaults", {})
+    merged_defaults = WorkspaceConfig(root=path.parent).defaults
+    for section in ("model", "execution"):
+        merged_defaults[section].update(defaults.get(section, {}))
+    return WorkspaceConfig(
+        root=path.parent.resolve(),
+        config_path=path,
+        case_patterns=list(workspace.get("case_patterns", DEFAULT_CASE_PATTERNS)),
+        result_dir=workspace.get("result_dir", ".yama/runs"),
+        defaults=merged_defaults,
+        plugins=dict(raw.get("plugins", {})),
+    )
+
+
+def resolve_plugin_root(
+    config: WorkspaceConfig,
+    *,
+    explicit_root: Path | None = None,
+    plugin_name: str | None = None,
+) -> tuple[Path, dict[str, Any]]:
+    if explicit_root is not None:
+        root = explicit_root.resolve()
+        plugin = {}
+    elif plugin_name is not None:
+        if plugin_name not in config.plugins:
+            raise ConfigurationError(f"unknown plugin: {plugin_name}")
+        plugin = config.plugins[plugin_name]
+        root = (config.root / plugin["path"]).resolve()
+    else:
+        root = config.root
+        plugin = {}
+    if not root.is_dir():
+        raise ConfigurationError(f"plugin root does not exist: {root}")
+    system_path = root / plugin.get("system_prompt", "SYSTEM.md")
+    if not system_path.is_file():
+        raise ConfigurationError(f"system prompt does not exist: {system_path}")
+    return root, plugin
+
+
+def collect_case_paths(
+    plugin_root: Path,
+    workspace: WorkspaceConfig,
+    plugin_config: dict[str, Any],
+    explicit_paths: list[Path] | None = None,
+) -> list[Path]:
+    if explicit_paths:
+        paths = [
+            (path if path.is_absolute() else Path.cwd() / path).resolve()
+            for path in explicit_paths
+        ]
+    else:
+        patterns = plugin_config.get("case_patterns", workspace.case_patterns)
+        paths = []
+        for pattern in patterns:
+            paths.extend(plugin_root.glob(pattern))
+        paths = sorted(set(path.resolve() for path in paths))
+    missing = [path for path in paths if not path.is_file()]
+    if missing:
+        raise ConfigurationError(f"case file does not exist: {missing[0]}")
+    return paths