UX Polish: Progress Bars, Cost Estimation, and Error Messages

[unclesp1d3r]

UX Polish: Progress Bars, Cost Estimation, and Error Messages

Overview

Implement user experience polish: detailed progress bars with indicatif, cost estimation and confirmation prompts, contextual error messages, and success summaries. This ticket makes ruley transparent, user-friendly, and trustworthy.

Scope

Included:

• Progress bars using indicatif::MultiProgress (file:src/utils/progress.rs)
• Cost estimation display with detailed breakdown
• User confirmation prompts
• Contextual error messages with suggestions
• Success summary with statistics
• Dry-run mode output
• --verbose flag support

Explicitly Out:

• Core pipeline logic (Tickets 1-6)
• LLM calls (Ticket 3)
• File writing (Ticket 5)

Acceptance Criteria

1. Progress Bar System

✅ Implement progress manager (file:src/utils/progress.rs):

pub struct ProgressManager {
    multi: MultiProgress,
    bars: HashMap<String, ProgressBar>,
}

impl ProgressManager {
    pub fn new() -> Self;

    pub fn add_stage(&mut self, name: &str, total: u64) -> ProgressBar;

    pub fn update(&self, stage: &str, current: u64, message: &str);

    pub fn finish(&self, stage: &str, message: &str);
}

✅ Create progress bars for each pipeline stage:

• Scanning: "Scanning files... {current}/{total} files"
• Compressing: "Compressing code... {current}/{total} files ({ratio}% reduction)"
• Analyzing: "Analyzing codebase... {tokens} tokens sent"
• Chunking: "Analyzing chunk {current}/{total}..."
• Formatting: "Generating {format} format..."
• Writing: "Writing output files... {current}/{total}"

✅ Use indicatif::MultiProgress for concurrent updates ✅ Each stage gets its own progress bar ✅ Clean console rendering with proper alignment

2. Cost Estimation Display

✅ Implement cost estimator (file:src/utils/cost.rs):

pub fn display_cost_estimate(
    codebase: &CompressedCodebase,
    chunks: &[Chunk],
    formats: &[String],
    provider: &Provider,
) -> Result<()>

✅ Display detailed breakdown:

Analysis Summary:
├─ Files: 127 files (45 TypeScript, 32 Python, 50 other)
├─ Tokens: 48,234 (before compression: 156,891)
├─ Compression: 69% reduction
├─ Chunks: 1 (within context limit)
├─ Formats: cursor, claude, copilot
└─ Estimated cost: $0.14 (Anthropic Claude Sonnet)

Breakdown:
├─ Initial analysis: $0.12 (48,234 tokens)
└─ Format refinements: $0.02 (3 formats × ~500 tokens each)

Continue? [Y/n]

✅ For chunked analysis:

Analysis Summary:
├─ Files: 487 files (234 TypeScript, 123 Python, 130 other)
├─ Tokens: 234,567 (before compression: 789,123)
├─ Compression: 70% reduction
├─ Chunks: 3 (exceeds context limit)
└─ Estimated cost: $1.87 (Anthropic Claude Sonnet)

Breakdown:
├─ Chunk 1 analysis: $0.58 (78,189 tokens)
├─ Chunk 2 analysis: $0.58 (78,189 tokens)
├─ Chunk 3 analysis: $0.58 (78,189 tokens)
├─ Merge call: $0.08 (~10,000 tokens)
└─ Format refinements: $0.05 (3 formats × ~500 tokens each)

Note: Large codebase requires chunking. Use --include patterns to reduce scope.

Continue? [Y/n]

✅ Respect --no-confirm flag (skip prompt) ✅ Handle user input (Y/n, default: Y)

3. Contextual Error Messages

✅ Implement error formatter (file:src/utils/error.rs):

pub fn format_error(
    error: &RuleyError,
    verbose: bool,
) -> String

✅ Error message structure:

 Error: {error_type}

 What happened:
 ├─ Stage: {stage}
 ├─ Error: {error_message}
 └─ Context: {additional_context}

 Suggestion:
 • {actionable_suggestion_1}
 • {actionable_suggestion_2}

 For more details, run with --verbose

