tasks: implement execIfModified

Author: domenkozar

Cargo.lock

@@ -9,6 +9,7 @@ members = [
     "http-client-tls",
     "nix-conf-parser",
     "xtask",
+    "devenv-cache-core",
 ]
 
 [workspace.package]
@@ -23,6 +24,7 @@ devenv = { path = "devenv" }
 devenv-eval-cache = { path = "devenv-eval-cache" }
 devenv-run-tests = { path = "devenv-run-tests" }
 devenv-tasks = { path = "devenv-tasks" }
+devenv-cache-core = { path = "devenv-cache-core" }
 http-client-tls = { path = "http-client-tls" }
 nix-conf-parser = { path = "nix-conf-parser" }
 xtask = { path = "xtask" }
@@ -83,6 +85,7 @@ which = "7.0.2"
 whoami = "1.5.1"
 xdg = "2.5.2"
 tokio-tar = "0.3.1"
+walkdir = "2.3"
 
 # The version of rustls must match the version used by reqwest to set up rustls-platform-verifier.
 # If you encounter an error, lock these versions down.

Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "devenv-cache-core"
+version = "0.1.0"
+edition = "2021"
+description = "Core utilities for file tracking and caching in devenv"
+license = "MIT"
+
+[dependencies]
+# Database
+sqlx = { workspace = true, features = [
+    "runtime-tokio",
+    "tls-rustls",
+    "sqlite",
+    "migrate",
+    "macros",
+] }
+
+# Error handling
+thiserror.workspace = true
+miette.workspace = true
+eyre.workspace = true
+
+# Hashing
+blake3.workspace = true
+
+# File operations
+walkdir.workspace = true
+
+# Async runtime
+tokio = { workspace = true, features = ["fs", "macros", "time"] }
+
+# Logging
+tracing.workspace = true
+serde_json.workspace = true
+
+[dev-dependencies]
+tempfile.workspace = true
+tokio = { workspace = true, features = ["rt", "macros"] }

devenv-cache-core/Cargo.toml

@@ -0,0 +1,98 @@
+# devenv-cache-core
+
+A shared library for file tracking and caching in devenv.
+
+## Overview
+
+This crate provides common functionality used by both the task cache and eval cache implementations:
+
+- File content hashing and modification detection
+- SQLite database connection and management
+- Time utilities for SystemTime ⟷ Unix timestamp conversion
+- Common error types
+
+## Components
+
+### Database Module (`db.rs`)
+
+Provides a configurable SQLite database connection manager with optimized settings:
+
+```rust
+// Create a database connection
+let config = DbConfig {
+    path: PathBuf::from("/path/to/cache.db"),
+    ..Default::default()
+};
+let db = Database::new(config).await?;
+
+// Initialize schema
+db.init_schema(MY_SCHEMA).await?;
+```
+
+### File Tracking (`file.rs`)
+
+Tracks file modifications using both modification time and content hashing:
+
+```rust
+// Track a file
+let file = TrackedFile::new(path)?;
+
+// Check if modified
+if file.is_modified()? {
+    // File changed since last check
+}
+
+// Update tracked state
+file.update()?;
+```
+
+### Time Utilities (`time.rs`)
+
+Convert between SystemTime and Unix timestamps:
+
+```rust
+let unix_time = system_time_to_unix_seconds(SystemTime::now());
+let system_time = system_time_from_unix_seconds(unix_time);
+```
+
+### Error Handling (`error.rs`)
+
+Common error types with thiserror and miette integration:
+
+```rust
+#[derive(Error, Diagnostic, Debug)]
+pub enum CacheError {
+    #[error("Database error: {0}")]
+    Database(#[from] sqlx::Error),
+    
+    #[error("I/O error: {0}")]
+    Io(#[from] std::io::Error),
+    
+    // Other error variants...
+}
+```
+
+## Integration Strategy
+
+### For Task Cache
+
+The task cache can use this shared library for file tracking and database operations, while keeping its own schema and business logic:
+
+1. Replace direct SQLite usage with the `Database` type
+2. Replace file monitoring with `TrackedFile`
+3. Use shared error types and time utilities
+
+### For Eval Cache 
+
+Similarly, the eval cache can leverage the shared library while maintaining its specific file input tracking:
+
+1. Use the shared `Database` type for connection management
+2. Leverage `TrackedFile` for file state tracking
+3. Keep specialized command caching logic
+
+## Benefits
+
+- **Reduced Code Duplication**: Core functionality defined once
+- **Consistent Behavior**: Same file change detection logic across caches
+- **Simplified Maintenance**: Bug fixes in one place
+- **Better Abstraction**: Clear separation of concerns