"skraak/db"

	// Begin transaction

	// Begin logged transaction

	tx, err := database.BeginTx(ctx, nil)

	tx, err := db.BeginLoggedTx(ctx, database, "import_audio_files")

	// Begin transaction
	tx, err := database.BeginTx(ctx, nil)

	// Begin logged transaction
	tx, err := db.BeginLoggedTx(ctx, database, "create_or_update_pattern")

	_, err = database.Exec(query, args...)

	// Begin logged transaction for update
	tx, err := db.BeginLoggedTx(ctx, database, "create_or_update_pattern")
	if err != nil {
		return output, fmt.Errorf("failed to begin transaction: %w", err)
	}
	defer func() {
		if err != nil {
			tx.Rollback()
		}
	}()
	_, err = tx.Exec(query, args...)

	err = database.QueryRow(

	err = tx.QueryRow(

	}
	if err = tx.Commit(); err != nil {
		return output, fmt.Errorf("failed to commit transaction: %w", err)

	// Begin transaction
	tx, err := database.BeginTx(ctx, nil)

	// Begin logged transaction
	tx, err := db.BeginLoggedTx(ctx, database, "create_or_update_location")

	_, err = database.Exec(query, args...)

	// Begin logged transaction for update
	tx, err := db.BeginLoggedTx(ctx, database, "create_or_update_location")
	if err != nil {
		return output, fmt.Errorf("failed to begin transaction: %w", err)
	}
	defer func() {
		if err != nil {
			tx.Rollback()
		}
	}()
	_, err = tx.Exec(query, args...)

	err = database.QueryRow(

	err = tx.QueryRow(

	}
	if err = tx.Commit(); err != nil {
		return output, fmt.Errorf("failed to commit transaction: %w", err)

	"database/sql"

	// Begin transaction
	tx, err := database.BeginTx(ctx, nil)

	// Begin logged transaction
	tx, err := db.BeginLoggedTx(ctx, database, "import_unstructured")

func processUnstructuredFile(tx *sql.Tx, filePath, datasetID string) (*unstructuredFileResult, error) {

func processUnstructuredFile(tx *db.LoggedTx, filePath, datasetID string) (*unstructuredFileResult, error) {

	// Begin transaction
	tx, err := database.Begin()

	// Begin logged transaction
	ctx := context.Background()
	tx, err := db.BeginLoggedTx(ctx, database, "import_ml_selections")

	// Begin transaction

	// Begin logged transaction

	tx, err := database.BeginTx(ctx, nil)

	tx, err := db.BeginLoggedTx(ctx, database, "import_audio_file")

	// Begin transaction
	tx, err := database.BeginTx(ctx, nil)

	// Begin logged transaction
	tx, err := db.BeginLoggedTx(ctx, database, "create_or_update_dataset")

	_, err = database.Exec(query, args...)

	// Begin logged transaction for update
	tx, err := db.BeginLoggedTx(ctx, database, "create_or_update_dataset")
	if err != nil {
		return output, fmt.Errorf("failed to begin transaction: %w", err)
	}
	defer func() {
		if err != nil {
			tx.Rollback()
		}
	}()
	_, err = tx.Exec(query, args...)

	err = database.QueryRow(

	err = tx.QueryRow(

	}
	if err = tx.Commit(); err != nil {
		return output, fmt.Errorf("failed to commit transaction: %w", err)

	// Begin transaction
	tx, err := database.BeginTx(ctx, nil)

	// Begin logged transaction
	tx, err := db.BeginLoggedTx(ctx, database, "create_or_update_cluster")

	_, err = database.Exec(query, args...)

	// Begin logged transaction for update
	tx, err := db.BeginLoggedTx(ctx, database, "create_or_update_cluster")
	if err != nil {
		return output, fmt.Errorf("failed to begin transaction: %w", err)
	}
	defer func() {
		if err != nil {
			tx.Rollback()
		}
	}()
	_, err = tx.Exec(query, args...)

	err = database.QueryRow(

	err = tx.QueryRow(

	}
	if err = tx.Commit(); err != nil {
		return output, fmt.Errorf("failed to commit transaction: %w", err)

#!/bin/bash
# Test event log functionality
# Usage: ./test_event_log.sh [database_path]
set -e
DB="${1:-../db/test.duckdb}"
LOG="$DB.events.jsonl"
echo "=== Testing Event Log ==="
echo "Database: $DB"
echo "Event log: $LOG"
echo ""
# Clean up
rm -f "$LOG"
# Check if database exists and has schema
if [ ! -f "$DB" ]; then
    echo "Error: Database $DB does not exist"
    exit 1
fi
# Test 1: Create dataset
echo "Test 1: Create dataset..."
RESULT=$(./skraak dataset create --db "$DB" --name "EventLogTest_$(date +%s)" --type structured 2>&1)
DATASET_ID=$(echo "$RESULT" | jq -r '.dataset.id')
echo "  Created dataset: $DATASET_ID"
# Check event log
if [ ! -f "$LOG" ]; then
    echo "  ERROR: Event log not created!"
    exit 1
fi
EVENT_COUNT=$(wc -l < "$LOG")
if [ "$EVENT_COUNT" -lt 1 ]; then
    echo "  ERROR: No events logged!"
    exit 1
fi
echo "  Event log has $EVENT_COUNT entry/entries"
# Test 2: Verify event structure
echo ""
echo "Test 2: Verify event structure..."
EVENT=$(head -1 "$LOG")
echo "$EVENT" | jq -e '.id' > /dev/null && echo "  ✓ Has id"
echo "$EVENT" | jq -e '.timestamp' > /dev/null && echo "  ✓ Has timestamp"
echo "$EVENT" | jq -e '.tool' > /dev/null && echo "  ✓ Has tool"
echo "$EVENT" | jq -e '.queries' > /dev/null && echo "  ✓ Has queries"
echo "$EVENT" | jq -e '.success' > /dev/null && echo "  ✓ Has success"
# Test 3: Create location
echo ""
echo "Test 3: Create location..."
RESULT=$(./skraak location create --db "$DB" --dataset "$DATASET_ID" --name "TestLoc_$(date +%s)" --lat -36.85 --lon 174.76 --timezone Pacific/Auckland 2>&1)
LOCATION_ID=$(echo "$RESULT" | jq -r '.location.id')
echo "  Created location: $LOCATION_ID"
# Test 4: Verify multiple events
EVENT_COUNT=$(wc -l < "$LOG")
if [ "$EVENT_COUNT" -lt 2 ]; then
    echo "  ERROR: Expected at least 2 events, got $EVENT_COUNT"
    exit 1
fi
echo "  Event log has $EVENT_COUNT entries"
# Test 5: Dry-run replay
echo ""
echo "Test 5: Dry-run replay..."
./skraak replay events --db "$DB" --log "$LOG" --dry-run > /dev/null 2>&1
echo "  ✓ Dry-run succeeded"
# Test 6: Verify replay command flags
echo ""
echo "Test 6: Verify replay flags..."
./skraak replay events --db "$DB" --log "$LOG" --last 1 --dry-run > /dev/null 2>&1
echo "  ✓ --last flag works"
echo ""
echo "=== All tests passed ==="
echo ""
echo "Event log contents:"
cat "$LOG" | jq -c '{id, tool, queries: (.queries | length), success}'

	case "replay":
		cmd.RunReplay(os.Args[2:])

	fmt.Fprintf(os.Stderr, "  replay     Replay event log into database\n")

	fmt.Fprintf(os.Stderr, "  %s replay events --db ./backup.duckdb --log ./skraak.duckdb.events.jsonl\n", os.Args[0])

package db
import (
	"context"
	"database/sql"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"
	gonanoid "github.com/matoous/go-nanoid/v2"
)
// LoggedTx wraps *sql.Tx and records all Exec/ExecContext calls for mutation logging
type LoggedTx struct {
	tx        *sql.Tx
	queries   []QueryRecord
	mu        sync.Mutex
	toolName  string
	startTime time.Time
}
// QueryRecord represents a single SQL statement with parameters
type QueryRecord struct {
	SQL        string        `json:"sql"`
	Parameters []interface{} `json:"parameters"`
}
// TransactionEvent represents a complete transaction for the event log
type TransactionEvent struct {
	ID        string        `json:"id"`
	Timestamp time.Time     `json:"timestamp"`
	Tool      string        `json:"tool,omitempty"`
	Queries   []QueryRecord `json:"queries"`
	Success   bool          `json:"success"`
	Duration  int64         `json:"duration_ms"`
}
// LoggedStmt wraps *sql.Stmt to intercept Exec calls on prepared statements
type LoggedStmt struct {
	stmt *sql.Stmt
	tx   *LoggedTx
	sql  string
}
// EventLogConfig holds configuration for event logging
type EventLogConfig struct {
	Enabled bool
	Path    string
}
var (
	eventLogConfig EventLogConfig
	eventLogMu     sync.Mutex
	eventLogFile   *os.File
	eventLogEnc    *json.Encoder
)
// SetEventLogConfig configures event logging globally
func SetEventLogConfig(cfg EventLogConfig) {
	eventLogMu.Lock()
	defer eventLogMu.Unlock()
	// Close existing file if path changed
	if eventLogFile != nil && eventLogConfig.Path != cfg.Path {
		eventLogFile.Close()
		eventLogFile = nil
		eventLogEnc = nil
	}
	eventLogConfig = cfg
}
// GetEventLogConfig returns the current event log configuration
func GetEventLogConfig() EventLogConfig {
	eventLogMu.Lock()
	defer eventLogMu.Unlock()
	return eventLogConfig
}
// BeginLoggedTx starts a new transaction that logs all mutations
// toolName is optional and identifies which tool initiated the transaction
func BeginLoggedTx(ctx context.Context, db *sql.DB, toolName string) (*LoggedTx, error) {
	tx, err := db.BeginTx(ctx, nil)
	if err != nil {
		return nil, err
	}
	return &LoggedTx{
		tx:        tx,
		queries:   make([]QueryRecord, 0),
		toolName:  toolName,
		startTime: time.Now(),
	}, nil
}
// ExecContext executes and records the SQL statement if it's a mutation
func (l *LoggedTx) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
	result, err := l.tx.ExecContext(ctx, query, args...)
	if err == nil && isMutation(query) {
		l.mu.Lock()
		l.queries = append(l.queries, QueryRecord{
			SQL:        query,
			Parameters: args,
		})
		l.mu.Unlock()
	}
	return result, err
}
// Exec executes and records the SQL statement if it's a mutation
func (l *LoggedTx) Exec(query string, args ...interface{}) (sql.Result, error) {
	return l.ExecContext(context.Background(), query, args...)
}
// QueryRowContext delegates to underlying tx (not logged - read operation)
func (l *LoggedTx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
	return l.tx.QueryRowContext(ctx, query, args...)
}
// QueryRow delegates to underlying tx (not logged - read operation)
func (l *LoggedTx) QueryRow(query string, args ...interface{}) *sql.Row {
	return l.tx.QueryRow(query, args...)
}
// QueryContext delegates to underlying tx (not logged - read operation)
func (l *LoggedTx) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
	return l.tx.QueryContext(ctx, query, args...)
}
// Query delegates to underlying tx (not logged - read operation)
func (l *LoggedTx) Query(query string, args ...interface{}) (*sql.Rows, error) {
	return l.tx.Query(query, args...)
}
// PrepareContext creates a logged prepared statement
func (l *LoggedTx) PrepareContext(ctx context.Context, query string) (*LoggedStmt, error) {
	stmt, err := l.tx.PrepareContext(ctx, query)
	if err != nil {
		return nil, err
	}
	return &LoggedStmt{stmt: stmt, tx: l, sql: query}, nil
}
// Prepare creates a logged prepared statement
func (l *LoggedTx) Prepare(query string) (*LoggedStmt, error) {
	return l.PrepareContext(context.Background(), query)
}
// Rollback rolls back the transaction (discards recorded queries)
func (l *LoggedTx) Rollback() error {
	l.mu.Lock()
	l.queries = nil // Discard recorded queries
	l.mu.Unlock()
	return l.tx.Rollback()
}
// Commit commits the transaction and logs all recorded queries on success
func (l *LoggedTx) Commit() error {
	err := l.tx.Commit()
	if err != nil {
		return err
	}
	// Log on success only
	l.mu.Lock()
	queries := l.queries
	l.mu.Unlock()
	if len(queries) > 0 && eventLogConfig.Enabled {
		l.writeEvent(queries)
	}
	return nil
}
// writeEvent writes the transaction to the event log
func (l *LoggedTx) writeEvent(queries []QueryRecord) {
	eventLogMu.Lock()
	defer eventLogMu.Unlock()
	if !eventLogConfig.Enabled {
		return
	}
	// Ensure file is open
	if err := ensureEventLogFile(); err != nil {
		// Log to stderr but don't fail the commit
		fmt.Fprintf(os.Stderr, "Warning: failed to open event log: %v\n", err)
		return
	}
	id, err := gonanoid.New(21)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Warning: failed to generate event ID: %v\n", err)
		return
	}
	event := TransactionEvent{
		ID:        id,
		Timestamp: time.Now(),
		Tool:      l.toolName,
		Queries:   queries,
		Success:   true,
		Duration:  time.Since(l.startTime).Milliseconds(),
	}
	if err := eventLogEnc.Encode(event); err != nil {
		fmt.Fprintf(os.Stderr, "Warning: failed to write event log: %v\n", err)
	}
}
// LoggedStmt methods
// ExecContext executes the prepared statement and logs if it's a mutation
func (s *LoggedStmt) ExecContext(ctx context.Context, args ...interface{}) (sql.Result, error) {
	result, err := s.stmt.ExecContext(ctx, args...)
	if err == nil && isMutation(s.sql) {
		s.tx.mu.Lock()
		s.tx.queries = append(s.tx.queries, QueryRecord{
			SQL:        s.sql,
			Parameters: args,
		})
		s.tx.mu.Unlock()
	}
	return result, err
}
// Exec executes the prepared statement and logs if it's a mutation
func (s *LoggedStmt) Exec(args ...interface{}) (sql.Result, error) {
	return s.ExecContext(context.Background(), args...)
}
// QueryRowContext delegates to underlying statement
func (s *LoggedStmt) QueryRowContext(ctx context.Context, args ...interface{}) *sql.Row {
	return s.stmt.QueryRowContext(ctx, args...)
}
// QueryRow delegates to underlying statement
func (s *LoggedStmt) QueryRow(args ...interface{}) *sql.Row {
	return s.stmt.QueryRow(args...)
}
// QueryContext delegates to underlying statement
func (s *LoggedStmt) QueryContext(ctx context.Context, args ...interface{}) (*sql.Rows, error) {
	return s.stmt.QueryContext(ctx, args...)
}
// Query delegates to underlying statement
func (s *LoggedStmt) Query(args ...interface{}) (*sql.Rows, error) {
	return s.stmt.Query(args...)
}
// Close closes the prepared statement
func (s *LoggedStmt) Close() error {
	return s.stmt.Close()
}
// isMutation returns true if the SQL is a mutation (INSERT, UPDATE, DELETE)
func isMutation(sqlStr string) bool {
	upper := strings.ToUpper(strings.TrimSpace(sqlStr))
	// Handle WITH clauses (CTEs) that may contain mutations
	if strings.HasPrefix(upper, "WITH") {
		// Check for INSERT/UPDATE/DELETE within the query
		return strings.Contains(upper, "INSERT") ||
			strings.Contains(upper, "UPDATE") ||
			strings.Contains(upper, "DELETE")
	}
	return strings.HasPrefix(upper, "INSERT") ||
		strings.HasPrefix(upper, "UPDATE") ||
		strings.HasPrefix(upper, "DELETE")
}
// ensureEventLogFile opens the event log file if not already open
func ensureEventLogFile() error {
	if eventLogFile != nil {
		return nil
	}
	dir := filepath.Dir(eventLogConfig.Path)
	if err := os.MkdirAll(dir, 0755); err != nil {
		return fmt.Errorf("failed to create event log directory: %w", err)
	}
	f, err := os.OpenFile(eventLogConfig.Path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return fmt.Errorf("failed to open event log file: %w", err)
	}
	eventLogFile = f
	eventLogEnc = json.NewEncoder(f)
	eventLogEnc.SetEscapeHTML(false)
	return nil
}
// CloseEventLog closes the event log file
func CloseEventLog() error {
	eventLogMu.Lock()
	defer eventLogMu.Unlock()
	// Disable logging before closing
	eventLogConfig.Enabled = false
	if eventLogFile != nil {
		err := eventLogFile.Close()
		eventLogFile = nil
		eventLogEnc = nil
		return err
	}
	return nil
}
// MarshalJSON implements json.Marshaler for QueryRecord
// Handles special types like time.Time, nil, and nullable types
func (q QueryRecord) MarshalJSON() ([]byte, error) {
	// Create a helper struct with string parameters
	type QueryRecordJSON struct {
		SQL        string        `json:"sql"`
		Parameters []interface{} `json:"parameters"`
	}
	result := QueryRecordJSON{
		SQL:        q.SQL,
		Parameters: make([]interface{}, len(q.Parameters)),
	}
	for i, param := range q.Parameters {
		result.Parameters[i] = marshalParam(param)
	}
	return json.Marshal(result)
}
// marshalParam converts a parameter to a JSON-serializable value
func marshalParam(param interface{}) interface{} {
	if param == nil {
		return nil
	}
	switch v := param.(type) {
	case time.Time:
		return v.Format(time.RFC3339Nano)
	case *time.Time:
		if v == nil {
			return nil
		}
		return v.Format(time.RFC3339Nano)
	case string:
		return v
	case *string:
		if v == nil {
			return nil
		}
		return *v
	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
		return v
	case float32, float64, bool:
		return v
	case []byte:
		return v
	default:
		// For other types, try to convert to string
		return fmt.Sprintf("%v", v)
	}
}

package cmd
import (
	"bufio"
	"context"
	"database/sql"
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"strings"
	"skraak/db"
)
// RunReplay handles the "replay" subcommand
func RunReplay(args []string) {
	if len(args) < 1 {
		printReplayUsage()
		os.Exit(1)
	}
	switch args[0] {
	case "events":
		runReplayEvents(args[1:])
	default:
		fmt.Fprintf(os.Stderr, "Unknown replay subcommand: %s\n\n", args[0])
		printReplayUsage()
		os.Exit(1)
	}
}
func printReplayUsage() {
	fmt.Fprintf(os.Stderr, "Usage: skraak replay <subcommand> [options]\n\n")
	fmt.Fprintf(os.Stderr, "Subcommands:\n")
	fmt.Fprintf(os.Stderr, "  events    Replay event log into database\n")
	fmt.Fprintf(os.Stderr, "\nExamples:\n")
	fmt.Fprintf(os.Stderr, "  skraak replay events --db ./backup.duckdb --log ./skraak.duckdb.events.jsonl\n")
	fmt.Fprintf(os.Stderr, "  skraak replay events --db ./backup.duckdb --log ./events.jsonl --dry-run\n")
	fmt.Fprintf(os.Stderr, "  skraak replay events --db ./backup.duckdb --log ./events.jsonl --last 10\n")
}
func runReplayEvents(args []string) {
	fs := flag.NewFlagSet("replay events", flag.ExitOnError)
	dbPath := fs.String("db", "", "Path to target database (required)")
	logPath := fs.String("log", "", "Path to event log file (required)")
	dryRun := fs.Bool("dry-run", false, "Print events without executing")
	fromID := fs.String("from", "", "Start from event ID (inclusive)")
	toID := fs.String("to", "", "Stop at event ID (inclusive)")
	lastN := fs.Int("last", 0, "Replay last N events (0 = all)")
	continueOnError := fs.Bool("continue", false, "Continue past errors")
	fs.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: skraak replay events [options]\n\n")
		fmt.Fprintf(os.Stderr, "Replay event log into database.\n\n")
		fmt.Fprintf(os.Stderr, "Options:\n")
		fs.PrintDefaults()
		fmt.Fprintf(os.Stderr, "\nExamples:\n")
		fmt.Fprintf(os.Stderr, "  skraak replay events --db ./backup.duckdb --log ./events.jsonl\n")
		fmt.Fprintf(os.Stderr, "  skraak replay events --db ./backup.duckdb --log ./events.jsonl --dry-run\n")
		fmt.Fprintf(os.Stderr, "  skraak replay events --db ./backup.duckdb --log ./events.jsonl --last 10\n")
	}
	if err := fs.Parse(args); err != nil {
		os.Exit(1)
	}
	// Validate required flags
	missing := []string{}
	if *dbPath == "" {
		missing = append(missing, "--db")
	}
	if *logPath == "" {
		missing = append(missing, "--log")
	}
	if len(missing) > 0 {
		fmt.Fprintf(os.Stderr, "Error: missing required flags: %v\n\n", missing)
		fs.Usage()
		os.Exit(1)
	}
	// Read events
	events, err := readEvents(*logPath)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error reading events: %v\n", err)
		os.Exit(1)
	}
	// Filter events
	events = filterEvents(events, *fromID, *toID, *lastN)
	fmt.Fprintf(os.Stderr, "Found %d events to replay\n", len(events))
	if *dryRun {
		for i, event := range events {
			fmt.Printf("\n[%d/%d] Event %s (%s)\n", i+1, len(events), event.ID, event.Tool)
			for _, q := range event.Queries {
				fmt.Printf("  SQL: %s\n", truncateSQL(q.SQL, 80))
				fmt.Printf("  Params: %v\n", q.Parameters)
			}
		}
		return
	}
	// Open database
	database, err := db.OpenWriteableDB(*dbPath)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error opening database: %v\n", err)
		os.Exit(1)
	}
	defer database.Close()
	// Disable event logging for replay
	db.SetEventLogConfig(db.EventLogConfig{Enabled: false})
	// Replay each event
	successCount := 0
	failCount := 0
	for i, event := range events {
		fmt.Fprintf(os.Stderr, "\n[%d/%d] Replaying event %s (%s)...\n", i+1, len(events), event.ID, event.Tool)
		err := replayEvent(database, event)
		if err != nil {
			failCount++
			fmt.Fprintf(os.Stderr, "  ERROR: %v\n", err)
			if !*continueOnError {
				fmt.Fprintf(os.Stderr, "Stopping due to error. Use --continue to skip errors.\n")
				os.Exit(1)
			}
		} else {
			successCount++
			fmt.Fprintf(os.Stderr, "  OK (%d queries)\n", len(event.Queries))
		}
	}
	fmt.Fprintf(os.Stderr, "\nReplay complete: %d succeeded, %d failed\n", successCount, failCount)
}
// TransactionEvent represents a transaction event from the log
type TransactionEvent struct {
	ID        string        `json:"id"`
	Timestamp string        `json:"timestamp"`
	Tool      string        `json:"tool,omitempty"`
	Queries   []QueryRecord `json:"queries"`
	Success   bool          `json:"success"`
	Duration  int64         `json:"duration_ms"`
}
// QueryRecord represents a single SQL statement with parameters
type QueryRecord struct {
	SQL        string        `json:"sql"`
	Parameters []interface{} `json:"parameters"`
}
// readEvents reads all events from a JSONL file
func readEvents(path string) ([]TransactionEvent, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, fmt.Errorf("failed to open event log: %w", err)
	}
	defer file.Close()
	var events []TransactionEvent
	scanner := bufio.NewScanner(file)
	lineNum := 0
	for scanner.Scan() {
		lineNum++
		line := scanner.Bytes()
		if len(line) == 0 {
			continue
		}
		var event TransactionEvent
		if err := json.Unmarshal(line, &event); err != nil {
			fmt.Fprintf(os.Stderr, "Warning: failed to parse line %d: %v\n", lineNum, err)
			continue
		}
		events = append(events, event)
	}
	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("error reading event log: %w", err)
	}
	return events, nil
}
// filterEvents filters events based on criteria
func filterEvents(events []TransactionEvent, fromID, toID string, lastN int) []TransactionEvent {
	// Filter by fromID
	if fromID != "" {
		startIdx := 0
		for i, e := range events {
			if e.ID == fromID {
				startIdx = i
				break
			}
		}
		events = events[startIdx:]
	}
	// Filter by toID
	if toID != "" {
		endIdx := len(events)
		for i, e := range events {
			if e.ID == toID {
				endIdx = i + 1
				break
			}
		}
		events = events[:endIdx]
	}
	// Filter by lastN
	if lastN > 0 && len(events) > lastN {
		events = events[len(events)-lastN:]
	}
	// Only replay successful events
	var filtered []TransactionEvent
	for _, e := range events {
		if e.Success {
			filtered = append(filtered, e)
		}
	}
	return filtered
}
// replayEvent replays a single transaction event
func replayEvent(database *sql.DB, event TransactionEvent) error {
	ctx := context.Background()
	tx, err := database.BeginTx(ctx, nil)
	if err != nil {
		return fmt.Errorf("failed to begin transaction: %w", err)
	}
	for _, q := range event.Queries {
		// Convert parameters to []interface{} for Exec
		_, err := tx.ExecContext(ctx, q.SQL, q.Parameters...)
		if err != nil {
			tx.Rollback()
			return fmt.Errorf("query failed: %w (SQL: %s)", err, truncateSQL(q.SQL, 50))
		}
	}
	if err := tx.Commit(); err != nil {
		return fmt.Errorf("failed to commit transaction: %w", err)
	}
	return nil
}
// truncateSQL truncates a SQL string for display
func truncateSQL(sql string, maxLen int) string {
	sql = strings.Join(strings.Fields(sql), " ") // Normalize whitespace
	if len(sql) <= maxLen {
		return sql
	}
	return sql[:maxLen] + "..."
}

	"skraak/db"

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	"skraak/db"

	// Initialize event log for mutation logging
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	"skraak/db"

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	"skraak/db"

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	"skraak/db"

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	"skraak/db"

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

	// Initialize event log
	eventLogPath := *dbPath + ".events.jsonl"
	db.SetEventLogConfig(db.EventLogConfig{
		Enabled: true,
		Path:    eventLogPath,
	})
	defer db.CloseEventLog()

## Event Log
All mutating SQL operations logged to `<database>.events.jsonl` for backup synchronization.
**What's logged:**
- INSERT, UPDATE, DELETE operations
- On successful commit only (rollbacks discarded)
- Includes tool name, SQL, parameters, timestamp
**Replay on backup:**
```bash
skraak replay events --db backup.duckdb --log skraak.duckdb.events.jsonl
skraak replay events --db backup.duckdb --log events.jsonl --dry-run
skraak replay events --db backup.duckdb --log events.jsonl --last 10
```

**Key files:**
- `db/tx_logger.go` - Transaction wrapper for logging
- `cmd/replay.go` - Replay CLI command
---

**Status:** CLI refactoring complete (2026-02-14)

**Status:** Event log complete (2026-02-18)

**CLI Commands:** `mcp`, `sql`, `dataset`, `location`, `cluster`, `pattern`, `import`
**Test Scripts:** 8 comprehensive shell scripts

**CLI Commands:** `mcp`, `sql`, `dataset`, `location`, `cluster`, `pattern`, `import`, `replay`
**Event Log:** SQL-level mutation capture for backup sync (`<db>.events.jsonl`)
**Test Scripts:** 9 comprehensive shell scripts

**Last Updated:** 2026-02-15 NZDT

**Last Updated:** 2026-02-18 NZDT

## [2026-02-18] Event Log for Database Mutation Replay
**New feature: SQL-level event logging for backup synchronization**
**Purpose:** Capture all mutating SQL operations (INSERT, UPDATE, DELETE) to enable replay on backup databases for synchronization.
**Architecture:**
- Transaction wrapper (`db.LoggedTx`) intercepts all mutations
- Logged only on successful commit (rollback discards recorded queries)
- Events written to JSONL file (`<database>.events.jsonl`)
- Prepared statements fully supported via `LoggedStmt` wrapper
**Added:**
- `db/tx_logger.go` — LoggedTx, LoggedStmt, TransactionEvent types
- `cmd/replay.go` — `skraak replay events` CLI command
- `shell_scripts/test_event_log.sh` — Integration test script
**Modified:**
- All CLI commands initialize event log with defer close
- All tools use `db.BeginLoggedTx()` instead of `database.BeginTx()`
- `utils/cluster_import.go` updated for batch imports
**Event format (JSONL):**
```json
{
  "id": "V1StGXR8_Z5jdHi6B-myT",
  "timestamp": "2026-02-18T14:30:22+13:00",
  "tool": "create_or_update_dataset",
  "queries": [
    {"sql": "INSERT INTO ...", "parameters": [...]}
  ],
  "success": true,
  "duration_ms": 45
}
```
**Replay command:**
```bash
skraak replay events --db backup.duckdb --log skraak.duckdb.events.jsonl
skraak replay events --db backup.duckdb --log events.jsonl --dry-run
skraak replay events --db backup.duckdb --log events.jsonl --last 10
```

**Key design decisions:**
- SQL-level (not tool-level) for complete fidelity including imports
- Tool name included for context/debugging
- Only successful transactions logged
- Failed events skipped during replay
- `--continue` flag to proceed past errors
---

docs/
.pi/