✅ Example error messages:

Missing API Key:

 Error: API key not found

 What happened:
 ├─ Attempting to connect to Anthropic Claude
 └─ No API key found

 How to fix:
 Set the ANTHROPIC_API_KEY environment variable:

   export ANTHROPIC_API_KEY=sk-...

 Get your key at: https://console.anthropic.com/

 Note: You can also configure via ruley.toml or CLI flags

 Alternative:
 • Use OpenAI with --provider openai (requires OPENAI_API_KEY)

Rate Limit:

 Error: Failed to analyze codebase

 What happened:
 ├─ Stage: Analyzing codebase with Anthropic Claude
 ├─ Error: Rate limit exceeded (429)
 └─ Tokens sent: 48,234

 Suggestion:
 • Wait 60 seconds and try again
 • Or use --provider openai to switch providers
 • Or reduce scope with --include patterns

 For more details, run with --verbose

Context Limit:

 Error: Codebase too large

 What happened:
 ├─ Stage: Analyzing codebase
 ├─ Tokens: 456,789
 └─ Context limit: 200,000 tokens

 Suggestion:
 • Use --include patterns to reduce scope
 • Example: ruley --include "src/**/*.ts"
 • Or use --compress to enable tree-sitter compression

 For more details, run with --verbose

✅ With --verbose, include:

• Full error chain
• Stack trace
• Debug information
• Temp file locations

4. Success Summary

✅ Implement success formatter:

pub fn display_success_summary(
    ctx: &Context,
    written_paths: &[PathBuf],
) -> Result<()>

✅ Display summary:

 ✓ Rules generated successfully

 Output Files:
 ├─ Cursor: .cursor/rules/project.mdc (3.2 KB)
 ├─ Claude: CLAUDE.md (2.8 KB)
 └─ Copilot: .github/copilot-instructions.md (2.1 KB)

 Statistics:
 ├─ Files analyzed: 127
 ├─ Tokens processed: 48,234
 ├─ Compression: 69% reduction
 ├─ Actual cost: $0.14
 └─ Time: 12.3s

 Next Steps:
 • Restart your AI IDE to load the new rules
 • Test AI suggestions in your codebase
 • Re-run ruley when conventions change

✅ Show actual cost vs estimated cost ✅ Show time elapsed ✅ Show file sizes

5. Dry-Run Mode Output

✅ Implement dry-run display:

pub fn display_dry_run_summary(
    codebase: &CompressedCodebase,
    formats: &[String],
) -> Result<()>

✅ Display preview:

 Dry Run - No LLM calls will be made

 Files to be analyzed:
 ├─ TypeScript (45 files, 12,345 tokens)
 │  ├─ src/main.ts (234 tokens)
 │  ├─ src/lib.ts (189 tokens)
 │  └─ ... (43 more files)
 ├─ Python (32 files, 8,901 tokens)
 │  └─ ...
 └─ Other (50 files, 26,988 tokens)

 Total: 127 files, 48,234 tokens
 Compression: 69% reduction (from 156,891 tokens)
 Estimated cost: $0.14

 Output formats: cursor, claude, copilot
 Output locations:
 ├─ .cursor/rules/project.mdc
 ├─ CLAUDE.md
 └─ .github/copilot-instructions.md

6. Integration with Pipeline

✅ Orchestrator uses progress manager:

let mut progress = ProgressManager::new();

// Stage 1: Scanning
let scan_bar = progress.add_stage("scan", file_count);
// ... update during scanning
progress.finish("scan", "Scanned 127 files");

// Stage 2: Compressing
let compress_bar = progress.add_stage("compress", file_count);
// ... update during compression
progress.finish("compress", "Compressed 127 files (69% reduction)");

// Stage 3: Cost estimation
display_cost_estimate(&codebase, &chunks, &config.formats, &config.provider)?;
if !config.no_confirm {
    let confirmed = prompt_user("Continue? [Y/n]")?;
    if !confirmed { return Ok(()); }
}

