jettypod 4.4.118 → 4.4.121

package/crates/jettypod-core/src/db/startup.rs

@@ -0,0 +1,101 @@
+//! Startup validation and automatic recovery.
+//!
+//! Port of Node.js `validateOnStartup()` — opens the database with integrity
+//! checks, schema validation, and automatic snapshot recovery on failure.
+
+use crate::error::{CoreError, Result};
+use std::path::Path;
+use super::Database;
+
+impl Database {
+    /// Open the work database for a project root directory.
+    ///
+    /// The database file is at `<project_root>/.jettypod/work.db`.
+    /// Includes integrity checks, schema validation, and automatic
+    /// snapshot recovery on failure.
+    pub fn open(project_root: &Path) -> Result<Self> {
+        let db_path = project_root.join(".jettypod").join("work.db");
+        Self::open_path(&db_path)
+    }
+
+    /// Open a database at a specific path with full validation and recovery.
+    ///
+    /// This is the primary entry point for production callers. It:
+    /// 1. Recovers from snapshots if the DB file is missing
+    /// 2. Attempts snapshot recovery if the DB fails to open
+    /// 3. Runs integrity checks with recovery on corruption
+    /// 4. Validates schema and tables
+    pub fn open_path(path: &Path) -> Result<Self> {
+        // 1. If DB file is missing, try snapshot recovery first
+        if !path.exists() {
+            match Self::recover_from_snapshots(path) {
+                Ok(count) => {
+                    eprintln!("Recovered {count} rows from snapshots");
+                    return Self::open_path_unchecked(path);
+                }
+                Err(_) => {
+                    // No snapshots or recovery failed — open_path_unchecked will create fresh
+                }
+            }
+        }
+
+        // 2. Try to open
+        let db = match Self::open_path_unchecked(path) {
+            Ok(db) => db,
+            Err(open_err) => {
+                // Try snapshot recovery
+                match Self::recover_from_snapshots(path) {
+                    Ok(count) => {
+                        eprintln!("Recovered {count} rows from snapshots");
+                        return Self::open_path_unchecked(path);
+                    }
+                    Err(recovery_err) => {
+                        return Err(CoreError::Config(format!(
+                            "Database failed to open and recovery failed.\n\
+                             Original error: {open_err}\n\
+                             Recovery error: {recovery_err}\n\n\
+                             Manual recovery options:\n  \
+                             1. Restore from backup: jettypod work restore-backup latest\n  \
+                             2. Check ~/.jettypod-backups/ for global backups"
+                        )));
+                    }
+                }
+            }
+        };
+
+        // 3. Check integrity
+        let integrity = db.check_integrity()?;
+        if !integrity.ok {
+            drop(db);
+            match Self::recover_from_snapshots(path) {
+                Ok(count) => {
+                    eprintln!("Recovered {count} rows from snapshots (corruption detected)");
+                    let db = Self::open_path_unchecked(path)?;
+                    let verify = db.check_integrity()?;
+                    if verify.ok {
+                        db.fixup_missing_columns()?;
+                        db.validate_schema()?;
+                        db.validate_tables()?;
+                        return Ok(db);
+                    }
+                }
+                Err(_) => {}
+            }
+            let errors = integrity.errors.join("\n  - ");
+            return Err(CoreError::Config(format!(
+                "Database integrity check failed and automatic recovery was unsuccessful.\n\
+                 Errors found:\n  - {errors}\n\n\
+                 Manual recovery options:\n  \
+                 1. Restore from backup: jettypod work restore-backup latest\n  \
+                 2. Check ~/.jettypod-backups/ for global backups"
+            )));
+        }
+
+        // 4. Fix up missing columns, then validate schema and tables
+        db.fixup_missing_columns()?;
+        db.validate_schema()?;
+        db.validate_tables()?;
+
+        Ok(db)
+    }
+}

package/crates/jettypod-core/src/db/validate.rs

