compass-st 1.1.2

package/cli/src/cmd/context.rs

@@ -0,0 +1,59 @@
+use crate::helpers;
+use serde_json::json;
+use std::path::Path;
+
+pub fn run(args: &[String]) -> Result<String, String> {
+    if args.len() < 3 { return Err("Usage: compass-cli context pack <session_dir> <task_id>".into()); }
+    if args[0] != "pack" && args[0] != "get" {
+        return Err(format!("Unknown context command: {}", args[0]));
+    }
+
+    let session_dir = Path::new(&args[1]);
+    let task_id = &args[2];
+    let plan_path = session_dir.join("plan.json");
+
+    if !plan_path.exists() { return Err("plan.json not found in session dir".into()); }
+    let plan = helpers::read_json(&plan_path)?;
+
+    let tasks_key = if plan.get("colleagues").is_some() { "colleagues" } else { "tasks" };
+    let tasks = plan.get(tasks_key).and_then(|t| t.as_array())
+        .ok_or("No tasks array in plan")?;
+
+    let task = tasks.iter()
+        .find(|t| t["id"].as_str() == Some(task_id))
+        .ok_or(format!("Task {} not found", task_id))?;
+
+    let mut files: serde_json::Map<String, serde_json::Value> = serde_json::Map::new();
+
+    if let Some(pointers) = task.get("context_pointers").and_then(|p| p.as_array()) {
+        for ptr in pointers {
+            if let Some(ptr_str) = ptr.as_str() {
+                // Parse "path:start-end" or just "path"
+                let (file_path, _range) = if let Some(colon_pos) = ptr_str.rfind(':') {
+                    let maybe_range = &ptr_str[colon_pos + 1..];
+                    if maybe_range.contains('-') && maybe_range.chars().all(|c| c.is_ascii_digit() || c == '-') {
+                        (&ptr_str[..colon_pos], Some(maybe_range))
+                    } else {
+                        (ptr_str, None)
+                    }
+                } else {
+                    (ptr_str, None)
+                };
+
+                if let Ok(content) = std::fs::read_to_string(file_path) {
+                    files.insert(file_path.to_string(), json!(content));
+                }
+            }
+        }
+    }
+
+    let output = json!({"task_id": task_id, "files": files});
+
+    // Write context pack file
+    if args[0] == "pack" {
+        let out_path = session_dir.join(format!("{}.context.json", task_id));
+        helpers::write_json(&out_path, &output)?;
+    }
+
+    Ok(serde_json::to_string_pretty(&output).unwrap())
+}

package/cli/src/cmd/dag.rs

