diff --git a/crates/ai/src/rebuild/kept_check.rs b/crates/ai/src/rebuild/kept_check.rs new file mode 100644 index 00000000..08cd32df --- /dev/null +++ b/crates/ai/src/rebuild/kept_check.rs @@ -0,0 +1,80 @@ +//! A check round in which every check worked stands while nothing it looks at changes, so a +//! prompt that changes nothing in app/ doesn't build and start the app again (and the check +//! after the builder's turn doesn't repeat the builder's own `rebuild_check`). A round with a +//! failure is never kept: something outside the project (a program installed, a browser back) +//! may make it work, and Try again must look again. + +use super::kinds::{TargetKind, plugin_ids}; +use super::*; +use craft_anything_engine::workspace::progress::CheckedBuild; + +/// The run's kept round, and the scan cache its digests reuse. +#[derive(Default)] +pub(super) struct KeptChecks { + files: AppFingerprintCache, + kept: Option<(String, Vec)>, +} + +impl KeptChecks { + /// Start from the round `progress` kept, when `craft.json` still has it. + pub(super) fn from_saved(progress: &BuildProgress, ws: &Workspace) -> KeptChecks { + let kept = progress.checked.as_ref().and_then(|c| { + let last = ws.manifest.checks.last()?.round; + let round: Vec = ws.manifest.checks.iter().filter(|r| r.round == c.round).cloned().collect(); + (last == c.round && all_worked(&round)).then(|| (c.key.clone(), round)) + }); + KeptChecks { files: AppFingerprintCache::default(), kept } + } + + /// What to save for `round`: the kept key when the kept results are this round's. + pub(super) fn saved_for(&self, round: u32) -> Option { + self.kept.as_ref().filter(|(_, r)| r.first().is_some_and(|c| c.round == round)).map(|(key, _)| CheckedBuild { key: key.clone(), round }) + } +} + +fn all_worked(round: &[CheckResult]) -> bool { + !round.is_empty() && round.iter().all(|c| c.passed) +} + +impl Worker { + /// `run`'s results, or the kept round's (numbered `round`) when what the checks look at + /// hasn't changed since it ran. A digest that can't be taken just means checking again. + pub(super) fn checks_unless_unchanged( + &self, + ws: &Workspace, + kind: &dyn TargetKind, + round: u32, + run: impl FnOnce() -> Result, ToolError>, + ) -> Result, ToolError> { + let extra = { + let session = self.engine.session(); + // The folder too: a copy of the project has none of the build outputs the round checked. + let mut extra = + vec![ws.root.display().to_string(), kind.id().to_string(), ws.manifest.stack.clone(), format!("clean_room={}", session.clean_room())]; + extra.extend(plugin_ids(&session, kind)); + extra + }; + let extra: Vec<&str> = extra.iter().map(String::as_str).collect(); + let mut kept = self.kept_checks.lock().unwrap_or_else(PoisonError::into_inner); + let before = ws.check_fingerprint(&mut kept.files, &extra, &self.stop).ok(); + if let (Some(now), Some((key, results))) = (&before, &kept.kept) + && now == key + { + let results: Vec = results.iter().map(|c| CheckResult { round, ..c.clone() }).collect(); + kept.kept = Some((key.clone(), results.clone())); + drop(kept); + self.emit(RunEvent::Agent(AgentEvent::Status { + text: "Nothing the check looks at has changed since it last worked, so its results stand.".into(), + })); + return Ok(results); + } + // Checks take minutes; the lock isn't held while they run. + drop(kept); + let results = run()?; + let mut kept = self.kept_checks.lock().unwrap_or_else(PoisonError::into_inner); + // Taken after the round: a build writes files of its own that the next scan sees too. + let after = if all_worked(&results) { ws.check_fingerprint(&mut kept.files, &extra, &self.stop).ok() } else { None }; + kept.kept = after.map(|key| (key, results.clone())); + Ok(results) + } +} diff --git a/crates/ai/src/rebuild/kinds/mod.rs b/crates/ai/src/rebuild/kinds/mod.rs index c5590a96..951b03b3 100644 --- a/crates/ai/src/rebuild/kinds/mod.rs +++ b/crates/ai/src/rebuild/kinds/mod.rs @@ -255,6 +255,15 @@ impl CheckCx<'_> { } } +/// The ids of the WASM plugins' checks that join `kind`'s. +pub(super) fn plugin_ids(session: &craft_anything_engine::Session, kind: &dyn TargetKind) -> Vec { + craft_anything_engine::wasm_plugins::checks(session) + .iter() + .filter(|c| c.kinds.is_empty() || c.kinds.iter().any(|k| k == kind.id())) + .map(|c| c.id.to_string()) + .collect() +} + impl Worker { /// Run the checks the kind asks for in this round, in order, then the WASM plugins' checks for /// this kind. One that fails stops the rest: a later check needs what an earlier one proved (a diff --git a/crates/ai/src/rebuild/mod.rs b/crates/ai/src/rebuild/mod.rs index 9f92dce0..94953a62 100644 --- a/crates/ai/src/rebuild/mod.rs +++ b/crates/ai/src/rebuild/mod.rs @@ -42,6 +42,7 @@ pub mod activity; mod brief; mod check; pub mod feed; +mod kept_check; pub mod kinds; mod locate; pub mod notes; @@ -300,6 +301,7 @@ impl RebuildRun { self_check: None, reset_progress_after_notes: false, keys: hub.keys.clone(), + kept_checks: Mutex::default(), }; let r2 = running.clone(); let key_store = hub.keys.clone(); @@ -496,6 +498,8 @@ struct Worker { reset_progress_after_notes: bool, /// The backends' stored keys, for an agent CLI that asks the host to authenticate (Devin). keys: crate::keys::KeyStore, + /// The last check round in which everything worked, kept while nothing it looks at changes. + kept_checks: Mutex, } /// The project a run records its usage in, and when it last did. @@ -743,6 +747,7 @@ impl Worker { opts: &RunOptions, ) -> Result { let mut progress = BuildProgress::load(&ws.root)?; + *self.kept_checks.lock().unwrap_or_else(PoisonError::into_inner) = kept_check::KeptChecks::from_saved(&progress, ws); let mut progress_available = true; let mut fingerprints = AppFingerprintCache::default(); // Try again has no message. Only an explicit new request starts another attempt on @@ -978,6 +983,9 @@ impl Worker { // round adds to it, across runs, until the limit stops the build. ws.manifest.not_working_checks = if checks.iter().all(|c| c.passed) { 0 } else { ws.manifest.not_working_checks.saturating_add(1) }; ws.save()?; + // Kept for the next prompt when every check worked; saved after craft.json has the round. + progress.checked = self.kept_checks.lock().unwrap_or_else(PoisonError::into_inner).saved_for(round); + progress.save(&ws.root)?; for c in &checks { self.emit(RunEvent::Checked(c.clone())); } @@ -1112,6 +1120,10 @@ impl Worker { /// an error couldn't look at all (a browser that went away), which says nothing about the /// build, so it gets a second go before the run stops, and the run says what is really wrong. fn checks_with_a_retry(&self, ws: &Workspace, kind: &dyn kinds::TargetKind, round: u32) -> Result, ToolError> { + self.checks_unless_unchanged(ws, kind, round, || self.checks_with_a_retry_now(ws, kind, round)) + } + + fn checks_with_a_retry_now(&self, ws: &Workspace, kind: &dyn kinds::TargetKind, round: u32) -> Result, ToolError> { let e = match self.run_checks(ws, kind, round) { Err(e) if e.code != ErrorCode::Cancelled => e, done => return done, diff --git a/crates/ai/src/rebuild/note_progress_tests.rs b/crates/ai/src/rebuild/note_progress_tests.rs index 2c18b5fe..17957292 100644 --- a/crates/ai/src/rebuild/note_progress_tests.rs +++ b/crates/ai/src/rebuild/note_progress_tests.rs @@ -187,7 +187,7 @@ fn consumed_note_resets_survive_failed_and_cancelled_turns() { for cancelled in [false, true] { for text in ["Keep the header blue", " "] { - for record in ["", "{ broken progress", r#"{"version":2,"fingerprint":null,"unchanged_turns":1}"#] { + for record in ["", "{ broken progress", r#"{"version":3,"fingerprint":null,"unchanged_turns":1}"#] { let dir = tempfile::tempdir().unwrap(); let mut ws = Workspace::create(dir.path(), "Interrupted note", "Build an app", TargetRef::None).unwrap(); std::fs::create_dir_all(ws.capture_dir()).unwrap(); diff --git a/crates/ai/src/rebuild/self_check.rs b/crates/ai/src/rebuild/self_check.rs index 52f5ba06..f63585cd 100644 --- a/crates/ai/src/rebuild/self_check.rs +++ b/crates/ai/src/rebuild/self_check.rs @@ -129,7 +129,10 @@ impl Worker { "The builder is checking its work against the original…" }; self.step(ws, Step::Build, Status::Building, checking)?; - let (text, line) = match self.run_checks_within(ws, kind.as_ref(), SELF_CHECK_ROUND, Some(SELF_CHECK_LIMIT)) { + let checked = self.checks_unless_unchanged(ws, kind.as_ref(), SELF_CHECK_ROUND, || { + self.run_checks_within(ws, kind.as_ref(), SELF_CHECK_ROUND, Some(SELF_CHECK_LIMIT)) + }); + let (text, line) = match checked { Ok(checks) => { let line = format!("The builder checked its work: {}.", summary(&checks, good_enough)); (report(&checks, good_enough, &open_questions(ws)), line) diff --git a/crates/ai/src/rebuild/tests.rs b/crates/ai/src/rebuild/tests.rs index 4bef8231..db5ffabb 100644 --- a/crates/ai/src/rebuild/tests.rs +++ b/crates/ai/src/rebuild/tests.rs @@ -451,6 +451,7 @@ fn notes_added_while_it_works_reach_the_agent_at_its_next_step() { notes: notes.clone(), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, @@ -1358,6 +1359,7 @@ fn an_api_backend_builds_with_the_build_tools() { notes: Arc::default(), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, @@ -1476,6 +1478,7 @@ fn the_mechanics_sheet_is_required_and_held_against_the_code() { notes: Arc::default(), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, @@ -2600,9 +2603,92 @@ fn check_worker(ws: &Workspace, deep: bool) -> Worker { self_check: None, reset_progress_after_notes: false, keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), } } +#[test] +fn a_check_that_worked_stands_while_nothing_it_looks_at_changes() { + use craft_anything_engine::workspace::progress::CheckedBuild; + use std::cell::Cell; + let d = tempfile::tempdir().unwrap(); + let mut ws = Workspace::create(d.path(), "Arena", "Recreate this game", TargetRef::None).unwrap(); + std::fs::create_dir_all(ws.app_dir().join("src")).unwrap(); + std::fs::write(ws.app_dir().join("src/main.rs"), "fn main() {}\n").unwrap(); + let w = check_worker(&ws, false); + let runs = Cell::new(0); + let worked = Cell::new(true); + let check = |ws: &Workspace, round| { + w.checks_unless_unchanged(ws, &SheetKind, round, || { + runs.set(runs.get() + 1); + Ok(vec![CheckResult::new(CheckResult::BUILD, round, worked.get(), "built")]) + }) + .unwrap() + }; + + assert_eq!(check(&ws, 1)[0].round, 1); + assert_eq!(runs.get(), 1); + // The builder's own check, then the one after its turn: nothing changed, so it isn't run again. + let kept = check(&ws, self_check::SELF_CHECK_ROUND); + assert_eq!((runs.get(), kept[0].round, kept[0].passed), (1, self_check::SELF_CHECK_ROUND, true)); + assert_eq!(check(&ws, 2)[0].round, 2); + assert_eq!(runs.get(), 1); + + // A changed file, a new picture to compare with, or Deep mode checks again. + std::fs::write(ws.app_dir().join("src/main.rs"), "fn main() { println!(\"hi\"); }\n").unwrap(); + check(&ws, 3); + assert_eq!(runs.get(), 2); + std::fs::create_dir_all(ws.reference_dir()).unwrap(); + std::fs::write(ws.reference_dir().join("look.png"), "a picture").unwrap(); + check(&ws, 4); + assert_eq!(runs.get(), 3); + let deep = check_worker(&ws, true); + *deep.kept_checks.lock().unwrap_or_else(PoisonError::into_inner) = std::mem::take(&mut *w.kept_checks.lock().unwrap_or_else(PoisonError::into_inner)); + deep.checks_unless_unchanged(&ws, &SheetKind, 5, || { + runs.set(runs.get() + 1); + Ok(vec![CheckResult::new(CheckResult::BUILD, 5, true, "built")]) + }) + .unwrap(); + assert_eq!(runs.get(), 4, "Deep mode checks again"); + + // A round with a failure is never kept: Try again looks again. + worked.set(false); + check(&ws, 6); + check(&ws, 7); + assert_eq!(runs.get(), 6); + worked.set(true); + + // Kept across runs: the round saved in the progress record, while craft.json still ends with it. + let round = check(&ws, 8); + assert_eq!(runs.get(), 7); + let saved = w.kept_checks.lock().unwrap_or_else(PoisonError::into_inner).saved_for(8); + assert!(w.kept_checks.lock().unwrap_or_else(PoisonError::into_inner).saved_for(7).is_none()); + ws.manifest.checks.extend(round); + let progress = BuildProgress { checked: saved.clone(), ..BuildProgress::default() }; + let next_run = check_worker(&ws, false); + *next_run.kept_checks.lock().unwrap_or_else(PoisonError::into_inner) = kept_check::KeptChecks::from_saved(&progress, &ws); + let again = next_run.checks_unless_unchanged(&ws, &SheetKind, 9, || panic!("an unchanged build isn't checked again")).unwrap(); + assert_eq!((again[0].round, again[0].note.as_str()), (9, "built")); + // A copy of the project, with the same files, checks its own build. + let other = tempfile::tempdir().unwrap(); + let copy = Workspace::create(other.path(), "Arena", "Recreate this game", TargetRef::None).unwrap(); + std::fs::create_dir_all(copy.app_dir().join("src")).unwrap(); + std::fs::copy(ws.app_dir().join("src/main.rs"), copy.app_dir().join("src/main.rs")).unwrap(); + std::fs::create_dir_all(copy.reference_dir()).unwrap(); + std::fs::copy(ws.reference_dir().join("look.png"), copy.reference_dir().join("look.png")).unwrap(); + let copied = Cell::new(false); + next_run + .checks_unless_unchanged(©, &SheetKind, 10, || { + copied.set(true); + Ok(Vec::new()) + }) + .unwrap(); + assert!(copied.get(), "a copy is checked again"); + // A record naming another round than craft.json's last one keeps nothing. + let stale = BuildProgress { checked: Some(CheckedBuild { round: 7, ..saved.unwrap() }), ..BuildProgress::default() }; + assert!(kept_check::KeptChecks::from_saved(&stale, &ws).saved_for(7).is_none()); +} + /// A new Python project reaches the same build/screenshot path as a packaged app. The local /// interpreter is a stand-in: no installed Python, packages, window, network or user settings. #[cfg(unix)] @@ -3068,6 +3154,7 @@ fn preparing_the_builders_agent_does_not_lock_up() { notes: Arc::default(), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, @@ -3111,6 +3198,7 @@ fn the_run_answers_the_builders_own_check_during_its_turn() { notes: Arc::default(), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, @@ -3309,6 +3397,7 @@ fn a_note_the_builder_took_at_a_step_joins_the_feed_and_isnt_sent_again() { ])), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, @@ -3668,6 +3757,7 @@ fn a_session_left_on_another_computer_starts_a_new_one_from_the_project() { notes: Arc::default(), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, @@ -3724,6 +3814,7 @@ fn a_missing_session_with_nothing_to_start_from_is_said_plainly() { notes: Arc::default(), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, @@ -3791,6 +3882,7 @@ fn the_builders_conversation_travels_with_the_project() { notes: Arc::default(), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, @@ -3869,6 +3961,7 @@ fn a_build_says_when_it_waits_for_an_analysis_started_earlier() { notes: Arc::default(), feed: Arc::new(Mutex::new(feed::FeedLog::open(&ws))), keys: crate::KeyStore::file_only(ws.root.join("keys.toml")), + kept_checks: Mutex::default(), assets: false, decompiled: false, usage: None, diff --git a/crates/engine/src/workspace/progress.rs b/crates/engine/src/workspace/progress.rs index 79ee0db2..25c779f3 100644 --- a/crates/engine/src/workspace/progress.rs +++ b/crates/engine/src/workspace/progress.rs @@ -18,18 +18,23 @@ pub const UNCHANGED_TURN_LIMIT: u32 = 2; // Keep state inside an already reserved Craft directory. A project created by an older // version may have its own app data named build-progress.json at the root. pub const BUILD_PROGRESS_FILE: &str = "inbox/build-progress.json"; -pub const BUILD_PROGRESS_VERSION: u32 = 1; +pub const BUILD_PROGRESS_VERSION: u32 = 2; const MAX_RECORD_BYTES: u64 = 16 * 1024; const MAX_ENTRIES: usize = 100_000; const MAX_DEPTH: usize = 64; -const STEPS: &[crate::versioned::Step] = &[v0_to_v1]; +const STEPS: &[crate::versioned::Step] = &[v0_to_v1, v1_to_v2]; const _: () = assert!(STEPS.len() == BUILD_PROGRESS_VERSION as usize); fn v0_to_v1(doc: &mut Value) -> Result<(), String> { if doc.is_object() { Ok(()) } else { Err("the progress record isn't a JSON object".into()) } } +/// Version 2 adds `checked`; a version 1 record has no kept check. +fn v1_to_v2(doc: &mut Value) -> Result<(), String> { + v0_to_v1(doc) +} + /// The app as the builder last left it, and turns since it last changed. Only the rebuild run /// writes this record. An older project without one has no counted turns. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] @@ -40,11 +45,25 @@ pub struct BuildProgress { pub fingerprint: Option, #[serde(default)] pub unchanged_turns: u32, + /// The last check round in which every check worked, and what it looked at; while that + /// stays the same, the round's results stand instead of building and starting the app again. + #[serde(default)] + pub checked: Option, +} + +/// A check round kept with the state it judged. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct CheckedBuild { + /// A digest of what the round's checks look at, taken after they ran. + pub key: String, + /// The round in `craft.json`'s `checks` whose results stand. + pub round: u32, } impl Default for BuildProgress { fn default() -> Self { - Self { version: BUILD_PROGRESS_VERSION, fingerprint: None, unchanged_turns: 0 } + Self { version: BUILD_PROGRESS_VERSION, fingerprint: None, unchanged_turns: 0, checked: None } } } @@ -137,6 +156,67 @@ impl Workspace { pub fn app_fingerprint(&self, stop: &CancelToken) -> Result { AppFingerprintCache::default().scan(self, stop) } + + /// A digest of what a check round looks at: the app's files (as [`Workspace::app_fingerprint`] + /// reads them), the names, sizes and times of the files in `reference/` and `capture/` it + /// compares with, and `extra` (the folder, kind, stack, mode and plugin checks, from the caller). + /// Equal digests mean the same round would judge the same build against the same things. + pub fn check_fingerprint(&self, cache: &mut AppFingerprintCache, extra: &[&str], stop: &CancelToken) -> Result { + let mut hash = Sha256::new(); + hash.update(b"craft-check-inputs-v1\0"); + hash.update(cache.scan(self, stop)?.as_bytes()); + for dir in [self.reference_dir(), self.capture_dir()] { + hash.update(b"\0dir\0"); + let mut visited = 0; + stamp_tree(&dir, &dir, &mut hash, &mut visited, 0, stop)?; + } + for e in extra { + hash.update(b"\0extra\0"); + hash.update(e.as_bytes()); + } + Ok(hex::encode(hash.finalize())) + } +} + +/// Names, sizes, kinds and modification times under `dir`, in name order; a missing folder adds +/// nothing. Bounded like the app scan, and symlinks are recorded, never followed. +fn stamp_tree(root: &Path, dir: &Path, hash: &mut Sha256, visited: &mut usize, depth: usize, stop: &CancelToken) -> Result<(), ToolError> { + if depth > MAX_DEPTH { + return Err(ToolError::new(ErrorCode::OverLimit, format!("{} is nested too deeply to compare.", root.display()))); + } + let read = match std::fs::read_dir(dir) { + Ok(r) => r, + Err(e) if e.kind() == std::io::ErrorKind::NotFound && depth == 0 => return Ok(()), + Err(e) => return Err(ToolError::io(dir.display(), e)), + }; + let mut entries = Vec::new(); + for entry in read { + stop.check()?; + let entry = entry.map_err(|e| ToolError::io(dir.display(), e))?; + *visited = visited.saturating_add(1); + if *visited > MAX_ENTRIES { + return Err(ToolError::new(ErrorCode::OverLimit, format!("{} has too many files to compare.", root.display()))); + } + entries.push(entry.path()); + } + entries.sort(); + for path in entries { + let metadata = std::fs::symlink_metadata(&path).map_err(|e| ToolError::io(path.display(), e))?; + let name = path.strip_prefix(root).unwrap_or(&path).to_string_lossy().replace('\\', "/"); + let kind = if metadata.is_symlink() { + "l" + } else if metadata.is_dir() { + "d" + } else { + "f" + }; + let modified = metadata.modified().ok().and_then(|t| t.duration_since(SystemTime::UNIX_EPOCH).ok()).map_or(0, |d| d.as_nanos()); + hash.update(format!("{kind}\0{name}\0{}\0{modified}\n", metadata.len()).as_bytes()); + if metadata.is_dir() { + stamp_tree(root, &path, hash, visited, depth.saturating_add(1), stop)?; + } + } + Ok(()) } /// Content digests reused within one build run. The first scan reads the files; subsequent @@ -562,8 +642,15 @@ mod tests { let old = BuildProgress::load(d.path()).unwrap(); assert_eq!(old.version, BUILD_PROGRESS_VERSION); assert!(old.stalled()); + assert_eq!(old.checked, None); old.save(d.path()).unwrap(); - assert!(std::fs::read_to_string(&path).unwrap().contains("\"version\": 1")); + assert!(std::fs::read_to_string(&path).unwrap().contains("\"version\": 2")); + // A version 1 record has no kept check; a kept one round-trips. + std::fs::write(&path, r#"{"version":1,"fingerprint":"previous","unchanged_turns":1}"#).unwrap(); + assert_eq!(BuildProgress::load(d.path()).unwrap().checked, None); + let kept = BuildProgress { checked: Some(CheckedBuild { key: "k".into(), round: 3 }), ..old.clone() }; + kept.save(d.path()).unwrap(); + assert_eq!(BuildProgress::load(d.path()).unwrap(), kept); for bad in [r#"{"version":99,"future":true}"#, "not json", r#"{"version":-1}"#, r#"{"app_data":"not a Craft progress record"}"#] { std::fs::write(&path, bad).unwrap(); assert!(BuildProgress::load(d.path()).is_err()); diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index f80aeba9..7f4cec9a 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -1051,6 +1051,13 @@ Gaps found while using the app for real projects. — claimed: tanish2k09, branch feature/r2.9-approvals-ui - [ ] The new approvals strings in every catalog were written with an AI; not reviewed by native speakers yet — pt-BR claimed: marlonferreira1800-hue, branch docs/r2.9-approvals-pt-br-review +- [x] A prompt that changes nothing in app/ still builds and starts the app again, often twice (the + builder's own rebuild_check, then the check after its turn). Keep a check whose round all + worked while the app's files and what it's compared with are unchanged + — claimed: tanish2k09, branch feature/r2.9-reuse-unchanged-check +- [ ] A check starts the app in front, with focus, on the main monitor, in the way of whatever the + person is doing. Start it behind other windows without taking focus (it's still pictured); + Play keeps opening it in front - [x] Keep New project's content column fixed while the vertical scrollbar animates in or out, hiding it when there is nothing to scroll, so switching tabs never shifts the page horizontally — claimed: Codex, branch bugfix/r2.9-home-scrollbar-gutter diff --git a/docs/STATUS.md b/docs/STATUS.md index 89d26a2a..50a94dab 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -448,6 +448,13 @@ later readable run starts a fresh comparison. Checks and the existing round limi Cancellation still stops the run; completed builder replies are saved as awaiting checks before the post-turn scan. Broken or newer progress records and record-write failures remain errors. +A check round in which every check worked is kept (in memory, and as `checked` in the record once +`craft.json` has the round). While nothing it looks at changes (the app's files as above, the +names, sizes and times of `reference/` and `capture/`, the kind, stack, mode, plugin checks and +the project's folder), the next check, the builder's own `rebuild_check` included, takes its +results instead of building and starting the app again, and the feed says so. A round with any +failure is never kept, so Try again always looks again. Not run live. + Scripted API turns and executable CLI stand-ins cover the stop, persistence, fresh requests and check recovery. This change has not been verified with a paid model or a live provider. Copying a whole project keeps its progress record; Duplicate creates a new attempt with a fresh conversation diff --git a/docs/file-formats.md b/docs/file-formats.md index df7d8703..b5d92238 100644 --- a/docs/file-formats.md +++ b/docs/file-formats.md @@ -8,7 +8,7 @@ version up to the current one, then turn the document into Rust types. The step | File | Owner | Current version | Older files | Newer files | |---|---|---|---|---| | `/craft.json` | `engine::workspace` (`Manifest`) | `MANIFEST_VERSION` = 4 (`version`; missing = 0; 3 adds `approvals`, 4 adds the saved builder session's mode `agent_session_deep`; a version-3 session migrates as Deep) | brought forward, saved as current | opened read-only: saving is refused | -| `/inbox/build-progress.json` | `engine::workspace::progress` (`BuildProgress`; written only by the rebuild run) | `BUILD_PROGRESS_VERSION` = 1 (`version`; missing = 0) | brought forward; an absent file starts with no counted turns | the build stops and the record is left unchanged | +| `/inbox/build-progress.json` | `engine::workspace::progress` (`BuildProgress`; written only by the rebuild run) | `BUILD_PROGRESS_VERSION` = 2 (`version`; missing = 0; 2 adds `checked`, the round kept while nothing it looked at changes) | brought forward; an absent file starts with no counted turns | the build stops and the record is left unchanged | | `config.toml` (`settings::config_dir()`) | `engine::settings` (`Settings`) | `SETTINGS_VERSION` = 2 (`version`; missing = 0; 2 moved `[engines.ghidra] enabled` to `deep_mode`) | brought forward | loaded, never saved over | | `.cany/project.toml` | `engine::project` (`ProjectMeta`) | `FORMAT_VERSION` = 1 (`format_version`, required) | brought forward | refused, with "update Craft Anything" | | `/transcript.json` | `ai::context` (the API builder's conversation) | `TRANSCRIPT_VERSION` = 2 (`{version, deep, history}`; a version-1 transcript counts as Deep) | read as before; one without `deep` is resumed only in Deep | not resumed; a fresh build replaces it | diff --git a/docs/schemas/build-progress.schema.json b/docs/schemas/build-progress.schema.json index 003a1d60..c30e3b69 100644 --- a/docs/schemas/build-progress.schema.json +++ b/docs/schemas/build-progress.schema.json @@ -4,6 +4,18 @@ "description": "The app as the builder last left it, and turns since it last changed. Only the rebuild run\nwrites this record. An older project without one has no counted turns.", "type": "object", "properties": { + "checked": { + "description": "The last check round in which every check worked, and what it looked at; while that\nstays the same, the round's results stand instead of building and starting the app again.", + "anyOf": [ + { + "$ref": "#/$defs/CheckedBuild" + }, + { + "type": "null" + } + ], + "default": null + }, "fingerprint": { "type": [ "string", @@ -26,5 +38,28 @@ "additionalProperties": false, "required": [ "version" - ] + ], + "$defs": { + "CheckedBuild": { + "description": "A check round kept with the state it judged.", + "type": "object", + "properties": { + "key": { + "description": "A digest of what the round's checks look at, taken after they ran.", + "type": "string" + }, + "round": { + "description": "The round in `craft.json`'s `checks` whose results stand.", + "type": "integer", + "format": "uint32", + "minimum": 0 + } + }, + "additionalProperties": false, + "required": [ + "key", + "round" + ] + } + } }