// Stage 4: Analyzing
let analyze_bar = progress.add_stage("analyze", chunks.len());
// ... update during analysis
progress.finish("analyze", "Analysis complete");

// ... other stages

// Success
display_success_summary(&ctx, &written_paths)?;

✅ Errors use contextual formatter:

if let Err(e) = run(config).await {
    let error_msg = format_error(&e, config.verbose);
    eprintln!("{}", error_msg);
    std::process::exit(1);
}

Technical References

• Core Flows: Flow 2 (Basic Usage) steps 3-5, 9; Flow 4 (Dry-Run Mode); Flow 7 (Error Handling)
• Technical Plan: Section "Architectural Approach" → "Progress Reporting"
• AGENTS.md: CLI Design, Error Handling sections

Dependencies

• Ticket 1: Foundation (Context, Config, Error types)
• Ticket 2: Input Processing (CompressedCodebase)
• Ticket 3: LLM Integration (cost calculation)
• Ticket 5: Output Handling (written paths)

Testing

• Unit tests for cost calculation (verify accuracy)
• Unit tests for error formatting (verify structure)
• Integration test: Run with --dry-run, verify output
• Integration test: Trigger rate limit, verify error message
• Integration test: Complete successful run, verify summary
• Integration test: Run with --verbose, verify detailed errors
• Manual test: Verify progress bars render correctly in terminal

sequenceDiagram
    participant User
    participant Progress
    participant Pipeline
    participant CostEstimator
    
    User->>Pipeline: ruley
    Pipeline->>Progress: Initialize MultiProgress
    
    Pipeline->>Progress: Start "Scanning" stage
    Progress-->>User: [=====>    ] Scanning files... 50/100
    
    Pipeline->>Progress: Start "Compressing" stage
    Progress-->>User: [=========>] Compressing... 90/100 (69% reduction)
    
    Pipeline->>CostEstimator: Calculate estimate
    CostEstimator-->>User: Display cost breakdown
    User->>Pipeline: Confirm (Y)
    
    Pipeline->>Progress: Start "Analyzing" stage
    Progress-->>User: [====>     ] Analyzing... 48,234 tokens
    
    Pipeline->>Progress: Complete
    Progress-->>User: ✓ Rules generated successfully

Loading

[traycerai]

Plan

Implementation Plan: UX Polish - Progress Bars, Cost Estimation, and Error Messages

Observations

The codebase has a solid foundation with a 10-stage pipeline architecture in file:src/lib.rs, existing cost calculation infrastructure in file:src/llm/cost.rs, and basic error types in file:src/utils/error.rs. The indicatif dependency is already included. A basic create_progress_bar function exists in file:src/utils/progress.rs, but the full ProgressManager with MultiProgress support needs implementation. The pipeline has clear transition points between stages (Scanning, Compressing, Analyzing, Formatting, Writing, etc.) where progress updates should be integrated. Cost estimation logic exists but needs user-facing display functions with detailed breakdowns.

Approach

Implement a comprehensive UX polish layer by creating a ProgressManager using indicatif::MultiProgress for concurrent stage tracking, enhancing the cost estimation display with detailed breakdowns and confirmation prompts, adding contextual error formatting with actionable suggestions, and implementing success summaries. The approach focuses on integrating these components into the existing pipeline stages without modifying core logic. Progress bars will be managed through a centralized ProgressManager stored in PipelineContext, cost displays will leverage existing CostCalculator and CostEstimate structures, and error formatting will extend the existing RuleyError enum with rich contextual messages.

Implementation Steps

1. Progress Bar System Implementation

File: file:src/utils/progress.rs

Implement the ProgressManager struct with MultiProgress support:

• Add ProgressManager struct containing MultiProgress and a HashMap<String, ProgressBar> to track stage-specific progress bars
• Implement new() to initialize MultiProgress
• Implement add_stage(name: &str, total: u64) -> ProgressBar to create and register a new progress bar for a pipeline stage
• Implement update(stage: &str, current: u64, message: &str) to update progress for a specific stage
• Implement finish(stage: &str, message: &str) to mark a stage as complete
• Use ProgressStyle with templates matching the ticket requirements (e.g., "[{bar:40.cyan/blue}] {pos}/{len} {msg}")
• Ensure thread-safety for async operations

