VectorCraft: An open-source, vector art tool written by scratch in pure Rust
MCP: the trace-and-style prompt's steps run as written
dotCooCoo4ca0c26f2f2a
diff --git a/crates/mcp/src/prompts.rs b/crates/mcp/src/prompts.rsindex 0c0a43926..3633bf3c4 100644--- a/crates/mcp/src/prompts.rs+++ b/crates/mcp/src/prompts.rs@@ -270,7 +270,7 @@ One undo step covers the whole change; gradients and linked swatches stay linkedPromptDef {name: "trace-and-style",title: "Trace an image and style it",- description: "Trace a placed raster with Image Trace, then apply a live effect and paint over the result.",+ description: "Trace an image with Image Trace and expand the trace, then apply a live effect and recolor the result.",arguments: &[PromptArg { name: "path", description: "Path to the image file", required: true, default: "", values: Values::Fixed(NONE) },PromptArg {@@ -293,8 +293,13 @@ Trace the image at {path} in VectorCraft with the \"{preset}\" preset, then stylwith the {effect} effect.Method:-1. open_file the image: it becomes a document of its own pixel size.-2. imageTrace.make with the preset name, adjusting `params` — mode blackAndWhite, grayscale,+1. open_file the image: it becomes a document of the image's size at the resolution it declares+ (1 px = 1 pt at 72 ppi or when it declares none), with nothing selected.+ Then run_command select.all to select the image, or pass the image's `id` (inspect_document+ lists it) to imageTrace.make.+2. imageTrace.make with the preset name. The Default preset traces in black and white; a color+ preset such as 6 Colors or 16 Colors, or `params` with mode color, keeps the image's colors.+ Adjust `params`: mode blackAndWhite, grayscale,color (palette limited, fullTone for photos, automatic, or documentLibrary to trace withthe document's swatches or a swatch `library`) or logo (flat-colour logos only; the Flat Logopreset; colours via logoColors), then threshold, colors (colorDetail for@@ -304,11 +309,16 @@ Method:imageTrace.presets to see every preset with its numbers.Lower paths and higher corners give the clean, logo-like result; high fidelity needs pathsnear 90. imageTrace.setView {view: \"outlinesWithSourceImage\"} draws the traced outlines- over the image on screen to compare them (screenshots show it; exports keep the result).-3. apply_effect {effect} on the traced shapes. Call apply_effect with no `effect` for the+ over the image in the app's window to compare them (screenshot {window: true} captures it);+ render_preview and screenshot without `window` draw the tracing result, as exports do.+3. imageTrace.expand keeps only the traced paths and removes the source image.+ imageTrace.makeAndExpand traces and expands in one command, in place of steps 2 and 3.+4. apply_effect {effect} on the traced shapes. Call apply_effect with no `effect` for thecatalogue and each effect's parameters.-4. set_paint over the traced shapes to give the artwork its own colours.-5. screenshot, then remove the placed image if it is still underneath.+5. To change the colors, run recolor.colors on the traced shapes, then recolor.apply with a+ `map` from each traced color to its new color. set_paint gives every selected shape the+ same fill or stroke.+6. render_preview or screenshot, and compare the result with the source image.The trace is real geometry: every traced shape stays selectable and editable.",},@@ -546,6 +556,26 @@ mod tests {assert!(e.contains("brief"), "{e}");}+ /// trace-and-style selects the opened image before tracing it, expands the trace, recolors it+ /// instead of painting it one color, and says that screenshots draw the tracing result.+ #[test]+ fn trace_and_style_selects_expands_and_recolors() {+ let v = get("trace-and-style", &json!({"path": "art.png"})).unwrap();+ let text = v["messages"][0]["content"]["text"].as_str().unwrap_or_default();+ for step in ["open_file", "select.all", "imageTrace.make", "imageTrace.expand", "apply_effect", "recolor.apply", "render_preview"] {+ assert!(text.contains(step), "{step}: {text}");+ }+ let at = |s: &str| text.find(s).unwrap_or(usize::MAX);+ assert!(at("select.all") < at("imageTrace.make") && at("imageTrace.make") < at("imageTrace.expand"), "{text}");+ assert!(text.contains("black and white"), "{text}");+ assert!(!text.contains("screenshots show it"), "{text}");+ assert!(!text.contains("own pixel size") && text.contains("resolution it declares"), "{text}");+ // No step of its own paints the trace with set_paint.+ let steps: Vec<&str> = text.lines().filter(|l| is_item(l)).filter_map(|l| l.split_once(". ").map(|(_, rest)| rest)).collect();+ assert!(!steps.is_empty(), "{text}");+ assert!(steps.iter().all(|s| !s.starts_with("set_paint")), "{steps:?}");+ }+#[test]fn completions_rank_prefix_first_and_cap_at_100() {let mut b = b();diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rsindex 3777380ed..3410f4fa5 100644--- a/crates/mcp/src/tests.rs+++ b/crates/mcp/src/tests.rs@@ -296,6 +296,60 @@ fn headless_end_to_end() {assert_eq!(v["error"]["code"], -32002);}+/// The trace-and-style prompt's steps, run in its order on an image drawn here: each one+/// succeeds, the expanded trace holds no image, and its paths keep the image's colors.+#[test]+fn trace_and_style_prompt_steps_run_in_order() {+ let mut s = server();+ // 60 × 40 pixels: a red and a blue block on white.+ let png = tmp("trace-and-style.png");+ image::RgbImage::from_fn(60, 40, |x, y| match (x, y) {+ (5..25, 5..35) => image::Rgb([220, 30, 30]),+ (35..55, 5..35) => image::Rgb([30, 60, 200]),+ _ => image::Rgb([255, 255, 255]),+ })+ .save(&png)+ .unwrap();+ let path = png.to_str().unwrap();+ let v = rpc(&mut s, 1, "prompts/get", json!({"name": "trace-and-style", "arguments": {"path": path}}));+ let prompt = v["result"]["messages"][0]["content"]["text"].as_str().unwrap().to_string();++ let ok = |s: &mut Server, id: u64, name: &str, args: Value| {+ let r = call(s, id, name, args);+ assert_eq!(r["isError"], false, "{name}: {r}");+ serde_json::from_str::<Value>(&text_of(&r)).unwrap_or(Value::Null)+ };+ let command = |s: &mut Server, id: u64, command: &str, params: Value| {+ assert!(prompt.contains(command), "the prompt names {command}: {prompt}");+ ok(s, id, "run_command", json!({"command": command, "params": params}))+ };+ ok(&mut s, 2, "open_file", json!({"path": path}));+ command(&mut s, 3, "select.all", json!({}));+ let traced = command(&mut s, 4, "imageTrace.make", json!({"preset": "6 Colors"}));+ assert!(traced["colors"].as_u64().unwrap() > 1, "{traced}");+ command(&mut s, 5, "imageTrace.expand", json!({}));+ ok(&mut s, 6, "apply_effect", json!({"effect": "stylize.scribble"}));+ let colors = command(&mut s, 7, "recolor.colors", json!({}));+ let from = colors["colors"].as_array().unwrap().iter().filter_map(|c| c["hex"].as_str()).find(|h| *h != "#ffffff").unwrap().to_string();+ command(&mut s, 8, "recolor.apply", json!({"map": {from.as_str(): "#00aa00"}}));+ let r = call(&mut s, 9, "render_preview", json!({}));+ assert_eq!(r["isError"], false, "{r}");++ // No image is left, and the paths carry more than one fill color, the new one among them.+ let doc = ok(&mut s, 10, "inspect_document", json!({}));+ let (mut kinds, mut fills) = (vec![], std::collections::BTreeSet::new());+ let mut stack: Vec<&Value> = doc["layers"].as_array().unwrap().iter().collect();+ while let Some(n) = stack.pop() {+ kinds.push(n["kind"].as_str().unwrap_or_default().to_string());+ if let Some(fill) = n["fill"].as_str().filter(|f| f.starts_with('#')) {+ fills.insert(fill.to_string());+ }+ stack.extend(n["children"].as_array().into_iter().flatten());+ }+ assert!(!kinds.iter().any(|k| k == "Image"), "{kinds:?}");+ assert!(fills.len() > 1 && fills.contains("#00aa00") && !fills.contains(&from), "{fills:?}");+}+#[test]fn headless_path_gesture_undo() {let mut s = server();