argus-code 0.2.0__py3-none-any.whl

argus/server/app.py

@@ -0,0 +1,97 @@
+"""FastAPI app builder + uvicorn launcher."""
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import uvicorn
+from fastapi import FastAPI, Request
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from ..adapters.base import Adapter
+from ..collector.first_run import FirstRunHandle
+from ..pricing.types import PricingTable
+from ..store.repository import Repository
+from .api import ApiDeps, build_api, is_allowed_origin
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ServerOpts:
+    pricing_table_version: str
+    ingest_status: Any  # callable returning IngestStatus
+    dashboard_dir: Path
+    port: int
+    adapters: list[Adapter]
+    pricing_table: PricingTable
+    host: str = "127.0.0.1"
+
+
+def build_app(repo: Repository, opts: ServerOpts) -> FastAPI:
+    """Build the FastAPI app with CSRF middleware, API routes, static mount."""
+    app = FastAPI(title="Argus", docs_url=None, redoc_url=None, openapi_url=None)
+
+    @app.exception_handler(RequestValidationError)
+    async def on_validation_error(request: Request, exc: RequestValidationError):
+        return JSONResponse(
+            {"error": "bad request", "detail": exc.errors()}, status_code=400
+        )
+
+    # CSRF origin guard for state-changing requests. GETs are unrestricted
+    # because the dashboard issues same-origin GETs without an Origin
+    # header in some setups; POSTs from browsers always carry Origin.
+    @app.middleware("http")
+    async def csrf_origin_check(request: Request, call_next):
+        method = request.method
+        if method in ("GET", "HEAD", "OPTIONS"):
+            return await call_next(request)
+        # Allow API-prefixed paths to enforce the check; non-API endpoints
+        # don't exist on this server today, but apply uniformly.
+        if not is_allowed_origin(request.headers.get("origin")):
+            return JSONResponse(
+                {"error": "cross-origin requests not allowed"}, status_code=403
+            )
+        return await call_next(request)
+
+    api = build_api(
+        repo,
+        ApiDeps(
+            pricing_table_version=opts.pricing_table_version,
+            ingest_status=opts.ingest_status,
+            adapters=opts.adapters,
+            pricing_table=opts.pricing_table,
+        ),
+    )
+    app.include_router(api)
+
+    # Static dashboard mount LAST so /api/* routes win.
+    if opts.dashboard_dir.exists():
+        app.mount(
+            "/",
+            StaticFiles(directory=str(opts.dashboard_dir), html=True),
+            name="dashboard",
+        )
+
+    return app
+
+
+def serve_blocking(app: FastAPI, *, host: str, port: int) -> None:
+    """Run uvicorn in the current thread until SIGINT or .should_exit."""
+    config = uvicorn.Config(
+        app,
+        host=host,
+        port=port,
+        log_level="warning",  # quiet access log; user opts in via --verbose
+        access_log=False,
+    )
+    server = uvicorn.Server(config)
+    try:
+        server.run()
+    except KeyboardInterrupt:
+        pass

argus/store/db.py

