symphony-linear 0.1.0__py3-none-any.whl

symphony_linear/__init__.py

@@ -0,0 +1,3 @@
+"""symphony-lite: AI-powered ticket orchestration daemon."""
+
+__version__ = "0.1.0"

symphony_linear/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as ``python -m symphony_linear``."""
+
+from symphony_linear.cli import main
+
+main()

symphony_linear/cli.py

@@ -0,0 +1,85 @@
+"""CLI entry-point for ``symphony-linear``."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from pathlib import Path
+
+from symphony_linear.config import AppConfig, load_config
+from symphony_linear.linear import LinearClient
+from symphony_linear.logging import get_logger, setup_logging
+from symphony_linear.orchestrator import Orchestrator
+from symphony_linear.state import load_state
+
+logger = get_logger(__name__)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="symphony-linear",
+        description="AI-powered ticket orchestration daemon",
+    )
+    parser.add_argument(
+        "--workspace",
+        type=str,
+        default=None,
+        help="Path to workspace directory (default: current working directory). "
+        "Expects config.yaml and state.json inside this directory.",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug-level logging",
+    )
+    parser.add_argument(
+        "--validate-config",
+        action="store_true",
+        help="Load and validate the config file, then exit",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Entry point for the ``symphony-linear`` CLI."""
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    setup_logging(debug=args.debug)
+
+    workspace = (
+        Path(args.workspace).expanduser().resolve()
+        if args.workspace
+        else Path.cwd().resolve()
+    )
+
+    try:
+        config: AppConfig = load_config(workspace)
+    except FileNotFoundError:
+        config_path = workspace / "config.yaml"
+        print(
+            f"Config file not found: {config_path}\n"
+            f"Create a config.yaml file in {workspace} with the required settings.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    except ValueError as exc:
+        logger.error("Config error: %s", exc)
+        sys.exit(1)
+
+    if args.validate_config:
+        logger.info("Config is valid.")
+        logger.info("  workspace       = %s", workspace)
+        logger.info("  poll_interval   = %s s", config.poll_interval_seconds)
+        return
+
+    # Load state and create the Linear client.
+    state = load_state(workspace)
+    linear = LinearClient(api_key=config.linear.api_key)
+
+    # Create and run the orchestrator daemon.
+    orchestrator = Orchestrator(
+        config=config, state=state, linear=linear, workspace=workspace
+    )
+    orchestrator.run()

symphony_linear/config.py

@@ -0,0 +1,198 @@
+"""Typed configuration loader for symphony-lite.
+
+Reads YAML from ``<workspace_dir>/config.yaml``, validates with Pydantic v2,
+and expands ``~`` / ``$VAR`` references in string values.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, ConfigDict, Field, ValidationError, model_validator
+
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_HIDE_PATHS: list[str] = [
+    "~/.ssh",
+    "~/.gnupg",
+    "~/.aws",
+    "~/.config/gcloud",
+    "~/.netrc",
+    "~/.docker",
+    # Docker socket (real path; /var/run is a symlink to /run on most systems)
+    "/run/docker.sock",
+]
+
+
+# ---------------------------------------------------------------------------
+# Helpers: env-var / tilde expansion
+# ---------------------------------------------------------------------------
+
+_VAR_RE = re.compile(r"\$\{?(\w+)\}?")
+
+
+def _expand(value: str) -> str:
+    """Expand ``~`` and ``$VAR`` / ``${VAR}`` references in *value*."""
+    # Tilde expansion
+    if value.startswith("~") and (len(value) == 1 or value[1] in ("/", os.sep)):
+        value = str(Path(value).expanduser())
+
+    # Env-var expansion
+    def _sub(m: re.Match[str]) -> str:
+        return os.environ.get(m.group(1), "")
+
+    return _VAR_RE.sub(_sub, value)
+
+
+def _expand_values(obj: Any) -> Any:
+    """Recursively expand env vars in every string inside *obj*."""
+    if isinstance(obj, str):
+        return _expand(obj)
+    if isinstance(obj, dict):
+        return {k: _expand_values(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_expand_values(v) for v in obj]
+    return obj
+
+
+# ---------------------------------------------------------------------------
+# Pydantic sub-models
+# ---------------------------------------------------------------------------
+
+
+class _LinearConfig(BaseModel):
+    api_key: str = Field(..., description="Linear API key (bearer token)")
+    trigger_label: str = Field("agent", description="Label that triggers the bot")
+    in_progress_state: str = Field(
+        "In Progress", description="Linear state for active work"
+    )
+    needs_input_state: str = Field(
+        "Needs Input", description="Linear state when input is needed"
+    )
+    qa_state: str | None = Field(
+        None,
+        description="Optional Linear state for QA; polled in addition to in_progress and needs_input",
+    )
+    bot_user_email: str = Field(..., description="Email of the bot user in Linear")
+
+
+class _SandboxConfig(BaseModel):
+    hide_paths: list[str] = Field(
+        default_factory=lambda: list(DEFAULT_HIDE_PATHS),
+        description="Paths to conceal inside the sandbox",
+    )
+    extra_rw_paths: list[str] = Field(
+        default_factory=list,
+        description="Additional host paths to bind read-write inside the sandbox",
+    )
+
+
+class AppConfig(BaseModel):
+    """Top-level application configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    linear: _LinearConfig
+    sandbox: _SandboxConfig = Field(default_factory=_SandboxConfig)
+    poll_interval_seconds: int = Field(
+        30, gt=0, description="Seconds between Linear poll cycles"
+    )
+    turn_timeout_seconds: int = Field(1800, gt=0, description="Max seconds per AI turn")
+    auto_branch: bool = Field(
+        True,
+        description=(
+            "If true (default), switch the workspace to a per-ticket branch "
+            "during prepare() — Linear's branchName, or symphony/<id> as "
+            "fallback. If false, no branch switch runs and the workspace "
+            "stays on whatever git clone checked out (the remote default "
+            "branch). Useful when the agent commits straight to the default "
+            "branch and pushes are handled outside Symphony's scope."
+        ),
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def _drop_null_subconfigs(cls, data: Any) -> Any:
+        # YAML keys with empty values (e.g. `sandbox:` on its own line) parse
+        # as ``None``. For sub-config fields that have a default, treat ``None``
+        # as "use the default" rather than failing validation.
+        if isinstance(data, dict):
+            if "sandbox" in data and data["sandbox"] is None:
+                del data["sandbox"]
+        return data
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def load_config(workspace_dir: Path) -> AppConfig:
+    """Load, expand, and validate the application configuration.
+
+    Args:
+        workspace_dir: Path to the workspace directory containing
+            ``config.yaml``.
+
+    Returns:
+        A fully-validated ``AppConfig`` instance.
+
+    Raises:
+        FileNotFoundError: The config file does not exist.
+        ValueError: The config file contains invalid YAML or fails validation.
+    """
+    path = workspace_dir / "config.yaml"
+
+    if not path.exists():
+        raise FileNotFoundError(
+            f"Config file not found: {path}. "
+            f"Create a config.yaml file in {workspace_dir} with the required settings."
+        )
+
+    try:
+        raw = yaml.safe_load(path.read_text())
+    except yaml.YAMLError as exc:
+        raise ValueError(f"Invalid YAML in {path}: {exc}") from exc
+
+    if raw is None:
+        raise ValueError(f"Config file is empty: {path}")
+
+    expanded = _expand_values(raw)
+
+    # LINEAR_API_KEY environment variable fallback: if linear.api_key is
+    # missing or empty in the YAML, fall back to the LINEAR_API_KEY env var.
+    if isinstance(expanded, dict):
+        linear = expanded.setdefault("linear", {})
+        if isinstance(linear, dict) and not linear.get("api_key", ""):
+            env_key = os.environ.get("LINEAR_API_KEY", "")
+            if env_key:
+                linear["api_key"] = env_key
+            else:
+                raise ValueError(
+                    f"Linear API key not set. Provide it in {path} "
+                    f"(linear.api_key) or via the LINEAR_API_KEY "
+                    f"environment variable."
+                )
+
+    try:
+        return AppConfig.model_validate(expanded)
+    except ValidationError as exc:
+        # Re-raise with a friendlier message that includes the file path.
+        msg = f"Config validation failed for {path}:\n{_format_errors(exc)}"
+        raise ValueError(msg) from exc
+
+
+def _format_errors(exc: ValidationError) -> str:
+    """Format Pydantic validation errors into a readable multi-line string."""
+    lines: list[str] = []
+    for err in exc.errors():
+        loc = " -> ".join(str(part) for part in err["loc"])
+        lines.append(f"  {loc}: {err['msg']}")
+    return "\n".join(lines)