Create stage-specific progress bar configurations:

• Scanning: Template showing files discovered
• Compressing: Template showing compression ratio
• Analyzing: Template showing tokens processed
• Chunking: Template showing current chunk number
• Formatting: Template showing format being generated
• Writing: Template showing files written

2. Cost Estimation Display

File: file:src/utils/cost.rs (new file)

Create cost estimation display functions:

• Implement display_cost_estimate(codebase: &CompressedCodebase, chunks: &[Chunk], formats: &[String], provider: &Provider) -> Result<()>
• Calculate file breakdown by language using codebase.metadata.languages
• Calculate token counts using existing tokenizer infrastructure
• Display detailed breakdown with tree-style formatting using Unicode box-drawing characters
• For single-chunk analysis: show initial analysis cost + format refinement costs
• For multi-chunk analysis: show per-chunk costs + merge cost + format refinement costs
• Include helpful notes for large codebases suggesting --include patterns
• Return formatted string for display

Implement user confirmation prompt:

• Create prompt_user_confirmation(message: &str) -> Result<bool> function
• Use tokio::io for async stdin reading
• Handle Y/n input (default to Y)
• Respect --no-confirm flag by skipping the prompt
• Respect --quiet flag by suppressing output

3. Contextual Error Formatting

File: file:src/utils/error.rs

Enhance error formatting:

• Implement format_error(error: &RuleyError, verbose: bool) -> String function
• Create structured error messages with sections: "What happened", "Suggestion", "For more details"
• Use Unicode symbols (⚠, ✗, •) for visual clarity
• Map each RuleyError variant to contextual suggestions:
  • Provider errors: Check API key, suggest alternative providers
  • RateLimited: Show retry time, suggest waiting or switching providers
  • TokenLimitExceeded: Suggest --include patterns or --compress flag
  • Config: Show configuration file locations and valid values
  • ValidationError: Already has suggestions, format nicely
• In verbose mode, include full error chain, stack traces, and debug information
• Add helper functions for common error scenarios (missing API key, rate limits, context limits)

Add specific error message builders:

• format_missing_api_key_error(provider: &str) -> String
• format_rate_limit_error(provider: &str, retry_after: Option<Duration>) -> String
• format_context_limit_error(tokens: usize, limit: usize) -> String

4. Success Summary Display

File: file:src/utils/summary.rs (new file)

Implement success summary:

• Create display_success_summary(ctx: &PipelineContext, written_paths: &[PathBuf]) -> Result<()>
• Display output files with sizes (use std::fs::metadata to get file sizes)
• Show statistics: files analyzed, tokens processed, compression ratio, actual cost, time elapsed
• Format file sizes in human-readable format (KB, MB)
• Include "Next Steps" section with actionable items
• Use tree-style formatting with Unicode box-drawing characters
• Compare estimated vs actual cost if available from ctx.cost_tracker

Calculate and display time elapsed:

• Add start_time: std::time::Instant to PipelineContext in file:src/lib.rs
• Calculate elapsed time at completion
• Format as seconds with one decimal place

5. Dry-Run Mode Display

File: file:src/utils/dry_run.rs (new file)

Implement dry-run display:

• Create display_dry_run_summary(codebase: &CompressedCodebase, formats: &[String]) -> Result<()>
• Group files by language using codebase.metadata.languages
• Show token counts per language
• Display compression statistics
• Show estimated cost using existing cost calculation
• List output formats and their target paths
• Use tree-style formatting for file breakdown
• Limit file listing to first few files per language with "... (N more files)" notation

6. Pipeline Integration

File: file:src/lib.rs

Integrate progress manager into pipeline:

