feat: untracked file support, path abbreviation, fast model defaults (v0.6.0)

- Show untracked files in diff view and sidebar with [untracked]/[U] badges
- Discover via `git ls-files --others --exclude-standard`, generate synthetic
  unified diff, merge with regular git diff before parsing
- Binary detection (null bytes), 1MB size cap, path traversal validation
- Structural sampling for LLM summaries: head/mid/tail instead of first 4 lines
- Abbreviate long paths in sidebar to fit: s/a/c/s-a/routes.ts
- Default model changed from sonnet to haiku (Claude) / gemini-flash (Copilot)
  for faster grouping response times on this classification task

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Alan Shum

.claude/skills/review.md

@@ -1,20 +1,20 @@
 # Rust Code Review
 
-Review Rust code changes for correctness, safety, and idiomatic patterns.
+Review Rust code changes for correctness, safety, idiomatic patterns, regressions, and scope discipline. Automatically split oversized commits.
 
 ## Steps
 
 1. Get the diff to review:
    ```bash
    git diff origin/main...HEAD
    ```
-   If origin/main doesn't exist (new repo), use:
+   If that's empty, try unstaged changes:
    ```bash
-   git diff --cached HEAD
+   git diff
    ```
-   If that's empty, diff all commits:
+   If origin/main doesn't exist (new repo), use:
    ```bash
-   git log --oneline --all
+   git diff --cached HEAD
    ```
 
 2. Run `cargo clippy` for lint checks:
