From d9c179aeee4aadb261fbc4b39d49ec800aa62e85 Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Tue, 17 Nov 2026 09:42:31 +0000 Subject: [PATCH 1/2] feat: integrate incremental engine for certified task skipping Integrate the frontal-labs/incremental libraries (TypeScript SDK surface + Rust binding) across three surfaces to let the control plane certify "no change" and skip redundant reconcile/execution work. - code-incremental crate: Store API wrapping the vendored Rust binding, engine binary resolution, context builder, and e2e tests through the real engine (certified-skip + safe-fallback paths). - code-runtime adapter: incremental_observer bridge (observe_task, affected, advance) plus a flag gate read from settings.json; task-ID convention keyed on the stable server task ID. - code-server control plane: reconcile gate that skips a task when `affected` certifies no change (safe default: fallback -> run everything), and observe-on-complete to record task outcomes. - tools/incremental CLI: `affected` command with changeset from git, exit code 3 on fallback (suppressible), registered as a devtool. - Vendor the Rust binding at pinned commit 5039a33, pin the darwin-arm64 engine binary by SHA-256, and add a fetch script + manifest. Falls back to "run everything" (never a hard error) whenever the engine cannot certify a skip. --- .frontal-code/settings.json | 11 + .gitignore | 3 + BUILD | 4 + Cargo.lock | 32 + Cargo.toml | 2 +- crates/BUILD.bazel | 1 + crates/code-incremental/BUILD.bazel | 52 ++ crates/code-incremental/Cargo.toml | 15 + crates/code-incremental/NOTICE.md | 10 + crates/code-incremental/src/context.rs | 176 +++++ crates/code-incremental/src/engine_binary.rs | 149 ++++ crates/code-incremental/src/lib.rs | 690 ++++++++++++++++++ crates/code-runtime/Cargo.toml | 1 + .../code-runtime/src/incremental_observer.rs | 188 +++++ crates/code-runtime/src/lib.rs | 30 + crates/code-runtime/src/task_registry.rs | 55 ++ crates/code-runtime/src/worker_boot.rs | 53 +- crates/code-server/Cargo.toml | 1 + crates/code-server/src/lib.rs | 81 +- crates/code-tools/src/lib.rs | 10 +- scripts/fetch-incremental.sh | 126 ++++ third_party/incremental/BUILD.bazel | 20 + .../engine-binaries/darwin-arm64/incremental | Bin 0 -> 314008 bytes third_party/incremental/rust/Cargo.lock | 135 ++++ third_party/incremental/rust/Cargo.toml | 9 + third_party/incremental/rust/src/lib.rs | 515 +++++++++++++ third_party/manifests/incremental.json | 8 + tools/incremental/BUILD.bazel | 7 + tools/incremental/Cargo.toml | 16 + tools/incremental/src/main.rs | 411 +++++++++++ 30 files changed, 2805 insertions(+), 6 deletions(-) create mode 100644 crates/code-incremental/BUILD.bazel create mode 100644 crates/code-incremental/Cargo.toml create mode 100644 crates/code-incremental/NOTICE.md create mode 100644 crates/code-incremental/src/context.rs create mode 100644 crates/code-incremental/src/engine_binary.rs create mode 100644 crates/code-incremental/src/lib.rs create mode 100644 crates/code-runtime/src/incremental_observer.rs create mode 100755 scripts/fetch-incremental.sh create mode 100644 third_party/incremental/BUILD.bazel create mode 100755 third_party/incremental/engine-binaries/darwin-arm64/incremental create mode 100644 third_party/incremental/rust/Cargo.lock create mode 100644 third_party/incremental/rust/Cargo.toml create mode 100644 third_party/incremental/rust/src/lib.rs create mode 100644 third_party/manifests/incremental.json create mode 100644 tools/incremental/BUILD.bazel create mode 100644 tools/incremental/Cargo.toml create mode 100644 tools/incremental/src/main.rs diff --git a/.frontal-code/settings.json b/.frontal-code/settings.json index e36dc6ad..9c657d5d 100644 --- a/.frontal-code/settings.json +++ b/.frontal-code/settings.json @@ -284,6 +284,10 @@ "audit_logging": true, "sandbox_mode": false }, + "incremental": { + "_comment": "Incremental Compute Engine integration (see tools/incremental). When enabled, task status transitions are observed and the reconcile loop is gated by `affected` queries. Absent or false = disabled.", + "enabled": false + }, "tools": { "bash": { "enabled": true, @@ -362,6 +366,13 @@ "make_target": "generators", "description": "Scaffold crates from templates" }, + "incremental": { + "kind": "rust", + "cargo_pkg": "tools-incremental", + "bazel_label": "//tools/incremental:incremental", + "make_target": "incremental", + "description": "Incremental Compute Engine: observe, baseline, affected" + }, "remote": { "kind": "rust", "cargo_pkg": "tools-remote", diff --git a/.gitignore b/.gitignore index 2fa2822d..5826b1ad 100644 --- a/.gitignore +++ b/.gitignore @@ -32,6 +32,9 @@ Thumbs.db extensions/slack-agent/.bun-cache/ extensions/slack-agent/node_modules/ +# Incremental engine store +.incremental/ + # Bazel (Bzlmod) .bazelrc.project coverage/ diff --git a/BUILD b/BUILD index bc715f19..aed5fcc8 100644 --- a/BUILD +++ b/BUILD @@ -30,6 +30,7 @@ filegroup( "//:.cargo/config.toml", "//:rust-toolchain.toml", "//crates:all_crates", + "//third_party/incremental:rust_src", "//crates/code-plugins:bundled_plugins", "//examples:srcs", "//sdks/rust:rust_sdk_srcs", @@ -70,6 +71,7 @@ test_suite( "//crates/code-embeddings:test", "//crates/code-events:test", "//crates/code-harness:test", + "//crates/code-incremental:test", "//crates/code-integrations:test", "//crates/code-memory:test", "//crates/code-orchestrator:test", @@ -101,6 +103,7 @@ test_suite( "//crates/code-embeddings:lint", "//crates/code-events:lint", "//crates/code-harness:lint", + "//crates/code-incremental:lint", "//crates/code-integrations:lint", "//crates/code-memory:lint", "//crates/code-orchestrator:lint", @@ -132,6 +135,7 @@ test_suite( "//crates/code-embeddings:fmt", "//crates/code-events:fmt", "//crates/code-harness:fmt", + "//crates/code-incremental:fmt", "//crates/code-integrations:fmt", "//crates/code-memory:fmt", "//crates/code-orchestrator:fmt", diff --git a/Cargo.lock b/Cargo.lock index 4ea075c3..9fcada89 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -553,6 +553,16 @@ dependencies = [ "code-tools", ] +[[package]] +name = "code-incremental" +version = "0.3.0" +dependencies = [ + "incremental", + "serde", + "serde_json", + "thiserror 1.0.69", +] + [[package]] name = "code-integrations" version = "0.3.0" @@ -629,6 +639,7 @@ name = "code-runtime" version = "0.3.0" dependencies = [ "code-core", + "code-incremental", "code-integrations", "code-plugins", "code-sandbox", @@ -658,6 +669,7 @@ version = "0.3.0" dependencies = [ "axum", "code-events", + "code-incremental", "code-integrations", "code-orchestrator", "code-repo", @@ -1646,6 +1658,13 @@ dependencies = [ "icu_properties", ] +[[package]] +name = "incremental" +version = "0.1.0" +dependencies = [ + "serde_json", +] + [[package]] name = "indexmap" version = "2.14.2" @@ -2664,6 +2683,8 @@ version = "1.0.154" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" dependencies = [ + "foldhash", + "indexmap", "itoa", "memchr", "serde", @@ -3256,6 +3277,17 @@ dependencies = [ "serde_json", ] +[[package]] +name = "tools-incremental" +version = "0.3.0" +dependencies = [ + "anyhow", + "clap", + "code-incremental", + "serde", + "serde_json", +] + [[package]] name = "tools-remote" version = "0.3.0" diff --git a/Cargo.toml b/Cargo.toml index 1815c092..cd24e2a6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -members = ["cli", "crates/*", "sdks/rust", "tools/*", "tests/*"] +members = ["cli", "crates/*", "sdks/rust", "tools/*", "tests/*", "third_party/incremental/rust"] exclude = ["tools/fuzz/fuzz_targets/*"] resolver = "2" diff --git a/crates/BUILD.bazel b/crates/BUILD.bazel index abc098b2..9e4f40c5 100644 --- a/crates/BUILD.bazel +++ b/crates/BUILD.bazel @@ -11,6 +11,7 @@ filegroup( "//crates/code-embeddings:srcs", "//crates/code-events:srcs", "//crates/code-harness:srcs", + "//crates/code-incremental:srcs", "//crates/code-integrations:srcs", "//crates/code-memory:srcs", "//crates/code-orchestrator:srcs", diff --git a/crates/code-incremental/BUILD.bazel b/crates/code-incremental/BUILD.bazel new file mode 100644 index 00000000..2363a7e9 --- /dev/null +++ b/crates/code-incremental/BUILD.bazel @@ -0,0 +1,52 @@ +package(default_visibility = ["//visibility:public"]) + +filegroup( + name = "srcs", + srcs = glob( + ["**/*.rs"], + exclude = ["**/target/**"], + ) + ["Cargo.toml"], +) + +sh_test( + name = "test", + srcs = ["//tools:crate.sh"], + data = ["//:cargo_workspace"], + args = [ + "code-incremental", + "test", + ], + tags = [ + "rust", + "test", + ], +) + +sh_test( + name = "fmt", + size = "small", + srcs = ["//tools:crate.sh"], + data = ["//:cargo_workspace"], + args = [ + "code-incremental", + "fmt-check", + ], + tags = [ + "fmt", + "rust", + ], +) + +sh_test( + name = "lint", + srcs = ["//tools:crate.sh"], + data = ["//:cargo_workspace"], + args = [ + "code-incremental", + "clippy", + ], + tags = [ + "lint", + "rust", + ], +) diff --git a/crates/code-incremental/Cargo.toml b/crates/code-incremental/Cargo.toml new file mode 100644 index 00000000..43786fcd --- /dev/null +++ b/crates/code-incremental/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "code-incremental" +version.workspace = true +edition.workspace = true +license.workspace = true +publish = false + +[dependencies] +incremental = { path = "../../third_party/incremental/rust" } +serde = { version = "1", features = ["derive"] } +serde_json.workspace = true +thiserror = "1" + +[lints] +workspace = true diff --git a/crates/code-incremental/NOTICE.md b/crates/code-incremental/NOTICE.md new file mode 100644 index 00000000..010c8924 --- /dev/null +++ b/crates/code-incremental/NOTICE.md @@ -0,0 +1,10 @@ +// code-incremental +// +// This crate wraps the vendored Incremental Rust binding +// (third_party/incremental/rust) and provides the affected-plan and +// observation API used by the CLI runtime, code-server control plane, +// and the Bazel/dev pipeline. +// +// Vendored from: frontal-labs/incremental +// Pinned at: see third_party/manifests/incremental.json +// License: Apache-2.0 diff --git a/crates/code-incremental/src/context.rs b/crates/code-incremental/src/context.rs new file mode 100644 index 00000000..9daeb12b --- /dev/null +++ b/crates/code-incremental/src/context.rs @@ -0,0 +1,176 @@ +//! Context builder for the Incremental protocol. +//! +//! Every observation and every `affected` query carries a `context` object — +//! the set of global facts that change what a task's result means. The context +//! must be identical between observations and queries, or the engine falls back +//! to running everything (policy P2: `context_changed`). + +use serde_json::{json, Value}; +use std::path::Path; + +/// Build the context object for this repo. +/// +/// # Arguments +/// +/// * `repo_root` - The repository root directory. +/// * `runner` - The runner identifier (e.g. `frontal-code-sdk@0.3.0` or `cargo@1.85`). +/// * `node` - The runtime node version (e.g. `1.85.0` for Rust, `22.11.0` for Node). +/// +/// The context includes: +/// - `lockfile`: digest of `Cargo.lock` (Rust) or `package-lock.json` (TS), if present. +/// - `runner`: the runner identifier. +/// - `node`: the runtime version. +/// - `fmt`: the engine's format version (1). +/// - `caps`: capability flags. We only claim capabilities the adapter really records. +#[must_use] +pub fn build_context(repo_root: &Path, runner: &str, node: &str) -> Value { + let lockfile = lockfile_digest(repo_root); + let mut ctx = json!({ + "lockfile": lockfile, + "runner": runner, + "node": node, + "fmt": 1, + }); + if lockfile.is_none() { + ctx["lockfile"] = Value::Null; + } + // Capability flags: we only claim what the adapter actually records. + ctx["caps"] = json!({ + "reads": true, + "lists": false, + "probes": false, + "writes": true, + "env": false, + "config": false, + "declared_tasks": false, + }); + ctx +} + +/// Build a minimal context for tests (no real lockfile, fixed runner/node). +#[must_use] +pub fn test_context() -> Value { + build_context(Path::new("/nonexistent"), "test-runner@1.0.0", "1.0.0") +} + +/// Compute the lockfile digest. +/// +/// Reads `Cargo.lock` or `package-lock.json` from `repo_root` and returns a +/// deterministic 32-byte digest as a hex string, or `None` if no lockfile is +/// present or the read fails. +fn lockfile_digest(repo_root: &Path) -> Option { + // Try Rust lockfile first, then Node. + for name in ["Cargo.lock", "package-lock.json"] { + let path = repo_root.join(name); + if path.is_file() { + if let Ok(content) = std::fs::read(&path) { + return Some(hex(&sha256_bytes(&content))); + } + } + } + None +} + +/// Compute a deterministic 32-byte digest of a byte slice. +/// +/// This is a small inline implementation to avoid pulling in the `sha2` crate +/// as a dependency of `code-incremental`. The lockfile digest only needs to be +/// stable and collision-resistant enough for the engine to compare it — it is +/// not cryptographically secure. Uses FNV-1a 64-bit extended to 32 bytes by +/// hashing with 4 different offset mixings. +#[must_use] +fn sha256_bytes(data: &[u8]) -> [u8; 32] { + fn fnv1a_64(data: &[u8], offset: u64) -> u64 { + let mut hash: u64 = 0xcbf2_9ce4_8422_2325u64 ^ offset; + for &byte in data { + hash ^= u64::from(byte); + hash = hash.wrapping_mul(0x1000_0000_01b3u64); + } + hash + } + + let mut out = [0u8; 32]; + for (i, &offset) in [0u64, 1, 2, 3].iter().enumerate() { + out[i * 8..(i + 1) * 8].copy_from_slice(&fnv1a_64(data, offset).to_le_bytes()); + } + out +} + +/// Encode a byte slice as a lowercase hex string. +#[must_use] +fn hex(data: &[u8]) -> String { + use std::fmt::Write; + let mut s = String::with_capacity(data.len() * 2); + for &byte in data { + let _ = write!(s, "{byte:02x}"); + } + s +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_context_has_required_fields() { + let ctx = test_context(); + assert!(ctx.get("lockfile").is_some()); + assert!(ctx.get("runner").is_some()); + assert!(ctx.get("node").is_some()); + assert_eq!(ctx["fmt"], 1); + let caps = &ctx["caps"]; + assert!(caps["reads"].is_boolean()); + assert!(caps["writes"].is_boolean()); + } + + #[test] + fn build_context_in_empty_dir() { + let dir = std::env::temp_dir().join(format!( + "code-inc-ctx-empty-{}-{}", + std::process::id(), + nanos() + )); + std::fs::create_dir_all(&dir).unwrap(); + let ctx = build_context(&dir, "runner", "1.0"); + assert!(ctx["lockfile"].is_null(), "no lockfile in empty dir"); + assert_eq!(ctx["runner"], "runner"); + let _ = std::fs::remove_dir_all(&dir); + } + + #[test] + fn build_context_with_cargo_lock() { + let dir = std::env::temp_dir().join(format!( + "code-inc-ctx-lock-{}-{}", + std::process::id(), + nanos() + )); + std::fs::create_dir_all(&dir).unwrap(); + std::fs::write(dir.join("Cargo.lock"), "[package]\nname = \"x\"\n").unwrap(); + let ctx = build_context(&dir, "runner", "1.0"); + assert!( + ctx["lockfile"].is_string(), + "lockfile should be a hex string" + ); + let _ = std::fs::remove_dir_all(&dir); + } + + #[test] + fn fnv_hash_is_deterministic() { + let a = sha256_bytes(b"hello world"); + let b = sha256_bytes(b"hello world"); + assert_eq!(a, b); + } + + #[test] + fn fnv_hash_differs_for_different_input() { + let a = sha256_bytes(b"hello"); + let b = sha256_bytes(b"world"); + assert_ne!(a, b); + } + + fn nanos() -> u128 { + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_or(0, |d| d.as_nanos()) + } +} diff --git a/crates/code-incremental/src/engine_binary.rs b/crates/code-incremental/src/engine_binary.rs new file mode 100644 index 00000000..755b374b --- /dev/null +++ b/crates/code-incremental/src/engine_binary.rs @@ -0,0 +1,149 @@ +//! Engine binary resolution and spawn. +//! +//! Resolves the `incremental` engine binary from (in order): +//! 1. `FRONTAL_CODE_INCREMENTAL_ENGINE` env var (explicit path). +//! 2. `INCREMENTAL_ENGINE` env var (the binding's own default). +//! 3. A path baked in at build time (relative to the workspace root). +//! 4. `incremental` on `PATH`. +//! +//! If no binary is found, the integration degrades to "always run everything" +//! (a safe fallback). It never returns a hard error for a missing binary. + +use std::env; +use std::path::{Path, PathBuf}; +use std::process::Command; + +/// Result of attempting to locate the engine binary. +#[derive(Debug, Clone)] +pub enum EngineBinary { + /// The binary was found at the given path. + Found(PathBuf), + /// No binary is available. The integration should degrade to "always run everything." + Missing, +} + +impl EngineBinary { + /// Whether a usable binary was found. + #[must_use] + pub fn is_available(&self) -> bool { + matches!(self, EngineBinary::Found(_)) + } + + /// The resolved path, if found. + #[must_use] + pub fn path(&self) -> Option<&Path> { + match self { + EngineBinary::Found(path) => Some(path), + EngineBinary::Missing => None, + } + } + + /// Resolve the engine binary from env vars and build-time paths. + #[must_use] + pub fn resolve() -> Self { + resolve() + } +} + +/// Resolve the engine binary from env vars and build-time paths. +#[must_use] +pub fn resolve() -> EngineBinary { + // 1. Explicit override. + if let Some(path) = env::var_os("FRONTAL_CODE_INCREMENTAL_ENGINE") { + let path = PathBuf::from(path); + if path.is_file() { + return EngineBinary::Found(path); + } + } + + // 2. The binding's own env var. + if let Some(path) = env::var_os("INCREMENTAL_ENGINE") { + let path = PathBuf::from(path); + if path.is_file() { + return EngineBinary::Found(path); + } + } + + // 3. Build-time baked path (workspace root). + if let Some(baked) = baked_path() { + if baked.is_file() { + return EngineBinary::Found(baked); + } + } + + // 4. PATH lookup. + if which_binary("incremental") { + return EngineBinary::Found(PathBuf::from("incremental")); + } + + EngineBinary::Missing +} + +/// Build-time-baked path to the engine binary, computed relative to the +/// workspace root (which is two directories above `crates/code-incremental`). +fn baked_path() -> Option { + let workspace_root = Path::new(env!("CARGO_MANIFEST_DIR")) + .parent() // code-incremental + .and_then(|p| p.parent()) // crates + .and_then(|p| p.parent()); // workspace root + + let triple = target_triple(); + workspace_root.map(|root| { + root.join(format!( + "third_party/incremental/engine-binaries/{triple}/incremental" + )) + }) +} + +/// Check whether a binary is on the PATH. +fn which_binary(name: &str) -> bool { + Command::new("which") + .arg(name) + .output() + .is_ok_and(|o| o.status.success()) +} + +/// The target triple for this platform (e.g. `darwin-arm64`, `linux-x86_64`). +#[must_use] +pub fn target_triple() -> String { + let os = env::consts::OS; + let arch = env::consts::ARCH; + // Normalize arch names to match the directory layout. + let arch = match arch { + "aarch64" => "arm64", + "x86_64" => "x86_64", + "x86" => "x86", + other => other, + }; + format!("{os}-{arch}") +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn target_triple_is_well_formed() { + let triple = target_triple(); + assert!( + triple.contains('-'), + "triple should contain a dash: {triple}" + ); + } + + #[test] + fn missing_engine_reports_unavailable() { + // We can't guarantee a missing engine in all environments, so just + // check the API shape. + let missing = EngineBinary::Missing; + assert!(!missing.is_available()); + assert!(missing.path().is_none()); + } + + #[test] + fn found_engine_reports_available() { + let found = EngineBinary::Found(PathBuf::from("/bin/true")); + assert!(found.is_available()); + assert!(found.path().is_some()); + } +} diff --git a/crates/code-incremental/src/lib.rs b/crates/code-incremental/src/lib.rs new file mode 100644 index 00000000..b1d7b7ca --- /dev/null +++ b/crates/code-incremental/src/lib.rs @@ -0,0 +1,690 @@ +//! `code-incremental` — the Incremental Compute Engine integration for frontal-code. +//! +//! This crate wraps the vendored Incremental Rust binding and provides the +//! affected-plan and observation API used by the CLI runtime, code-server +//! control plane, and the Bazel/dev pipeline. +//! +//! # Design +//! +//! - A [`Store`] manages a single engine process and its store directory. +//! - A task may be skipped **only** with a certificate: an observation at the +//! current baseline whose inputs are all unchanged. Unknown or unverifiable +//! input makes the task invalid, or makes the whole answer a fallback. +//! No silent skips. +//! - A `fallback` result means "run everything" (the safe default). It is +//! never a hard error. +//! - The store is per-worktree by default (`/.incremental/`). +//! `tg.log` is the source of truth (append-only JSONL); indexes are +//! rebuildable caches. + +pub mod context; +pub mod engine_binary; + +use std::path::{Path, PathBuf}; +use std::time::Duration; + +use serde::{Deserialize, Serialize}; +use serde_json::Value; + +pub use context::build_context; +pub use engine_binary::{target_triple, EngineBinary}; + +// --------------------------------------------------------------------------- +// Errors +// --------------------------------------------------------------------------- + +/// Errors returned by [`Store`] methods. +#[derive(Debug, thiserror::Error)] +pub enum Error { + /// The engine binary could not be found. + #[error("incremental engine binary not found; use FRONTAL_CODE_INCREMENTAL_ENGINE or INCREMENTAL_ENGINE")] + EngineNotFound, + + /// The engine process failed to start. + #[error("engine failed to start: {0}")] + EngineStartup(String), + + /// A protocol error from the engine. + #[error("{code}: {message}")] + Protocol { code: String, message: String }, + + /// A timeout waiting for the engine to respond. + #[error("engine request timed out: {0}")] + Timeout(String), + + /// A filesystem error. + #[error("io error: {0}")] + Io(#[from] std::io::Error), + + /// A JSON serialization error. + #[error("json error: {0}")] + Json(#[from] serde_json::Error), +} + +pub type Result = std::result::Result; + +// --------------------------------------------------------------------------- +// Store +// --------------------------------------------------------------------------- + +/// A handle to one Incremental engine process and its store directory. +/// +/// The store is per-worktree by default (`/.incremental/`). Override +/// with `FRONTAL_CODE_INCREMENTAL_STORE` (passed through to +/// `INCREMENTAL_STORE`) or via [`Store::open`]. +/// +/// # Example +/// +/// ```no_run +/// use code_incremental::Store; +/// use std::path::Path; +/// +/// let mut store = Store::open(Path::new(".")).unwrap(); +/// let ctx = code_incremental::build_context(Path::new("."), "cargo@1.85", "1.85.0"); +/// let plan = store.affected( +/// &serde_json::json!({"changes": []}), +/// "abc123", +/// &ctx, +/// ).unwrap(); +/// +/// if plan.is_fallback() { +/// println!("fallback: run everything"); +/// } else { +/// for task in &plan.tasks { +/// println!("affected: {}", task.task_id); +/// } +/// } +/// ``` +pub struct Store { + client: incremental::Incremental, + path: PathBuf, + repo_root: PathBuf, +} + +impl Store { + /// Open a store rooted at `repo_root`. + /// + /// The store directory is `/.incremental/` by default. + /// The engine binary is resolved via [`EngineBinary::resolve`]. + /// + /// If no engine binary is available, returns `Err(Error::EngineNotFound)`. + /// Callers should catch this and degrade to "always run everything." + pub fn open(repo_root: &Path) -> Result { + let engine = EngineBinary::resolve(); + let binary = engine.path().ok_or(Error::EngineNotFound)?.to_path_buf(); + + let store_path = env_store_path(repo_root); + let cfg = incremental::Config { + engine: vec![binary.display().to_string()], + store: store_path.clone(), + root: repo_root.to_path_buf(), + timeout: Duration::from_secs(30), + restart: true, + }; + + let client = incremental::Incremental::connect(cfg) + .map_err(|e| Error::EngineStartup(format!("{}: {}", e.code, e.message)))?; + + Ok(Store { + client, + path: store_path, + repo_root: repo_root.to_path_buf(), + }) + } + + /// Ensure the store directory is initialized. + /// + /// Runs the engine's `init` command, which creates the store directory, + /// any missing parents, and an empty log with a header. Safe to call + /// multiple times (idempotent — the engine skips when the log exists). + /// + /// Call this before the first [`observe`](Self::observe) or + /// [`affected`](Self::affected) on a fresh worktree; a store that was + /// never initialized returns `store_missing` from the engine. + pub fn ensure_initialized(&self) { + let engine = EngineBinary::resolve(); + let Some(binary) = engine.path() else { + return; + }; + let _ = std::process::Command::new(binary) + .args([ + "init", + "--store", + &self.path.to_string_lossy(), + "--root", + &self.repo_root.to_string_lossy(), + ]) + .status(); + } + + /// The store directory path. + #[must_use] + pub fn store_path(&self) -> &Path { + &self.path + } + + /// The repo root this store is rooted at. + #[must_use] + pub fn repo_root(&self) -> &Path { + &self.repo_root + } + + // -- observation ------------------------------------------------------- + + /// Record a single observation. + /// + /// The observation JSON follows the protocol v1 schema: + /// ```json + /// { + /// "task": "src/foo.rs#test", + /// "inputs": [{"type": "file", "path": "src/foo.rs"}], + /// "outputs": [], + /// "outcome": "pass", + /// "duration_ms": 1234, + /// "dirty": false, + /// "context": { ... } + /// } + /// ``` + pub fn observe(&mut self, observation: &Value) -> Result { + self.client.observe(observation).map_err(protocol_err) + } + + /// Record multiple observations atomically. + /// + /// Either all observations are stored or none. Returns `{accepted: n}`. + pub fn observe_many(&mut self, observations: &[Value]) -> Result { + self.client.observe_many(observations).map_err(protocol_err) + } + + // -- baseline ---------------------------------------------------------- + + /// Query the current baseline. + /// + /// Returns `{baseline: | null}`. + pub fn baseline(&mut self) -> Result { + self.client.baseline().map_err(protocol_err) + } + + /// Advance the baseline to `to`. + /// + /// Fails with `baseline_conflict` unless `expected` equals the current + /// baseline (`null` before the first advance). It never overwrites. + pub fn advance(&mut self, to: &str, expected: Option<&str>) -> Result { + self.client.advance(to, expected).map_err(protocol_err) + } + + // -- affected ---------------------------------------------------------- + + /// Compute the affected plan for a changeset. + /// + /// `changes` is the changeset JSON: `{"changes": [{"path": ..., "status": ...}]}`. + /// `baseline` is the baseline to compare against (must equal the store's + /// current baseline for the engine to certify any skips — policy P0). + /// `context` is the context object; it **must** be present and must match + /// the observation contexts for the engine to certify any skips + /// (policy P0b). Use [`build_context`](crate::build_context) to build it. + /// + /// A `fallback` result means "run everything" (the safe default). + /// It is never a hard error — the plan is returned with `is_fallback == true`. + pub fn affected(&mut self, changes: &Value, baseline: &str, context: &Value) -> Result { + let mut opts = incremental::Affected::new(baseline); + opts.context = Some(context.clone()); + let raw = self.client.affected(changes, &opts).map_err(protocol_err)?; + Ok(Plan::from_json(&raw)) + } + + // -- explain / forget / stats ------------------------------------------ + + /// Explain why a task is or is not invalid. + pub fn explain(&mut self, task: &str) -> Result { + self.client.explain(task).map_err(protocol_err) + } + + /// Drop a task's observations. + pub fn forget(&mut self, task: &str) -> Result { + self.client.forget(task).map_err(protocol_err) + } + + /// Store statistics (tasks, observations, baseline). + pub fn stats(&mut self) -> Result { + self.client.stats().map_err(protocol_err) + } + + // -- hello / ping / compact -------------------------------------------- + + /// The `hello` handshake result: `{protocol, engine, capabilities, store}`. + pub fn hello(&mut self) -> Result { + self.client.hello().map_err(protocol_err) + } + + /// Ping the engine. + pub fn ping(&mut self) -> Result { + self.client.ping().map_err(protocol_err) + } + + /// Compact the store (no-op in the current build). + pub fn compact(&mut self) -> Result { + self.client.compact().map_err(protocol_err) + } +} + +// --------------------------------------------------------------------------- +// Plan +// --------------------------------------------------------------------------- + +/// The result of an `affected` query. +/// +/// A plan is never returned partially (protocol v1 §9.6). If the engine +/// cannot produce a complete plan, it returns a fallback instead. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Plan { + /// Tasks that must be re-run. + pub tasks: Vec, + /// Tasks that were skipped (have a valid certificate). + pub skipped: usize, + /// Tasks the engine knows about but has no observation for. + pub unobserved: Vec, + /// Tasks that were explicitly ignored. + pub ignored: Vec, + /// Tasks that have been deleted. + pub deleted_tasks: Vec, + /// Non-null when the engine ran everything instead of answering per task. + /// `fallback.reason` says why (e.g. `no_baseline`, `context_changed`, `dirty_observation`). + pub fallback: Option, + /// Policy confidence label (`medium`, `high`, `low`). Not a probability. + pub confidence: String, + /// The graph version at query time (e.g. `"g_a71d37aa"`). + pub graph_version: String, +} + +/// A single task in an affected plan. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Task { + /// The task ID (repo-relative path + task kind). + pub task_id: String, + /// Why the task is selected (e.g. `reads:src/math.ts`, `dirty_observation`, `fallback`). + pub reasons: Vec, +} + +/// The fallback annotation on a plan. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Fallback { + /// Why the fallback was triggered. + pub reason: String, +} + +impl Plan { + /// Whether the plan is a fallback (meaning "run everything"). + #[must_use] + pub fn is_fallback(&self) -> bool { + self.fallback.is_some() + } + + /// The number of tasks that must be re-run. + #[must_use] + pub fn task_count(&self) -> usize { + self.tasks.len() + } + + /// Deserialize a plan from the engine's raw JSON response. + #[must_use] + pub fn from_json(raw: &Value) -> Self { + let tasks = raw + .get("tasks") + .and_then(Value::as_array) + .map(|arr| { + arr.iter() + .filter_map(|t| { + Some(Task { + task_id: t["id"].as_str()?.to_string(), + reasons: t + .get("reasons") + .and_then(Value::as_array) + .map(|r| { + r.iter() + .filter_map(|v| v.as_str().map(String::from)) + .collect() + }) + .unwrap_or_default(), + }) + }) + .collect() + }) + .unwrap_or_default(); + + let skipped = raw + .get("skipped") + .and_then(Value::as_u64) + .and_then(|v| usize::try_from(v).ok()) + .unwrap_or(0); + let unobserved = string_array(raw, "unobserved"); + let ignored = string_array(raw, "ignored"); + let deleted_tasks = string_array(raw, "deleted_tasks"); + + let fallback = raw.get("fallback").and_then(|f| { + if f.is_null() { + None + } else { + Some(Fallback { + reason: f + .get("reason") + .and_then(Value::as_str) + .unwrap_or("unknown") + .to_string(), + }) + } + }); + + let confidence = raw + .get("confidence") + .and_then(Value::as_str) + .unwrap_or("unknown") + .to_string(); + + let graph_version = raw + .get("graph_version") + .and_then(Value::as_str) + .unwrap_or("unknown") + .to_string(); + + Plan { + tasks, + skipped, + unobserved, + ignored, + deleted_tasks, + fallback, + confidence, + graph_version, + } + } + + /// A plan with no tasks and no fallback (empty changeset). + #[must_use] + pub fn empty() -> Self { + Plan { + tasks: vec![], + skipped: 0, + unobserved: vec![], + ignored: vec![], + deleted_tasks: vec![], + fallback: None, + confidence: "high".to_string(), + graph_version: "unknown".to_string(), + } + } + + /// A fallback plan (run everything). + #[must_use] + pub fn fallback(reason: impl Into) -> Self { + Plan { + tasks: vec![], + skipped: 0, + unobserved: vec![], + ignored: vec![], + deleted_tasks: vec![], + fallback: Some(Fallback { + reason: reason.into(), + }), + confidence: "low".to_string(), + graph_version: "unknown".to_string(), + } + } +} + +fn string_array(raw: &Value, key: &str) -> Vec { + raw.get(key) + .and_then(Value::as_array) + .map(|arr| { + arr.iter() + .filter_map(|v| v.as_str().map(String::from)) + .collect() + }) + .unwrap_or_default() +} + +fn protocol_err(e: incremental::Error) -> Error { + match e.code.as_str() { + "timeout" => Error::Timeout(e.message), + "engine_exited" => Error::EngineStartup(e.message), + _ => Error::Protocol { + code: e.code, + message: e.message, + }, + } +} + +/// Resolve the store directory from the environment, falling back to +/// `/.incremental/`. +fn env_store_path(repo_root: &Path) -> PathBuf { + std::env::var_os("FRONTAL_CODE_INCREMENTAL_STORE") + .or_else(|| std::env::var_os("INCREMENTAL_STORE")) + .map_or_else(|| repo_root.join(".incremental"), PathBuf::from) +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn plan_from_json_full() { + let raw = json!({ + "tasks": [ + {"id": "src/foo.rs#test", "reasons": ["reads:src/bar.rs"]}, + {"id": "src/baz.rs#test", "reasons": ["dirty_observation"]} + ], + "skipped": 3, + "unobserved": ["src/new.rs#test"], + "ignored": [], + "deleted_tasks": ["src/old.rs#test"], + "fallback": null, + "confidence": "medium", + "graph_version": "g_a71d37aa" + }); + let plan = Plan::from_json(&raw); + assert_eq!(plan.task_count(), 2); + assert!(!plan.is_fallback()); + assert_eq!(plan.tasks[0].task_id, "src/foo.rs#test"); + assert_eq!(plan.tasks[0].reasons, vec!["reads:src/bar.rs"]); + assert_eq!(plan.tasks[1].task_id, "src/baz.rs#test"); + assert_eq!(plan.skipped, 3); + assert_eq!(plan.unobserved, vec!["src/new.rs#test"]); + assert_eq!(plan.ignored, Vec::::new()); + assert_eq!(plan.deleted_tasks, vec!["src/old.rs#test"]); + assert_eq!(plan.confidence, "medium"); + assert_eq!(plan.graph_version, "g_a71d37aa"); + } + + #[test] + fn plan_from_json_fallback() { + let raw = json!({ + "tasks": [], + "skipped": 0, + "unobserved": [], + "ignored": [], + "deleted_tasks": [], + "fallback": {"reason": "no_baseline"}, + "confidence": "low", + "graph_version": "g_00000000" + }); + let plan = Plan::from_json(&raw); + assert!(plan.is_fallback()); + assert_eq!(plan.task_count(), 0); + assert_eq!(plan.fallback.as_ref().unwrap().reason, "no_baseline"); + } + + #[test] + fn plan_empty() { + let plan = Plan::empty(); + assert!(!plan.is_fallback()); + assert_eq!(plan.task_count(), 0); + assert_eq!(plan.confidence, "high"); + } + + #[test] + fn plan_fallback_convenience() { + let plan = Plan::fallback("context_changed"); + assert!(plan.is_fallback()); + assert_eq!(plan.fallback.as_ref().unwrap().reason, "context_changed"); + assert_eq!(plan.confidence, "low"); + } + + #[test] + fn plan_missing_fields_defaults() { + let raw = json!({}); + let plan = Plan::from_json(&raw); + assert_eq!(plan.task_count(), 0); + assert!(!plan.is_fallback()); + assert_eq!(plan.confidence, "unknown"); + assert_eq!(plan.graph_version, "unknown"); + } + + #[test] + fn env_store_path_uses_repo_root() { + // Unset the env vars to test the default. + std::env::remove_var("FRONTAL_CODE_INCREMENTAL_STORE"); + std::env::remove_var("INCREMENTAL_STORE"); + let repo = Path::new("/tmp/test-repo"); + let store = env_store_path(repo); + assert_eq!(store, Path::new("/tmp/test-repo/.incremental")); + } + + #[test] + fn task_id_roundtrip() { + let task = Task { + task_id: "crates/code-runtime/src/task_registry.rs#test".to_string(), + reasons: vec!["reads:crates/code-runtime/src/task_registry.rs".to_string()], + }; + let json_val = serde_json::to_value(&task).unwrap(); + assert_eq!(json_val["task_id"], task.task_id); + assert_eq!(json_val["reasons"][0], task.reasons[0]); + } + + // -- end-to-end against the real engine -------------------------------- + // + // These tests spawn the vendored engine binary (skipped when it is not + // available for the current platform) and drive the full observe → + // advance → affected cycle through the `Store` API, not the raw + // protocol. They mirror the protocol probe that proved the engine + // certifies skips: matching baseline + context yields a certified skip, + // while any mismatch (context, baseline) falls back. + + /// A unique, engine-free temp dir for one test process run. + fn e2e_dir(name: &str) -> PathBuf { + std::env::temp_dir().join(format!( + "code-inc-e2e-{name}-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_or(0, |d| d.as_nanos()) + )) + } + + /// Build a fresh store on a temp repo, initialized with a baseline. + /// Skips (returns `None`) when the engine binary is unavailable. + fn fresh_e2e_store(baseline: &str) -> Option<(Store, PathBuf)> { + let engine = EngineBinary::resolve(); + let engine_path = engine.path()?; + // Skip cleanly on platforms without a prebuilt engine binary. + if !engine_path.exists() { + return None; + } + let repo = e2e_dir("repo"); + std::fs::create_dir_all(&repo).unwrap(); + let store_dir = repo.join(".incremental"); + std::process::Command::new(engine_path) + .args([ + "init", + "--store", + &store_dir.to_string_lossy(), + "--root", + &repo.to_string_lossy(), + ]) + .status() + .ok() + .filter(std::process::ExitStatus::success)?; + let mut store = Store::open(&repo).ok()?; + // First advance: null → baseline. + store.advance(baseline, None).ok()?; + Some((store, repo)) + } + + #[test] + fn e2e_certified_skip_and_fallbacks() { + let Some((mut store, repo)) = fresh_e2e_store("abc123") else { + eprintln!("skipping: engine binary unavailable"); + return; + }; + let ctx = build_context(&repo, "test-runner@1.0.0", "1.0.0"); + + // Observe a task whose only input is a file, at the store baseline. + let observation = json!({ + "task": "src/foo.rs#test", + "baseline": "abc123", + "inputs": [{"kind": "file", "path": "src/foo.rs"}], + "outputs": [], + "outcome": "pass", + "dirty": false, + "context": ctx, + }); + store.observe(&observation).unwrap(); + + // 1. Matching baseline + context, empty changeset → certified skip. + let plan = store + .affected(&json!({"changes": []}), "abc123", &ctx) + .unwrap(); + assert!( + !plan.is_fallback(), + "expected a certified plan, got fallback {:?}", + plan.fallback + ); + assert_eq!(plan.skipped, 1, "task should be skipped"); + assert_eq!(plan.task_count(), 0); + + // 2. Context mismatch → fallback (policy P2). + let mut bad_ctx = ctx.clone(); + bad_ctx["runner"] = json!("other-runner@9.9.9"); + let plan = store + .affected(&json!({"changes": []}), "abc123", &bad_ctx) + .unwrap(); + assert!(plan.is_fallback(), "context mismatch must fall back"); + assert_eq!(plan.fallback.as_ref().unwrap().reason, "context_changed"); + + // 3. Baseline mismatch → fallback (policy P0). + let plan = store + .affected(&json!({"changes": []}), "zzz999", &ctx) + .unwrap(); + assert!(plan.is_fallback(), "baseline mismatch must fall back"); + assert_eq!(plan.fallback.as_ref().unwrap().reason, "baseline_mismatch"); + + let _ = std::fs::remove_dir_all(&repo); + } + + #[test] + fn e2e_missing_store_degrades_safely() { + // A store that was never initialized returns `store_missing` from the + // engine. `affected` must surface that as an error the caller can + // degrade on — never a certified plan, never a panic. + // No engine at all: the safe default, also acceptable. + if EngineBinary::resolve().path().is_none() { + return; + } + let repo = e2e_dir("uninit"); + std::fs::create_dir_all(&repo).unwrap(); + let Some(mut store) = Store::open(&repo).ok() else { + // Engine exists but store could not be opened. + let _ = std::fs::remove_dir_all(&repo); + return; + }; + let ctx = build_context(&repo, "test-runner@1.0.0", "1.0.0"); + // The store is missing: the engine rejects the query. We assert that + // the call does not panic and either errors or returns a fallback. + let result = store.affected(&json!({"changes": []}), "abc123", &ctx); + match result { + Err(_) => {} // expected: store_missing + Ok(plan) => assert!(plan.is_fallback()), + } + let _ = std::fs::remove_dir_all(&repo); + } +} diff --git a/crates/code-runtime/Cargo.toml b/crates/code-runtime/Cargo.toml index 6acb0238..f062d15d 100644 --- a/crates/code-runtime/Cargo.toml +++ b/crates/code-runtime/Cargo.toml @@ -7,6 +7,7 @@ publish.workspace = true [dependencies] code-core = { path = "../code-core" } +code-incremental = { path = "../code-incremental" } sha2 = "0.11" glob = "0.3" getrandom = "0.4" diff --git a/crates/code-runtime/src/incremental_observer.rs b/crates/code-runtime/src/incremental_observer.rs new file mode 100644 index 00000000..e06df97e --- /dev/null +++ b/crates/code-runtime/src/incremental_observer.rs @@ -0,0 +1,188 @@ +//! Flag-gated observation bridge between the runtime task lifecycle and the +//! Incremental engine store. +//! +//! This module is the Phase-2 hook surface: +//! - **Observe**: task status transitions are recorded as protocol-v1 +//! observations so that a future `affected` query can certify skips. +//! - **Advance**: on terminal worker transitions, the store baseline is +//! advanced so subsequent queries measure against the latest completed +//! state. +//! +//! The bridge is **flag-gated** on `incremental.enabled` in +//! `.frontal-code/settings.json` and **best-effort**: every method swallows +//! errors so a missing engine binary or store directory never disrupts task +//! execution. The safe default — run everything — is preserved because +//! `affected` falls back to a full plan when the engine is unavailable. +//! +//! Task IDs follow the convention `#` (see the +//! integration plan). Callers are responsible for building a stable ID; this +//! module provides a helper for the common case. + +use std::path::Path; + +use code_incremental::{build_context, Store}; +use serde_json::{json, Value}; + +/// The runner identifier embedded in every observation context. +const RUNNER: &str = "frontal-code-runtime"; + +/// The runtime node version embedded in the context. Bump when the +/// runtime changes in a way that affects task outcomes. +const NODE: &str = "0.3.0"; + +/// Build a stable task ID for a sub-agent task. +/// +/// `rel_path` is the repo-relative path of the primary file the task +/// operates on; `kind` is the task kind (`test`, `build`, `run`, etc.). +#[must_use] +pub fn task_id(rel_path: &str, kind: &str) -> String { + format!("{rel_path}#{kind}") +} + +/// Map a terminal task status to the protocol-v1 outcome string. +#[must_use] +pub fn outcome_for(status: &str) -> &'static str { + match status { + "completed" => "pass", + "failed" => "fail", + "stopped" => "error", + _ => "none", + } +} + +/// Lazily opened store. Re-opened on every call for now; the engine process +/// is short-lived and the cost is dominated by the JSONL append, not process +/// spawn. A process-pooling optimization is a follow-up. +/// +/// Ensures the store is initialized (idempotent) so the first observation +/// on a fresh worktree does not hit `store_missing`. +fn open_store(repo_root: &Path) -> Option { + let store = Store::open(repo_root).ok()?; + store.ensure_initialized(); + Some(store) +} + +/// Record a task status transition as a protocol-v1 observation. +/// +/// # Arguments +/// +/// * `repo_root` - repository root (used to locate the store). +/// * `id` - stable task ID (`#`). +/// * `inputs` - the protocol-v1 input list (files, dirs, probes) the task +/// consumed. Pass an empty slice when unknown; the engine will treat the +/// observation as non-certifiable but not dirty. +/// * `status` - the terminal task status (`completed`, `failed`, `stopped`). +/// * `dirty` - set true if the run crashed before inputs could be verified. +pub fn observe_task(repo_root: &Path, id: &str, inputs: &[Value], status: &str, dirty: bool) { + let Some(mut store) = open_store(repo_root) else { + return; + }; + let context = build_context(repo_root, RUNNER, NODE); + // The engine requires the observation's baseline to match the store + // baseline for the observation to count as a certificate (policy P0). + let obs_baseline = store + .baseline() + .ok() + .and_then(|v| { + v.get("baseline") + .and_then(serde_json::Value::as_str) + .map(String::from) + }) + .unwrap_or_default(); + let obs_baseline = if obs_baseline.is_empty() { + "unknown".to_string() + } else { + obs_baseline + }; + let observation = json!({ + "task": id, + "baseline": obs_baseline, + "inputs": inputs, + "outputs": [], + "outcome": outcome_for(status), + "dirty": dirty, + "context": context, + }); + let _ = store.observe(&observation); +} + +/// Record a batch of observations (e.g. all task transitions for a batch). +pub fn observe_many(repo_root: &Path, observations: &[Value]) { + let Some(mut store) = open_store(repo_root) else { + return; + }; + let _ = store.observe_many(observations); +} + +/// Advance the store baseline to `to`. Called after a worker finishes a +/// session so that the next `affected` query measures against the +/// post-completion state. +pub fn advance(repo_root: &Path, to: &str, expected: Option<&str>) { + let Some(mut store) = open_store(repo_root) else { + return; + }; + let _ = store.advance(to, expected); +} + +/// Build the observation context for this repo (useful for constructing +/// `affected` queries from the runtime). +#[must_use] +pub fn context(repo_root: &Path) -> Value { + build_context(repo_root, RUNNER, NODE) +} + +/// Query the store for tasks affected by the given changeset relative to +/// `baseline`. Returns `None` if the store is unavailable or the query +/// falls back (caller should then run everything). +#[must_use] +pub fn affected(repo_root: &Path, baseline: &str, changes: &Value) -> Option> { + let mut store = open_store(repo_root)?; + // The engine requires a context object on every `affected` query to + // certify skips (policy P0b). Build it the same way observations do. + let ctx = build_context(repo_root, RUNNER, NODE); + let plan = store.affected(changes, baseline, &ctx).ok()?; + if plan.is_fallback() { + return None; + } + Some(plan.tasks.iter().map(|t| t.task_id.clone()).collect()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn task_id_is_stable() { + assert_eq!(task_id("crates/foo.rs", "test"), "crates/foo.rs#test"); + } + + #[test] + fn outcome_mapping() { + assert_eq!(outcome_for("completed"), "pass"); + assert_eq!(outcome_for("failed"), "fail"); + assert_eq!(outcome_for("stopped"), "error"); + assert_eq!(outcome_for("created"), "none"); + } + + #[test] + fn context_is_deterministic() { + let root = Path::new(env!("CARGO_MANIFEST_DIR")); + let a = context(root); + let b = context(root); + assert_eq!(a, b); + } + + #[test] + fn observe_task_does_not_panic_without_store() { + // No store exists at this path; observe_task must swallow the error. + let root = Path::new("/nonexistent-repo-root-for-test"); + observe_task(root, "task_1", &[], "completed", false); + } + + #[test] + fn affected_returns_none_without_store() { + let root = Path::new("/nonexistent-repo-root-for-test"); + let changes = json!({"changes": []}); + assert!(affected(root, "HEAD", &changes).is_none()); + } +} diff --git a/crates/code-runtime/src/lib.rs b/crates/code-runtime/src/lib.rs index 4cc171cb..3a55b99a 100644 --- a/crates/code-runtime/src/lib.rs +++ b/crates/code-runtime/src/lib.rs @@ -15,6 +15,7 @@ pub mod core_config; mod file_ops; pub mod green_contract; mod hooks; +pub mod incremental_observer; mod json; mod lane_events; pub mod lsp_client; @@ -65,6 +66,35 @@ pub use code_integrations::mcp::stdio::{ pub use code_integrations::mcp::tool_bridge::{ McpConnectionStatus, McpServerState, McpToolRegistry, }; +/// Returns `true` when the `incremental.enabled` setting is `true` in the +/// merged runtime settings. Defaults to `false` when the setting is absent. +/// +/// This is the flag gate for all Incremental engine interactions: when +/// disabled, no observations are recorded and no baseline advances occur. +#[must_use] +pub fn incremental_enabled() -> bool { + // The config module is loaded lazily; we check the project-local + // settings file directly to avoid a full config load on every call. + let path = std::env::current_dir() + .ok() + .map(|cwd| cwd.join(".frontal-code").join("settings.json")) + .filter(|p| p.exists()); + let Some(path) = path else { + return false; + }; + let Ok(raw) = std::fs::read_to_string(path) else { + return false; + }; + let Ok(value) = serde_json::from_str::(&raw) else { + return false; + }; + value + .get("incremental") + .and_then(|v| v.get("enabled")) + .and_then(serde_json::Value::as_bool) + .unwrap_or(false) +} + pub use code_integrations::mcp::tools::{ execute_mcp_tool, mcp_tool_specs, ToolSpec as McpToolSpec, }; diff --git a/crates/code-runtime/src/task_registry.rs b/crates/code-runtime/src/task_registry.rs index adedcc10..38d876ef 100644 --- a/crates/code-runtime/src/task_registry.rs +++ b/crates/code-runtime/src/task_registry.rs @@ -31,6 +31,13 @@ impl std::fmt::Display for TaskStatus { } } +impl TaskStatus { + #[must_use] + pub fn is_terminal(self) -> bool { + matches!(self, Self::Completed | Self::Failed | Self::Stopped) + } +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Task { pub task_id: String, @@ -55,6 +62,7 @@ pub struct TaskMessage { #[derive(Debug, Clone, Default)] pub struct TaskRegistry { inner: Arc>, + repo_root: Option, } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -82,6 +90,18 @@ impl TaskRegistry { Self::default() } + /// Return a registry rooted at `repo_root`, so that terminal task + /// transitions are recorded as Incremental observations (flag-gated on + /// `incremental.enabled` and best-effort: a missing engine binary is a + /// no-op). + #[must_use] + pub fn with_repo_root(repo_root: impl Into) -> Self { + Self { + repo_root: Some(repo_root.into()), + ..Self::default() + } + } + pub fn create(&self, prompt: &str, description: Option<&str>) -> Task { self.create_task(prompt.to_owned(), description.map(str::to_owned), None) } @@ -203,8 +223,25 @@ impl TaskRegistry { .tasks .get_mut(task_id) .ok_or_else(|| format!("task not found: {task_id}"))?; + let was_terminal = task.status.is_terminal(); task.status = status; task.updated_at = now_secs(); + let terminal = status.is_terminal(); + drop(inner); + // Record the transition as an Incremental observation on the first + // terminal status. Best-effort: a missing engine or disabled flag is + // a no-op (the safe default is to run everything). + if terminal && !was_terminal && crate::incremental_enabled() { + if let Some(repo_root) = &self.repo_root { + crate::incremental_observer::observe_task( + repo_root, + task_id, + &[], + &status.to_string(), + false, + ); + } + } Ok(()) } @@ -235,6 +272,23 @@ impl TaskRegistry { #[must_use] pub fn from_snapshot(snapshot: TaskRegistrySnapshot) -> Self { + Self::from_snapshot_inner(snapshot, None) + } + + /// Like [`from_snapshot`], but sets a repo root so terminal task + /// transitions are recorded as Incremental observations. + #[must_use] + pub fn from_snapshot_with_repo_root( + snapshot: TaskRegistrySnapshot, + repo_root: impl Into, + ) -> Self { + Self::from_snapshot_inner(snapshot, Some(repo_root.into())) + } + + fn from_snapshot_inner( + snapshot: TaskRegistrySnapshot, + repo_root: Option, + ) -> Self { let tasks = snapshot .tasks .into_iter() @@ -245,6 +299,7 @@ impl TaskRegistry { tasks, counter: snapshot.counter, })), + repo_root, } } diff --git a/crates/code-runtime/src/worker_boot.rs b/crates/code-runtime/src/worker_boot.rs index c8ed3d00..558683fc 100644 --- a/crates/code-runtime/src/worker_boot.rs +++ b/crates/code-runtime/src/worker_boot.rs @@ -144,6 +144,7 @@ pub struct Worker { #[derive(Debug, Clone, Default)] pub struct WorkerRegistry { inner: Arc>, + repo_root: Option, } #[derive(Debug, Default)] @@ -158,6 +159,18 @@ impl WorkerRegistry { Self::default() } + /// Return a registry rooted at `repo_root`, so that terminal worker + /// transitions advance the Incremental store baseline (flag-gated on + /// `incremental.enabled` and best-effort: a missing engine binary is a + /// no-op). + #[must_use] + pub fn with_repo_root(repo_root: impl Into) -> Self { + Self { + repo_root: Some(repo_root.into()), + ..Self::default() + } + } + #[must_use] pub fn create( &self, @@ -461,6 +474,7 @@ impl WorkerRegistry { .workers .get_mut(worker_id) .ok_or_else(|| format!("worker not found: {worker_id}"))?; + let was_terminal = is_worker_terminal(worker.status); worker.status = WorkerStatus::Finished; worker.prompt_in_flight = false; push_event( @@ -470,7 +484,12 @@ impl WorkerRegistry { Some("worker terminated by control plane".to_string()), None, ); - Ok(worker.clone()) + let result = Ok(worker.clone()); + drop(inner); + if !was_terminal { + self.advance_if_enabled(worker_id); + } + result } /// Classify session completion and transition worker to appropriate terminal state. @@ -489,6 +508,7 @@ impl WorkerRegistry { let is_provider_failure = (finish_reason == "unknown" && tokens_output == 0) || finish_reason == "error"; + let was_terminal = is_worker_terminal(worker.status); if is_provider_failure { let message = if finish_reason == "unknown" && tokens_output == 0 { @@ -526,8 +546,37 @@ impl WorkerRegistry { ); } - Ok(worker.clone()) + let result = Ok(worker.clone()); + drop(inner); + if !was_terminal { + self.advance_if_enabled(worker_id); + } + result } + + /// Advance the Incremental store baseline if the feature is enabled and + /// a repo root was set. Best-effort: a missing engine binary is a no-op. + fn advance_if_enabled(&self, worker_id: &str) { + let Some(repo_root) = &self.repo_root else { + return; + }; + if !crate::incremental_enabled() { + return; + } + let Some(status_str) = self + .inner + .lock() + .ok() + .and_then(|inner| inner.workers.get(worker_id).map(|w| w.status.to_string())) + else { + return; + }; + crate::incremental_observer::advance(repo_root, &status_str, None); + } +} + +fn is_worker_terminal(status: WorkerStatus) -> bool { + matches!(status, WorkerStatus::Finished | WorkerStatus::Failed) } #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] diff --git a/crates/code-server/Cargo.toml b/crates/code-server/Cargo.toml index 8acd5475..25fecc48 100644 --- a/crates/code-server/Cargo.toml +++ b/crates/code-server/Cargo.toml @@ -17,6 +17,7 @@ code-orchestrator = { path = "../code-orchestrator" } code-repo = { path = "../code-repo" } code-types = { path = "../code-types" } code-runtime = { path = "../code-runtime" } +code-incremental = { path = "../code-incremental" } code-tools = { path = "../code-tools" } serde = { version = "1", features = ["derive"] } serde_json.workspace = true diff --git a/crates/code-server/src/lib.rs b/crates/code-server/src/lib.rs index 7bc4dc48..e99e7756 100644 --- a/crates/code-server/src/lib.rs +++ b/crates/code-server/src/lib.rs @@ -514,20 +514,30 @@ impl ServerState { write_lock: Mutex::new(()), }) }); + let repo_root = std::env::current_dir().ok(); let (tasks, contexts, event_history) = persistence .as_ref() .and_then(|persistence| persistence.load().ok()) .map_or_else( || { ( - TaskRegistry::new(), + match &repo_root { + Some(root) => TaskRegistry::with_repo_root(root.clone()), + None => TaskRegistry::new(), + }, HashMap::new(), VecDeque::with_capacity(event_replay_limit.max(1)), ) }, |snapshot| { + let tasks = match &repo_root { + Some(root) => { + TaskRegistry::from_snapshot_with_repo_root(snapshot.tasks, root.clone()) + } + None => TaskRegistry::from_snapshot(snapshot.tasks), + }; ( - TaskRegistry::from_snapshot(snapshot.tasks), + tasks, snapshot.contexts, trim_event_history(snapshot.event_history, event_replay_limit.max(1)), ) @@ -817,6 +827,54 @@ impl ServerState { } } +/// Returns `true` when the Incremental engine should gate reconcile for +/// this task. When `false`, the task is reconciled unconditionally. +/// +/// The gate is best-effort: when the engine is unavailable or the query +/// falls back, reconcile proceeds as usual (safe default: run everything). +/// +/// # Task-ID scheme +/// +/// The stable identity for the Incremental engine is the **server task ID** +/// (`task_{:08x}_{counter}`), not the ephemeral `work_item_id` (a fresh UUID +/// regenerated on every `plan_work_item` call). The server task ID is +/// persisted in the `TaskRegistry` snapshot and survives restarts within a +/// single server lifetime. Across restarts the counter resets, so a new +/// task gets a new ID; the engine treats it as unobserved and falls back +/// (safe default). The `work_item_id` is not suitable because it is +/// regenerated on replan and multiple work items can map to one task. +fn incremental_gate_should_skip_reconcile(task_id: &str, repo_root: &std::path::Path) -> bool { + if !code_runtime::incremental_enabled() { + return false; + } + let changes = serde_json::json!({ + "changes": [ + { + "path": format!("{task_id}/artifacts"), + "status": "M" + } + ] + }); + let Some(affected) = code_runtime::incremental_observer::affected(repo_root, "HEAD", &changes) + else { + // Engine unavailable or fallback — reconcile as usual. + return false; + }; + // If the task ID is not in the affected set, skip reconcile. + !affected.iter().any(|t| t == task_id) +} + +/// Record a task completion as an Incremental observation and advance +/// the baseline. Best-effort: a missing engine or disabled flag is a +/// no-op. +fn observe_task_completion(task_id: &str, status: &str, repo_root: &std::path::Path) { + if !code_runtime::incremental_enabled() { + return; + } + code_runtime::incremental_observer::observe_task(repo_root, task_id, &[], status, false); + code_runtime::incremental_observer::advance(repo_root, status, None); +} + #[derive(Debug)] struct ServerStatePersistence { path: PathBuf, @@ -2780,6 +2838,17 @@ fn reconcile_active_tasks(state: &ServerState) { .collect::>(); for task_id in active_task_ids { + // Incremental gate: skip reconcile when the engine certifies the + // task is unaffected by changes. Fallback (engine unavailable or + // query falls back) means reconcile proceeds as usual. + if let Some(context) = state.context_for(&task_id) { + if let Some(repo) = &context.repository { + let repo_root = state.publish_workspace_root.join(repo); + if incremental_gate_should_skip_reconcile(&task_id, &repo_root) { + continue; + } + } + } let _ = reconcile_task_from_artifacts(state, &task_id); } } @@ -3449,6 +3518,14 @@ async fn complete_task( state.record_context(&task_id, context.clone()); let failure_error = request.error.clone().or(completion.error.clone()); + // Record the completion as an Incremental observation (flag-gated, + // best-effort). The repo root is derived from the workspace + repository + // name when available. + if let Some(repo) = &context.repository { + let repo_root = state.publish_workspace_root.join(repo); + observe_task_completion(&task_id, &completion.worker_status.to_string(), &repo_root); + } + match completion.worker_status { WorkerStatus::Finished => { state diff --git a/crates/code-tools/src/lib.rs b/crates/code-tools/src/lib.rs index 75aed636..e3b8dc66 100644 --- a/crates/code-tools/src/lib.rs +++ b/crates/code-tools/src/lib.rs @@ -66,7 +66,15 @@ fn global_cron_registry() -> &'static CronRegistry { fn global_task_registry() -> &'static TaskRegistry { use std::sync::OnceLock; static REGISTRY: OnceLock = OnceLock::new(); - REGISTRY.get_or_init(TaskRegistry::new) + // Root the registry at the current working directory so terminal task + // transitions can be recorded as Incremental observations (flag-gated on + // `incremental.enabled`; a no-op when the flag is off or the engine is + // missing). + REGISTRY.get_or_init(|| { + std::env::current_dir() + .map(TaskRegistry::with_repo_root) + .unwrap_or_default() + }) } fn global_worker_registry() -> &'static WorkerRegistry { diff --git a/scripts/fetch-incremental.sh b/scripts/fetch-incremental.sh new file mode 100755 index 00000000..31fc1ce4 --- /dev/null +++ b/scripts/fetch-incremental.sh @@ -0,0 +1,126 @@ +#!/usr/bin/env bash +# Fetch and vendor the Incremental engine at a pinned commit. +# +# This script is the reproducibility anchor for the vendored Incremental +# artifacts. It reads the pin from third_party/manifests/incremental.json, +# clones at that SHA, and copies the Rust binding source and the prebuilt +# engine binaries into third_party/incremental/. +# +# Usage: +# scripts/fetch-incremental.sh [--source DIR] +# +# --source DIR Use a local checkout instead of cloning (for offline use). +# DIR must be a checkout of frontal-labs/incremental at the +# pinned commit. +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)" +MANIFEST="$REPO_ROOT/third_party/manifests/incremental.json" +DEST="$REPO_ROOT/third_party/incremental" + +# --- read pin from manifest --- +if [[ ! -f "$MANIFEST" ]]; then + echo "error: manifest not found: $MANIFEST" >&2 + exit 1 +fi + +COMMIT="$(python3 -c "import json; print(json.load(open('$MANIFEST'))['commit'])")" +SHA256_RUST="$(python3 -c "import json; print(json.load(open('$MANIFEST'))['sha256_rust_src'])")" +REPO_URL="$(python3 -c "import json; print(json.load(open('$MANIFEST'))['repo'])")" + +echo "==> Pinned incremental commit: $COMMIT" + +# --- resolve source --- +SOURCE_DIR="" +if [[ "${1:-}" == "--source" ]]; then + SOURCE_DIR="${2:?usage: --source DIR}" + if [[ ! -d "$SOURCE_DIR" ]]; then + echo "error: source directory not found: $SOURCE_DIR" >&2 + exit 1 + fi +else + # Clone at the pinned SHA + SOURCE_DIR="$(mktemp -d)" + trap 'rm -rf "$SOURCE_DIR"' EXIT + echo "==> Cloning $REPO_URL at $COMMIT ..." + git clone --quiet "$REPO_URL" "$SOURCE_DIR" + (cd "$SOURCE_DIR" && git checkout --quiet "$COMMIT") +fi + +ACTUAL_COMMIT="$(cd "$SOURCE_DIR" && git rev-parse HEAD)" +if [[ "$ACTUAL_COMMIT" != "$COMMIT" ]]; then + echo "error: source commit $ACTUAL_COMMIT does not match pinned $COMMIT" >&2 + exit 1 +fi + +# --- verify Rust binding source hash --- +COMPUTED_HASH="$(cd "$SOURCE_DIR" && tar -cf - \ + bindings/rust/Cargo.toml \ + bindings/rust/Cargo.lock \ + bindings/rust/src/ \ + 2>/dev/null | shasum -a 256 | awk '{print $1}')" + +if [[ "$COMPUTED_HASH" != "$SHA256_RUST" ]]; then + echo "error: Rust binding source hash mismatch" >&2 + echo " expected: $SHA256_RUST" >&2 + echo " computed: $COMPUTED_HASH" >&2 + exit 1 +fi +echo "==> Rust binding source hash verified" + +# --- copy Rust binding --- +echo "==> Copying Rust binding to $DEST/rust ..." +rm -rf "$DEST/rust" +mkdir -p "$DEST/rust/src" +cp "$SOURCE_DIR/bindings/rust/Cargo.toml" "$DEST/rust/Cargo.toml" +cp "$SOURCE_DIR/bindings/rust/Cargo.lock" "$DEST/rust/Cargo.lock" +cp "$SOURCE_DIR/bindings/rust/src/lib.rs" "$DEST/rust/src/lib.rs" + +# --- copy engine binary (if present in source) --- +BIN_SRC="$SOURCE_DIR/core/dist/incremental" +if [[ -f "$BIN_SRC" ]]; then + # Detect the binary's platform triple + OS="$(uname -s | tr '[:upper:]' '[:lower:]')" + ARCH="$(uname -m)" + case "$ARCH" in + x86_64) ARCH="x64" ;; + aarch64) ARCH="arm64" ;; + arm64) ARCH="arm64" ;; + esac + TRIPLE="$OS-$ARCH" + echo "==> Copying engine binary ($TRIPLE) ..." + mkdir -p "$DEST/engine-binaries/$TRIPLE" + cp "$BIN_SRC" "$DEST/engine-binaries/$TRIPLE/incremental" + chmod +x "$DEST/engine-binaries/$TRIPLE/incremental" + + # Verify SHA-256 against the manifest + EXPECTED_BIN_HASH="$(python3 -c " +import json, sys +m = json.load(open('$MANIFEST')) +bins = m.get('sha256_bins', {}) +h = bins.get('$TRIPLE') +if h is None: + print('NOT_PINNED') +else: + print(h) +")" + ACTUAL_BIN_HASH="$(shasum -a 256 "$DEST/engine-binaries/$TRIPLE/incremental" | awk '{print $1}')" + if [[ "$EXPECTED_BIN_HASH" == "NOT_PINNED" ]]; then + echo "==> WARNING: engine binary for $TRIPLE is not pinned in the manifest." >&2 + echo "==> Computed SHA-256: $ACTUAL_BIN_HASH" >&2 + echo "==> Add it to third_party/manifests/incremental.json sha256_bins." >&2 + elif [[ "$ACTUAL_BIN_HASH" != "$EXPECTED_BIN_HASH" ]]; then + echo "error: engine binary hash mismatch for $TRIPLE" >&2 + echo " expected: $EXPECTED_BIN_HASH" >&2 + echo " computed: $ACTUAL_BIN_HASH" >&2 + exit 1 + else + echo "==> Engine binary hash verified" + fi +else + echo "==> No engine binary found in source (core/dist/incremental). Skipping." >&2 + echo "==> Build it with: cd incremental && make build" >&2 +fi + +echo "==> Done. Incremental vendored at $COMMIT" diff --git a/third_party/incremental/BUILD.bazel b/third_party/incremental/BUILD.bazel new file mode 100644 index 00000000..f080cd0e --- /dev/null +++ b/third_party/incremental/BUILD.bazel @@ -0,0 +1,20 @@ +load("@rules_shell//shell:sh_binary.bzl", "sh_binary") + +package(default_visibility = ["//visibility:public"]) + +# Vendored Rust binding source. +filegroup( + name = "rust_src", + srcs = glob( + ["rust/**/*"], + exclude = ["rust/target/**"], + ), +) + +# Prebuilt engine binaries per platform. +filegroup( + name = "engine_binary", + srcs = [ + "engine-binaries/darwin-arm64/incremental", + ], +) diff --git a/third_party/incremental/engine-binaries/darwin-arm64/incremental b/third_party/incremental/engine-binaries/darwin-arm64/incremental new file mode 100755 index 0000000000000000000000000000000000000000..3ca93af17d319626f2a590ce48f68bf9ab3170b6 GIT binary patch literal 314008 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, +} + +impl Error { + fn new(code: &str, message: impl Into, data: Option) -> Self { + Error { + code: code.to_string(), + message: message.into(), + data, + } + } +} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}: {}", self.code, self.message) + } +} + +impl std::error::Error for Error {} + +pub type Result = std::result::Result; + +/// Engine command, store, root and timing. `Config::default()` reads +/// `INCREMENTAL_ENGINE` and `INCREMENTAL_STORE`, and uses the enclosing git repository. +#[derive(Debug, Clone)] +pub struct Config { + /// Command prefix. The client runs ` serve --store --root `. + pub engine: Vec, + pub store: PathBuf, + pub root: PathBuf, + /// Budget for each request. A timeout kills the engine. + pub timeout: Duration, + /// Start a new engine when the old one has exited. + pub restart: bool, +} + +impl Default for Config { + fn default() -> Self { + let root = repo_root(); + Config { + engine: vec![env::var("INCREMENTAL_ENGINE") + .unwrap_or_else(|_| root.join("core/dist/incremental").display().to_string())], + store: env::var_os("INCREMENTAL_STORE") + .map_or_else(|| root.join(".incremental"), PathBuf::from), + timeout: Duration::from_secs(10), + restart: true, + root, + } + } +} + +fn repo_root() -> PathBuf { + let here = env::current_dir().unwrap_or_else(|_| PathBuf::from(".")); + match here.ancestors().find(|dir| dir.join(".git").exists()) { + Some(dir) => dir.to_path_buf(), + None => here.clone(), + } +} + +/// The options of an `affected` call (PROTOCOL.md 9.3). `context`, `env`, +/// `config` and `declared_tasks` are sent only when set. +#[derive(Debug, Clone)] +pub struct Affected { + pub baseline: String, + pub context: Option, + pub verify: bool, + pub policy: String, + pub env: Option, + pub config: Option, + pub declared_tasks: Option, +} + +impl Affected { + pub fn new(baseline: impl Into) -> Self { + Affected { + baseline: baseline.into(), + context: None, + verify: false, + policy: "balanced".to_string(), + env: None, + config: None, + declared_tasks: None, + } + } + + /// The `options` object of the request. + pub fn options(&self) -> Value { + let mut opts = + json!({"baseline": self.baseline, "verify": self.verify, "policy": self.policy}); + let map = opts.as_object_mut().expect("options is an object"); + let extra = [ + ("context", &self.context), + ("env", &self.env), + ("config", &self.config), + ("declared_tasks", &self.declared_tasks), + ]; + for (key, value) in extra { + if let Some(value) = value { + map.insert(key.to_string(), value.clone()); + } + } + opts + } +} + +/// A running engine and the reader threads for its stdout and stderr. +#[derive(Debug)] +struct Run { + child: Child, + stdin: ChildStdin, + lines: Receiver>, + stderr: Arc>>, + hello: Value, +} + +/// A client for one engine process. The process is started by `connect` and +/// restarted on the next call if it died (when `Config::restart` is set). +#[derive(Debug)] +pub struct Incremental { + cfg: Config, + run: Option, + started: bool, + next_id: u64, +} + +impl Incremental { + /// Starts the engine and runs the `hello` handshake. + pub fn connect(cfg: Config) -> Result { + let mut client = Incremental { + cfg, + run: None, + started: false, + next_id: 1, + }; + client.ensure()?; + Ok(client) + } + + /// The `hello` result: `{protocol, engine, capabilities, store}`. + pub fn hello(&mut self) -> Result { + Ok(self.ensure()?.hello.clone()) + } + + pub fn observe(&mut self, observation: &Value) -> Result { + self.request("observe", &json!({"observation": observation})) + } + + /// Atomic: either all observations are stored or none. Returns `{accepted: n}`. + pub fn observe_many(&mut self, observations: &[Value]) -> Result { + self.request("observe_many", &json!({"observations": observations})) + } + + pub fn baseline(&mut self) -> Result { + self.request("baseline", &json!({})) + } + + /// Fails with `baseline_conflict` unless `expected` equals the current baseline. + pub fn advance(&mut self, to: &str, expected: Option<&str>) -> Result { + self.request("advance", &json!({"to": to, "expected": expected})) + } + + /// Returns the plan (PROTOCOL.md 9.6). A partial plan is an error. + pub fn affected(&mut self, changes: &Value, options: &Affected) -> Result { + let plan = self.request( + "affected", + &json!({"changes": changes, "options": options.options()}), + )?; + check_plan(plan) + } + + pub fn explain(&mut self, task: &str) -> Result { + self.request("explain", &json!({"task": task})) + } + + pub fn forget(&mut self, task: &str) -> Result { + self.request("forget", &json!({"task": task})) + } + + pub fn stats(&mut self) -> Result { + self.request("stats", &json!({})) + } + + /// Forwarded to the engine, which may refuse (`compact` is not in this milestone). + pub fn compact(&mut self) -> Result { + self.request("compact", &json!({})) + } + + pub fn ping(&mut self) -> Result { + self.request("ping", &json!({})) + } + + /// Sends `shutdown`, waits up to the request timeout for the exit, then kills the engine. + pub fn close(self) { + drop(self); + } + + fn take_id(&mut self) -> u64 { + let id = self.next_id; + self.next_id += 1; + id + } + + // The running engine, starting one when there is none or the last one exited. + fn ensure(&mut self) -> Result<&mut Run> { + let exited = match self.run.as_mut() { + Some(run) => matches!(run.child.try_wait(), Ok(Some(_))), + None => true, + }; + if exited { + self.run = None; + if self.started && !self.cfg.restart { + return Err(Error::new( + "engine_exited", + "the engine exited and restart is disabled", + None, + )); + } + let run = self.start()?; + self.run = Some(run); + } + Ok(self.run.as_mut().expect("engine is running")) + } + + fn start(&mut self) -> Result { + let mut run = spawn(&self.cfg)?; + self.started = true; + let params = json!({"protocol": PROTOCOL, "client": {"name": CLIENT_NAME, "version": CLIENT_VERSION}}); + let id = self.take_id(); + let hello = match call(&mut run, id, "hello", ¶ms, STARTUP_TIMEOUT) { + Ok(hello) => hello, + Err(err) => { + kill(&mut run.child); + return Err(err); + } + }; + match hello.get("protocol").and_then(Value::as_u64) { + Some(PROTOCOL) => {} + Some(_) => { + kill(&mut run.child); + return Err(Error::new( + "protocol_mismatch", + "the engine does not speak protocol 1", + Some(hello), + )); + } + None => { + kill(&mut run.child); + return Err(Error::new( + "internal", + "the engine answered hello with no protocol", + None, + )); + } + } + run.hello = hello; + Ok(run) + } + + fn request(&mut self, method: &str, params: &Value) -> Result { + match self.exchange(method, params) { + Err(err) + if err.code == "engine_exited" + && self.cfg.restart + && READ_ONLY.contains(&method) => + { + self.exchange(method, params) + } + other => other, + } + } + + fn exchange(&mut self, method: &str, params: &Value) -> Result { + let id = self.take_id(); + let timeout = self.cfg.timeout; + let run = self.ensure()?; + let result = call(run, id, method, params, timeout); + if matches!(&result, Err(err) if err.code == "timeout" || err.code == "engine_exited") { + self.run = None; + } + result + } + + fn stop(&mut self) { + let Some(mut run) = self.run.take() else { + return; + }; + if matches!(run.child.try_wait(), Ok(None)) { + let id = self.take_id(); + // The engine writes its index image before it exits, so give it time. + let _ = call(&mut run, id, "shutdown", &json!({}), self.cfg.timeout); + } + if wait_exit(&mut run.child, self.cfg.timeout).is_none() { + kill(&mut run.child); + } + } +} + +impl Drop for Incremental { + fn drop(&mut self) { + self.stop(); + } +} + +fn spawn(cfg: &Config) -> Result { + let (cmd, prefix) = cfg + .engine + .split_first() + .ok_or_else(|| Error::new("internal", "the engine command is empty", None))?; + let mut child = Command::new(cmd) + .args(prefix) + .arg("serve") + .arg("--store") + .arg(&cfg.store) + .arg("--root") + .arg(&cfg.root) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .map_err(|err| Error::new("internal", format!("cannot run the engine: {err}"), None))?; + let stdin = child.stdin.take().expect("stdin is piped"); + let stdout = child.stdout.take().expect("stdout is piped"); + let stderr = child.stderr.take().expect("stderr is piped"); + + let (tx, lines) = mpsc::channel(); + thread::spawn(move || { + for line in BufReader::new(stdout) + .lines() + .map_while(std::io::Result::ok) + { + if tx.send(Some(line)).is_err() { + return; + } + } + let _ = tx.send(None); + }); + + let tail = Arc::new(Mutex::new(Vec::::new())); + let sink = Arc::clone(&tail); + thread::spawn(move || { + for line in BufReader::new(stderr) + .lines() + .map_while(std::io::Result::ok) + { + let mut kept = sink.lock().unwrap_or_else(|poisoned| poisoned.into_inner()); + kept.push(line); + let excess = kept.len().saturating_sub(STDERR_LINES); + kept.drain(..excess); + } + }); + + Ok(Run { + child, + stdin, + lines, + stderr: tail, + hello: Value::Null, + }) +} + +// Sends one request and reads lines until the answer with `id` arrives. A +// timeout or the end of the output ends the run; the caller drops it. +fn call(run: &mut Run, id: u64, method: &str, params: &Value, timeout: Duration) -> Result { + let line = json!({"id": id, "method": method, "params": params}).to_string(); + // A failed write means the engine is gone. Its end of output is reported below. + let _ = writeln!(run.stdin, "{line}"); + let _ = run.stdin.flush(); + + let deadline = Instant::now() + timeout; + loop { + let raw = match run + .lines + .recv_timeout(deadline.saturating_duration_since(Instant::now())) + { + Ok(Some(raw)) => raw, + Ok(None) | Err(RecvTimeoutError::Disconnected) => return Err(exited(run)), + Err(RecvTimeoutError::Timeout) => { + kill(&mut run.child); + let data = json!({"partial": false}); + return Err(Error::new( + "timeout", + format!("no response within {timeout:?}"), + Some(data), + )); + } + }; + let msg: Map = match serde_json::from_str(&raw) { + Ok(Value::Object(msg)) => msg, + _ => { + let text = format!("engine wrote a line that is not a JSON object: {raw:?}"); + return Err(Error::new("bad_response", text, None)); + } + }; + if msg.get("id") == Some(&json!(id)) { + if let Some(err) = msg.get("error") { + return Err(error_of(err)); + } + return msg.get("result").cloned().ok_or_else(|| { + Error::new( + "bad_response", + "response has neither result nor error", + None, + ) + }); + } + // A store-level failure is printed without an id (CLI style): {"ok": false, "error": {...}}. + if msg.get("id").is_none_or(|v| v.is_null()) && msg.get("ok") == Some(&Value::Bool(false)) { + if let Some(err) = msg.get("error") { + return Err(error_of(err)); + } + } + // Any other line belongs to an earlier request and is dropped. + } +} + +fn error_of(err: &Value) -> Error { + Error { + code: err + .get("code") + .and_then(Value::as_str) + .unwrap_or("internal") + .to_string(), + message: err + .get("message") + .and_then(Value::as_str) + .unwrap_or("") + .to_string(), + data: err.get("data").filter(|data| !data.is_null()).cloned(), + } +} + +// The engine ended while a request was in flight, or before one was sent. +fn exited(run: &mut Run) -> Error { + let status = wait_exit(&mut run.child, Duration::from_secs(5)).and_then(|status| status.code()); + kill(&mut run.child); + let stderr = run + .stderr + .lock() + .map(|lines| lines.join("\n")) + .unwrap_or_default(); + let code = status.map_or_else(|| "unknown".to_string(), |code| code.to_string()); + let data = (!stderr.is_empty()).then(|| Value::String(stderr)); + Error::new( + "engine_exited", + format!("engine exited (status {code})"), + data, + ) +} + +fn wait_exit(child: &mut Child, timeout: Duration) -> Option { + let deadline = Instant::now() + timeout; + loop { + match child.try_wait() { + Ok(Some(status)) => return Some(status), + Ok(None) if Instant::now() < deadline => thread::sleep(Duration::from_millis(5)), + _ => return None, + } + } +} + +fn kill(child: &mut Child) { + let _ = child.kill(); + let _ = child.wait(); +} + +// A plan is never returned partially (PROTOCOL.md 9.6). +fn check_plan(plan: Value) -> Result { + let lists = ["tasks", "unobserved", "ignored", "deleted_tasks"]; + let fields = ["fallback", "confidence", "graph_version"]; + let complete = lists + .iter() + .all(|key| plan.get(*key).is_some_and(|v| v.is_array())) + && fields.iter().all(|key| plan.get(*key).is_some()); + if complete { + Ok(plan) + } else { + let data = json!({"reason": "partial_plan"}); + Err(Error::new( + "internal", + "the engine answered affected with an incomplete plan", + Some(data), + )) + } +} diff --git a/third_party/manifests/incremental.json b/third_party/manifests/incremental.json new file mode 100644 index 00000000..efe7a209 --- /dev/null +++ b/third_party/manifests/incremental.json @@ -0,0 +1,8 @@ +{ + "repo": "frontal-labs/incremental", + "commit": "5039a33ce9b8ca4160bb9d5c326e6107932b6782", + "sha256_rust_src": "acd214ebb81a5678f4885d83e49c4fa1423f1601466c6abfb13bcaceee98b11f", + "sha256_bins": { + "darwin-arm64": "8a3bd414981961d684dead2d3456b54f27a9b1d9dc21d506fe0d047fadd3dd83" + } +} diff --git a/tools/incremental/BUILD.bazel b/tools/incremental/BUILD.bazel new file mode 100644 index 00000000..865b2fee --- /dev/null +++ b/tools/incremental/BUILD.bazel @@ -0,0 +1,7 @@ +package(default_visibility = ["//visibility:public"]) + +sh_binary( + name = "incremental", + srcs = ["//tools:cargo_run.sh"], + args = ["tools-incremental"], +) diff --git a/tools/incremental/Cargo.toml b/tools/incremental/Cargo.toml new file mode 100644 index 00000000..02c18e88 --- /dev/null +++ b/tools/incremental/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "tools-incremental" +version.workspace = true +edition.workspace = true +license.workspace = true +publish.workspace = true + +[dependencies] +anyhow = "1" +clap = { version = "4", features = ["derive"] } +code-incremental = { path = "../../crates/code-incremental" } +serde = { version = "1", features = ["derive"] } +serde_json = "1" + +[lints] +workspace = true diff --git a/tools/incremental/src/main.rs b/tools/incremental/src/main.rs new file mode 100644 index 00000000..a8c873e5 --- /dev/null +++ b/tools/incremental/src/main.rs @@ -0,0 +1,411 @@ +//! `tools-incremental` — dev-pipeline CLI for the Incremental Compute Engine. +//! +//! Wraps the `code-incremental` crate so the repo's build/test pipeline can +//! observe task outcomes, advance the baseline, and ask which tasks are +//! affected by a changeset. Fallbacks ("run everything") are the safe +//! default and never a hard error. + +use std::fs; +use std::path::{Path, PathBuf}; + +use anyhow::{bail, Context, Result}; +use clap::{Parser, Subcommand}; +use code_incremental::{build_context, target_triple, EngineBinary, Store}; +use serde::Serialize; +use serde_json::{json, Value}; + +#[derive(Parser)] +#[command( + name = "code-incremental", + about = "Incremental Compute Engine dev CLI" +)] +struct Cli { + /// Repository root the store is rooted at (defaults to the current directory). + #[arg(long, global = true, default_value = ".")] + root: PathBuf, + + /// Output format. + #[arg(long, value_enum, default_value_t = Format::Text, global = true)] + format: Format, + + /// Suppress the fallback-safe exit code (always exit 0 on success). + #[arg(long, global = true)] + no_fail_on_fallback: bool, + + #[command(subcommand)] + command: Command, +} + +#[derive(Copy, Clone, PartialEq, Eq, clap::ValueEnum, Serialize)] +#[value(rename_all = "lowercase")] +enum Format { + Text, + Json, +} + +#[derive(Subcommand)] +enum Command { + /// Resolve the engine binary and print its path. + Doctor, + /// The engine `hello` handshake (protocol, engine, capabilities, store). + Hello, + /// Ping the engine. + Ping, + /// Store statistics (tasks, observations, baseline). + Stats, + /// Query the current baseline. + Baseline, + /// Advance the baseline to a new sha. + Advance { + /// New baseline sha to advance to. + to: String, + /// Expected current baseline; omit (or use `--expected null`) for the first advance. + #[arg(long, default_value = "null")] + expected: String, + }, + /// Record a single observation (JSON file or `-` for stdin). + Observe { + /// Path to a JSON observation file, or `-` for stdin. + input: PathBuf, + }, + /// Record multiple observations from a JSON array file (or `-` for stdin). + ObserveMany { + /// Path to a JSON array of observations, or `-` for stdin. + input: PathBuf, + }, + /// Explain why a task is or is not invalid. + Explain { task: String }, + /// Drop a task's observations. + Forget { task: String }, + /// Compute the affected plan for a changeset. + Affected { + /// Baseline to compare against. + baseline: String, + /// Path to a changeset JSON file (`{"changes": [{"path": ..., "status": ...}]}`), + /// or `-` for stdin. When omitted, a git diff against the baseline is used. + #[arg(long)] + changes: Option, + /// Runner identifier for the observation context (default: `frontal-code-cli`). + #[arg(long, default_value = "frontal-code-cli")] + runner: String, + /// Runtime node version for the observation context. + #[arg(long, default_value = "0.0.0")] + node: String, + /// Repo-relative path to the lockfile (default: auto-detect `Cargo.lock`). + #[arg(long)] + lockfile: Option, + }, +} + +fn main() { + if let Err(err) = run() { + eprintln!("error: {err:#}"); + std::process::exit(1); + } +} + +#[allow(clippy::too_many_lines)] +fn run() -> Result<()> { + let cli = Cli::parse(); + let repo_root = canonicalize(&cli.root)?; + + if matches!(cli.command, Command::Doctor) { + let triple = target_triple(); + let engine = EngineBinary::resolve(); + let path = engine.path().map(Path::display); + let report = json!({ + "platform": triple, + "engine_found": engine.is_available(), + "engine_path": path.map(|p| p.to_string()), + "store_path": store_display_path(&repo_root), + }); + print_result(cli.format, &report, &doctor_text(&report)); + return Ok(()); + } + + let Some(mut store) = open_store(&repo_root)? else { + // No engine binary available: degrade to the safe default. + eprintln!("incremental engine unavailable; assuming everything is affected"); + if !cli.no_fail_on_fallback { + std::process::exit(EXIT_FALLBACK); + } + return Ok(()); + }; + + match &cli.command { + Command::Doctor => unreachable!("handled above"), + Command::Hello => { + print_raw(cli.format, &store.hello().context("hello")?); + } + Command::Ping => { + print_raw(cli.format, &store.ping().context("ping")?); + } + Command::Stats => { + print_raw(cli.format, &store.stats().context("stats")?); + } + Command::Baseline => { + print_raw(cli.format, &store.baseline().context("baseline")?); + } + Command::Advance { to, expected } => { + let expected_opt = (expected != "null").then_some(expected.as_str()); + print_raw( + cli.format, + &store.advance(to, expected_opt).context("advance")?, + ); + } + Command::Observe { input } => { + let observation = read_json(input).context("read observation")?; + print_raw(cli.format, &store.observe(&observation).context("observe")?); + } + Command::ObserveMany { input } => { + let value = read_json(input).context("read observations")?; + let arr = value + .as_array() + .context("input must be a JSON array of observations")?; + print_raw( + cli.format, + &store.observe_many(arr).context("observe_many")?, + ); + } + Command::Explain { task } => { + print_raw(cli.format, &store.explain(task).context("explain")?); + } + Command::Forget { task } => { + print_raw(cli.format, &store.forget(task).context("forget")?); + } + Command::Affected { + baseline, + changes, + runner, + node, + lockfile, + } => { + let changeset = match changes { + Some(path) => read_json(path).context("read changeset")?, + None => git_changeset(baseline, &repo_root)?, + }; + // Lockfile override: the digest is embedded in the context; + // an explicit `--lockfile` path is honored by re-deriving + // the digest for that specific file. + let context = if let Some(lock) = lockfile { + context_with_lockfile(&repo_root, lock, runner, node) + } else { + build_context(&repo_root, runner, node) + }; + let plan = store + .affected(&changeset, baseline, &context) + .with_context(|| format!("affected against baseline {baseline}"))?; + + let report = json!({ + "baseline": baseline, + "fallback": plan.is_fallback(), + "fallback_reason": plan.fallback.as_ref().map(|f| &f.reason), + "tasks": plan.tasks, + "skipped": plan.skipped, + "unobserved": plan.unobserved, + "confidence": plan.confidence, + "graph_version": plan.graph_version, + }); + print_result(cli.format, &report, &affected_text(&report)); + if plan.is_fallback() && !cli.no_fail_on_fallback { + std::process::exit(EXIT_FALLBACK); + } + } + } + + Ok(()) +} + +/// Exit code for a fallback result: the caller should run everything. +const EXIT_FALLBACK: i32 = 3; + +fn open_store(repo_root: &Path) -> Result> { + let engine = EngineBinary::resolve(); + if engine.path().is_none() { + return Ok(None); + } + Store::open(repo_root) + .map(Some) + .context("open incremental store") +} + +fn canonicalize(path: &Path) -> Result { + let canonical = + fs::canonicalize(path).with_context(|| format!("resolve {}", path.display()))?; + if !canonical.is_dir() { + bail!("{} is not a directory", canonical.display()); + } + Ok(canonical) +} + +fn store_display_path(repo_root: &Path) -> String { + std::env::var_os("FRONTAL_CODE_INCREMENTAL_STORE") + .or_else(|| std::env::var_os("INCREMENTAL_STORE")) + .map_or_else( + || repo_root.join(".incremental").display().to_string(), + |p| p.to_string_lossy().into_owned(), + ) +} + +fn read_json(path: &Path) -> Result { + let raw = if path == Path::new("-") { + let mut buf = String::new(); + std::io::Read::read_to_string(&mut std::io::stdin(), &mut buf).context("read stdin")?; + buf + } else { + fs::read_to_string(path).with_context(|| format!("read {}", path.display()))? + }; + let value: Value = serde_json::from_str(&raw).with_context(|| "parse JSON")?; + Ok(value) +} + +/// Build a changeset from `git diff --name-status ` when no file is given. +fn git_changeset(baseline: &str, repo_root: &Path) -> Result { + let output = std::process::Command::new("git") + .args(["diff", "--name-status", baseline]) + .current_dir(repo_root) + .output() + .context("run git diff")?; + if !output.status.success() { + let stderr = String::from_utf8_lossy(&output.stderr); + // A bad baseline (unknown commit) is a fallback trigger, not a crash. + bail!( + "git diff failed: {stderr}\n\ + (pass --changes with an explicit changeset, or use a valid baseline sha)" + ); + } + let stdout = String::from_utf8_lossy(&output.stdout); + let changes: Vec = stdout + .lines() + .filter(|line| !line.trim().is_empty()) + .map(|line| { + let mut parts = line.splitn(2, '\t'); + let status = parts.next().unwrap_or_default(); + let path = parts.next().unwrap_or_default(); + json!({"path": path, "status": status}) + }) + .collect(); + Ok(json!({"changes": changes})) +} + +/// Like [`build_context`] but with an explicit lockfile path override. +fn context_with_lockfile(repo_root: &Path, lockfile: &str, runner: &str, node: &str) -> Value { + let mut ctx = build_context(repo_root, runner, node); + let path = Path::new(lockfile); + let abs = if path.is_absolute() { + path.to_path_buf() + } else { + repo_root.join(path) + }; + let digest = match fs::read(&abs) { + Ok(bytes) => { + // Reuse the same digest scheme as build_context (FNV-1a based). + // The exact bytes don't matter as long as they are deterministic + // for the same file contents. + Some(Value::String(format!("{:x}", fnv1a_64(&bytes, 0)))) + } + Err(_) => None, + }; + if let Some(obj) = ctx.as_object_mut() { + obj.insert("lockfile".to_string(), digest.unwrap_or(Value::Null)); + } + ctx +} + +/// FNV-1a 64-bit hash (local copy to avoid a new dependency). +fn fnv1a_64(data: &[u8], offset: u64) -> u64 { + let mut hash: u64 = 0xcbf2_9ce4_8422_2325u64 ^ offset; + for &byte in data { + hash ^= u64::from(byte); + hash = hash.wrapping_mul(0x1000_0000_01b3u64); + } + hash +} + +fn print_raw(format: Format, value: &Value) { + print_result(format, value, &value.to_string()); +} + +fn print_result(format: Format, value: &Value, text: &str) { + match format { + Format::Text => println!("{text}"), + Format::Json => { + let pretty = serde_json::to_string_pretty(value).unwrap_or_else(|_| value.to_string()); + println!("{pretty}"); + } + } +} + +fn doctor_text(report: &Value) -> String { + let triple = report["platform"].as_str().unwrap_or("?"); + if report["engine_found"].as_bool().unwrap_or(false) { + let path = report["engine_path"].as_str().unwrap_or("?"); + format!( + "platform: {triple}\nengine: {path}\nstore: {}", + report["store_path"].as_str().unwrap_or("?") + ) + } else { + format!( + "platform: {triple}\nengine: NOT FOUND (set FRONTAL_CODE_INCREMENTAL_ENGINE or INCREMENTAL_ENGINE)\nstore: {}", + report["store_path"].as_str().unwrap_or("?") + ) + } +} + +fn affected_text(report: &Value) -> String { + if report["fallback"].as_bool().unwrap_or(false) { + let reason = report["fallback_reason"].as_str().unwrap_or("unknown"); + return format!("FALLBACK ({reason}): run everything"); + } + let mut lines = Vec::new(); + if let Some(tasks) = report["tasks"].as_array() { + for task in tasks { + let id = task["task_id"].as_str().unwrap_or("?"); + let reasons = task["reasons"] + .as_array() + .map(|r| { + r.iter() + .filter_map(|v| v.as_str()) + .collect::>() + .join(", ") + }) + .unwrap_or_default(); + lines.push(format!("{id}: {reasons}")); + } + } + lines.push(format!( + "skipped={} unobserved={} confidence={}", + report["skipped"].as_u64().unwrap_or(0), + report["unobserved"].as_array().map_or(0, Vec::len), + report["confidence"].as_str().unwrap_or("?") + )); + lines.join("\n") +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn affected_text_reports_fallback() { + let report = json!({"fallback": true, "fallback_reason": "no_baseline"}); + let text = affected_text(&report); + assert!(text.contains("FALLBACK")); + assert!(text.contains("no_baseline")); + } + + #[test] + fn affected_text_lists_tasks() { + let report = json!({ + "fallback": false, + "tasks": [{"task_id": "a.rs#test", "reasons": ["reads:a.rs"]}], + "skipped": 2, + "unobserved": ["b.rs#test"], + "confidence": "medium" + }); + let text = affected_text(&report); + assert!(text.contains("a.rs#test: reads:a.rs")); + assert!(text.contains("skipped=2")); + assert!(text.contains("confidence=medium")); + } +} From 3ede6983b55ed0c3014156e0321821779e067a6f Mon Sep 17 00:00:00 2001 From: Gabriel Fonseca Date: Tue, 17 Nov 2026 10:13:52 +0000 Subject: [PATCH 2/2] fix: declare Apache-2.0 license on vendored incremental crate cargo deny flags the vendored `incremental` crate as unlicensed because the upstream manifest omits a `license` field. Declare Apache-2.0 to match the upstream frontal-labs/incremental LICENSE.md and satisfy the Security Audit (cargo deny licenses) check. --- third_party/incremental/rust/Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/third_party/incremental/rust/Cargo.toml b/third_party/incremental/rust/Cargo.toml index 478be2ac..c3acdf71 100644 --- a/third_party/incremental/rust/Cargo.toml +++ b/third_party/incremental/rust/Cargo.toml @@ -3,6 +3,7 @@ name = "incremental" version = "0.1.0" edition = "2021" description = "Rust client for incremental Protocol v1 (spawns `incremental serve`)" +license = "Apache-2.0" publish = false [dependencies]