• Add progress_manager: Option<ProgressManager> to PipelineContext
• Initialize ProgressManager in run() function (skip if --quiet flag is set)
• Update each pipeline stage to use progress bars:
  • Stage 2 (Scanning): Create progress bar, update during file discovery, finish with file count
  • Stage 3 (Compressing): Create progress bar, update during compression, finish with compression ratio
  • Stage 4 (Analyzing): Create progress bar for chunks, update during analysis, finish with completion message
  • Stage 5 (Formatting): Create progress bar for formats, update per format, finish when done
  • Stage 6 (Writing): Create progress bar for output files, update per file, finish with file count

Replace existing cost confirmation:

• Remove simple cost confirmation in file:src/lib.rs (around line 406-417)
• Call display_cost_estimate() from file:src/utils/cost.rs
• Use prompt_user_confirmation() for user input
• Respect --no-confirm and --quiet flags

Enhance dry-run mode:

• Replace display_dry_run_config() function (around line 482-511)
• Call display_dry_run_summary() from file:src/utils/dry_run.rs
• Include codebase analysis results

Update error handling in main:

• Modify file:src/main.rs error handling (around line 6-13)
• Call format_error() from file:src/utils/error.rs
• Pass verbose flag from merged config
• Display formatted error with proper styling

Add success summary:

• After Stage 10 (Cleanup) and before Complete transition
• Call display_success_summary() with context and written file paths
• Only display if not in --quiet mode

7. Module Exports and Dependencies

File: file:src/utils/mod.rs

Add new module exports:

• Add pub mod cost;
• Add pub mod summary;
• Add pub mod dry_run;

Update public API:

• Export key functions for use in file:src/lib.rs and file:src/main.rs
• Ensure proper visibility of ProgressManager, error formatters, and display functions

8. Testing Considerations

While not writing tests, ensure the implementation supports:

• Unit tests for cost calculation accuracy (verify against known pricing)
• Unit tests for error formatting structure (verify all error variants are handled)
• Integration tests for dry-run output (verify no LLM calls are made)
• Integration tests for progress bar rendering (verify correct stage transitions)
• Manual testing for terminal rendering (verify progress bars display correctly)

Visual Representation

sequenceDiagram
    participant User
    participant Main
    participant Pipeline
    participant ProgressMgr
    participant CostDisplay
    participant ErrorFormatter
    
    User->>Main: ruley
    Main->>Pipeline: run(config)
    Pipeline->>ProgressMgr: Initialize MultiProgress
    
    Pipeline->>ProgressMgr: add_stage("Scanning")
    ProgressMgr-->>User: [=====>    ] Scanning files... 50/100
    Pipeline->>ProgressMgr: finish("Scanning")
    
    Pipeline->>ProgressMgr: add_stage("Compressing")
    ProgressMgr-->>User: [=========>] Compressing... 90/100 (69%)
    Pipeline->>ProgressMgr: finish("Compressing")
    
    Pipeline->>CostDisplay: display_cost_estimate()
    CostDisplay-->>User: Cost breakdown with tree view
    CostDisplay->>User: Prompt for confirmation
    User->>CostDisplay: Y (confirm)
    
    Pipeline->>ProgressMgr: add_stage("Analyzing")
    ProgressMgr-->>User: [====>     ] Analyzing... chunk 1/3
    Pipeline->>ProgressMgr: finish("Analyzing")
    
    alt Success
        Pipeline->>Pipeline: display_success_summary()
        Pipeline-->>User: ✓ Success with statistics
    else Error
        Pipeline->>ErrorFormatter: format_error()
        ErrorFormatter-->>User: ⚠ Contextual error with suggestions
    end

Loading

Key Files Modified

File	Changes
file:src/utils/progress.rs	Implement ProgressManager with MultiProgress
file:src/utils/cost.rs	New file: cost estimation display and confirmation
file:src/utils/error.rs	Add format_error() function with contextual messages
file:src/utils/summary.rs	New file: success summary display
file:src/utils/dry_run.rs	New file: dry-run mode display
file:src/utils/mod.rs	Export new modules
file:src/lib.rs	Integrate progress bars, cost display, and success summary
file:src/main.rs	Use contextual error formatting

Dependencies

This implementation depends on:

