rusty_beads/cli/

mod.rs

//! CLI commands for Beads.

use std::path::PathBuf;
use std::sync::Arc;

use anyhow::{Context, Result};
use clap::{Parser, Subcommand};

use crate::daemon::{Daemon, DaemonClient, DaemonConfig};
use crate::git::{find_beads_dir, find_database_path, init_beads_dir};
use crate::storage::{SqliteStorage, Storage};
use crate::types::{IssueFilter, Status};
use crate::compact::Compactor;
use crate::context::{ContextStore, ContextEntry, Namespace, FileContext, ProjectContext};
use crate::{Issue, Dependency, generate_id};

/// Beads - Git-backed graph issue tracker for AI coding agents.
#[derive(Parser)]
#[command(name = "bd", version, about, long_about = None)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Command,

    /// Skip daemon and use direct database access.
    #[arg(long, global = true)]
    pub no_daemon: bool,

    /// Override the actor name.
    #[arg(long, global = true)]
    pub actor: Option<String>,

    /// Output in JSON format.
    #[arg(long, global = true)]
    pub json: bool,
}

#[derive(Subcommand)]
pub enum Command {
    /// Initialize a new .beads directory.
    Init {
        /// Path to initialize (defaults to current directory).
        #[arg(short, long)]
        path: Option<PathBuf>,
    },

    /// Create a new issue.
    Create {
        /// Issue title.
        #[arg(short, long)]
        title: String,

        /// Issue description.
        #[arg(short, long)]
        description: Option<String>,

        /// Issue type (bug, feature, task, epic, chore).
        #[arg(short = 'T', long, default_value = "task")]
        issue_type: String,

        /// Priority (0-4, lower is higher).
        #[arg(short, long, default_value = "2")]
        priority: i32,

        /// Assignee.
        #[arg(short, long)]
        assignee: Option<String>,

        /// Parent issue ID (creates child issue).
        #[arg(long)]
        parent: Option<String>,

        /// Labels (comma-separated).
        #[arg(short, long)]
        labels: Option<String>,
    },

    /// Show issue details.
    Show {
        /// Issue ID.
        id: String,

        /// Include comments.
        #[arg(long)]
        comments: bool,

        /// Include events.
        #[arg(long)]
        events: bool,
    },

    /// List issues.
    List {
        /// Filter by status.
        #[arg(short, long)]
        status: Option<String>,

        /// Filter by type.
        #[arg(short = 'T', long)]
        issue_type: Option<String>,

        /// Filter by assignee.
        #[arg(short, long)]
        assignee: Option<String>,

        /// Filter by label.
        #[arg(short, long)]
        label: Option<String>,

        /// Include closed issues.
        #[arg(long)]
        all: bool,

        /// Maximum number of results.
        #[arg(short = 'n', long)]
        limit: Option<usize>,
    },

    /// Show ready (unblocked) issues.
    Ready {
        /// Maximum number of results.
        #[arg(short = 'n', long)]
        limit: Option<usize>,
    },

    /// Update an issue.
    Update {
        /// Issue ID.
        id: String,

        /// New title.
        #[arg(short, long)]
        title: Option<String>,

        /// New description.
        #[arg(short, long)]
        description: Option<String>,

        /// New status.
        #[arg(short, long)]
        status: Option<String>,

        /// New priority.
        #[arg(short, long)]
        priority: Option<i32>,

        /// New assignee.
        #[arg(short, long)]
        assignee: Option<String>,
    },

    /// Close an issue.
    Close {
        /// Issue ID.
        id: String,

        /// Reason for closing.
        #[arg(short, long)]
        reason: Option<String>,
    },

    /// Delete (tombstone) an issue.
    Delete {
        /// Issue ID.
        id: String,

        /// Reason for deletion.
        #[arg(short, long)]
        reason: Option<String>,
    },

    /// Manage dependencies.
    Dep {
        #[command(subcommand)]
        action: DepAction,
    },

    /// Manage labels.
    Label {
        #[command(subcommand)]
        action: LabelAction,
    },

    /// Show statistics.
    Stats,

    /// Daemon management.
    Daemon {
        #[command(subcommand)]
        action: DaemonAction,
    },

    /// Compact completed issues.
    Compact {
        /// Maximum compaction level (1-3).
        #[arg(short, long, default_value = "1")]
        level: i32,

        /// Compact a specific issue.
        #[arg(short, long)]
        id: Option<String>,
    },

