fix(report): write run data to project-local target/piano/runs/

Add shutdown_to(dir) to the runtime that writes to a specified directory.
The CLI now injects shutdown_to with the project's target/piano/runs/ path
instead of shutdown(), making run data project-scoped by default.

piano report and piano tag check ./target/piano/runs/ first, falling back
to ~/.piano/runs/ for backward compatibility with existing global runs.

PIANO_RUNS_DIR env var still takes priority in both shutdown and
shutdown_to for testing and user overrides.

Closes #71

Author: rocketman-code

piano-runtime/src/collector.rs

@@ -663,6 +663,23 @@ pub fn shutdown() {
         Some(d) => d,
         None => return,
     };
+    shutdown_impl(&dir);
+}
+
+/// Like `shutdown`, but writes run files to the specified directory.
+///
+/// Used by the CLI to write to project-local `target/piano/runs/` instead
+/// of the global `~/.piano/runs/`. `PIANO_RUNS_DIR` env var takes priority
+/// if set (for testing and user overrides).
+pub fn shutdown_to(dir: &str) {
+    if let Ok(override_dir) = std::env::var("PIANO_RUNS_DIR") {
+        shutdown_impl(std::path::Path::new(&override_dir));
+    } else {
+        shutdown_impl(std::path::Path::new(dir));
+    }
+}
+
+fn shutdown_impl(dir: &std::path::Path) {
     let ts = timestamp_ms();
 
     // Write frame-level data if present (NDJSON format).

piano-runtime/src/lib.rs

@@ -11,5 +11,6 @@ pub use alloc::PianoAllocator;
 pub use collector::collect_invocations;
 pub use collector::{
     adopt, collect, collect_all, collect_frames, enter, flush, fork, init, register, reset,
-    shutdown, AdoptGuard, FrameFnSummary, FunctionRecord, Guard, InvocationRecord, SpanContext,
+    shutdown, shutdown_to, AdoptGuard, FrameFnSummary, FunctionRecord, Guard, InvocationRecord,
+    SpanContext,
 };

src/main.rs

@@ -300,9 +300,14 @@ fn cmd_build(
                 source,
             })?;
 