• Ticket 1: PipelineContext, MergedConfig, RuleyError types
• Ticket 2: CompressedCodebase structure and file scanning
• Ticket 3: CostCalculator, CostEstimate, Chunk types, and LLM client
• Ticket 5: Output file paths for success summary

Existing dependencies in file:Cargo.toml:

• indicatif = "0.18.3" for progress bars
• console = "0.16.2" for terminal styling
• tokio for async I/O in confirmation prompts

Import In IDE

🤖 Prompt for AI Agents

# Implementation Plan: UX Polish - Progress Bars, Cost Estimation, and Error Messages

## Observations

The codebase has a solid foundation with a 10-stage pipeline architecture in `file:src/lib.rs`, existing cost calculation infrastructure in `file:src/llm/cost.rs`, and basic error types in `file:src/utils/error.rs`. The `indicatif` dependency is already included. A basic `create_progress_bar` function exists in `file:src/utils/progress.rs`, but the full `ProgressManager` with `MultiProgress` support needs implementation. The pipeline has clear transition points between stages (Scanning, Compressing, Analyzing, Formatting, Writing, etc.) where progress updates should be integrated. Cost estimation logic exists but needs user-facing display functions with detailed breakdowns.

## Approach

Implement a comprehensive UX polish layer by creating a `ProgressManager` using `indicatif::MultiProgress` for concurrent stage tracking, enhancing the cost estimation display with detailed breakdowns and confirmation prompts, adding contextual error formatting with actionable suggestions, and implementing success summaries. The approach focuses on integrating these components into the existing pipeline stages without modifying core logic. Progress bars will be managed through a centralized `ProgressManager` stored in `PipelineContext`, cost displays will leverage existing `CostCalculator` and `CostEstimate` structures, and error formatting will extend the existing `RuleyError` enum with rich contextual messages.

## Implementation Steps

### 1. Progress Bar System Implementation

**File: `file:src/utils/progress.rs`**

Implement the `ProgressManager` struct with `MultiProgress` support:
- Add `ProgressManager` struct containing `MultiProgress` and a `HashMap<String, ProgressBar>` to track stage-specific progress bars
- Implement `new()` to initialize `MultiProgress`
- Implement `add_stage(name: &str, total: u64) -> ProgressBar` to create and register a new progress bar for a pipeline stage
- Implement `update(stage: &str, current: u64, message: &str)` to update progress for a specific stage
- Implement `finish(stage: &str, message: &str)` to mark a stage as complete
- Use `ProgressStyle` with templates matching the ticket requirements (e.g., `"[{bar:40.cyan/blue}] {pos}/{len} {msg}"`)
- Ensure thread-safety for async operations

Create stage-specific progress bar configurations:
- **Scanning**: Template showing files discovered
- **Compressing**: Template showing compression ratio
- **Analyzing**: Template showing tokens processed
- **Chunking**: Template showing current chunk number
- **Formatting**: Template showing format being generated
- **Writing**: Template showing files written

### 2. Cost Estimation Display

**File: `file:src/utils/cost.rs` (new file)**

Create cost estimation display functions:
- Implement `display_cost_estimate(codebase: &CompressedCodebase, chunks: &[Chunk], formats: &[String], provider: &Provider) -> Result<()>`
- Calculate file breakdown by language using `codebase.metadata.languages`
- Calculate token counts using existing tokenizer infrastructure
- Display detailed breakdown with tree-style formatting using Unicode box-drawing characters
- For single-chunk analysis: show initial analysis cost + format refinement costs
- For multi-chunk analysis: show per-chunk costs + merge cost + format refinement costs
- Include helpful notes for large codebases suggesting `--include` patterns
- Return formatted string for display

Implement user confirmation prompt:
- Create `prompt_user_confirmation(message: &str) -> Result<bool>` function
- Use `tokio::io` for async stdin reading
- Handle Y/n input (default to Y)
- Respect `--no-confirm` flag by skipping the prompt
- Respect `--quiet` flag by suppressing output

### 3. Contextual Error Formatting

**File: `file:src/utils/error.rs`**