@@ -0,0 +1,133 @@
+use crate::helpers;
+use serde_json::json;
+use std::collections::{HashMap, HashSet, VecDeque};
+use std::path::Path;
+
+pub fn run(args: &[String]) -> Result<String, String> {
+    if args.len() < 2 { return Err("Usage: compass-cli dag <check|waves> <path>".into()); }
+    let data = helpers::read_json(Path::new(&args[1]))?;
+    let tasks_key = if data.get("colleagues").is_some() { "colleagues" } else { "tasks" };
+    let tasks = data.get(tasks_key).and_then(|t| t.as_array())
+        .ok_or("Missing tasks/colleagues array")?;
+
+    match args[0].as_str() {
+        "check" => dag_check(tasks),
+        "waves" => dag_waves(tasks),
+        _ => Err(format!("Unknown dag command: {}", args[0])),
+    }
+}
+
+fn dag_check(tasks: &[serde_json::Value]) -> Result<String, String> {
+    let ids: HashSet<&str> = tasks.iter().filter_map(|t| t["id"].as_str()).collect();
+    let mut dangling = vec![];
+    let mut adj: HashMap<&str, Vec<&str>> = HashMap::new();
+
+    for task in tasks {
+        let id = task["id"].as_str().unwrap_or("");
+        adj.entry(id).or_default();
+        if let Some(deps) = task.get("depends_on").and_then(|d| d.as_array()) {
+            for dep in deps {
+                if let Some(dep_id) = dep.as_str() {
+                    if !ids.contains(dep_id) { dangling.push(format!("{} -> {}", id, dep_id)); }
+                    adj.entry(dep_id).or_default().push(id);
+                }
+            }
+        }
+    }
+
+    // Cycle detection via DFS
+    let mut visited: HashSet<&str> = HashSet::new();
+    let mut stack: HashSet<&str> = HashSet::new();
+    let mut cycles = vec![];
+
+    fn dfs<'a>(
+        node: &'a str,
+        adj: &HashMap<&'a str, Vec<&'a str>>,
+        visited: &mut HashSet<&'a str>,
+        stack: &mut HashSet<&'a str>,
+        cycles: &mut Vec<String>,
+    ) {
+        visited.insert(node);
+        stack.insert(node);
+        if let Some(neighbors) = adj.get(node) {
+            for &next in neighbors {
+                if !visited.contains(next) {
+                    dfs(next, adj, visited, stack, cycles);
+                } else if stack.contains(next) {
+                    cycles.push(format!("{} -> {}", node, next));
+                }
+            }
+        }
+        stack.remove(node);
+    }
+
+    for &id in &ids {
+        if !visited.contains(id) {
+            dfs(id, &adj, &mut visited, &mut stack, &mut cycles);
+        }
+    }
+
+    Ok(serde_json::to_string_pretty(&json!({
+        "valid": cycles.is_empty() && dangling.is_empty(),
+        "cycles": cycles,
+        "dangling": dangling,
+    })).unwrap())
+}
+
+fn dag_waves(tasks: &[serde_json::Value]) -> Result<String, String> {
+    let mut in_degree: HashMap<String, usize> = HashMap::new();
+    let mut adj: HashMap<String, Vec<String>> = HashMap::new();
+    let mut task_map: HashMap<String, &serde_json::Value> = HashMap::new();
+
+    for task in tasks {
+        let id = task["id"].as_str().unwrap_or("").to_string();
+        in_degree.entry(id.clone()).or_insert(0);
+        adj.entry(id.clone()).or_default();
+        task_map.insert(id.clone(), task);
+
+        if let Some(deps) = task.get("depends_on").and_then(|d| d.as_array()) {
+            for dep in deps {
+                if let Some(dep_id) = dep.as_str() {
+                    adj.entry(dep_id.to_string()).or_default().push(id.clone());
+                    *in_degree.entry(id.clone()).or_insert(0) += 1;
+                }
+            }
+        }
+    }
+
+    let mut waves: Vec<Vec<serde_json::Value>> = vec![];
+    let mut queue: VecDeque<String> = in_degree.iter()
+        .filter(|(_, &deg)| deg == 0)
+        .map(|(id, _)| id.clone())
+        .collect();
+
+    while !queue.is_empty() {
+        let mut wave = vec![];
+        let mut next_queue = VecDeque::new();
+        while let Some(id) = queue.pop_front() {
+            if let Some(task) = task_map.get(&id) {
+                wave.push(json!({
+                    "id": id,
+                    "name": task["name"].as_str().unwrap_or(""),
+                    "complexity": task["complexity"].as_str().unwrap_or(""),
+                    "budget_tokens": task["budget_tokens"].as_u64().unwrap_or(0),
+                }));
+            }
+            if let Some(neighbors) = adj.get(&id) {
+                for next in neighbors {
+                    if let Some(deg) = in_degree.get_mut(next) {
+                        *deg -= 1;
+                        if *deg == 0 { next_queue.push_back(next.clone()); }
+                    }
+                }
+            }
+        }
+        if !wave.is_empty() { waves.push(wave); }
+        queue = next_queue;
+    }
+
+    Ok(serde_json::to_string_pretty(&json!({
+        "wave_count": waves.len(),
+        "waves": waves,
+    })).unwrap())
+}

package/cli/src/cmd/git.rs