@@ -27,16 +27,61 @@ Review Rust code changes for correctness, safety, and idiomatic patterns.
    cd /Users/kshum/Documents/gitproj/semantic-diff && cargo build 2>&1
    ```
 
-4. Review the diff for:
+4. Run `cargo test` to catch regressions:
+   ```bash
+   cd /Users/kshum/Documents/gitproj/semantic-diff && cargo test 2>&1
+   ```
+
+5. **Regression analysis** — Review the diff for changes that may break existing behavior:
+   - Changed function signatures (parameters added/removed/retyped)
+   - Modified match arms or conditional branches that alter control flow
+   - Removed or renamed public items (structs, enums, functions, methods)
+   - Changed default values or config parsing logic
+   - Modified serialization/deserialization formats
+   - Altered event handling or key binding behavior
+   Flag each potential regression with the affected area and severity.
+
+6. **Code quality review** — Check for:
    - Unsafe code without justification
    - Unwrap/expect on fallible operations in non-test code
    - Missing error handling
    - Unused dependencies
    - Dead code that should be cleaned up
 
-5. After review completes, write the state file to allow push:
+7. **Scope analysis — Detect out-of-scope changes:**
+   Classify every changed file into a logical concern (e.g., "config parsing", "diff engine", "UI rendering", "file tree sidebar", "grouper logic"). Then:
+   - Identify the **primary intent** of the changeset (the concern touching the most files/lines)
+   - Flag files whose concern does **not** match the primary intent as **out-of-scope**
+   - Flag unrelated formatting-only, refactor-only, or drive-by fixes as out-of-scope
+   - Report a scope summary table:
+     | Concern | Files | In-scope? |
+     |---------|-------|-----------|
+
+8. **Auto-split into smaller commits** if the changeset spans multiple concerns:
+   - Group changed files by concern from step 7
+   - For each concern group, stage only its files and create a focused commit
+   - Use clear commit message prefixes: `feat:`, `fix:`, `refactor:`, `chore:`
+   - Commit order: foundational changes first (models/types → logic → UI → config)
+   - If a single file contains changes for multiple concerns, use `git add -p` to stage only the relevant hunks
+   - **Ask the user for confirmation** before creating any commits, showing the proposed split plan:
+     ```
+     Proposed commit split:
+     1. feat(diff): add untracked file support — src/diff/mod.rs, src/diff/untracked.rs, src/diff/parser.rs
+     2. refactor(grouper): improve group filtering — src/grouper/mod.rs
+     3. feat(ui): enhance file tree with search and icons — src/ui/file_tree.rs, src/ui/diff_view.rs
+     4. fix(config): update default settings — src/config.rs, src/main.rs
+     ```
+   - Only proceed with committing after user approval
+
+9. After review and commits complete, write the state file to allow push:
    ```bash
    cd /Users/kshum/Documents/gitproj/semantic-diff && git rev-parse HEAD > "$(git rev-parse --git-dir)/.pre-push-reviewed"
    ```
 
-6. Report findings as a short summary.
+10. Report findings as a structured summary:
+    - **Build/Lint**: pass/fail
+    - **Tests**: pass/fail (number of tests)
+    - **Regressions**: list of potential regressions found
+    - **Scope**: in-scope vs out-of-scope breakdown
+    - **Commits**: split plan (proposed or executed)
+    - **Action items**: anything the user should address

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "semantic-diff"
-version = "0.5.1"
+version = "0.6.0"
 edition = "2021"
 description = "A terminal diff viewer with AI-powered semantic grouping (Claude CLI / Copilot)"
 license = "MIT"

Cargo.toml

@@ -49,8 +49,8 @@ impl Config {
     pub fn default_config() -> Self {
         Self {
             preferred_ai_cli: None,
-            claude_model: "sonnet".to_string(),
-            copilot_model: "sonnet".to_string(),
+            claude_model: "haiku".to_string(),
+            copilot_model: "gemini-flash".to_string(),
             theme_mode: ThemeMode::Auto,
         }
     }
@@ -119,16 +119,16 @@ const DEFAULT_CONFIG: &str = r#"{
 
   // Claude CLI settings
   "claude": {
-    // Model to use: "sonnet", "opus", "haiku"
+    // Model to use: "haiku" (fast, default), "sonnet" (balanced), "opus" (powerful)
     // Cross-backend models are mapped automatically:
     //   gemini-flash -> haiku, gemini-pro -> sonnet
-    "model": "sonnet"
+    "model": "haiku"
   },
 
   // Copilot CLI settings
   "copilot": {
-    // Model to use: "sonnet", "opus", "haiku", "gemini-flash", "gemini-pro"
-    "model": "sonnet"
+    // Model to use: "gemini-flash" (fast, default), "sonnet", "opus", "haiku", "gemini-pro"
+    "model": "gemini-flash"
   }
 
   // Theme: "dark", "light", or "auto" (detects from terminal)
@@ -188,7 +188,7 @@ pub fn load() -> Config {
 
 /// Map any model name to the closest Claude CLI model.
 fn resolve_model_for_claude(model: Option<&str>) -> String {
-    let tier = model.map(model_tier).unwrap_or(ModelTier::Balanced);
+    let tier = model.map(model_tier).unwrap_or(ModelTier::Fast);
     match tier {
         ModelTier::Fast => "haiku",
         ModelTier::Balanced => "sonnet",
@@ -215,7 +215,7 @@ fn resolve_model_for_copilot(model: Option<&str>) -> String {
                 .to_string(),
             }
         }
-        None => "sonnet".to_string(),
+        None => "gemini-flash".to_string(),
     }
 }
 
@@ -348,24 +348,24 @@ mod tests {
         assert_eq!(resolve_model_for_claude(Some("sonnet")), "sonnet");
         assert_eq!(resolve_model_for_claude(Some("opus")), "opus");
         assert_eq!(resolve_model_for_claude(Some("gemini-pro")), "sonnet");
-        assert_eq!(resolve_model_for_claude(None), "sonnet");
+        assert_eq!(resolve_model_for_claude(None), "haiku");
     }
 
     #[test]
     fn test_resolve_copilot_model() {
         assert_eq!(resolve_model_for_copilot(Some("gemini-flash")), "gemini-flash");
         assert_eq!(resolve_model_for_copilot(Some("sonnet")), "sonnet");
         assert_eq!(resolve_model_for_copilot(Some("haiku")), "haiku");
-        assert_eq!(resolve_model_for_copilot(None), "sonnet");
+        assert_eq!(resolve_model_for_copilot(None), "gemini-flash");
     }
 
     #[test]
     fn test_default_config_parses() {
         let stripped = strip_json_comments(DEFAULT_CONFIG);
         let raw: RawConfig = serde_json::from_str(&stripped).unwrap();
         assert!(raw.preferred_ai_cli.is_none());
-        assert_eq!(raw.claude.model.as_deref(), Some("sonnet"));
-        assert_eq!(raw.copilot.model.as_deref(), Some("sonnet"));
+        assert_eq!(raw.claude.model.as_deref(), Some("haiku"));
+        assert_eq!(raw.copilot.model.as_deref(), Some("gemini-flash"));
     }
 
     #[test]

src/config.rs

@@ -1,7 +1,50 @@
 mod parser;
+pub mod untracked;
 
 pub use parser::parse;
 
+/// Append synthetic diff for untracked files to a raw diff string, parse the
+/// combined result, and mark the untracked files in the returned DiffData.
+pub fn parse_with_untracked(raw_diff: &str) -> (DiffData, String) {
+    let untracked_paths = untracked::discover_untracked_files();
+    parse_with_untracked_paths(raw_diff, &untracked_paths)
+}
+
+/// Same as `parse_with_untracked` but accepts pre-discovered untracked paths.
+/// Returns `(diff_data, combined_raw_diff)`.
+pub fn parse_with_untracked_paths(raw_diff: &str, untracked_paths: &[String]) -> (DiffData, String) {
+    if untracked_paths.is_empty() {
+        let data = parse(raw_diff);
+        return (data, raw_diff.to_string());
+    }
+
+    let (untracked_diff, binary_untracked) =
+        untracked::generate_untracked_diff(untracked_paths);
+
+    let combined = if untracked_diff.is_empty() {
+        raw_diff.to_string()
+    } else {
+        format!("{raw_diff}{untracked_diff}")
+    };
+
+    let mut data = parse(&combined);
+
+    // Mark untracked files by matching their paths
+    let untracked_set: std::collections::HashSet<&str> =
+        untracked_paths.iter().map(|s| s.as_str()).collect();
+    for file in &mut data.files {
+        let path = file.target_file.trim_start_matches("b/");
+        if untracked_set.contains(path) {
+            file.is_untracked = true;
+        }
+    }
+
+    // Add binary untracked files to the binary list
+    data.binary_files.extend(binary_untracked);
+
+    (data, combined)
+}
+
 /// Top-level parsed diff result.
 #[derive(Debug, Clone)]
 pub struct DiffData {
@@ -15,6 +58,7 @@ pub struct DiffFile {
     pub source_file: String,
     pub target_file: String,
     pub is_rename: bool,
+    pub is_untracked: bool,
     pub hunks: Vec<Hunk>,
     pub added_count: usize,
     pub removed_count: usize,

src/diff/mod.rs

@@ -82,6 +82,7 @@ pub fn parse(raw: &str) -> DiffData {
                 source_file: source,
                 target_file: target,
                 is_rename,
+                is_untracked: false,
                 hunks,
                 added_count: pf.added(),
                 removed_count: pf.removed(),