Enhance error formatting:
- Implement `format_error(error: &RuleyError, verbose: bool) -> String` function
- Create structured error messages with sections: "What happened", "Suggestion", "For more details"
- Use Unicode symbols (⚠, ✗, •) for visual clarity
- Map each `RuleyError` variant to contextual suggestions:
  - `Provider` errors: Check API key, suggest alternative providers
  - `RateLimited`: Show retry time, suggest waiting or switching providers
  - `TokenLimitExceeded`: Suggest `--include` patterns or `--compress` flag
  - `Config`: Show configuration file locations and valid values
  - `ValidationError`: Already has suggestions, format nicely
- In verbose mode, include full error chain, stack traces, and debug information
- Add helper functions for common error scenarios (missing API key, rate limits, context limits)

Add specific error message builders:
- `format_missing_api_key_error(provider: &str) -> String`
- `format_rate_limit_error(provider: &str, retry_after: Option<Duration>) -> String`
- `format_context_limit_error(tokens: usize, limit: usize) -> String`

### 4. Success Summary Display

**File: `file:src/utils/summary.rs` (new file)**

Implement success summary:
- Create `display_success_summary(ctx: &PipelineContext, written_paths: &[PathBuf]) -> Result<()>`
- Display output files with sizes (use `std::fs::metadata` to get file sizes)
- Show statistics: files analyzed, tokens processed, compression ratio, actual cost, time elapsed
- Format file sizes in human-readable format (KB, MB)
- Include "Next Steps" section with actionable items
- Use tree-style formatting with Unicode box-drawing characters
- Compare estimated vs actual cost if available from `ctx.cost_tracker`

Calculate and display time elapsed:
- Add `start_time: std::time::Instant` to `PipelineContext` in `file:src/lib.rs`
- Calculate elapsed time at completion
- Format as seconds with one decimal place

### 5. Dry-Run Mode Display

**File: `file:src/utils/dry_run.rs` (new file)**

Implement dry-run display:
- Create `display_dry_run_summary(codebase: &CompressedCodebase, formats: &[String]) -> Result<()>`
- Group files by language using `codebase.metadata.languages`
- Show token counts per language
- Display compression statistics
- Show estimated cost using existing cost calculation
- List output formats and their target paths
- Use tree-style formatting for file breakdown
- Limit file listing to first few files per language with "... (N more files)" notation

### 6. Pipeline Integration

**File: `file:src/lib.rs`**

Integrate progress manager into pipeline:
- Add `progress_manager: Option<ProgressManager>` to `PipelineContext`
- Initialize `ProgressManager` in `run()` function (skip if `--quiet` flag is set)
- Update each pipeline stage to use progress bars:
  - **Stage 2 (Scanning)**: Create progress bar, update during file discovery, finish with file count
  - **Stage 3 (Compressing)**: Create progress bar, update during compression, finish with compression ratio
  - **Stage 4 (Analyzing)**: Create progress bar for chunks, update during analysis, finish with completion message
  - **Stage 5 (Formatting)**: Create progress bar for formats, update per format, finish when done
  - **Stage 6 (Writing)**: Create progress bar for output files, update per file, finish with file count

Replace existing cost confirmation:
- Remove simple cost confirmation in `file:src/lib.rs` (around line 406-417)
- Call `display_cost_estimate()` from `file:src/utils/cost.rs`
- Use `prompt_user_confirmation()` for user input
- Respect `--no-confirm` and `--quiet` flags

Enhance dry-run mode:
- Replace `display_dry_run_config()` function (around line 482-511)
- Call `display_dry_run_summary()` from `file:src/utils/dry_run.rs`
- Include codebase analysis results

Update error handling in main:
- Modify `file:src/main.rs` error handling (around line 6-13)
- Call `format_error()` from `file:src/utils/error.rs`
- Pass `verbose` flag from merged config
- Display formatted error with proper styling

Add success summary:
- After Stage 10 (Cleanup) and before Complete transition
- Call `display_success_summary()` with context and written file paths
- Only display if not in `--quiet` mode

### 7. Module Exports and Dependencies

**File: `file:src/utils/mod.rs`**

