use crate::error::{Context, Result};
use crate::branch::{BranchInfo, BranchManager, BranchStatus};
use crate::resolution::PendingResolution;
use crate::vcs::VcsManager;
use super::{load_config, staleness_label, STALE_THRESHOLD_DAYS};
pub async fn status_command(json: bool) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let branch_manager = BranchManager::new(
current_dir.join(".codetree").join("branches.json")
).await?;
let current_branch = git_manager.get_current_branch().await?;
let git_status = git_manager.get_status().await?;
let branches = branch_manager.list_branches();
let active_ops: Vec<_> = branches.iter()
.filter(|b| matches!(b.status, BranchStatus::Active))
.collect();
let pending_path = current_dir.join(".codetree").join("pending_resolution.json");
let pending = PendingResolution::load(&pending_path).await?;
let conflict_paths: Vec<String> = pending.as_ref()
.map(|p| p.conflicts.iter().map(|c| c.path.clone()).collect())
.unwrap_or_default();
if json {
let active_op_names: Vec<String> = active_ops.iter().map(|b| b.name.clone()).collect();
let json_status = serde_json::json!({
"branch": current_branch,
"staged": git_status.staged,
"modified": git_status.modified,
"untracked": git_status.untracked,
"conflicts_pending": pending.is_some(),
"conflict_files": conflict_paths,
"active_operations": active_op_names,
});
println!("{}", serde_json::to_string_pretty(&json_status)?);
return Ok(());
}
println!("Current branch: {}", current_branch);
if !git_status.staged.is_empty() {
println!("Staged ({}):", git_status.staged.len());
for f in &git_status.staged {
println!(" + {}", f);
}
}
if !git_status.modified.is_empty() {
println!("Modified ({}):", git_status.modified.len());
for f in &git_status.modified {
println!(" ~ {}", f);
}
}
if !git_status.untracked.is_empty() {
println!("Untracked ({}):", git_status.untracked.len());
for f in &git_status.untracked {
println!(" ? {}", f);
}
}
if git_status.staged.is_empty() && git_status.modified.is_empty() && git_status.untracked.is_empty() {
println!("Working tree clean");
}
if let Some(ref pending) = pending {
println!("Conflicts ({}):", pending.conflicts.len());
for c in &pending.conflicts {
println!(" ! {}", c.path);
}
println!(" Resolve with: codetree resolve");
}
println!("Active operations: {}", active_ops.len());
for op in &active_ops {
let stale = staleness_label(op.updated_at);
println!(" - {}: {}{}", op.name, op.change_group.description, stale);
}
if active_ops.len() >= 2 {
for i in 0..active_ops.len() {
for j in (i + 1)..active_ops.len() {
let files_i: std::collections::HashSet<&String> = active_ops[i].change_group.files.iter().collect();
let conflicts: Vec<&String> = active_ops[j].change_group.files.iter()
.filter(|f| files_i.contains(f))
.collect();
if !conflicts.is_empty() {
println!("Warning: operations '{}' and '{}' both modify: {}",
active_ops[i].name, active_ops[j].name,
conflicts.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", "));
}
}
}
}
Ok(())
}
pub async fn list_command(tag: Option<String>, query: Option<String>, json: bool, format: Option<String>) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let branch_manager = BranchManager::new(
current_dir.join(".codetree").join("branches.json")
).await?;
let all_branches = branch_manager.list_branches();
let branches: Vec<_> = if let Some(ref q) = query {
let all: Vec<BranchInfo> = all_branches.iter().map(|b| (*b).clone()).collect();
all_branches.into_iter().filter(|b| matches_query(b, q, &all)).collect()
} else if let Some(ref tag) = tag {
all_branches.into_iter().filter(|b| b.tags.iter().any(|t| t == tag)).collect()
} else {
all_branches
};
if json {
let branch_list: Vec<BranchInfo> = branches.iter().map(|b| (*b).clone()).collect();
println!("{}", serde_json::to_string_pretty(&branch_list)?);
return Ok(());
}
if branches.is_empty() {
if let Some(ref q) = query {
println!("No branches matching query '{}'", q);
} else if let Some(ref t) = tag {
println!("No branches with tag '{}'", t);
} else {
println!("No branches");
}
return Ok(());
}
if let Some(ref fmt) = format {
for branch in branches {
let line = render_template(fmt, branch);
println!("{}", line);
}
} else {
println!("Branches:");
for branch in branches {
let tags_str = if branch.tags.is_empty() {
String::new()
} else {
format!(" | [{}]", branch.tags.join(", "))
};
let stale = staleness_label(branch.updated_at);
println!(" {} | {} | {} | {}{}{}",
branch.name,
branch.status.as_str(),
branch.created_at,
branch.change_group.description,
tags_str,
stale
);
}
}
Ok(())
}
fn render_template(template: &str, branch: &BranchInfo) -> String {
let tags = if branch.tags.is_empty() {
String::new()
} else {
branch.tags.join(",")
};
let stale = staleness_label(branch.updated_at);
template
.replace("{name}", &branch.name)
.replace("{status}", branch.status.as_str())
.replace("{description}", &branch.change_group.description)
.replace("{created}", &branch.created_at.to_string())
.replace("{tags}", &tags)
.replace("{stale}", stale.trim())
}
fn matches_query(branch: &BranchInfo, query: &str, all: &[BranchInfo]) -> bool {
let query = query.trim();
if query.is_empty() {
return true;
}
for or_group in query.split("||") {
let or_group = or_group.trim();
let terms: Vec<&str> = or_group.split("&&").map(|t| t.trim()).collect();
if terms.iter().all(|term| matches_term(branch, term, all)) {
return true;
}
}
false
}
fn matches_term(branch: &BranchInfo, term: &str, all: &[BranchInfo]) -> bool {
let term = term.trim();
if term == "!" {
return is_only_child(branch, all);
}
if let Some(rest) = term.strip_prefix('!') {
let rest = rest.trim();
return !matches_term(branch, rest, all);
}
match term {
"active" => branch.status == BranchStatus::Active,
"merged" => branch.status == BranchStatus::Merged,
"archived" => branch.status == BranchStatus::Archived,
"branchless" => branch.branchless,
"stale" => {
let now = crate::branch::now_ts();
let age_days = now.saturating_sub(branch.updated_at) / 86400;
age_days >= STALE_THRESHOLD_DAYS
}
"merges()" => branch.status == BranchStatus::Merged,
_ if term.starts_with("tag:") => {
let tag = &term[4..];
branch.tags.iter().any(|t| t == tag)
}
_ if term.starts_with("branches(") && term.ends_with(')') => {
let pattern = &term["branches(".len()..term.len()-1];
if pattern.is_empty() {
true } else {
if let Some(mid) = pattern.strip_prefix('*').and_then(|s| s.strip_suffix('*')) {
branch.name.contains(mid)
} else if let Some(suffix) = pattern.strip_prefix('*') {
branch.name.ends_with(suffix)
} else if let Some(prefix) = pattern.strip_suffix('*') {
branch.name.starts_with(prefix)
} else {
branch.name == pattern
}
}
}
_ => false,
}
}
fn is_only_child(branch: &BranchInfo, all: &[BranchInfo]) -> bool {
let parent = match &branch.parent_branch {
Some(p) => p,
None => return false,
};
let siblings = all.iter().filter(|b| {
b.name != branch.name
&& b.status == BranchStatus::Active
&& b.parent_branch.as_deref() == Some(parent)
});
siblings.count() == 0
}
pub async fn smartlog_command(verbose: bool, position: bool, limit: Option<usize>, offset: Option<usize>, reverse: bool, exact: bool) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let branch_manager = BranchManager::new(
current_dir.join(".codetree").join("branches.json")
).await?;
let config = load_config(None).await?;
let base_branch = &config.git.base_branch;
let current = git_manager.get_current_branch().await.unwrap_or_default();
let all_branches: Vec<_> = branch_manager.list_branches()
.into_iter()
.filter(|b| !matches!(b.status, BranchStatus::Archived))
.collect();
let total = all_branches.len();
let off = offset.unwrap_or(0);
let lim = limit.unwrap_or(total);
let mut paginated: Vec<_> = all_branches.into_iter()
.skip(off)
.take(lim)
.collect();
if reverse {
paginated.reverse();
}
if paginated.is_empty() {
if total == 0 {
println!("No operations to display");
} else {
println!("No operations in this segment (offset: {}, total: {})", off, total);
}
return Ok(());
}
let all_branches = paginated;
if all_branches.is_empty() {
println!("No operations to display");
return Ok(());
}
let git_branch_names: Vec<String> = all_branches.iter()
.filter(|b| !b.branchless && b.status == BranchStatus::Active)
.map(|b| b.name.clone())
.collect();
let mut parent_map: std::collections::HashMap<String, String> = std::collections::HashMap::new();
for name in &git_branch_names {
let parent = branch_manager.get_parent_branch(name)
.map(|p| p.to_string())
.unwrap_or_else(|| {
git_manager.get_branch_parent(name, base_branch, &git_branch_names)
.unwrap_or_else(|_| base_branch.clone())
});
parent_map.insert(name.clone(), parent);
}
let mut children_map: std::collections::HashMap<String, Vec<String>> = std::collections::HashMap::new();
for (branch, parent) in &parent_map {
children_map.entry(parent.clone()).or_default().push(branch.clone());
}
for children in children_map.values_mut() {
children.sort();
}
let branchless: Vec<_> = all_branches.iter()
.filter(|b| b.branchless)
.collect();
let merged: Vec<_> = all_branches.iter()
.filter(|b| matches!(b.status, BranchStatus::Merged) && !b.branchless)
.collect();
if position && !exact && !current.is_empty() {
if current == *base_branch {
println!(">>> You are on BASE: {} <<<", base_branch);
} else {
let (ahead, behind) = git_manager.get_branch_divergence(¤t, base_branch).unwrap_or((0, 0));
println!(">>> You are on: {} (+{}/-{} from base) <<<", current, ahead, behind);
}
println!();
}
if off > 0 || (off + all_branches.len()) < total {
println!("[Segment: {}-{} of {} operations]", off, off + all_branches.len(), total);
println!();
}
if !exact {
println!("{}", base_branch);
}
let mut divergence: std::collections::HashMap<String, (usize, usize)> = std::collections::HashMap::new();
for name in &git_branch_names {
if let Ok((ahead, behind)) = git_manager.get_branch_divergence(name, base_branch) {
divergence.insert(name.clone(), (ahead, behind));
}
}
if let Some(root_children) = children_map.get(base_branch) {
for (i, child) in root_children.iter().enumerate() {
let is_last = i == root_children.len() - 1;
print_tree_node(child, &children_map, &all_branches, ¤t, is_last, "", &divergence, &git_manager, verbose, &parent_map);
}
}
if !merged.is_empty() {
println!();
println!("Merged:");
for branch in &merged {
let (ahead, behind) = git_manager.get_branch_divergence(&branch.name, base_branch)
.unwrap_or((0, 0));
let tags_str = if branch.tags.is_empty() {
String::new()
} else {
format!(" [{}]", branch.tags.join(", "))
};
println!(" {} (merged, +{}/-{}{})", branch.name, ahead, behind, tags_str);
}
}
if !branchless.is_empty() {
println!();
println!("Branchless bookmarks:");
for branch in &branchless {
let marker = if branch.name == current { " *" } else { "" };
let tags_str = if branch.tags.is_empty() {
String::new()
} else {
format!(" [{}]", branch.tags.join(", "))
};
println!(" {} ({}){}{}", branch.name, branch.status.as_str(), tags_str, marker);
}
}
Ok(())
}
#[allow(clippy::too_many_arguments, clippy::collapsible_if)]
fn print_tree_node(
branch_name: &str,
children_map: &std::collections::HashMap<String, Vec<String>>,
all_branches: &[&crate::branch::BranchInfo],
current: &str,
is_last: bool,
prefix: &str,
divergence: &std::collections::HashMap<String, (usize, usize)>,
git_manager: &VcsManager,
verbose: bool,
parent_map: &std::collections::HashMap<String, String>,
) {
let branch_info = all_branches.iter().find(|b| b.name == branch_name);
let connector = if is_last { "└── " } else { "├── " };
let marker = if branch_name == current { " *" } else { "" };
if let Some(info) = branch_info {
let (ahead, behind) = divergence.get(branch_name).copied().unwrap_or((0, 0));
let deps_str = if info.depends_on.is_empty() {
String::new()
} else {
format!(" (depends: {})", info.depends_on.join(", "))
};
let tags_str = if info.tags.is_empty() {
String::new()
} else {
format!(" [{}]", info.tags.join(", "))
};
let stale = staleness_label(info.updated_at);
println!("{}{}{} (active, +{}/-{}{}{}){}{}", prefix, connector, branch_name, ahead, behind, deps_str, tags_str, marker, stale);
if verbose
&& let Some(parent) = parent_map.get(branch_name)
&& !parent.is_empty()
{
if let Ok(commits) = git_manager.get_commits_between(branch_name, parent) {
let commit_prefix = format!("{}{}", prefix, if is_last { " " } else { "│ " });
for commit in &commits {
let short_hash = &commit.hash[..7.min(commit.hash.len())];
let msg = commit.message.lines().next().unwrap_or("");
let files = if commit.files_changed.is_empty() {
String::new()
} else if commit.files_changed.len() <= 3 {
format!(" ({})", commit.files_changed.join(", "))
} else {
format!(" ({} files)", commit.files_changed.len())
};
println!("{} {} {}{}", commit_prefix, short_hash, msg, files);
}
}
}
} else {
println!("{}{}{}{}", prefix, connector, branch_name, marker);
}
if let Some(children) = children_map.get(branch_name) {
let child_prefix = format!("{}{}", prefix, if is_last { " " } else { "│ " });
for (i, child) in children.iter().enumerate() {
let child_is_last = i == children.len() - 1;
print_tree_node(child, children_map, all_branches, current, child_is_last, &child_prefix, divergence, git_manager, verbose, parent_map);
}
}
}
pub async fn show_command(commit: String, mutation: bool) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let repo = git_manager.repo();
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = git_manager.resolve_commit_pub(&commit, &head_id)?;
let commit_obj = repo.read_commit(&target_id)?;
let short = &target_id[..7.min(target_id.len())];
let date = format_timestamp(commit_obj.timestamp);
println!("commit {}", short);
println!("Date: {}", date);
println!();
for line in commit_obj.message.lines() {
println!(" {}", line);
}
println!();
if mutation {
let evolog = crate::evolog::EvologLog::load(¤t_dir)?;
let history = evolog.history(&target_id);
if !history.is_empty() {
println!("Mutation history:");
for entry in &history {
let old_short = &entry.old_hash[..7.min(entry.old_hash.len())];
let new_short = &entry.new_hash[..7.min(entry.new_hash.len())];
println!(" {} -> {} ({})", old_short, new_short, entry.operation);
}
println!();
}
}
let diff = git_manager.show_commit_diff(&target_id)?;
if diff.is_empty() {
println!("(no changes)");
} else {
print!("{}", diff);
}
Ok(())
}
pub async fn diff_command(commit: Option<String>) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let diff = if let Some(c) = commit {
let repo = git_manager.repo();
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = git_manager.resolve_commit_pub(&c, &head_id)?;
git_manager.diff_working_tree(Some(&target_id))?
} else {
git_manager.diff_working_tree(None)?
};
if diff.is_empty() {
println!("(no changes)");
} else {
print!("{}", diff);
}
Ok(())
}
pub async fn blame_command(file: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let annotations = git_manager.blame(&file)?;
for (lineno, commit, content) in &annotations {
println!("{:>4} {} {}", lineno, commit, content);
}
Ok(())
}
pub async fn filelog_command(file: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let history = git_manager.file_log(&file)?;
if history.is_empty() {
println!("No history found for '{}'", file);
return Ok(());
}
for (hash, ts, message) in &history {
let short = &hash[..7.min(hash.len())];
let date = format_timestamp(*ts);
println!("{} {} {}", short, date, message);
}
Ok(())
}
pub async fn clean_command() -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let removed = git_manager.clean()?;
if removed.is_empty() {
println!("No untracked files to remove");
} else {
println!("Removed {} untracked file(s):", removed.len());
for file in &removed {
println!(" {}", file);
}
}
Ok(())
}
pub async fn gc_command() -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let removed = git_manager.gc()?;
println!("Garbage collected {} unreachable object(s)", removed);
Ok(())
}
pub async fn file_search_command(pattern: String, name_only: bool) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
if name_only {
let names = git_manager.file_search_names(&pattern)?;
if names.is_empty() {
println!("No files matching '{}'", pattern);
} else {
for name in &names {
println!("{}", name);
}
}
return Ok(());
}
let results = git_manager.file_search(&pattern)?;
if results.is_empty() {
println!("No matches found for '{}'", pattern);
return Ok(());
}
println!("Found {} match(es) for '{}':", results.len(), pattern);
for (file, line_num, line) in &results {
println!("{}:{}: {}", file, line_num, line);
}
Ok(())
}
pub async fn forks_command() -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let forks = git_manager.forks()?;
if forks.is_empty() {
println!("No fork points found.");
return Ok(());
}
println!("{:<12} MESSAGE", "COMMIT");
println!("{}", "-".repeat(40));
for (hash, msg) in &forks {
let short = &hash[..7.min(hash.len())];
println!("{:<12} {}", short, msg);
}
Ok(())
}
pub async fn merge_point_command(commit_a: String, commit_b: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let result = git_manager.merge_point(&commit_a, &commit_b)?;
match result {
Some(hash) => {
let short = &hash[..7.min(hash.len())];
println!("Merge point of '{}' and '{}': {}", commit_a, commit_b, short);
}
None => {
println!("No common ancestor found between '{}' and '{}'", commit_a, commit_b);
}
}
Ok(())
}
pub async fn verify_command(commit: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let issues = git_manager.verify_commit(&commit)?;
if issues.is_empty() {
let head_id = git_manager.repo().refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = git_manager.resolve_commit_pub(&commit, &head_id)?;
let short = &target_id[..7.min(target_id.len())];
println!("Commit {} ({}) verified successfully — no issues found.", commit, short);
} else {
println!("Commit '{}' has {} issue(s):", commit, issues.len());
for issue in &issues {
println!(" - {}", issue);
}
}
Ok(())
}
pub async fn run_command(from: String, command: Vec<String>) -> Result<()> {
if command.is_empty() {
bail!("No command specified. Usage: codetree run --from <commit> -- <command...>");
}
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let results = git_manager.run_across_commits(&from, &command).await?;
let mut all_success = true;
for (hash, success) in &results {
let short = &hash[..7.min(hash.len())];
let status = if *success { "PASS" } else { "FAIL" };
println!("{} {} {}", short, status,
git_manager.repo().read_commit(hash).ok()
.and_then(|c| c.message.lines().next().map(|s| s.to_string()))
.unwrap_or_default());
if !success {
all_success = false;
}
}
if !all_success {
bail!("Some commands failed");
}
Ok(())
}
pub async fn speculative_merge_command(branch: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let conflicts = git_manager.speculative_merge(&branch)?;
if conflicts.is_empty() {
println!("Merging '{}' into HEAD would be clean — no conflicts.", branch);
} else {
println!("Merging '{}' into HEAD would conflict in {} file(s):", branch, conflicts.len());
for file in &conflicts {
println!(" {}", file);
}
}
Ok(())
}
pub async fn file_list_command(commit: Option<String>) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let files = git_manager.file_list(commit.as_deref())?;
if files.is_empty() {
println!("No files found.");
return Ok(());
}
for file in &files {
println!("{}", file);
}
Ok(())
}
pub async fn heads_command() -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let heads = git_manager.heads()?;
if heads.is_empty() {
println!("No branches found.");
return Ok(());
}
println!("{:<20} COMMIT", "BRANCH");
println!("{}", "-".repeat(30));
for (branch, commit) in &heads {
let short = &commit[..7.min(commit.len())];
println!("{:<20} {}", branch, short);
}
Ok(())
}
pub async fn evolog_command(commit: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let head_id = git_manager.repo().refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = git_manager.resolve_commit_pub(&commit, &head_id)?;
let evolog = crate::evolog::EvologLog::load(¤t_dir)?;
let history = evolog.history(&target_id);
if history.is_empty() {
let short = &target_id[..7.min(target_id.len())];
println!("No evolution history for {} ({})", commit, short);
return Ok(());
}
println!("Evolution history for '{}':", commit);
for entry in &history {
let old_short = &entry.old_hash[..7.min(entry.old_hash.len())];
let new_short = &entry.new_hash[..7.min(entry.new_hash.len())];
println!(" {} -> {} ({})", old_short, new_short, entry.operation);
}
Ok(())
}
pub async fn interdiff_command(commit_a: String, commit_b: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let diff = git_manager.interdiff(&commit_a, &commit_b)?;
if diff.is_empty() {
println!("No differences between '{}' and '{}'", commit_a, commit_b);
} else {
print!("{}", diff);
}
Ok(())
}
pub async fn restore_command(from: String, to: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let new_head = git_manager.restore(&from, &to).await?;
let short = &new_head[..7.min(new_head.len())];
println!("Restored '{}' -> '{}' (tree content replaced)", from, to);
println!("New HEAD: {}", short);
Ok(())
}
pub async fn hide_command(commit: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let head_id = git_manager.repo().refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = git_manager.resolve_commit_pub(&commit, &head_id)?;
let mut hidden = crate::hidden::HiddenCommits::load(¤t_dir)?;
hidden.hide(&target_id);
hidden.save(¤t_dir)?;
let short = &target_id[..7.min(target_id.len())];
println!("Hid commit '{}' ({})", commit, short);
println!("Use 'codetree unhide {}' to restore it", commit);
Ok(())
}
pub async fn unhide_command(commit: String) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let head_id = git_manager.repo().refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = git_manager.resolve_commit_pub(&commit, &head_id)?;
let mut hidden = crate::hidden::HiddenCommits::load(¤t_dir)?;
if !hidden.is_hidden(&target_id) {
println!("Commit '{}' is not hidden", commit);
return Ok(());
}
hidden.unhide(&target_id);
hidden.save(¤t_dir)?;
let short = &target_id[..7.min(target_id.len())];
println!("Unhid commit '{}' ({})", commit, short);
Ok(())
}
pub async fn log_command(commit: Option<String>, limit: Option<usize>, count_only: bool) -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let repo = git_manager.repo();
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let start_id = if let Some(spec) = commit {
git_manager.resolve_commit_pub(&spec, &head_id)?
} else {
head_id
};
let mut current = start_id;
let mut count = 0;
let lim = limit.unwrap_or(usize::MAX);
while count < lim {
let commit_obj = repo.read_commit(¤t)?;
if !count_only {
let short = ¤t[..7.min(current.len())];
let date = format_timestamp(commit_obj.timestamp);
let first_line = commit_obj.message.lines().next().unwrap_or("");
println!("{} {} {}", short, date, first_line);
}
if commit_obj.parents.is_empty() {
count += 1;
break;
}
current = commit_obj.parents[0].clone();
count += 1;
}
if count_only {
println!("{}", count);
}
Ok(())
}
fn format_timestamp(ts: u64) -> String {
let days_since_epoch = ts / 86400;
let secs_today = ts % 86400;
let hours = secs_today / 3600;
let minutes = (secs_today % 3600) / 60;
let (year, month, day) = days_to_date(days_since_epoch);
format!("{:04}-{:02}-{:02} {:02}:{:02}", year, month, day, hours, minutes)
}
fn days_to_date(days: u64) -> (u64, u64, u64) {
let year = 1970 + days / 365;
let day_of_year = days % 365;
let months = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
let mut remaining = day_of_year;
let mut month = 1u64;
for &days_in_month in &months {
if remaining < days_in_month {
break;
}
remaining -= days_in_month;
month += 1;
}
(year, month, remaining + 1)
}
pub async fn whereami_command() -> Result<()> {
let current_dir = std::env::current_dir()
.context("Failed to get current directory")?;
let git_manager = VcsManager::new(current_dir.clone())?;
let branch_manager = BranchManager::new(
current_dir.join(".codetree").join("branches.json")
).await?;
let config = load_config(None).await?;
let base_branch = &config.git.base_branch;
let current = git_manager.get_current_branch().await?;
println!("You are here: {}", current);
if current == *base_branch {
println!(" This is the base branch.");
let active_ops: Vec<_> = branch_manager.list_branches()
.into_iter()
.filter(|b| matches!(b.status, BranchStatus::Active) && !b.branchless)
.collect();
if active_ops.is_empty() {
println!(" No active operations.");
} else {
println!(" Active operations branching from here: {}", active_ops.len());
for op in &active_ops {
let parent = branch_manager.get_parent_branch(&op.name)
.map(|p| p.to_string())
.unwrap_or_else(|| base_branch.clone());
if parent == *base_branch {
let (ahead, behind) = git_manager.get_branch_divergence(&op.name, base_branch)
.unwrap_or((0, 0));
let marker = if op.name == current { " *" } else { "" };
println!(" - {} (+{}/-{}{}){}", op.name, ahead, behind, op.change_group.description, marker);
}
}
}
return Ok(());
}
let branch_info = branch_manager.get_branch(¤t);
let parent = branch_info
.and_then(|b| b.parent_branch.clone())
.unwrap_or_else(|| {
let git_branch_names: Vec<String> = branch_manager.list_branches()
.into_iter()
.filter(|b| matches!(b.status, BranchStatus::Active) && !b.branchless)
.map(|b| b.name.clone())
.collect();
git_manager.get_branch_parent(¤t, base_branch, &git_branch_names)
.unwrap_or_else(|_| base_branch.clone())
});
println!(" Parent: {}", parent);
println!(" Base: {}", base_branch);
let (ahead, behind) = git_manager.get_branch_divergence(¤t, base_branch)
.unwrap_or((0, 0));
println!(" Divergence from base: +{} / -{}", ahead, behind);
if let Some(info) = branch_info {
println!(" Description: {}", info.change_group.description);
if !info.tags.is_empty() {
println!(" Tags: [{}]", info.tags.join(", "));
}
if !info.depends_on.is_empty() {
println!(" Depends on: {}", info.depends_on.join(", "));
}
if let Some(agent_id) = &info.agent_id {
println!(" Agent: {}", agent_id);
}
let stale = staleness_label(info.updated_at);
if !stale.is_empty() {
println!(" Updated: {}{}", info.updated_at, stale);
}
}
let siblings: Vec<_> = branch_manager.list_branches()
.into_iter()
.filter(|b| {
matches!(b.status, BranchStatus::Active)
&& !b.branchless
&& b.name != current
&& b.parent_branch.as_deref() == Some(&parent)
})
.collect();
if !siblings.is_empty() {
println!(" Sibling operations (same parent):");
for sib in &siblings {
let (sib_ahead, _) = git_manager.get_branch_divergence(&sib.name, base_branch)
.unwrap_or((0, 0));
println!(" - {} (+{} — {})", sib.name, sib_ahead, sib.change_group.description);
}
}
let children: Vec<_> = branch_manager.list_branches()
.into_iter()
.filter(|b| {
matches!(b.status, BranchStatus::Active)
&& !b.branchless
&& b.parent_branch.as_deref() == Some(¤t)
})
.collect();
if !children.is_empty() {
println!(" Stacked operations (children):");
for child in &children {
let (child_ahead, _) = git_manager.get_branch_divergence(&child.name, base_branch)
.unwrap_or((0, 0));
println!(" - {} (+{} — {})", child.name, child_ahead, child.change_group.description);
}
}
Ok(())
}