@@ -0,0 +1,103 @@
+"""SQLite connection opener + migration runner.
+
+Verifies FTS5 is compiled in at startup; failing fast with a clear error
+is better than a confusing OperationalError deep in searchPrompts later.
+"""
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from .migrations.inline import (
+    MIGRATION_001,
+    MIGRATION_002,
+    MIGRATION_003,
+    MIGRATION_004,
+    MIGRATION_005,
+)
+
+SCHEMA_VERSION = 5
+
+
+class FTS5NotAvailableError(RuntimeError):
+    """Raised when the Python sqlite3 build lacks FTS5 support."""
+
+
+def _assert_fts5(conn: sqlite3.Connection) -> None:
+    """Fail loudly if FTS5 isn't compiled into this Python's sqlite3.
+
+    CPython's standard distributions for Windows / macOS / Linux all ship
+    FTS5 since 3.11. Alpine minimal builds and some custom builds don't.
+    """
+    cur = conn.execute("PRAGMA compile_options")
+    opts = {row[0] for row in cur.fetchall()}
+    if "ENABLE_FTS5" not in opts:
+        raise FTS5NotAvailableError(
+            "Your Python's sqlite3 was built without FTS5 (ENABLE_FTS5). "
+            "Argus requires FTS5 for prompt and transcript search. "
+            "Use the official CPython distribution or build sqlite with FTS5."
+        )
+
+
+def open_db(path: str | Path) -> sqlite3.Connection:
+    """Open the Argus SQLite DB at ``path``, applying migrations 1..N."""
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+
+    # check_same_thread=False because the Repository may be accessed from
+    # the request thread, the watcher thread, the first-run worker, and
+    # the scheduler thread. SQLite itself is thread-safe in serialized
+    # mode; better-sqlite3 in TS makes the same assumption.
+    #
+    # cached_statements=0 disables Python sqlite3's per-Connection
+    # prepared-statement cache. With the cache enabled, two threads that
+    # call execute(SAME_SQL, ...) concurrently can both pull the cached
+    # sqlite3_stmt*, both call reset+bind on it, and one loses with
+    # SQLITE_MISUSE ("bad parameter or other API misuse"). The cost of
+    # disabling the cache is ~10µs of statement prep per query, which is
+    # well below the cost of the queries themselves. SQLite's own internal
+    # compilation cache (sqlite3_prepare_v2 fast path) still applies.
+    conn = sqlite3.connect(
+        str(p),
+        check_same_thread=False,
+        isolation_level=None,
+        cached_statements=0,
+    )
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.execute("PRAGMA busy_timeout = 5000")
+
+    _assert_fts5(conn)
+
+    # MIGRATION_001 is fully idempotent (CREATE TABLE IF NOT EXISTS) so we
+    # always run it. After this point app_meta is guaranteed to exist.
+    conn.executescript(MIGRATION_001)
+
+    # Versioned migrations: ALTER TABLE has no IF NOT EXISTS in SQLite, so
+    # we gate later migrations on a schema_version row. Fresh DBs start at
+    # 1 (everything in MIGRATION_001 has been applied) and step up.
+    row = conn.execute(
+        "SELECT value FROM app_meta WHERE key = 'schema_version'"
+    ).fetchone()
+    current = int(row["value"]) if row else 1
+
+    if current < 2:
+        conn.executescript(MIGRATION_002)
+        current = 2
+    if current < 3:
+        conn.executescript(MIGRATION_003)
+        current = 3
+    if current < 4:
+        conn.executescript(MIGRATION_004)
+        current = 4
+    if current < 5:
+        conn.executescript(MIGRATION_005)
+        current = 5
+
+    conn.execute(
+        "INSERT OR REPLACE INTO app_meta (key, value) VALUES ('schema_version', ?)",
+        (str(SCHEMA_VERSION),),
+    )
+
+    return conn

argus/store/migrations/inline.py

