Add comprehensive documentation on Jujutsu usage in CLAUDE.md

Author: erik-balfe

DEVELOPMENT_PLAN.md

@@ -1,5 +1,45 @@
 # Smart Tree Development Plan
 
+## Version Management
+
+Smart Tree uses a versioning system with the following components:
+
+- **Single Source of Truth**: The version is stored in `Cargo.toml` and accessed via `env!("CARGO_PKG_VERSION")`
+- **Version Display**: The current version can be displayed with `smart-tree -v`
+- **Release Management**: The `release.sh` script manages version bumping and release creation
+
+### Using the Release Script
+
+The `release.sh` script provides a convenient way to manage versions:
+
+```bash
+# Show current version
+./release.sh current
+
+# Bump major version (x.0.0)
+./release.sh major
+
+# Bump minor version (0.x.0)
+./release.sh minor
+
+# Bump patch version (0.0.x)
+./release.sh patch
+```
+
+The script will:
+1. Update the version in `Cargo.toml`
+2. Create a Jujutsu bookmark for the version (acts as a tag)
+3. Offer to push changes to the remote repository
+
+### Release Workflow
+
+1. Make your changes to the codebase
+2. Run tests and lint checks: `cargo test && cargo clippy`
+3. Bump the version: `./release.sh [major|minor|patch]`
+4. Push to GitHub when prompted by the script
+5. The GitHub Action will automatically build binaries for all platforms
+6. The GitHub Release will be created from the tag
+
 ## Current Project Status
 
 Smart Tree is a modern directory tree viewer that intelligently displays file hierarchies with an emphasis on readability. Unlike traditional `tree` commands that output everything (often producing thousands of lines), Smart Tree makes smart decisions about what to show and what to fold.
@@ -123,10 +163,11 @@ Smart Tree is a modern directory tree viewer that intelligently displays file hi
 ### Phase 4: Distribution and Integration (Medium Term)
 
 1. **Package and Distribution**
-   - Create installation script (install.sh) for simple cross-platform installation
-   - Package for Homebrew (brew) installation on macOS
-   - Implement continuous integration/deployment pipeline
-   - Set up automated GitHub releases with versioned branches (e.g., 'v0.2.0')
+   - ✅ Create installation script (install.sh) for simple cross-platform installation
+   - ✅ Package for Homebrew (brew) installation on macOS
+   - ✅ Implement continuous integration/deployment pipeline
+   - ✅ Set up automated GitHub releases with versioned tags (e.g., 'v0.2.0')
+   - ✅ Create release script (release.sh) for managing versions
 
 2. **Integration Features**
    - VCS integration (show modified files since last commit)

README.MD

@@ -197,6 +197,9 @@ smart-tree --rule-debug
 # Disable all rules completely
 smart-tree --no-rules
 
+# Show version
+smart-tree -v
+
 # Show help with all options
 smart-tree --help
 ```
@@ -217,6 +220,9 @@ cargo install --path .
 
 # Now you can run from anywhere
 smart-tree [path] [options]
+
+# Check version
+smart-tree -v
 ```
 
 ## 🤝 Contributing

release.sh