    /// Configuration management.
    Config {
        /// Config key.
        key: Option<String>,

        /// Config value (if setting).
        value: Option<String>,

        /// Delete the key.
        #[arg(long)]
        delete: bool,
    },

    /// Context store management for agents.
    Context {
        #[command(subcommand)]
        action: ContextAction,
    },
}

#[derive(Subcommand)]
pub enum DepAction {
    /// Add a dependency.
    Add {
        /// Issue that depends on another.
        issue_id: String,

        /// Issue being depended upon.
        depends_on: String,

        /// Dependency type (blocks, parent-child, relates-to).
        #[arg(short = 'T', long, default_value = "blocks")]
        dep_type: String,
    },

    /// Remove a dependency.
    Remove {
        /// Issue that depends on another.
        issue_id: String,

        /// Issue being depended upon.
        depends_on: String,
    },

    /// List dependencies for an issue.
    List {
        /// Issue ID.
        issue_id: String,
    },
}

#[derive(Subcommand)]
pub enum LabelAction {
    /// Add a label.
    Add {
        /// Issue ID.
        issue_id: String,

        /// Label to add.
        label: String,
    },

    /// Remove a label.
    Remove {
        /// Issue ID.
        issue_id: String,

        /// Label to remove.
        label: String,
    },

    /// List labels for an issue.
    List {
        /// Issue ID.
        issue_id: String,
    },
}

#[derive(Subcommand)]
pub enum DaemonAction {
    /// Start the daemon.
    Start {
        /// Run in foreground.
        #[arg(long)]
        foreground: bool,

        /// Auto-commit changes.
        #[arg(long)]
        auto_commit: bool,

        /// Auto-push to remote.
        #[arg(long)]
        auto_push: bool,
    },

    /// Stop the daemon.
    Stop,

    /// Show daemon status.
    Status,
}

#[derive(Subcommand)]
pub enum ContextAction {
    /// Get a context entry by key.
    Get {
        /// Context key (e.g., "file:src/main.rs:summary").
        key: String,
    },

    /// Set a context entry.
    Set {
        /// Context key.
        key: String,

        /// JSON value.
        value: String,

        /// TTL in seconds (optional).
        #[arg(long)]
        ttl: Option<i64>,

        /// File path this entry relates to.
        #[arg(long)]
        file: Option<String>,
    },

    /// Delete a context entry.
    Delete {
        /// Context key to delete.
        key: String,
    },

    /// List context entries.
    List {
        /// Filter by namespace (file, symbol, project, session, agent).
        #[arg(short = 'N', long)]
        namespace: Option<String>,

        /// Filter by key prefix.
        #[arg(short, long)]
        prefix: Option<String>,

        /// Maximum number of entries.
        #[arg(short = 'n', long)]
        limit: Option<usize>,
    },

    /// Clear context entries.
    Clear {
        /// Clear only entries in this namespace.
        #[arg(short = 'N', long)]
        namespace: Option<String>,

        /// Clear expired entries only.
        #[arg(long)]
        expired: bool,
    },

    /// Show context store statistics.
    Stats,

    /// Get file context.
    File {
        /// File path.
        path: String,
    },

    /// Get or set project context.
    Project {
        /// Set project context (JSON value).
        #[arg(long)]
        set: Option<String>,
    },

    /// Get session context.
    Session {
        /// Session ID.
        session_id: String,
    },

    /// Refresh git state for invalidation.
    Refresh,
}

