runsight 0.1.0__tar.gz

runsight-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+dist/
+src/runsight_api/static/

runsight-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: runsight
+Version: 0.1.0
+Summary: YAML-first workflow engine for AI agents
+Requires-Python: >=3.11
+Requires-Dist: alembic>=1.14.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: ruamel-yaml>=0.18.0
+Requires-Dist: runsight-core
+Requires-Dist: sqlmodel>=0.0.24
+Requires-Dist: structlog>=24.0.0
+Requires-Dist: uvicorn[standard]>=0.34.0
+Provides-Extra: dev
+Requires-Dist: httpx>=0.28.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'

runsight-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "runsight"
+version = "0.1.0"
+description = "YAML-first workflow engine for AI agents"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.34.0",
+    "sqlmodel>=0.0.24",
+    "alembic>=1.14.0",
+    "pyyaml>=6.0",
+    "ruamel.yaml>=0.18.0",
+    "runsight-core",
+    "pydantic-settings>=2.0",
+    "httpx>=0.28.0",
+    "structlog>=24.0.0",
+]
+
+[project.scripts]
+runsight = "runsight_api.cli:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24.0",
+    "httpx>=0.28.0",
+    "ruff>=0.8.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/runsight_api"]
+artifacts = ["src/runsight_api/static/**"]
+exclude = ["**/*.db"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/test_run134_openapi_codegen.py" = ["F401"]
+
+[tool.ruff.format]
+quote-style = "double"
+exclude = ["tests/test_run134_openapi_codegen.py"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_mode = "auto"

runsight-0.1.0/src/runsight_api/alembic/env.py

@@ -0,0 +1,65 @@
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+from sqlmodel import SQLModel
+
+from runsight_api.domain.entities.log import LogEntry  # noqa: F401
+
+# Import all models so SQLModel.metadata is populated
+from runsight_api.domain.entities.run import Run, RunNode  # noqa: F401
+
+config = context.config
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = SQLModel.metadata
+
+# Naming convention for constraints (helps with batch mode migrations)
+NAMING_CONVENTION = {
+    "ix": "ix_%(column_0_label)s",
+    "uq": "uq_%(table_name)s_%(column_0_name)s",
+    "ck": "ck_%(table_name)s_%(constraint_name)s",
+    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+    "pk": "pk_%(table_name)s",
+}
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode."""
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        render_as_batch=True,
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode."""
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            render_as_batch=True,
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

runsight-0.1.0/src/runsight_api/alembic/script.py.mako

@@ -0,0 +1,27 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

runsight-0.1.0/src/runsight_api/alembic/versions/001_initial_schema.py

@@ -0,0 +1,29 @@
+"""Initial schema — baseline migration.
+
+Revision ID: 001_initial
+Revises: None
+Create Date: 2026-03-22
+"""
+
+from typing import Sequence, Union
+
+import sqlmodel
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "001_initial"
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Create all tables from SQLModel metadata."""
+    bind = op.get_bind()
+    sqlmodel.SQLModel.metadata.create_all(bind)
+
+
+def downgrade() -> None:
+    """Drop all tables from SQLModel metadata."""
+    bind = op.get_bind()
+    sqlmodel.SQLModel.metadata.drop_all(bind)

runsight-0.1.0/src/runsight_api/alembic.ini

@@ -0,0 +1,36 @@
+[alembic]
+script_location = alembic
+sqlalchemy.url = sqlite:///./runsight.db
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

runsight-0.1.0/src/runsight_api/cli.py

@@ -0,0 +1,39 @@
+"""CLI entry point for `uvx runsight` / `runsight` command."""
+
+import sys
+
+import uvicorn
+
+
+def main() -> None:
+    # Parse --host and --port from argv (keep it minimal)
+    host = "0.0.0.0"
+    port = 8000
+
+    args = sys.argv[1:]
+    i = 0
+    while i < len(args):
+        if args[i] == "--port" and i + 1 < len(args):
+            port = int(args[i + 1])
+            i += 2
+        elif args[i] == "--host" and i + 1 < len(args):
+            host = args[i + 1]
+            i += 2
+        elif args[i] in ("--help", "-h"):
+            print("Usage: runsight [--host HOST] [--port PORT]")
+            print()
+            print("Start the Runsight server.")
+            print()
+            print("Options:")
+            print("  --host HOST  Bind address (default: 0.0.0.0)")
+            print("  --port PORT  Bind port (default: 8000)")
+            sys.exit(0)
+        else:
+            print(f"Unknown argument: {args[i]}", file=sys.stderr)
+            sys.exit(1)
+
+    print(f"  Runsight running at http://localhost:{port}")
+    print("  Press Ctrl+C to stop")
+    print()
+
+    uvicorn.run("runsight_api.main:app", host=host, port=port)

runsight-0.1.0/src/runsight_api/core/config.py

@@ -0,0 +1,76 @@
+import logging
+from pathlib import Path
+from typing import List
+
+from pydantic import Field, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from .project import resolve_base_path
+
+_DB_URL_SENTINEL = "__auto__"
+
+logger = logging.getLogger(__name__)
+
+
+def _default_base_path() -> str:
+    """Compute the default base_path using project detection.
+
+    If ``RUNSIGHT_BASE_PATH`` is set, pydantic-settings will use it directly
+    and this default is never called.  Otherwise we run the marker / auto-detect
+    logic.
+    """
+    return resolve_base_path(env_value=None)
+
+
+def _parse_cors_origins(raw: str) -> List[str]:
+    """Parse a comma-separated string into a list of origin URLs."""
+    return [origin.strip() for origin in raw.split(",")]
+
+
+class Settings(BaseSettings):
+    base_path: str = Field(default_factory=_default_base_path)
+    db_url: str = _DB_URL_SENTINEL
+    debug: bool = False
+    host: str = "0.0.0.0"
+    port: int = 8000
+    cors_origins: str = "http://localhost:5173"
+    log_level: str = "INFO"
+    log_format: str = "json"
+
+    model_config = SettingsConfigDict(env_prefix="RUNSIGHT_")
+
+    @model_validator(mode="after")
+    def _resolve_db_url(self) -> "Settings":
+        if self.db_url == _DB_URL_SENTINEL:
+            db_path = Path(self.base_path).resolve() / ".runsight" / "runsight.db"
+            object.__setattr__(self, "db_url", f"sqlite:///{db_path}")
+        return self
+
+    @model_validator(mode="after")
+    def _split_cors_origins(self) -> "Settings":
+        raw = self.cors_origins
+        if isinstance(raw, str):
+            object.__setattr__(self, "cors_origins", _parse_cors_origins(raw))
+        return self
+
+
+def ensure_project_dirs(settings: Settings) -> None:
+    """Ensure the custom/workflows/, .canvas/, and .runsight/ directories exist.
+
+    Called once at application startup. Resolves base_path to an absolute
+    path and logs the result.  Creates missing directories as needed.
+    """
+    resolved = Path(settings.base_path).resolve()
+    logger.info("Runsight base_path resolved to: %s", resolved)
+
+    workflows_dir = resolved / "custom" / "workflows"
+    canvas_dir = workflows_dir / ".canvas"
+    runsight_dir = resolved / ".runsight"
+
+    for d in (workflows_dir, canvas_dir, runsight_dir):
+        if not d.exists():
+            d.mkdir(parents=True, exist_ok=True)
+            logger.info("Created missing directory: %s", d)
+
+
+settings = Settings()

runsight-0.1.0/src/runsight_api/core/context.py

@@ -0,0 +1,47 @@
+"""ContextVars for request/execution tracing, bridged to structlog."""
+
+import sys
+from contextvars import ContextVar
+
+import structlog
+
+request_id: ContextVar[str] = ContextVar("request_id", default="")
+run_id: ContextVar[str] = ContextVar("run_id", default="")
+block_id: ContextVar[str] = ContextVar("block_id", default="")
+workflow_name: ContextVar[str] = ContextVar("workflow_name", default="")
+
+# Keep references that won't be shadowed by parameter names
+_module = sys.modules[__name__]
+
+
+def bind_request_context(rid: str) -> None:
+    """Set request_id in both ContextVar and structlog context."""
+    request_id.set(rid)
+    structlog.contextvars.bind_contextvars(request_id=rid)
+
+
+def bind_execution_context(*, run_id: str, workflow_name: str) -> None:
+    """Set run_id and workflow_name in both ContextVar and structlog context."""
+    getattr(_module, "run_id").set(run_id)
+    getattr(_module, "workflow_name").set(workflow_name)
+    structlog.contextvars.bind_contextvars(run_id=run_id, workflow_name=workflow_name)
+
+
+def bind_block_context(bid: str) -> None:
+    """Set block_id in both ContextVar and structlog context."""
+    block_id.set(bid)
+    structlog.contextvars.bind_contextvars(block_id=bid)
+
+
+def clear_block_context() -> None:
+    """Reset block_id but leave execution context intact."""
+    block_id.set("")
+    structlog.contextvars.unbind_contextvars("block_id")
+
+
+def clear_execution_context() -> None:
+    """Reset run_id, workflow_name, and block_id."""
+    run_id.set("")
+    workflow_name.set("")
+    block_id.set("")
+    structlog.contextvars.unbind_contextvars("run_id", "workflow_name", "block_id")

runsight-0.1.0/src/runsight_api/core/di.py

@@ -0,0 +1,25 @@
+from sqlmodel import create_engine
+
+from .config import settings
+
+# SQLite :memory: needs check_same_thread=False for TestClient/async usage
+connect_args = {}
+if ":memory:" in settings.db_url:
+    connect_args["check_same_thread"] = False
+
+engine = create_engine(
+    settings.db_url,
+    echo=settings.debug,
+    connect_args=connect_args if connect_args else {},
+)
+
+
+class Container:
+    def __init__(self):
+        self.engine = engine
+
+    def setup_app_state(self, app):
+        pass
+
+
+container = Container()

runsight-0.1.0/src/runsight_api/core/logging.py

@@ -0,0 +1,62 @@
+"""Structured logging configuration using structlog + stdlib bridge."""
+
+import logging
+import sys
+
+import structlog
+
+
+def configure_logging(log_level: str, log_format: str) -> None:
+    """Configure structlog with JSON or console rendering and stdlib bridge.
+
+    Args:
+        log_level: Python log level name (e.g. "INFO", "DEBUG").
+        log_format: "json" for machine-readable output, "text" for human-readable.
+    """
+    timestamper = structlog.processors.TimeStamper(fmt="iso")
+
+    shared_processors: list[structlog.types.Processor] = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.add_logger_name,
+        timestamper,
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+    ]
+
+    if log_format == "json":
+        renderer: structlog.types.Processor = structlog.processors.JSONRenderer()
+    else:
+        renderer = structlog.dev.ConsoleRenderer()
+
+    # Configure structlog to route through stdlib logging
+    structlog.configure(
+        processors=[
+            *shared_processors,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=False,
+    )
+
+    # Configure stdlib logging with structlog formatter
+    formatter = structlog.stdlib.ProcessorFormatter(
+        processors=[
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            renderer,
+        ],
+        foreign_pre_chain=shared_processors,
+    )
+
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(formatter)
+
+    root_logger = logging.getLogger()
+    root_logger.handlers.clear()
+    root_logger.addHandler(handler)
+    root_logger.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+
+    # Suppress noisy loggers
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+    logging.getLogger("sqlalchemy.engine").setLevel(logging.WARNING)

runsight-0.1.0/src/runsight_api/core/project.py

@@ -0,0 +1,167 @@
+"""Project detection: resolve base_path from marker file or directory structure."""
+
+import logging
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+MARKER_FILE = ".runsight-project"
+MAX_WALK_DEPTH = 20
+
+
+def _parse_marker(marker_path: Path) -> Optional[str]:
+    """Parse a .runsight-project YAML file and return the resolved base_path.
+
+    Returns None if the file is invalid or missing the base_path field.
+    """
+    try:
+        text = marker_path.read_text(encoding="utf-8")
+        data = yaml.safe_load(text)
+        if not isinstance(data, dict) or "base_path" not in data:
+            logger.warning("Marker %s missing 'base_path' field, skipping", marker_path)
+            return None
+        raw = data["base_path"]
+        resolved = (marker_path.parent / raw).resolve()
+        return str(resolved)
+    except Exception:
+        logger.warning("Failed to parse marker %s, skipping", marker_path, exc_info=True)
+        return None
+
+
+def _find_marker(start: Path) -> Optional[str]:
+    """Walk up from *start* looking for a .runsight-project file.
+
+    Returns the resolved base_path string, or None.
+    """
+    current = start.resolve()
+    for _ in range(MAX_WALK_DEPTH):
+        candidate = current / MARKER_FILE
+        try:
+            found = candidate.is_file()
+        except OSError:
+            found = False
+        if found:
+            result = _parse_marker(candidate)
+            if result is not None:
+                logger.info("Found project marker at %s", candidate)
+                return result
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+def _find_custom_workflows(start: Path) -> Optional[str]:
+    """Walk up from *start* looking for a custom/workflows/ directory.
+
+    Returns the parent of ``custom/`` as base_path, or None.
+    """
+    current = start.resolve()
+    for _ in range(MAX_WALK_DEPTH):
+        try:
+            found = (current / "custom" / "workflows").is_dir()
+        except OSError:
+            found = False
+        if found:
+            logger.info("Auto-detected custom/workflows/ at %s", current)
+            return str(current)
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+def scaffold_project(base_path: Path) -> None:
+    """Create or verify the Runsight project structure at *base_path*.
+
+    Idempotent: existing files/dirs are never overwritten.
+    """
+    marker_path = base_path / MARKER_FILE
+    is_new = not marker_path.is_file()
+
+    # Marker file
+    if not marker_path.is_file():
+        marker_path.write_text(
+            yaml.dump({"version": 1, "base_path": "."}, default_flow_style=False),
+            encoding="utf-8",
+        )
+
+    # Directories
+    (base_path / "custom" / "workflows").mkdir(parents=True, exist_ok=True)
+    (base_path / "custom" / "souls").mkdir(parents=True, exist_ok=True)
+
+    # .gitignore
+    gitignore_path = base_path / ".gitignore"
+    if not gitignore_path.is_file():
+        gitignore_path.write_text(".canvas/\n.runsight/\n", encoding="utf-8")
+    else:
+        content = gitignore_path.read_text(encoding="utf-8")
+        if ".runsight/" not in content:
+            with gitignore_path.open("a", encoding="utf-8") as f:
+                if content and not content.endswith("\n"):
+                    f.write("\n")
+                f.write(".runsight/\n")
+
+    # Git init if no repo exists
+    if not (base_path / ".git").is_dir():
+        subprocess.run(["git", "init"], cwd=base_path, capture_output=True, check=True)
+        subprocess.run(
+            ["git", "config", "user.email", "runsight@localhost"],
+            cwd=base_path,
+            capture_output=True,
+            check=True,
+        )
+        subprocess.run(
+            ["git", "config", "user.name", "Runsight"],
+            cwd=base_path,
+            capture_output=True,
+            check=True,
+        )
+        subprocess.run(["git", "add", "."], cwd=base_path, capture_output=True, check=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Initial Runsight project"],
+            cwd=base_path,
+            capture_output=True,
+            check=True,
+        )
+
+    if is_new:
+        logger.info("Created new Runsight project at %s", base_path)
+    else:
+        logger.info("Found existing Runsight project at %s", base_path)
+
+
+def resolve_base_path(env_value: Optional[str] = None) -> str:
+    """Resolve the project base_path using a 4-tier priority.
+
+    1. ``RUNSIGHT_BASE_PATH`` env var (passed in as *env_value*)
+    2. ``.runsight-project`` marker file (walk up from CWD)
+    3. Auto-detect ``custom/workflows/`` directory in ancestors
+    4. CWD as last resort
+    """
+    # Tier 1: explicit env var
+    if env_value is not None:
+        logger.info("base_path from RUNSIGHT_BASE_PATH env var: %s", env_value)
+        return env_value
+
+    cwd = Path.cwd()
+
+    # Tier 2: marker file
+    marker_result = _find_marker(cwd)
+    if marker_result is not None:
+        return marker_result
+
+    # Tier 3: auto-detect custom/workflows/
+    auto_result = _find_custom_workflows(cwd)
+    if auto_result is not None:
+        return auto_result
+
+    # Tier 4: CWD fallback
+    logger.info("No project marker or custom/workflows/ found, using CWD: %s", cwd)
+    return str(cwd)