@@ -0,0 +1,149 @@
+//! Schema validation and database integrity utilities.
+
+use crate::error::{CoreError, Result};
+use super::Database;
+
+// Column and table lists derived from V1__baseline.sql at build time.
+include!(concat!(env!("OUT_DIR"), "/schema_info.rs"));
+
+// ---------------------------------------------------------------------------
+// Result types
+// ---------------------------------------------------------------------------
+
+/// Result of a WAL checkpoint operation.
+#[derive(Debug)]
+pub struct WalCheckpointResult {
+    /// Whether the checkpoint completed without being blocked.
+    pub success: bool,
+    /// Number of pages written to the database file.
+    pub pages_written: i32,
+}
+
+/// Result of an integrity check.
+#[derive(Debug)]
+pub struct IntegrityResult {
+    /// `true` if the database passed all integrity checks.
+    pub ok: bool,
+    /// Error messages, empty if `ok` is true.
+    pub errors: Vec<String>,
+}
+
+// ---------------------------------------------------------------------------
+// Database validation methods
+// ---------------------------------------------------------------------------
+
+impl Database {
+    /// Force a WAL checkpoint, flushing all pending writes to the main
+    /// database file.
+    ///
+    /// Uses TRUNCATE mode to also remove the WAL file. Should be called
+    /// before git checkout/merge operations to prevent WAL corruption.
+    pub fn wal_checkpoint(&self) -> Result<WalCheckpointResult> {
+        let row: (i32, i32, i32) = self
+            .conn
+            .query_row("PRAGMA wal_checkpoint(TRUNCATE)", [], |row| {
+                Ok((row.get(0)?, row.get(1)?, row.get(2)?))
+            })?;
+
+        let (busy, _log_pages, checkpointed) = row;
+        Ok(WalCheckpointResult {
+            success: busy == 0,
+            pages_written: checkpointed,
+        })
+    }
+
+    /// Run SQLite's built-in integrity check.
+    pub fn check_integrity(&self) -> Result<IntegrityResult> {
+        let mut stmt = self.conn.prepare("PRAGMA integrity_check")?;
+        let results: Vec<String> = stmt
+            .query_map([], |row| row.get(0))?
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+
+        let ok = results.len() == 1 && results[0] == "ok";
+        Ok(IntegrityResult {
+            ok,
+            errors: if ok { Vec::new() } else { results },
+        })
+    }
+
+    /// Add any missing columns to work_items using definitions from V1__baseline.sql.
+    ///
+    /// Existing databases created before new columns were added to V1 won't have them
+    /// since CREATE TABLE IF NOT EXISTS skips existing tables. This method fills the gap.
+    pub fn fixup_missing_columns(&self) -> Result<()> {
+        let mut stmt = self.conn.prepare("PRAGMA table_info(work_items)")?;
+        let existing: Vec<String> = stmt
+            .query_map([], |row| row.get::<_, String>(1))?
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+
+        for (col_name, col_def) in WORK_ITEM_COLUMN_DEFS {
+            if !existing.iter().any(|e| e == *col_name) {
+                let sql = format!("ALTER TABLE work_items ADD COLUMN {col_name} {col_def}");
+                self.conn.execute(&sql, [])?;
+                eprintln!("Schema fixup: added missing column {col_name}");
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Validate that all expected columns exist on the work_items table.
+    pub fn validate_schema(&self) -> Result<()> {
+        let mut stmt = self.conn.prepare("PRAGMA table_info(work_items)")?;
+        let existing: Vec<String> = stmt
+            .query_map([], |row| row.get::<_, String>(1))?
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+
+        let missing: Vec<&str> = EXPECTED_WORK_ITEM_COLUMNS
+            .iter()
+            .filter(|col| !existing.iter().any(|e| e == **col))
+            .copied()
+            .collect();
+
+        if missing.is_empty() {
+            Ok(())
+        } else {
+            Err(CoreError::Config(format!(
+                "Schema validation failed: missing columns: {}",
+                missing.join(", ")
+            )))
+        }
+    }
+
+    /// Validate that all expected tables exist in the database.
+    pub fn validate_tables(&self) -> Result<()> {
+        let mut stmt = self.conn.prepare(
+            "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'"
+        )?;
+        let existing: Vec<String> = stmt
+            .query_map([], |row| row.get::<_, String>(0))?
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+
+        let missing: Vec<&str> = EXPECTED_TABLES
+            .iter()
+            .filter(|tbl| !existing.iter().any(|e| e == **tbl))
+            .copied()
+            .collect();
+
+        if missing.is_empty() {
+            Ok(())
+        } else {
+            Err(CoreError::Config(format!(
+                "Schema validation failed: missing tables: {}",
+                missing.join(", ")
+            )))
+        }
+    }
+
+    /// Sync `_meta.schema_version` so the Node.js forward-compatibility guard
+    /// knows the current schema state. The value matches the count of Node.js
+    /// migration files (33) that our V1 baseline represents.
+    pub fn sync_meta_version(&self) -> Result<()> {
+        const NODE_MIGRATION_COUNT: &str = "33";
+        self.conn.execute(
+            "INSERT OR REPLACE INTO _meta (key, value) VALUES ('schema_version', ?1)",
+            [NODE_MIGRATION_COUNT],
+        )?;
+        Ok(())
+    }
+}

package/crates/jettypod-core/src/error.rs

@@ -0,0 +1,76 @@
+use thiserror::Error;
+
+/// Structured git operation errors.
+#[derive(Debug, Error)]
+pub enum GitError {
+    #[error("git command failed: git {args}\n{stderr}")]
+    CommandFailed { args: String, stderr: String },
+
+    #[error("git not available: {0}")]
+    NotAvailable(String),
+
+    #[error("invalid branch name: {0}")]
+    InvalidBranch(String),
+
+    #[error("not a git repository: {0}")]
+    NotARepo(String),
+
+    #[error("{0}")]
+    Other(String),
+}
+
+/// Structured work item errors.
+#[derive(Debug, Error)]
+pub enum WorkError {
+    #[error("work item #{0} not found")]
+    NotFound(i64),
+
+    #[error("title cannot be empty")]
+    EmptyTitle,
+
+    #[error("invalid state: {0}")]
+    InvalidState(String),
+
+    #[error("{0}")]
+    Other(String),
+}
+
+/// Core error type for all jettypod-core operations.
+///
+/// Each variant maps to a module boundary. Automatic `From` conversions
+/// via `#[from]` keep call sites clean — use `?` freely.
+#[derive(Debug, Error)]
+pub enum CoreError {
+    #[error("database: {0}")]
+    Database(#[from] rusqlite::Error),
+
+    #[error("I/O: {0}")]
+    Io(#[from] std::io::Error),
+
+    #[error("JSON: {0}")]
+    Json(#[from] serde_json::Error),
+
+    #[error("JWT: {0}")]
+    Jwt(#[from] jsonwebtoken::errors::Error),
+
+    #[error("config: {0}")]
+    Config(String),
+
+    #[error("git: {0}")]
+    Git(#[from] GitError),
+
+    #[error("work: {0}")]
+    Work(#[from] WorkError),
+
+    #[error("skills: {0}")]
+    Skills(String),
+
+    #[error("parse: {0}")]
+    Parse(#[from] strum::ParseError),
+
+    #[error("{0}")]
+    Other(String),
+}
+
+/// Convenience alias used throughout jettypod-core.
+pub type Result<T> = std::result::Result<T, CoreError>;