@@ -0,0 +1,148 @@
+use serde_json::json;
+use std::process::Command;
+
+const DOC_DIRS: &[&str] = &["prd", "epics", "research", "technical", "wiki", "compass"];
+
+fn git_available() -> bool {
+    Command::new("git")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+fn run_git(args: &[&str]) -> Result<std::process::Output, String> {
+    Command::new("git")
+        .args(args)
+        .output()
+        .map_err(|e| e.to_string())
+}
+
+pub fn run(args: &[String]) -> Result<String, String> {
+    if !git_available() {
+        return Ok(json!({"available": false}).to_string());
+    }
+
+    if args.is_empty() {
+        return Err("Usage: compass-cli git <branch|commit|status> [args...]".into());
+    }
+
+    match args[0].as_str() {
+        "branch" => cmd_branch(args),
+        "commit" => cmd_commit(args),
+        "status" => cmd_status(),
+        _ => Err(format!("Unknown git command: {}", args[0])),
+    }
+}
+
+fn cmd_branch(args: &[String]) -> Result<String, String> {
+    if args.len() < 2 {
+        return Err("Usage: compass-cli git branch <name>".into());
+    }
+    let name = &args[1];
+    let branch = format!("docs/{}", name);
+
+    let out = run_git(&["checkout", "-b", &branch])
+        .map_err(|e| e.to_string())?;
+
+    if out.status.success() {
+        Ok(json!({
+            "success": true,
+            "branch": branch,
+            "action": "created_and_checked_out"
+        })
+        .to_string())
+    } else {
+        // Branch may already exist — try just checking out
+        let out2 = run_git(&["checkout", &branch]).map_err(|e| e.to_string())?;
+        if out2.status.success() {
+            Ok(json!({
+                "success": true,
+                "branch": branch,
+                "action": "checked_out_existing"
+            })
+            .to_string())
+        } else {
+            let stderr = String::from_utf8_lossy(&out.stderr).to_string();
+            Err(format!("git checkout failed: {}", stderr))
+        }
+    }
+}
+
+fn cmd_commit(args: &[String]) -> Result<String, String> {
+    if args.len() < 2 {
+        return Err("Usage: compass-cli git commit <message>".into());
+    }
+    let message = &args[1];
+
+    // Stage only files inside designated doc dirs
+    let mut staged_count = 0usize;
+    for dir in DOC_DIRS {
+        let out = run_git(&["add", "--", dir]).map_err(|e| e.to_string())?;
+        if out.status.success() {
+            staged_count += 1;
+        }
+    }
+
+    // Check if there is anything staged
+    let status_out = run_git(&["diff", "--cached", "--name-only"]).map_err(|e| e.to_string())?;
+    let staged_files: Vec<String> = String::from_utf8_lossy(&status_out.stdout)
+        .lines()
+        .map(|l| l.to_string())
+        .filter(|l| !l.is_empty())
+        .collect();
+
+    if staged_files.is_empty() {
+        return Ok(json!({
+            "success": false,
+            "reason": "nothing_to_commit",
+            "staged": staged_count
+        })
+        .to_string());
+    }
+
+    let commit_out = run_git(&["commit", "-m", message]).map_err(|e| e.to_string())?;
+
+    if commit_out.status.success() {
+        Ok(json!({
+            "success": true,
+            "message": message,
+            "files": staged_files
+        })
+        .to_string())
+    } else {
+        let stderr = String::from_utf8_lossy(&commit_out.stderr).to_string();
+        Err(format!("git commit failed: {}", stderr))
+    }
+}
+
+fn cmd_status() -> Result<String, String> {
+    // Current branch
+    let branch_out = run_git(&["rev-parse", "--abbrev-ref", "HEAD"]).map_err(|e| e.to_string())?;
+    let branch = String::from_utf8_lossy(&branch_out.stdout)
+        .trim()
+        .to_string();
+
+    // Changed files in doc dirs only
+    let status_out = run_git(&["status", "--porcelain"]).map_err(|e| e.to_string())?;
+    let changed: Vec<String> = String::from_utf8_lossy(&status_out.stdout)
+        .lines()
+        .filter_map(|line| {
+            let path = line.get(3..).unwrap_or("").trim().to_string();
+            let in_doc_dir = DOC_DIRS.iter().any(|d| path.starts_with(d));
+            if in_doc_dir {
+                Some(path)
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    Ok(json!({
+        "available": true,
+        "branch": branch,
+        "changed_files": changed,
+        "changed_count": changed.len()
+    })
+    .to_string())
+}

package/cli/src/cmd/hook.rs

@@ -0,0 +1,51 @@
+use std::path::Path;
+
+pub fn run(args: &[String]) -> Result<String, String> {
+    if args.is_empty() { return Err("Usage: compass-cli hook <statusline|update-checker>".into()); }
+    match args[0].as_str() {
+        "statusline" => statusline(),
+        "update-checker" | "check-update" => update_checker(),
+        "context-monitor" => Ok(String::new()), // placeholder
+        _ => Err(format!("Unknown hook: {}", args[0])),
+    }
+}
+
+fn statusline() -> Result<String, String> {
+    let config_path = Path::new(".compass/.state/config.json");
+    if !config_path.exists() { return Ok("Compass: not initialized".to_string()); }
+
+    let content = std::fs::read_to_string(config_path).map_err(|e| e.to_string())?;
+    let data: serde_json::Value = serde_json::from_str(&content).map_err(|e| e.to_string())?;
+
+    let project = data.pointer("/project/name").and_then(|v| v.as_str()).unwrap_or("?");
+    let prefix = data.get("prefix").and_then(|v| v.as_str()).unwrap_or("?");
+    let mode = data.get("mode").and_then(|v| v.as_str()).unwrap_or("?");
+
+    Ok(format!("Compass: {} ({}) | {}", project, prefix, mode))
+}
+
+fn update_checker() -> Result<String, String> {
+    // Same logic as shell hook but in Rust — check once per day
+    let home = std::env::var("HOME").unwrap_or_default();
+    let cache_file = Path::new(&home).join(".compass").join(".update-check-cache");
+
+    if cache_file.exists() {
+        if let Ok(content) = std::fs::read_to_string(&cache_file) {
+            if let Ok(ts) = content.trim().parse::<u64>() {
+                let now = std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)
+                    .unwrap().as_secs();
+                if now - ts < 86400 { return Ok(String::new()); }
+            }
+        }
+    }
+
+    // Write cache timestamp
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH).unwrap().as_secs();
+    let _ = std::fs::write(&cache_file, now.to_string());
+
+    // We can't easily do HTTP in pure Rust without dependencies, so just output empty
+    // The shell hook handles the actual GitHub API call
+    Ok(String::new())
+}