Skip to content

armgit / ECC

Public Imported from GitHub
0

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

feat: add ecc2 worktree status command

Affaan Mustafa10b8471e3c79
diff --git a/ecc2/src/main.rs b/ecc2/src/main.rs
index 711506225..4be2fb96a 100644
--- a/ecc2/src/main.rs
+++ b/ecc2/src/main.rs
@@ -186,6 +186,14 @@ enum Commands {
#[arg(long, default_value_t = 2)]
depth: usize,
},
+ /// Show worktree diff and merge-readiness details for a session
+ WorktreeStatus {
+ /// Session ID or alias
+ session_id: Option<String>,
+ /// Emit machine-readable JSON instead of the human summary
+ #[arg(long)]
+ json: bool,
+ },
/// Stop a running session
Stop {
/// Session ID or alias
@@ -629,6 +637,19 @@ async fn main() -> Result<()> {
let team = session::manager::get_team_status(&db, &id, depth)?;
println!("{team}");
}
+ Some(Commands::WorktreeStatus { session_id, json }) => {
+ let id = session_id.unwrap_or_else(|| "latest".to_string());
+ let resolved_id = resolve_session_id(&db, &id)?;
+ let session = db
+ .get_session(&resolved_id)?
+ .ok_or_else(|| anyhow::anyhow!("Session not found: {resolved_id}"))?;
+ let report = build_worktree_status_report(&session)?;
+ if json {
+ println!("{}", serde_json::to_string_pretty(&report)?);
+ } else {
+ println!("{}", format_worktree_status_human(&report));
+ }
+ }
Some(Commands::Stop { session_id }) => {
session::manager::stop_session(&db, &session_id).await?;
println!("Session stopped: {session_id}");
@@ -845,6 +866,106 @@ struct MaintainCoordinationRun {
final_status: session::manager::CoordinationStatus,
}
+#[derive(Debug, Clone, Serialize)]
+struct WorktreeMergeReadinessReport {
+ status: String,
+ summary: String,
+ conflicts: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+struct WorktreeStatusReport {
+ session_id: String,
+ task: String,
+ session_state: String,
+ attached: bool,
+ path: Option<String>,
+ branch: Option<String>,
+ base_branch: Option<String>,
+ diff_summary: Option<String>,
+ file_preview: Vec<String>,
+ merge_readiness: Option<WorktreeMergeReadinessReport>,
+}
+
+fn build_worktree_status_report(session: &session::Session) -> Result<WorktreeStatusReport> {
+ let Some(worktree) = session.worktree.as_ref() else {
+ return Ok(WorktreeStatusReport {
+ session_id: session.id.clone(),
+ task: session.task.clone(),
+ session_state: session.state.to_string(),
+ attached: false,
+ path: None,
+ branch: None,
+ base_branch: None,
+ diff_summary: None,
+ file_preview: Vec::new(),
+ merge_readiness: None,
+ });
+ };
+
+ let diff_summary = worktree::diff_summary(worktree)?;
+ let file_preview = worktree::diff_file_preview(worktree, 8)?;
+ let merge_readiness = worktree::merge_readiness(worktree)?;
+
+ Ok(WorktreeStatusReport {
+ session_id: session.id.clone(),
+ task: session.task.clone(),
+ session_state: session.state.to_string(),
+ attached: true,
+ path: Some(worktree.path.display().to_string()),
+ branch: Some(worktree.branch.clone()),
+ base_branch: Some(worktree.base_branch.clone()),
+ diff_summary,
+ file_preview,
+ merge_readiness: Some(WorktreeMergeReadinessReport {
+ status: match merge_readiness.status {
+ worktree::MergeReadinessStatus::Ready => "ready".to_string(),
+ worktree::MergeReadinessStatus::Conflicted => "conflicted".to_string(),
+ },
+ summary: merge_readiness.summary,
+ conflicts: merge_readiness.conflicts,
+ }),
+ })
+}
+
+fn format_worktree_status_human(report: &WorktreeStatusReport) -> String {
+ let mut lines = vec![format!(
+ "Worktree status for {} [{}]",
+ short_session(&report.session_id),
+ report.session_state
+ )];
+ lines.push(format!("Task {}", report.task));
+
+ if !report.attached {
+ lines.push("No worktree attached".to_string());
+ return lines.join("\n");
+ }
+
+ if let Some(path) = report.path.as_ref() {
+ lines.push(format!("Path {path}"));
+ }
+ if let (Some(branch), Some(base_branch)) = (report.branch.as_ref(), report.base_branch.as_ref()) {
+ lines.push(format!("Branch {branch} (base {base_branch})"));
+ }
+ if let Some(diff_summary) = report.diff_summary.as_ref() {
+ lines.push(diff_summary.clone());
+ }
+ if !report.file_preview.is_empty() {
+ lines.push("Files".to_string());
+ for entry in &report.file_preview {
+ lines.push(format!("- {entry}"));
+ }
+ }
+ if let Some(merge_readiness) = report.merge_readiness.as_ref() {
+ lines.push(merge_readiness.summary.clone());
+ for conflict in merge_readiness.conflicts.iter().take(5) {
+ lines.push(format!("- conflict {conflict}"));
+ }
+ }
+
+ lines.join("\n")
+}
+
fn summarize_coordinate_backlog(
outcome: &session::manager::CoordinateBacklogOutcome,
) -> CoordinateBacklogPassSummary {
@@ -1072,6 +1193,82 @@ mod tests {
}
}
+ #[test]
+ fn cli_parses_worktree_status_command() {
+ let cli = Cli::try_parse_from(["ecc", "worktree-status", "planner"])
+ .expect("worktree-status should parse");
+
+ match cli.command {
+ Some(Commands::WorktreeStatus { session_id, json }) => {
+ assert_eq!(session_id.as_deref(), Some("planner"));
+ assert!(!json);
+ }
+ _ => panic!("expected worktree-status subcommand"),
+ }
+ }
+
+ #[test]
+ fn cli_parses_worktree_status_json_flag() {
+ let cli = Cli::try_parse_from(["ecc", "worktree-status", "--json"])
+ .expect("worktree-status --json should parse");
+
+ match cli.command {
+ Some(Commands::WorktreeStatus { session_id, json }) => {
+ assert_eq!(session_id, None);
+ assert!(json);
+ }
+ _ => panic!("expected worktree-status subcommand"),
+ }
+ }
+
+ #[test]
+ fn format_worktree_status_human_includes_readiness_and_conflicts() {
+ let report = WorktreeStatusReport {
+ session_id: "deadbeefcafefeed".to_string(),
+ task: "Review merge readiness".to_string(),
+ session_state: "running".to_string(),
+ attached: true,
+ path: Some("/tmp/ecc/wt-1".to_string()),
+ branch: Some("ecc/deadbeefcafefeed".to_string()),
+ base_branch: Some("main".to_string()),
+ diff_summary: Some("Branch 1 file changed, 2 insertions(+)".to_string()),
+ file_preview: vec!["Branch M README.md".to_string()],
+ merge_readiness: Some(WorktreeMergeReadinessReport {
+ status: "conflicted".to_string(),
+ summary: "Merge blocked by 1 conflict(s): README.md".to_string(),
+ conflicts: vec!["README.md".to_string()],
+ }),
+ };
+
+ let text = format_worktree_status_human(&report);
+ assert!(text.contains("Worktree status for deadbeef [running]"));
+ assert!(text.contains("Branch ecc/deadbeefcafefeed (base main)"));
+ assert!(text.contains("Branch M README.md"));
+ assert!(text.contains("Merge blocked by 1 conflict(s): README.md"));
+ assert!(text.contains("- conflict README.md"));
+ }
+
+ #[test]
+ fn format_worktree_status_human_handles_missing_worktree() {
+ let report = WorktreeStatusReport {
+ session_id: "deadbeefcafefeed".to_string(),
+ task: "No worktree here".to_string(),
+ session_state: "stopped".to_string(),
+ attached: false,
+ path: None,
+ branch: None,
+ base_branch: None,
+ diff_summary: None,
+ file_preview: Vec::new(),
+ merge_readiness: None,
+ };
+
+ let text = format_worktree_status_human(&report);
+ assert!(text.contains("Worktree status for deadbeef [stopped]"));
+ assert!(text.contains("Task No worktree here"));
+ assert!(text.contains("No worktree attached"));
+ }
+
#[test]
fn cli_parses_assign_command() {
let cli = Cli::try_parse_from([