Storage

storage:
  database: /path/to/custom.db

engine = Engine(db_path=":memory:")

class Storage:
    def __init__(self, db_path):
        self.db_path = db_path
        self._lock = threading.Lock()
        self._conn = sqlite3.connect(db_path, check_same_thread=False)
        self._conn.row_factory = sqlite3.Row
        self._conn.execute("PRAGMA journal_mode=WAL")
        self._conn.execute("PRAGMA busy_timeout=5000")
        self._create_tables()

CREATE TABLE IF NOT EXISTS runs (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    timestamp TEXT NOT NULL,
    provider TEXT NOT NULL,
    model TEXT NOT NULL,
    attack TEXT NOT NULL,
    target TEXT NOT NULL,
    mode TEXT NOT NULL,
    verdict TEXT NOT NULL,
    keyword_score REAL,
    regex_matches INTEGER,
    llm_judge_score INTEGER,
    confidence REAL,
    duration_ms INTEGER,
    tokens_in INTEGER,
    tokens_out INTEGER,
    verify_status TEXT,
    verify_confidence REAL,
    verify_ground_truth INTEGER,
    snapshot_id INTEGER
);

CREATE TABLE IF NOT EXISTS turns (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    run_id INTEGER REFERENCES runs(id),
    turn_number INTEGER NOT NULL,
    role TEXT NOT NULL,
    content TEXT NOT NULL,
    timestamp TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS tool_calls (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    run_id INTEGER REFERENCES runs(id),
    turn_number INTEGER,
    tool_name TEXT NOT NULL,
    tool_input TEXT NOT NULL,
    is_dangerous INTEGER NOT NULL DEFAULT 0
);

def save_run(self, ...):
    with self._lock:
        cur = self._conn.execute("INSERT INTO runs ...", (...))
        self._conn.commit()
        return cur.lastrowid

storage.list_runs(limit=100)    # Recent runs, newest first
storage.get_run(run_id)         # Single run by ID
storage.get_turns(run_id)       # All turns for a run
storage.get_tool_calls(run_id)  # All tool calls for a run
storage.get_stats()             # Summary: total, bypassed, blocked, models, attacks

# Open the database
sqlite3 ~/.ai-blackteam/results.db

# See all runs
SELECT * FROM runs ORDER BY id DESC LIMIT 10;

# Bypass rate by model
SELECT model,
       COUNT(*) as total,
       SUM(CASE WHEN verdict = 'BYPASSED' THEN 1 ELSE 0 END) as bypassed,
       ROUND(SUM(CASE WHEN verdict = 'BYPASSED' THEN 1.0 ELSE 0 END) / COUNT(*) * 100, 1) as bypass_pct
FROM runs
GROUP BY model;

# Most effective attacks
SELECT attack, COUNT(*) as bypasses
FROM runs
WHERE verdict = 'BYPASSED'
GROUP BY attack
ORDER BY bypasses DESC
LIMIT 20;

# Full conversation for a specific run
SELECT turn_number, role, content
FROM turns
WHERE run_id = 42
ORDER BY turn_number;

# Dangerous tool calls
SELECT r.attack, tc.tool_name, tc.tool_input
FROM tool_calls tc
JOIN runs r ON r.id = tc.run_id
WHERE tc.is_dangerous = 1;