Add new module exports:
- Add `pub mod cost;`
- Add `pub mod summary;`
- Add `pub mod dry_run;`

Update public API:
- Export key functions for use in `file:src/lib.rs` and `file:src/main.rs`
- Ensure proper visibility of `ProgressManager`, error formatters, and display functions

### 8. Testing Considerations

While not writing tests, ensure the implementation supports:
- Unit tests for cost calculation accuracy (verify against known pricing)
- Unit tests for error formatting structure (verify all error variants are handled)
- Integration tests for dry-run output (verify no LLM calls are made)
- Integration tests for progress bar rendering (verify correct stage transitions)
- Manual testing for terminal rendering (verify progress bars display correctly)

## Visual Representation

```mermaid
sequenceDiagram
    participant User
    participant Main
    participant Pipeline
    participant ProgressMgr
    participant CostDisplay
    participant ErrorFormatter
    
    User->>Main: ruley
    Main->>Pipeline: run(config)
    Pipeline->>ProgressMgr: Initialize MultiProgress
    
    Pipeline->>ProgressMgr: add_stage("Scanning")
    ProgressMgr-->>User: [=====>    ] Scanning files... 50/100
    Pipeline->>ProgressMgr: finish("Scanning")
    
    Pipeline->>ProgressMgr: add_stage("Compressing")
    ProgressMgr-->>User: [=========>] Compressing... 90/100 (69%)
    Pipeline->>ProgressMgr: finish("Compressing")
    
    Pipeline->>CostDisplay: display_cost_estimate()
    CostDisplay-->>User: Cost breakdown with tree view
    CostDisplay->>User: Prompt for confirmation
    User->>CostDisplay: Y (confirm)
    
    Pipeline->>ProgressMgr: add_stage("Analyzing")
    ProgressMgr-->>User: [====>     ] Analyzing... chunk 1/3
    Pipeline->>ProgressMgr: finish("Analyzing")
    
    alt Success
        Pipeline->>Pipeline: display_success_summary()
        Pipeline-->>User: ✓ Success with statistics
    else Error
        Pipeline->>ErrorFormatter: format_error()
        ErrorFormatter-->>User: ⚠ Contextual error with suggestions
    end
```

## Key Files Modified

| File | Changes |
|------|---------|
| `file:src/utils/progress.rs` | Implement `ProgressManager` with `MultiProgress` |
| `file:src/utils/cost.rs` | New file: cost estimation display and confirmation |
| `file:src/utils/error.rs` | Add `format_error()` function with contextual messages |
| `file:src/utils/summary.rs` | New file: success summary display |
| `file:src/utils/dry_run.rs` | New file: dry-run mode display |
| `file:src/utils/mod.rs` | Export new modules |
| `file:src/lib.rs` | Integrate progress bars, cost display, and success summary |
| `file:src/main.rs` | Use contextual error formatting |

## Dependencies

This implementation depends on:
- **Ticket 1**: `PipelineContext`, `MergedConfig`, `RuleyError` types
- **Ticket 2**: `CompressedCodebase` structure and file scanning
- **Ticket 3**: `CostCalculator`, `CostEstimate`, `Chunk` types, and LLM client
- **Ticket 5**: Output file paths for success summary

Existing dependencies in `file:Cargo.toml`:
- `indicatif = "0.18.3"` for progress bars
- `console = "0.16.2"` for terminal styling
- `tokio` for async I/O in confirmation prompts

---

Execution Information

Branch: main
Commit: 8ff2d91

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[coderabbitai]

📝 CodeRabbit Plan Mode

Generate an implementation plan and prompts that you can use with your favorite coding agent.

• Create Plan

Examples

• Example 1
• Example 2

---

🔗 Related PRs

#1 - Develop [merged]
#2 - feat(core): implement 10-stage pipeline architecture and config system [merged]
#5 - feat(packer): add repomix file parsing and compressed codebase structures [merged]
#6 - feat(llm): LLM Integration with Provider Abstraction, Chunking, and Retry Logic [merged]

---

🧪 Issue enrichment is currently in open beta.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!