-        let rewritten = inject_shutdown(&rewritten).map_err(|source| Error::ParseError {
-            path: main_file.clone(),
-            source,
+        let target_dir = project.join("target").join("piano");
+        let runs_dir = target_dir.join("runs");
+        let runs_dir_str = runs_dir.to_string_lossy().to_string();
+        let rewritten = inject_shutdown(&rewritten, Some(&runs_dir_str)).map_err(|source| {
+            Error::ParseError {
+                path: main_file.clone(),
+                source,
+            }
         })?;
         std::fs::write(&main_file, rewritten)?;
     }
@@ -397,6 +402,12 @@ fn default_runs_dir() -> Result<PathBuf, Error> {
     if let Ok(dir) = std::env::var("PIANO_RUNS_DIR") {
         return Ok(PathBuf::from(dir));
     }
+    // Project-local first: ./target/piano/runs/
+    let local = PathBuf::from("target/piano/runs");
+    if local.is_dir() {
+        return Ok(std::fs::canonicalize(local)?);
+    }
+    // Fall back to global ~/.piano/runs/ for backward compat
     let home = std::env::var_os("HOME").ok_or(Error::HomeNotFound)?;
     Ok(PathBuf::from(home).join(".piano").join("runs"))
 }
@@ -405,6 +416,12 @@ fn default_tags_dir() -> Result<PathBuf, Error> {
     if let Ok(dir) = std::env::var("PIANO_TAGS_DIR") {
         return Ok(PathBuf::from(dir));
     }
+    // Project-local first: ./target/piano/tags/
+    let local = PathBuf::from("target/piano/tags");
+    if local.is_dir() {
+        return Ok(std::fs::canonicalize(local)?);
+    }
+    // Fall back to global ~/.piano/tags/ for backward compat
     let home = std::env::var_os("HOME").ok_or(Error::HomeNotFound)?;
     Ok(PathBuf::from(home).join(".piano").join("tags"))
 }

src/rewrite.rs

@@ -480,15 +480,36 @@ pub fn inject_global_allocator(
     Ok(prettyplease::unparse(&file))
 }
 
-/// Inject `piano_runtime::shutdown()` as the last statement in `fn main`.
-pub fn inject_shutdown(source: &str) -> Result<String, syn::Error> {
+/// Inject `piano_runtime::shutdown_to(dir)` as the last statement in `fn main`.
+///
+/// When `runs_dir` is `Some`, emits `shutdown_to(dir)` to write run data to
+/// the given project-local directory. When `None`, falls back to `shutdown()`
+/// which uses the global `~/.piano/runs/`.
+pub fn inject_shutdown(source: &str, runs_dir: Option<&str>) -> Result<String, syn::Error> {
     let mut file: syn::File = syn::parse_str(source)?;
-    let mut injector = ShutdownInjector;
+    let mut injector = ShutdownInjector {
+        runs_dir: runs_dir.map(String::from),
+    };
     injector.visit_file_mut(&mut file);
     Ok(prettyplease::unparse(&file))
 }
 
-struct ShutdownInjector;
+struct ShutdownInjector {
+    runs_dir: Option<String>,
+}
+
+impl ShutdownInjector {
+    fn shutdown_stmt(&self) -> syn::Stmt {
+        match &self.runs_dir {
+            Some(dir) => syn::parse_quote! {
+                piano_runtime::shutdown_to(#dir);
+            },
+            None => syn::parse_quote! {
+                piano_runtime::shutdown();
+            },
+        }
+    }
+}
 
 impl VisitMut for ShutdownInjector {
     fn visit_item_fn_mut(&mut self, node: &mut syn::ItemFn) {
@@ -498,6 +519,7 @@ impl VisitMut for ShutdownInjector {
             // Wrap existing body in a block so all guards drop before shutdown.
             // This ensures main's own timing guard records before shutdown collects.
             let existing_stmts = std::mem::take(&mut node.block.stmts);
+            let shutdown_stmt = self.shutdown_stmt();
 
             if has_return_type {
                 // fn main() -> T: capture the body's result, shutdown, return it.
@@ -509,9 +531,6 @@ impl VisitMut for ShutdownInjector {
                 let combined: syn::Stmt = syn::parse_quote! {
                     let __piano_result = #inner_block;
                 };
-                let shutdown_stmt: syn::Stmt = syn::parse_quote! {
-                    piano_runtime::shutdown();
-                };
                 let return_expr: syn::Stmt =
                     syn::Stmt::Expr(syn::parse_quote! { __piano_result }, None);
                 node.block.stmts = vec![combined, shutdown_stmt, return_expr];
@@ -522,9 +541,6 @@ impl VisitMut for ShutdownInjector {
                         #(#existing_stmts)*
                     }
                 };
-                let shutdown_stmt: syn::Stmt = syn::parse_quote! {
-                    piano_runtime::shutdown();
-                };
                 node.block.stmts = vec![inner_block, shutdown_stmt];
             }
         }
@@ -719,7 +735,7 @@ fn main() {
     do_stuff();
 }
 "#;
-        let result = inject_shutdown(source).unwrap();
+        let result = inject_shutdown(source, None).unwrap();
         assert!(
             result.contains("piano_runtime::shutdown()"),
             "should inject shutdown. Got:\n{result}"
@@ -732,6 +748,20 @@ fn main() {
         );
     }
 
+    #[test]
+    fn injects_shutdown_to_with_dir() {
+        let source = r#"
+fn main() {
+    do_stuff();
+}
+"#;
+        let result = inject_shutdown(source, Some("/tmp/my-project/target/piano/runs")).unwrap();
+        assert!(
+            result.contains("piano_runtime::shutdown_to(\"/tmp/my-project/target/piano/runs\")"),
+            "should inject shutdown_to with dir. Got:\n{result}"
+        );
+    }
+
     #[test]
     fn injects_shutdown_preserves_main_return_type() {
         let source = r#"
@@ -741,7 +771,7 @@ fn main() -> ExitCode {
     ExitCode::SUCCESS
 }
 "#;
-        let result = inject_shutdown(source).unwrap();
+        let result = inject_shutdown(source, None).unwrap();
         // Must contain shutdown
         assert!(
             result.contains("piano_runtime::shutdown()"),