@@ -0,0 +1,144 @@
+#!/bin/bash
+set -euo pipefail
+
+# Colors for output
+GREEN="\033[0;32m"
+YELLOW="\033[1;33m"
+RED="\033[0;31m"
+BLUE="\033[0;34m"
+RESET="\033[0m"
+
+# Function to display usage instructions
+usage() {
+    echo -e "${BLUE}Smart Tree Release Tool${RESET}"
+    echo
+    echo "This script helps manage version and releases for the Smart Tree project"
+    echo
+    echo "Usage:"
+    echo "  ./release.sh [command]"
+    echo
+    echo "Commands:"
+    echo "  major      - Bump major version (X.0.0)"
+    echo "  minor      - Bump minor version (0.X.0)"
+    echo "  patch      - Bump patch version (0.0.X)"
+    echo "  current    - Show current version"
+    echo "  help       - Show this help message"
+    echo
+    echo "Examples:"
+    echo "  ./release.sh minor    # Increases minor version (e.g., 0.2.0 -> 0.3.0)"
+    echo "  ./release.sh patch    # Increases patch version (e.g., 0.2.0 -> 0.2.1)"
+    echo
+}
+
+# Function to extract current version from Cargo.toml
+get_current_version() {
+    grep -m 1 '^version =' Cargo.toml | awk -F '"' '{print $2}' | tr -d '[:space:]'
+}
+
+# Function to update version in Cargo.toml
+update_version_in_cargo_toml() {
+    local new_version=$1
+    sed -i "s/^version = \".*\"/version = \"$new_version\"/" Cargo.toml
+    echo -e "${GREEN}Updated Cargo.toml to version $new_version${RESET}"
+}
+
+# Function to tag release in Jujutsu
+tag_release() {
+    local new_version=$1
+    local tag_name="v$new_version"
+    local message="Release $tag_name"
+    
+    # Make sure the file is tracked by jj
+    jj file track release.sh || echo "release.sh already tracked"
+    
+    # Create a new change for the version update
+    jj new -m "Bump version to $new_version"
+    
+    # Create tag (bookmark) in Jujutsu
+    jj bookmark set "$tag_name" -r @ -B
+    
+    echo -e "${GREEN}Created bookmark/tag $tag_name${RESET}"
+    
+    # Optional: Push changes to remote
+    read -p "Push changes to remote? (y/n): " push_choice
+    if [[ $push_choice == "y" || $push_choice == "Y" ]]; then
+        jj bookmark set master -r @ -B
+        jj git push -b master
+        echo -e "${GREEN}Changes pushed to remote${RESET}"
+        echo
+        echo -e "${YELLOW}Now go to GitHub and create a release from tag $tag_name${RESET}"
+    else
+        echo -e "${YELLOW}Remember to push changes with: jj bookmark set master -r @ -B && jj git push -b master${RESET}"
+    fi
+}
+
+# Function to bump version
+bump_version() {
+    local component=$1
+    local current_version=$(get_current_version)
+    local major minor patch
+    
+    # Parse version components
+    IFS='.' read -r major minor patch <<< "$current_version"
+    
+    # Update appropriate component
+    case $component in
+        major)
+            major=$((major + 1))
+            minor=0
+            patch=0
+            ;;
+        minor)
+            minor=$((minor + 1))
+            patch=0
+            ;;
+        patch)
+            patch=$((patch + 1))
+            ;;
+        *)
+            echo -e "${RED}Invalid version component: $component${RESET}"
+            exit 1
+            ;;
+    esac
+    
+    local new_version="$major.$minor.$patch"
+    
+    echo -e "${BLUE}Current version: ${RESET}$current_version"
+    echo -e "${BLUE}New version:     ${RESET}$new_version"
+    
+    # Confirm before proceeding
+    read -p "Proceed with version update? (y/n): " choice
+    if [[ $choice != "y" && $choice != "Y" ]]; then
+        echo -e "${YELLOW}Version update cancelled${RESET}"
+        exit 0
+    fi
+    
+    # Update version in files
+    update_version_in_cargo_toml "$new_version"
+    
+    # Tag the release
+    tag_release "$new_version"
+}
+
+# Main script execution
+command=${1:-help}
+
+case $command in
+    major|minor|patch)
+        bump_version "$command"
+        ;;
+    current)
+        current_version=$(get_current_version)
+        echo -e "${BLUE}Current version: ${RESET}$current_version"
+        ;;
+    help)
+        usage
+        ;;
+    *)
+        echo -e "${RED}Unknown command: $command${RESET}"
+        usage
+        exit 1
+        ;;
+esac
+
+exit 0

src/main.rs

@@ -1,13 +1,14 @@
 use anyhow::Result;
 use clap::Parser;
+use log::debug;
 use smart_tree::rules::create_default_registry;
 use smart_tree::{
     format_tree, scan_directory, ColorTheme, DisplayConfig, GitIgnoreContext, SortBy,
 };
 use std::path::PathBuf;
 
 #[derive(Parser, Debug)]
