Merge pull request #1 from Swofty-Developments/feat/improvements

feat: cost display, CodeForge branding, tests_run events, image paste, palette content search, incremental re-index

Author: Swofty-Developments

crates/forge-daemon/src/hooks.rs

@@ -66,16 +66,51 @@ fn parse_post_tool_use(raw: &Value) -> Option<(EventKind, Value, Vec<PathBuf>)>
         Some((EventKind::FileEdited, payload, edited))
     } else if tool_name == "Bash" {
         let command = input_str("command")?;
+        let kind = if is_test_command(&command) {
+            EventKind::TestsRun
+        } else {
+            EventKind::CommandRun
+        };
         let payload = serde_json::json!({
             "command": command,
             "description": input_str("description"),
         });
-        Some((EventKind::CommandRun, payload, vec![]))
+        Some((kind, payload, vec![]))
     } else {
         None
     }
 }
 
+/// Test-runner detection: standalone runners or `<tool> test` invocations,
+/// anywhere in a compound command line.
+fn is_test_command(command: &str) -> bool {
+    const STANDALONE: [&str; 8] = [
+        "pytest", "jest", "vitest", "mocha", "rspec", "phpunit", "tox", "ctest",
+    ];
+    const TEST_SUBCOMMAND: [&str; 9] = [
+        "cargo", "go", "npm", "pnpm", "yarn", "bun", "dotnet", "mix", "mvn",
+    ];
+    let tokens: Vec<&str> = command
+        .split(|c: char| c.is_whitespace() || matches!(c, ';' | '(' | ')'))
+        .filter(|t| !t.is_empty() && *t != "&&" && *t != "||")
+        .collect();
+    tokens.iter().enumerate().any(|(i, tok)| {
+        let base = tok.rsplit('/').next().unwrap_or(tok);
+        if STANDALONE.contains(&base) {
+            return true;
+        }
+        if base == "gradle" || base == "gradlew" {
+            return tokens.get(i + 1).is_some_and(|next| *next == "test");
+        }
+        TEST_SUBCOMMAND.contains(&base)
+            && tokens.get(i + 1).is_some_and(|next| {
+                *next == "test"
+                    || *next == "nextest"
+                    || (*next == "run" && tokens.get(i + 2).is_some_and(|n| n.starts_with("test")))
+            })
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -113,15 +148,59 @@ mod tests {
         let raw = serde_json::json!({
             "hook_event_name": "PostToolUse",
             "tool_name": "Bash",
-            "tool_input": { "command": "cargo test", "description": "Run tests" }
+            "tool_input": { "command": "cargo build", "description": "Build" }
         });
         let parsed = parse_hook_event(&raw).unwrap();
         assert_eq!(parsed.kind, EventKind::CommandRun);
-        assert_eq!(parsed.payload["command"], "cargo test");
-        assert_eq!(parsed.payload["description"], "Run tests");
+        assert_eq!(parsed.payload["command"], "cargo build");
+        assert_eq!(parsed.payload["description"], "Build");
         assert!(parsed.edited_paths.is_empty());
     }
 
+    #[test]
+    fn bash_test_commands_map_to_tests_run() {
+        for cmd in [
+            "cargo test",
+            "cargo nextest run",
+            "cd api && cargo test -p forge-core",
+            "npm test",
+            "npm run test:unit",
+            "pnpm test --filter web",
+            "go test ./...",
+            "python -m pytest tests/",
+            "./node_modules/.bin/vitest run",
+            "./gradlew test",
+        ] {
+            let raw = serde_json::json!({
+                "hook_event_name": "PostToolUse",
+                "tool_name": "Bash",
+                "tool_input": { "command": cmd }
+            });
+            let parsed = parse_hook_event(&raw).unwrap();
+            assert_eq!(parsed.kind, EventKind::TestsRun, "command: {cmd}");
+            assert_eq!(parsed.payload["command"], cmd);
+        }
+    }
+
+    #[test]
+    fn bash_non_test_commands_stay_command_run() {
+        for cmd in [
+            "cargo build",
+            "npm run dev",
+            "go build ./...",
+            "ls tests/",
+            "git commit -m 'test: add coverage'",
+        ] {
+            let raw = serde_json::json!({
+                "hook_event_name": "PostToolUse",
+                "tool_name": "Bash",
+                "tool_input": { "command": cmd }
+            });
+            let parsed = parse_hook_event(&raw).unwrap();
+            assert_eq!(parsed.kind, EventKind::CommandRun, "command: {cmd}");
+        }
+    }
+
     #[test]
     fn stop_and_session_start_map_to_session_events() {
         let stop = serde_json::json!({ "hook_event_name": "Stop", "session_id": "s" });

crates/forge-index/src/lib.rs

@@ -171,6 +171,52 @@ impl FeatureIndex {
         classify::classify(&self.repo_root, &self.features, paths)
     }
 
+    /// Slugs of features that reference any of `rel_paths` (repo-relative,
+    /// `/`-separated — the index-meta manifest keys) as an entry point or file.
+    /// Exact membership only; no directory-prefix widening.
+    pub fn owners_of(&self, rel_paths: &[String]) -> Vec<String> {
+        let set: std::collections::BTreeSet<&str> =
+            rel_paths.iter().map(String::as_str).collect();
+        self.features
+            .iter()
+            .filter(|f| {
+                f.entry_points
+                    .iter()
+                    .chain(f.files.iter().map(|file| &file.path))
+                    .any(|p| set.contains(p.to_string_lossy().replace('\\', "/").as_str()))
+            })
+            .map(|f| f.slug.clone())
+            .collect()
+    }
+
+    /// Drop references to files that no longer exist on disk from the named
+    /// features. An unpinned feature left with no paths at all is removed (its
+    /// subject matter is gone); pinned features survive minus the dead paths.
+    /// Returns the slugs of removed features.
+    pub fn prune_missing_files(&mut self, slugs: &[String]) -> Vec<String> {
+        let root = self.repo_root.clone();
+        for feature in self.features.iter_mut().filter(|f| slugs.contains(&f.slug)) {
+            let before = feature.entry_points.len() + feature.files.len();
+            feature.entry_points.retain(|p| root.join(p).exists());
+            feature.files.retain(|f| root.join(&f.path).exists());
+            if feature.entry_points.len() + feature.files.len() != before {
+                feature.updated_at = Utc::now();
+            }
+        }
+        let mut removed = Vec::new();
+        self.features.retain(|f| {
+            let dead = !f.pinned
+                && slugs.contains(&f.slug)
+                && f.entry_points.is_empty()
+                && f.files.is_empty();
+            if dead {
+                removed.push(f.slug.clone());
+            }
+            !dead
+        });
+        removed
+    }
+
     /// The repo this index belongs to.
     pub fn repo_root(&self) -> &Path {
         &self.repo_root
@@ -335,6 +381,45 @@ mod tests {
         assert_eq!(index.get("unpinned").unwrap().group.as_deref(), Some("crates/forge-index"));
     }
 
+    #[test]
+    fn owners_of_matches_exact_membership_only() {
+        let tmp = TempDir::new("owners");
+        let mut index = FeatureIndex::load(tmp.path()).expect("load");
+        index.upsert(feature("auth", false)); // references src/auth.rs
+        index.upsert(feature("billing", false)); // references src/billing.rs
+
+        assert_eq!(index.owners_of(&["src/auth.rs".to_string()]), vec!["auth"]);
+        // A sibling under src/ is NOT an owner — no directory-prefix widening.
+        assert!(index.owners_of(&["src/other.rs".to_string()]).is_empty());
+    }
+
+    #[test]
+    fn prune_missing_files_drops_dead_paths_and_empty_unpinned_features() {
+        let tmp = TempDir::new("prune");
+        tmp.write("src/kept.rs", "fn kept() {}");
+        let mut index = FeatureIndex::load(tmp.path()).expect("load");
+
+        // "kept" has one real file; "gone" (unpinned) and "gone-pinned" (pinned)
+        // reference only files that don't exist on disk.
+        index.upsert(feature("kept", false));
+        index.get("kept").unwrap(); // sanity
+        index.upsert(feature("gone", false));
+        index.upsert(feature("gone-pinned", true));
+        // Point "kept" at the real file.
+        let mut kept = index.get("kept").unwrap().clone();
+        kept.files[0].path = PathBuf::from("src/kept.rs");
+        index.upsert(kept);
+
+        let slugs: Vec<String> =
+            ["kept", "gone", "gone-pinned"].iter().map(|s| s.to_string()).collect();
+        let removed = index.prune_missing_files(&slugs);
+
+        assert_eq!(removed, vec!["gone".to_string()]);
+        assert!(index.get("kept").is_some(), "feature with a live file survives");
+        let pinned = index.get("gone-pinned").expect("pinned survives even when empty");
+        assert!(pinned.files.is_empty(), "dead paths pruned from pinned feature");
+    }
+
     #[test]
     fn merge_reindex_preserves_pinned_feature_through_public_api() {
         let tmp = TempDir::new("reindex");