/// Run the CLI.
pub async fn run(cli: Cli) -> Result<()> {
    let actor = cli.actor.unwrap_or_else(get_default_actor);
    let json_output = cli.json;

    match cli.command {
        Command::Init { path } => {
            let target = path.unwrap_or_else(|| std::env::current_dir().unwrap());
            let beads_path = init_beads_dir(&target)?;

            // Create database
            let db_path = beads_path.join("beads.db");
            SqliteStorage::open(&db_path)?;

            if json_output {
                println!(r#"{{"success": true, "path": {:?}}}"#, beads_path);
            } else {
                println!("Initialized .beads directory at {:?}", beads_path);
            }
        }

        Command::Create {
            title,
            description,
            issue_type,
            priority,
            assignee,
            parent,
            labels,
        } => {
            let storage = open_storage()?;

            let id = if let Some(ref parent_id) = parent {
                let counter = storage.next_child_counter(parent_id)?;
                crate::idgen::generate_child_id(parent_id, counter)
            } else {
                generate_id("bd")
            };

            let mut issue = Issue::new(&id, &title, &actor);
            issue.description = description;
            issue.issue_type = issue_type.parse().unwrap_or_default();
            issue.priority = priority.clamp(0, 4);
            issue.assignee = assignee;
            issue.update_content_hash();

            storage.create_issue(&issue)?;

            // Add labels
            if let Some(labels_str) = labels {
                for label in labels_str.split(',').map(|s| s.trim()) {
                    storage.add_label(&id, label)?;
                }
            }

            // Add parent-child dependency
            if let Some(ref parent_id) = parent {
                let dep = Dependency::parent_child(&id, parent_id)
                    .with_creator(&actor);
                storage.add_dependency(&dep)?;
            }

            if json_output {
                println!("{}", serde_json::to_string(&issue)?);
            } else {
                println!("Created issue: {}", id);
            }
        }

        Command::Show { id, comments, events } => {
            let storage = open_storage()?;

            let issue = storage.get_issue(&id)?
                .context(format!("Issue not found: {}", id))?;

            if json_output {
                let mut output = serde_json::to_value(&issue)?;
                if comments {
                    let comments = storage.get_comments(&id)?;
                    output["comments"] = serde_json::to_value(&comments)?;
                }
                if events {
                    let events = storage.get_events(&id)?;
                    output["events"] = serde_json::to_value(&events)?;
                }
                println!("{}", serde_json::to_string_pretty(&output)?);
            } else {
                print_issue(&issue);

                if comments {
                    let comments = storage.get_comments(&id)?;
                    if !comments.is_empty() {
                        println!("\nComments:");
                        for comment in comments {
                            println!("  [{} by {}]: {}", comment.created_at.format("%Y-%m-%d"), comment.author, comment.text);
                        }
                    }
                }
            }
        }

        Command::List {
            status,
            issue_type,
            assignee,
            label,
            all,
            limit,
        } => {
            let storage = open_storage()?;

            let mut filter = if all {
                IssueFilter::new().include_deleted()
            } else {
                IssueFilter::active()
            };

            if let Some(ref s) = status {
                filter.status = s.parse().ok();
            }
            if let Some(ref t) = issue_type {
                filter.issue_type = t.parse().ok();
            }
            filter.assignee = assignee;
            filter.label = label;
            filter.limit = limit;

            let issues = storage.search_issues(&filter)?;

            if json_output {
                println!("{}", serde_json::to_string(&issues)?);
            } else {
                if issues.is_empty() {
                    println!("No issues found");
                } else {
                    for issue in &issues {
                        print_issue_summary(issue);
                    }
                    println!("\n{} issue(s)", issues.len());
                }
            }
        }

        Command::Ready { limit } => {
            let storage = open_storage()?;

            let mut issues = storage.get_ready_work()?;
            if let Some(n) = limit {
                issues.truncate(n);
            }

            if json_output {
                println!("{}", serde_json::to_string(&issues)?);
            } else {
                if issues.is_empty() {
                    println!("No ready issues");
                } else {
                    println!("Ready issues:");
                    for issue in &issues {
                        print_issue_summary(issue);
                    }
                    println!("\n{} ready issue(s)", issues.len());
                }
            }
        }

        Command::Update {
            id,
            title,
            description,
            status,
            priority,
            assignee,
        } => {
            let storage = open_storage()?;

            let mut issue = storage.get_issue(&id)?
                .context(format!("Issue not found: {}", id))?;

            if let Some(t) = title {
                issue.title = t;
            }
            if let Some(d) = description {
                issue.description = Some(d);
            }
            if let Some(s) = status {
                issue.status = s.parse().unwrap_or(issue.status);
            }
            if let Some(p) = priority {
                issue.priority = p.clamp(0, 4);
            }
            if let Some(a) = assignee {
                issue.assignee = Some(a);
            }

            issue.touch();
            issue.update_content_hash();
            storage.update_issue(&issue)?;

            if json_output {
                println!("{}", serde_json::to_string(&issue)?);
            } else {
                println!("Updated issue: {}", id);
            }
        }

        Command::Close { id, reason } => {
            let storage = open_storage()?;
            storage.close_issue(&id, &actor, reason.as_deref())?;

            if json_output {
                println!(r#"{{"success": true, "id": "{}"}}"#, id);
            } else {
                println!("Closed issue: {}", id);
            }
        }

        Command::Delete { id, reason } => {
            let storage = open_storage()?;
            storage.delete_issue(&id, &actor, reason.as_deref())?;

            if json_output {
                println!(r#"{{"success": true, "id": "{}"}}"#, id);
            } else {
                println!("Deleted issue: {}", id);
            }
        }

        Command::Dep { action } => {
            let storage = open_storage()?;

            match action {
                DepAction::Add { issue_id, depends_on, dep_type } => {
                    let dep = Dependency {
                        issue_id: issue_id.clone(),
                        depends_on_id: depends_on.clone(),
                        dep_type: dep_type.parse().unwrap_or_default(),
                        created_at: chrono::Utc::now(),
                        created_by: Some(actor),
                        metadata: None,
                        thread_id: None,
                    };
                    storage.add_dependency(&dep)?;

                    if json_output {
                        println!(r#"{{"success": true}}"#);
                    } else {
                        println!("Added dependency: {} -> {}", issue_id, depends_on);
                    }
                }

                DepAction::Remove { issue_id, depends_on } => {
                    storage.remove_dependency(&issue_id, &depends_on)?;

                    if json_output {
                        println!(r#"{{"success": true}}"#);
                    } else {
                        println!("Removed dependency: {} -> {}", issue_id, depends_on);
                    }
                }

                DepAction::List { issue_id } => {
                    let deps = storage.get_dependencies(&issue_id)?;

                    if json_output {
                        println!("{}", serde_json::to_string(&deps)?);
                    } else {
                        if deps.is_empty() {
                            println!("No dependencies");
                        } else {
                            println!("Dependencies for {}:", issue_id);
                            for dep in &deps {
                                println!("  {} ({})", dep.depends_on_id, dep.dep_type);
                            }
                        }
                    }
                }
            }
        }

        Command::Label { action } => {
            let storage = open_storage()?;

            match action {
                LabelAction::Add { issue_id, label } => {
                    storage.add_label(&issue_id, &label)?;

                    if json_output {
                        println!(r#"{{"success": true}}"#);
                    } else {
                        println!("Added label '{}' to {}", label, issue_id);
                    }
                }

                LabelAction::Remove { issue_id, label } => {
                    storage.remove_label(&issue_id, &label)?;

                    if json_output {
                        println!(r#"{{"success": true}}"#);
                    } else {
                        println!("Removed label '{}' from {}", label, issue_id);
                    }
                }

                LabelAction::List { issue_id } => {
                    let labels = storage.get_labels(&issue_id)?;

                    if json_output {
                        println!("{}", serde_json::to_string(&labels)?);
                    } else {
                        if labels.is_empty() {
                            println!("No labels");
                        } else {
                            println!("Labels: {}", labels.join(", "));
                        }
                    }
                }
            }
        }

        Command::Stats => {
            let storage = open_storage()?;
            let stats = storage.get_statistics()?;

            if json_output {
                println!("{}", serde_json::to_string(&stats)?);
            } else {
                println!("Issues:");
                println!("  Total:       {}", stats.total_issues);
                println!("  Open:        {}", stats.open_issues);
                println!("  In Progress: {}", stats.in_progress_issues);
                println!("  Blocked:     {}", stats.blocked_issues);
                println!("  Closed:      {}", stats.closed_issues);
                println!("  Ready:       {}", stats.ready_issues);
                println!("\nDependencies: {}", stats.total_dependencies);
            }
        }

        Command::Daemon { action } => {
            let beads_dir = find_beads_dir()
                .context("Not in a beads repository")?;

            match action {
                DaemonAction::Start { foreground, auto_commit, auto_push } => {
                    if !foreground {
                        // Fork to background
                        println!("Starting daemon in background...");

                        let db_path = beads_dir.join("beads.db");
                        let storage = SqliteStorage::open(&db_path)?;
                        let config = DaemonConfig {
                            auto_commit,
                            auto_push,
                            ..Default::default()
                        };

                        let daemon = Daemon::new(storage, beads_dir, config);
                        daemon.start().await?;
                    } else {
                        // Run in foreground
                        let db_path = beads_dir.join("beads.db");
                        let storage = SqliteStorage::open(&db_path)?;
                        let config = DaemonConfig {
                            auto_commit,
                            auto_push,
                            ..Default::default()
                        };

                        let daemon = Daemon::new(storage, beads_dir, config);
                        daemon.start().await?;
                    }
                }

                DaemonAction::Stop => {
                    let client = DaemonClient::new(&beads_dir);
                    client.shutdown().await?;
                    println!("Daemon stopped");
                }

                DaemonAction::Status => {
                    let client = DaemonClient::new(&beads_dir);
                    match client.health().await {
                        Ok(health) => {
                            if json_output {
                                println!("{}", serde_json::to_string(&health)?);
                            } else {
                                println!("Daemon running:");
                                println!("  PID:     {}", health.pid);
                                println!("  Uptime:  {}s", health.uptime_secs);
                                println!("  Version: {}", health.version);
                            }
                        }
                        Err(_) => {
                            if json_output {
                                println!(r#"{{"running": false}}"#);
                            } else {
                                println!("Daemon not running");
                            }
                        }
                    }
                }
            }
        }

        Command::Compact { level, id } => {
            let storage = Arc::new(open_storage()?);
            let compactor = Compactor::new(storage);

            let stats = if let Some(issue_id) = id {
                compactor.compact_issue(&issue_id, level)?
            } else {
                compactor.compact_completed(level)?
            };

            if json_output {
                println!("{}", serde_json::to_string(&stats)?);
            } else {
                println!("Compaction complete:");
                println!("  Compacted:   {}", stats.compacted);
                println!("  Skipped:     {}", stats.skipped);
                println!("  Bytes saved: {}", stats.bytes_saved);
                if !stats.errors.is_empty() {
                    println!("  Errors:      {}", stats.errors.len());
                }
            }
        }

        Command::Config { key, value, delete } => {
            let storage = open_storage()?;

            match (key, value, delete) {
                (None, None, _) => {
                    // List all config
                    let config = storage.get_all_config()?;
                    if json_output {
                        println!("{}", serde_json::to_string(&config)?);
                    } else {
                        for (k, v) in &config {
                            println!("{} = {}", k, v);
                        }
                    }
                }
                (Some(k), None, false) => {
                    // Get config value
                    if let Some(v) = storage.get_config(&k)? {
                        if json_output {
                            println!(r#"{{"{}": "{}"}}"#, k, v);
                        } else {
                            println!("{}", v);
                        }
                    } else if !json_output {
                        println!("Not set");
                    }
                }
                (Some(k), Some(v), _) => {
                    // Set config value
                    storage.set_config(&k, &v)?;
                    if json_output {
                        println!(r#"{{"success": true}}"#);
                    } else {
                        println!("Set {} = {}", k, v);
                    }
                }
                (Some(k), None, true) => {
                    // Delete config value
                    storage.delete_config(&k)?;
                    if json_output {
                        println!(r#"{{"success": true}}"#);
                    } else {
                        println!("Deleted {}", k);
                    }
                }
                (None, Some(_), _) => {
                    // Invalid: value without key
                    anyhow::bail!("Cannot set a value without a key");
                }
            }
        }

        Command::Context { action } => {
            let ctx_store = open_context_store()?;

            match action {
                ContextAction::Get { key } => {
                    if let Some(entry) = ctx_store.get(&key)? {
                        if json_output {
                            println!("{}", serde_json::to_string(&entry)?);
                        } else {
                            println!("Key:     {}", entry.key);
                            println!("Value:   {}", serde_json::to_string_pretty(&entry.value)?);
                            println!("Created: {}", entry.created_at.format("%Y-%m-%d %H:%M"));
                            println!("Updated: {}", entry.updated_at.format("%Y-%m-%d %H:%M"));
                            if let Some(ref expires) = entry.expires_at {
                                println!("Expires: {}", expires.format("%Y-%m-%d %H:%M"));
                            }
                        }
                    } else if json_output {
                        println!("null");
                    } else {
                        println!("Not found: {}", key);
                    }
                }

                ContextAction::Set { key, value, ttl, file } => {
                    let json_value: serde_json::Value = serde_json::from_str(&value)
                        .context("Invalid JSON value")?;

                    let mut entry = ContextEntry::new(&key, json_value);

                    if let Some(ttl_secs) = ttl {
                        entry = entry.with_ttl(ttl_secs);
                    }

                    if let Some(file_path) = file {
                        if let Some(mtime) = ctx_store.get_file_mtime(&file_path) {
                            entry = entry.with_file_info(&file_path, mtime);
                        }
                    }

                    ctx_store.set(entry)?;

                    if json_output {
                        println!(r#"{{"success": true}}"#);
                    } else {
                        println!("Set: {}", key);
                    }
                }

                ContextAction::Delete { key } => {
                    ctx_store.delete(&key)?;

                    if json_output {
                        println!(r#"{{"success": true}}"#);
                    } else {
                        println!("Deleted: {}", key);
                    }
                }

                ContextAction::List { namespace, prefix, limit } => {
                    let ns = namespace.as_deref().and_then(parse_namespace);
                    let entries = ctx_store.list_simple(ns, prefix.as_deref())?;

                    let entries: Vec<_> = if let Some(n) = limit {
                        entries.into_iter().take(n).collect()
                    } else {
                        entries
                    };

                    if json_output {
                        println!("{}", serde_json::to_string(&entries)?);
                    } else {
                        if entries.is_empty() {
                            println!("No entries found");
                        } else {
                            for entry in &entries {
                                let expired = if entry.is_expired() { " [EXPIRED]" } else { "" };
                                println!("  {}{}", entry.key, expired);
                            }
                            println!("\n{} entries", entries.len());
                        }
                    }
                }

                ContextAction::Clear { namespace, expired } => {
                    let count = if expired {
                        ctx_store.cleanup_expired()?
                    } else if let Some(ref ns_str) = namespace {
                        if let Some(ns) = parse_namespace(ns_str) {
                            ctx_store.clear_namespace(ns)?
                        } else {
                            anyhow::bail!("Invalid namespace: {}", ns_str);
                        }
                    } else {
                        ctx_store.clear_all()?
                    };

                    if json_output {
                        println!(r#"{{"cleared": {}}}"#, count);
                    } else {
                        println!("Cleared {} entries", count);
                    }
                }

                ContextAction::Stats => {
                    let stats = ctx_store.stats()?;

                    if json_output {
                        println!("{}", serde_json::to_string(&stats)?);
                    } else {
                        println!("Context Store Statistics:");
                        println!("  Total entries:   {}", stats.total_entries);
                        println!("  Expired entries: {}", stats.expired_entries);
                        println!("\nBy namespace:");
                        for (ns, count) in &stats.by_namespace {
                            println!("  {}: {}", ns, count);
                        }
                    }
                }

                ContextAction::File { path } => {
                    if let Some(file_ctx) = ctx_store.get_file_context(&path)? {
                        if json_output {
                            println!("{}", serde_json::to_string(&file_ctx)?);
                        } else {
                            println!("File: {}", file_ctx.path);
                            if let Some(ref summary) = file_ctx.summary {
                                println!("Summary: {}", summary);
                            }
                            if let Some(ref lang) = file_ctx.language {
                                println!("Language: {}", lang);
                            }
                            if !file_ctx.symbols.is_empty() {
                                println!("Symbols: {}", file_ctx.symbols.len());
                                for sym in &file_ctx.symbols {
                                    println!("  - {} ({:?})", sym.name, sym.kind);
                                }
                            }
                        }
                    } else if json_output {
                        println!("null");
                    } else {
                        println!("No context for file: {}", path);
                    }
                }

                ContextAction::Project { set } => {
                    if let Some(value) = set {
                        let project_ctx: ProjectContext = serde_json::from_str(&value)
                            .context("Invalid project context JSON")?;
                        ctx_store.set_project_context(&project_ctx)?;

                        if json_output {
                            println!(r#"{{"success": true}}"#);
                        } else {
                            println!("Project context updated");
                        }
                    } else {
                        if let Some(project_ctx) = ctx_store.get_project_context()? {
                            if json_output {
                                println!("{}", serde_json::to_string(&project_ctx)?);
                            } else {
                                if let Some(ref name) = project_ctx.name {
                                    println!("Name: {}", name);
                                }
                                if let Some(ref desc) = project_ctx.description {
                                    println!("Description: {}", desc);
                                }
                                if !project_ctx.languages.is_empty() {
                                    println!("Languages: {}", project_ctx.languages.join(", "));
                                }
                                if !project_ctx.frameworks.is_empty() {
                                    println!("Frameworks: {}", project_ctx.frameworks.join(", "));
                                }
                            }
                        } else if json_output {
                            println!("null");
                        } else {
                            println!("No project context set");
                        }
                    }
                }

                ContextAction::Session { session_id } => {
                    if let Some(session) = ctx_store.get_session(&session_id)? {
                        if json_output {
                            println!("{}", serde_json::to_string(&session)?);
                        } else {
                            println!("Session: {}", session.session_id);
                            if let Some(ref agent) = session.agent_id {
                                println!("Agent: {}", agent);
                            }
                            if let Some(ref task) = session.current_task {
                                println!("Task: {}", task);
                            }
                            if !session.working_files.is_empty() {
                                println!("Working files:");
                                for f in &session.working_files {
                                    println!("  - {}", f);
                                }
                            }
                            if !session.decisions.is_empty() {
                                println!("Decisions: {}", session.decisions.len());
                            }
                        }
                    } else if json_output {
                        println!("null");
                    } else {
                        println!("No session found: {}", session_id);
                    }
                }

                ContextAction::Refresh => {
                    ctx_store.refresh_invalidation()?;

                    if json_output {
                        println!(r#"{{"success": true}}"#);
                    } else {
                        println!("Git state refreshed");
                    }
                }
            }
        }
    }

    Ok(())
}

/// Open the storage database.
fn open_storage() -> Result<SqliteStorage> {
    let db_path = find_database_path()
        .context("Not in a beads repository. Run 'bd init' first.")?;
    SqliteStorage::open(&db_path).context("Failed to open database")
}

/// Open the context store database.
fn open_context_store() -> Result<ContextStore> {
    let beads_dir = find_beads_dir()
        .context("Not in a beads repository. Run 'bd init' first.")?;
    let ctx_path = beads_dir.join("context.db");
    ContextStore::open(&ctx_path).context("Failed to open context store")
}

/// Parse namespace from string.
fn parse_namespace(s: &str) -> Option<Namespace> {
    match s.to_lowercase().as_str() {
        "file" => Some(Namespace::File),
        "symbol" => Some(Namespace::Symbol),
        "project" => Some(Namespace::Project),
        "session" => Some(Namespace::Session),
        "agent" => Some(Namespace::Agent),
        "custom" => Some(Namespace::Custom),
        _ => None,
    }
}

/// Get the default actor name.
fn get_default_actor() -> String {
    std::env::var("BD_ACTOR")
        .or_else(|_| std::env::var("BEADS_ACTOR"))
        .or_else(|_| std::env::var("USER"))
        .unwrap_or_else(|_| "unknown".to_string())
}

/// Print an issue summary line.
fn print_issue_summary(issue: &Issue) {
    let status_icon = match issue.status {
        Status::Open => "○",
        Status::InProgress => "◐",
        Status::Blocked => "◌",
        Status::Closed => "●",
        Status::Deferred => "◇",
        _ => "○",
    };

    let priority_str = match issue.priority {
        0 => "P0",
        1 => "P1",
        2 => "P2",
        3 => "P3",
        _ => "P4",
    };

    println!(
        "{} {} [{}] {} - {}",
        status_icon,
        issue.id,
        priority_str,
        issue.issue_type,
        issue.title
    );
}

/// Print full issue details.
fn print_issue(issue: &Issue) {
    println!("ID:          {}", issue.id);
    println!("Title:       {}", issue.title);
    println!("Status:      {}", issue.status);
    println!("Type:        {}", issue.issue_type);
    println!("Priority:    {}", issue.priority);

    if let Some(ref assignee) = issue.assignee {
        println!("Assignee:    {}", assignee);
    }

    if !issue.labels.is_empty() {
        println!("Labels:      {}", issue.labels.join(", "));
    }

    if let Some(ref desc) = issue.description {
        println!("\nDescription:");
        println!("{}", desc);
    }

    println!("\nCreated:     {} by {}", issue.created_at.format("%Y-%m-%d %H:%M"), issue.created_by);
    println!("Updated:     {}", issue.updated_at.format("%Y-%m-%d %H:%M"));

    if let Some(ref closed_at) = issue.closed_at {
        println!("Closed:      {}", closed_at.format("%Y-%m-%d %H:%M"));
        if let Some(ref reason) = issue.close_reason {
            println!("Reason:      {}", reason);
        }
    }
}