@@ -0,0 +1,180 @@
+"""Schema migrations.
+
+Append-only. Never edit a published migration — production users have data
+that depends on the exact SQL that already ran. To change the schema, add
+a new MIGRATION_N+1 and bump SCHEMA_VERSION in db.py.
+"""
+
+MIGRATION_001 = """
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  agent TEXT NOT NULL,
+  agent_version TEXT,
+  project_path TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  ended_at TEXT,
+  duration_sec INTEGER,
+  total_fresh_input_tokens INTEGER NOT NULL DEFAULT 0,
+  total_output_tokens INTEGER NOT NULL DEFAULT 0,
+  total_cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  total_cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  total_cost_usd REAL NOT NULL DEFAULT 0,
+  primary_model TEXT NOT NULL,
+  turn_count INTEGER NOT NULL DEFAULT 0,
+  pricing_table_version TEXT NOT NULL,
+  computed_at TEXT NOT NULL,
+  agent_reported_cost_usd REAL,
+  metadata TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_started_at ON sessions(started_at DESC);
+CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent);
+
+CREATE TABLE IF NOT EXISTS turns (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  sequence INTEGER NOT NULL,
+  timestamp TEXT NOT NULL,
+  model TEXT NOT NULL,
+  model_raw TEXT NOT NULL,
+  fresh_input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_write_5m_tokens INTEGER,
+  cache_write_1h_tokens INTEGER,
+  tool_calls_count INTEGER NOT NULL DEFAULT 0,
+  cost_usd REAL NOT NULL DEFAULT 0,
+  metadata TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE INDEX IF NOT EXISTS idx_turns_session ON turns(session_id, sequence);
+
+CREATE TABLE IF NOT EXISTS file_offsets (
+  path TEXT PRIMARY KEY,
+  byte_offset INTEGER NOT NULL,
+  last_seen TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS parse_errors (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  file TEXT NOT NULL,
+  byte_offset INTEGER NOT NULL,
+  reason TEXT NOT NULL,
+  raw_line_truncated TEXT NOT NULL,
+  occurred_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS app_meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+"""
+
+MIGRATION_002 = """
+ALTER TABLE sessions ADD COLUMN started_at_ms INTEGER;
+ALTER TABLE sessions ADD COLUMN ended_at_ms INTEGER;
+CREATE INDEX IF NOT EXISTS idx_sessions_time ON sessions(project_path, started_at_ms, ended_at_ms);
+
+UPDATE sessions
+SET started_at_ms = CAST(strftime('%s', started_at) AS INTEGER) * 1000,
+    ended_at_ms = CASE WHEN ended_at IS NULL OR ended_at = '' THEN NULL
+                       ELSE CAST(strftime('%s', ended_at) AS INTEGER) * 1000 END
+WHERE started_at_ms IS NULL;
+
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  turn_index INTEGER NOT NULL,
+  tool_name TEXT NOT NULL,
+  is_error INTEGER NOT NULL DEFAULT 0,
+  input_size INTEGER NOT NULL DEFAULT 0,
+  subagent_type TEXT,
+  timestamp TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_name ON tool_calls(tool_name);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_ts ON tool_calls(timestamp);
+
+CREATE TABLE IF NOT EXISTS prompts (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp_ms INTEGER NOT NULL,
+  project_path TEXT NOT NULL,
+  display TEXT NOT NULL,
+  pasted_chars INTEGER NOT NULL DEFAULT 0,
+  is_slash INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_prompts_ts ON prompts(timestamp_ms);
+CREATE INDEX IF NOT EXISTS idx_prompts_project ON prompts(project_path);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS prompts_fts USING fts5(
+  display,
+  content='prompts',
+  content_rowid='id',
+  tokenize='unicode61'
+);
+
+CREATE TRIGGER IF NOT EXISTS prompts_ai AFTER INSERT ON prompts BEGIN
+  INSERT INTO prompts_fts(rowid, display) VALUES (new.id, new.display);
+END;
+CREATE TRIGGER IF NOT EXISTS prompts_ad AFTER DELETE ON prompts BEGIN
+  INSERT INTO prompts_fts(prompts_fts, rowid, display) VALUES('delete', old.id, old.display);
+END;
+CREATE TRIGGER IF NOT EXISTS prompts_au AFTER UPDATE ON prompts BEGIN
+  INSERT INTO prompts_fts(prompts_fts, rowid, display) VALUES('delete', old.id, old.display);
+  INSERT INTO prompts_fts(rowid, display) VALUES (new.id, new.display);
+END;
+"""
+
+MIGRATION_003 = """
+CREATE TABLE IF NOT EXISTS transcript_segments (
+  rowid INTEGER PRIMARY KEY AUTOINCREMENT,
+  uid TEXT UNIQUE NOT NULL,
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  timestamp TEXT NOT NULL,
+  role TEXT NOT NULL,
+  text TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_segments_session ON transcript_segments(session_id);
+CREATE INDEX IF NOT EXISTS idx_segments_ts ON transcript_segments(timestamp);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS transcript_fts USING fts5(
+  text,
+  content='transcript_segments',
+  content_rowid='rowid',
+  tokenize='unicode61'
+);
+
+CREATE TRIGGER IF NOT EXISTS segments_ai AFTER INSERT ON transcript_segments BEGIN
+  INSERT INTO transcript_fts(rowid, text) VALUES (new.rowid, new.text);
+END;
+CREATE TRIGGER IF NOT EXISTS segments_ad AFTER DELETE ON transcript_segments BEGIN
+  INSERT INTO transcript_fts(transcript_fts, rowid, text) VALUES('delete', old.rowid, old.text);
+END;
+CREATE TRIGGER IF NOT EXISTS segments_au AFTER UPDATE ON transcript_segments BEGIN
+  INSERT INTO transcript_fts(transcript_fts, rowid, text) VALUES('delete', old.rowid, old.text);
+  INSERT INTO transcript_fts(rowid, text) VALUES (new.rowid, new.text);
+END;
+"""
+
+MIGRATION_004 = """
+CREATE TABLE IF NOT EXISTS alerts (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  detector TEXT NOT NULL,
+  dedup_key TEXT NOT NULL,
+  severity TEXT NOT NULL CHECK (severity IN ('info', 'warning', 'critical')),
+  title TEXT NOT NULL,
+  message TEXT NOT NULL,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  first_seen_at TEXT NOT NULL,
+  last_seen_at TEXT NOT NULL,
+  seen_at TEXT,
+  UNIQUE (detector, dedup_key)
+);
+CREATE INDEX IF NOT EXISTS idx_alerts_unseen ON alerts(seen_at, severity);
+CREATE INDEX IF NOT EXISTS idx_alerts_recent ON alerts(last_seen_at DESC);
+"""
+
+MIGRATION_005 = """
+ALTER TABLE alerts ADD COLUMN resolved_at TEXT;
+"""