-#[command(author, version, about)]
+#[command(author, version, about, disable_version_flag = true)]
 struct Args {
     /// Directory path to display
     #[arg(default_value = ".")]
@@ -92,6 +93,10 @@ struct Args {
     /// Disable smart filtering rules completely
     #[arg(long)]
     no_rules: bool,
+
+    /// Display current version
+    #[arg(short = 'v', long)]
+    version: bool,
 }
 
 fn init_logger() {
@@ -111,6 +116,13 @@ fn init_logger() {
 fn main() -> Result<()> {
     init_logger();
     let args = Args::parse();
+    
+    // Check if version flag was used
+    if args.version {
+        let version = env!("CARGO_PKG_VERSION");
+        println!("smart-tree version {}", version);
+        return Ok(());
+    }
 
     // Determine if we should use emoji (default to true unless --no-emoji is specified)
     let use_emoji = if args.no_emoji {
@@ -119,6 +131,10 @@ fn main() -> Result<()> {
         args.emoji || !args.no_emoji
     };
 
+    // Clone the rules vectors for later usage
+    let disable_rules = args.disable_rule.clone();
+    let enable_rules = args.enable_rule.clone();
+
     let config = DisplayConfig {
         max_lines: args.max_lines,
         dir_limit: args.dir_limit,
@@ -175,9 +191,24 @@ fn main() -> Result<()> {
         None
     } else {
         // Create the rule registry
-        let registry = create_default_registry(&args.path)?;
-
-        // TODO: Handle enable/disable rules here
+        let mut registry = create_default_registry(&args.path)?;
+
+        // Handle enable/disable rules
+        if !disable_rules.is_empty() || !enable_rules.is_empty() {
+            // Apply rule enabling/disabling
+            
+            // Process rule disabling
+            for rule_id in &disable_rules {
+                debug!("Disabling rule: {}", rule_id);
+                registry.disable_rule(rule_id);
+            }
+            
+            // Process rule enabling
+            for rule_id in &enable_rules {
+                debug!("Enabling rule: {}", rule_id);
+                registry.enable_rule(rule_id);
+            }
+        }
 
         Some(registry)
     };

src/rules.rs

@@ -217,13 +217,15 @@ pub trait FilterRule: Send + Sync {
 pub struct FilterRegistry {
     rules: Vec<Box<dyn FilterRule>>,
     threshold: f32,
+    disabled_rules: Vec<String>,
 }
 
 impl Default for FilterRegistry {
     fn default() -> Self {
         Self {
             rules: Vec::new(),
             threshold: 0.5, // Default threshold is 0.5
+            disabled_rules: Vec::new(),
         }
     }
 }
@@ -246,13 +248,35 @@ impl FilterRegistry {
     pub fn set_threshold(&mut self, threshold: f32) {
         self.threshold = threshold.clamp(0.0, 1.0);
     }
+    
+    /// Disable a specific rule by ID
+    pub fn disable_rule(&mut self, rule_id: &str) {
+        if !self.disabled_rules.contains(&rule_id.to_string()) {
+            self.disabled_rules.push(rule_id.to_string());
+        }
+    }
+    
+    /// Enable a previously disabled rule
+    pub fn enable_rule(&mut self, rule_id: &str) {
+        self.disabled_rules.retain(|id| id != rule_id);
+    }
+
+    /// Check if a rule is disabled
+    pub fn is_rule_disabled(&self, rule_id: &str) -> bool {
+        self.disabled_rules.contains(&rule_id.to_string())
+    }
 
     /// Evaluate if a path should be hidden based on all applicable rules
     pub fn should_hide(&self, context: &FilterContext) -> Option<(bool, &str)> {
         let mut max_score = 0.0;
         let mut annotation = "[filtered]";
 
         for rule in &self.rules {
+            // Skip disabled rules
+            if self.is_rule_disabled(rule.id()) {
+                continue;
+            }
+            
             if rule.applies_to(context) {
                 let score = rule.evaluate(context);
                 if score > max_score {

src/scanner.rs

@@ -98,7 +98,10 @@ pub fn scan_directory(
     };
 
     // For filtered directories, decide whether to traverse or just provide basic metadata
-    let should_skip = should_filter;
+    // If this is the root path that was explicitly specified, never skip it regardless of filter rules
+    let is_direct_path = root.canonicalize().unwrap_or_else(|_| root.to_path_buf())
+        == Path::new(&root).canonicalize().unwrap_or_else(|_| root.to_path_buf());
+    let should_skip = should_filter && !is_direct_path;
 
     if should_skip {
         debug!(