@team-agent/installer 0.3.6 → 0.3.8

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.6"
+version = "0.3.8"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.6"
+version = "0.3.8"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/adapters.rs

@@ -133,13 +133,33 @@ pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
         }
         Ok(result)
     } else {
-        Ok(CmdResult::human(
-            value
-                .get("summary")
-                .and_then(Value::as_str)
-                .unwrap_or("quick-start complete"),
-        ))
+        // E13:happy 人类路径必须带 attach_commands(json 路径 cli/mod.rs:1775 已有)。
+        Ok(CmdResult::human(&quickstart_human(&value)))
+    }
+}
+
+/// E13:quick-start "team 起了" 人类输出 = summary + attach 块。所有成功出口共用(别每分支手拷)。
+/// attach_commands 缺/空 → 只 summary(向后兼容)。
+fn quickstart_human(value: &Value) -> String {
+    let summary = value
+        .get("summary")
+        .and_then(Value::as_str)
+        .unwrap_or("quick-start complete");
+    let attach: Vec<&str> = value
+        .get("attach_commands")
+        .and_then(Value::as_array)
+        .map(|items| items.iter().filter_map(Value::as_str).collect())
+        .unwrap_or_default();
+    if attach.is_empty() {
+        return summary.to_string();
+    }
+    let mut out = String::from(summary);
+    out.push_str("\n\nattach:");
+    for cmd in attach {
+        out.push_str("\n  ");
+        out.push_str(cmd);
     }
+    out
 }
 
 /// `cmd_compile`(`commands.py:42`)。
@@ -1522,9 +1542,34 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
 mod tests {
     #![allow(clippy::unwrap_used)]
 
-    use super::agent_pane_id;
+    use super::{agent_pane_id, quickstart_human};
     use serde_json::json;
 
+    // E13:happy 人类输出必须带 attach 块(此前 else 分支只打 summary 丢 attach_commands)。
+    #[test]
+    fn e13_quickstart_human_includes_attach_commands() {
+        let value = json!({
+            "summary": "team started",
+            "attach_commands": [
+                "tmux -S /tmp/ta-x attach -t team-y:w1",
+                "tmux -S /tmp/ta-x attach -t team-y:w2",
+            ],
+        });
+        let out = quickstart_human(&value);
+        assert!(out.contains("team started"), "must keep summary; got {out}");
+        assert!(out.contains("attach:"), "must render attach block; got {out}");
+        assert!(out.contains("team-y:w1") && out.contains("team-y:w2"), "must list each attach cmd; got {out}");
+    }
+
+    #[test]
+    fn e13_quickstart_human_summary_only_when_no_attach() {
+        let value = json!({"summary": "quick-start complete"});
+        assert_eq!(quickstart_human(&value), "quick-start complete");
+        // 空数组也只 summary。
+        let value2 = json!({"summary": "s", "attach_commands": []});
+        assert_eq!(quickstart_human(&value2), "s");
+    }
+
     #[test]
     fn agent_pane_id_resolves_session_window_even_with_recorded_pane_id() {
         let state = json!({

package/crates/team-agent/src/cli/diagnose.rs

@@ -208,11 +208,20 @@ pub(crate) fn build_profile_smoke_check_for_team(team: &std::path::Path) -> Resu
     let spec = match crate::compiler::compile_team(team) {
         Ok(spec) => spec,
         Err(error) => {
+            // SMOKE-1 (locate.md §"Smallest likely code touch" item 2):compile
+            // 失败时把 team_dir + next_action 带上,operator 才有可下手的诊断
+            // (不是只贴一行 reason)。
             return Ok(json!({
                 "name": "profile_smoke",
                 "ok": false,
                 "status": "profile_invalid",
+                "team_dir": team.to_string_lossy().to_string(),
                 "reason": error.to_string(),
+                "next_action": format!(
+                    "fix the team spec at `{}` (see reason above) or re-run \
+                     doctor with a different `<team-dir>`",
+                    team.display()
+                ),
                 "secret_values_printed": false,
                 "checks": [],
             }));

package/crates/team-agent/src/cli/emit.rs

@@ -108,6 +108,7 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "watch" => cmd_watch(&watch_args(args, cwd)).map(emit_result),
         "sessions" => cmd_sessions(&sessions_args(args, cwd)).map(emit_result),
         "validate" => cmd_validate(&validate_args(args, cwd)).map(emit_result),
+        "install-skill" => cmd_install_skill(&install_skill_args(args)?).map(emit_result),
         "profile" => cmd_profile(&profile_args(args, cwd)?).map(emit_result),
         "validate-result" if has_arg(args, "--result") => {
             eprintln!("team-agent: error: unrecognized arguments: --result");
@@ -160,6 +161,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "watch",
     "sessions",
     "validate",
+    "install-skill",
     "profile",
     "validate-result",
     "collect",
@@ -230,6 +232,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("watch") => "usage: team-agent watch [--workspace WORKSPACE] [--team TEAM]".to_string(),
         Some("sessions") => "usage: team-agent sessions [--workspace WORKSPACE] [--json]".to_string(),
         Some("validate") => "usage: team-agent validate [SPEC] [--json]".to_string(),
+        Some("install-skill") => "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]".to_string(),
         Some("profile") => "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--json]".to_string(),
         Some("validate-result") => "usage: team-agent validate-result [ENVELOPE] [--file FILE|--result JSON] [--json]".to_string(),
         Some("collect") => "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]".to_string(),
@@ -249,15 +252,164 @@ fn emit_unknown_subcommand_usage(command: &str) -> ExitCode {
     emit_usage_error(&format!(
         "argument {{codex,claude,...,doctor}}: invalid choice: '{command}' (choose from codex, claude, ..., doctor)"
     ));
+    // E8 (N38): 错路引导 —— 拼写近似时建议最接近的真子命令(additive,不改既有 golden 行)。
+    if let Some(suggestion) = nearest_subcommand(command) {
+        eprintln!("team-agent: did you mean `{suggestion}`?");
+    }
     ExitCode::Usage
 }
 
+/// 在已知子命令里找与 `input` 最接近的一个(Levenshtein ≤ 阈值)。无足够接近者 → None。
+fn nearest_subcommand(input: &str) -> Option<&'static str> {
+    let mut candidates: Vec<&'static str> = vec!["codex", "claude"];
+    candidates.extend_from_slice(DISPATCH_COMMANDS);
+    candidates.extend_from_slice(SPEC_ONLY_HELP_COMMANDS);
+    // 阈值随长度放宽,但短词收紧,避免 'x' 误配任何东西。
+    let max_distance = match input.chars().count() {
+        0..=3 => 1,
+        4..=6 => 2,
+        _ => 3,
+    };
+    candidates
+        .into_iter()
+        .map(|c| (c, levenshtein(input, c)))
+        .filter(|(_, d)| *d <= max_distance)
+        .min_by_key(|(_, d)| *d)
+        .map(|(c, _)| c)
+}
+
+/// 标准 Levenshtein 编辑距离(纯函数,无依赖;子命令建议用)。
+fn levenshtein(a: &str, b: &str) -> usize {
+    let a: Vec<char> = a.chars().collect();
+    let b: Vec<char> = b.chars().collect();
+    let mut prev: Vec<usize> = (0..=b.len()).collect();
+    let mut curr = vec![0usize; b.len() + 1];
+    for (i, &ca) in a.iter().enumerate() {
+        curr[0] = i + 1;
+        for (j, &cb) in b.iter().enumerate() {
+            let cost = if ca == cb { 0 } else { 1 };
+            curr[j + 1] = (prev[j + 1] + 1).min(curr[j] + 1).min(prev[j] + cost);
+        }
+        std::mem::swap(&mut prev, &mut curr);
+    }
+    prev[b.len()]
+}
+
 fn emit_usage_error(message: &str) {
     eprintln!("usage: team-agent [-h] {{codex,claude,...,doctor}} ...");
     eprintln!("team-agent: error: {message}");
 }
 
 /// `cmd_validate` delegates to runtime validate_file.
+/// `install-skill` 参数(RED-1 根治:把 skill 安装单源收敛到二进制,install.mjs 调它)。
+struct InstallSkillArgs {
+    target: crate::packaging::SkillTarget,
+    dest: Option<PathBuf>,
+    dry_run: bool,
+    /// `--uninstall`:删 target 的 skill 目标目录(单源,走同一 SkillTarget 表),不需 --source。
+    uninstall: bool,
+    source: Option<PathBuf>,
+    json: bool,
+}
+
+fn install_skill_args(args: &[String]) -> Result<InstallSkillArgs, CliError> {
+    let parsed = parse_args(args);
+    // `--target` 复用 parse_args.targets(codex|claude|copilot|all,默认 all)。
+    let target = match parsed.targets.as_deref() {
+        None | Some("all") => crate::packaging::SkillTarget::All,
+        Some("codex") => crate::packaging::SkillTarget::Codex,
+        Some("claude") => crate::packaging::SkillTarget::Claude,
+        Some("copilot") => crate::packaging::SkillTarget::Copilot,
+        Some(other) => {
+            return Err(CliError::Usage(format!(
+                "invalid --target: {other} (choose from codex, claude, copilot, all)"
+            )))
+        }
+    };
+    let uninstall = args.iter().any(|a| a == "--uninstall");
+    // `--source <dir>` 安装时必需(npm 包的 skills/team-agent;运行期无 CARGO_MANIFEST_DIR);
+    // 卸载不需要。
+    let source = flag_value(args, "--source").map(PathBuf::from);
+    if !uninstall && source.is_none() {
+        return Err(CliError::Usage("missing --source <skill dir>".to_string()));
+    }
+    let dest = flag_value(args, "--dest").map(PathBuf::from);
+    let dry_run = args.iter().any(|a| a == "--dry-run");
+    Ok(InstallSkillArgs {
+        target,
+        dest,
+        dry_run,
+        uninstall,
+        source,
+        json: parsed.json,
+    })
+}
+
+/// 取 `--flag <value>` 的值(用于 install-skill 的 --source/--dest,parse_args 不覆盖的旗标)。
+fn flag_value(args: &[String], flag: &str) -> Option<String> {
+    args.iter().position(|a| a == flag).and_then(|i| args.get(i + 1).cloned())
+}
+
+/// `team-agent install-skill`(RED-1 单源):repo `skills/team-agent` → `~/.codex|.claude|.copilot`。
+/// install.mjs 删 JS 拷贝逻辑、改调本命令(`--target all --source <pkg>/skills/team-agent`)。
+fn cmd_install_skill(args: &InstallSkillArgs) -> Result<CmdResult, CliError> {
+    // 卸载分支(单源:走同一 SkillTarget 表的 dest_dir;all → SINGLE_TARGETS 全集)。
+    if args.uninstall {
+        let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("."));
+        let targets: Vec<crate::packaging::SkillTarget> = match args.target {
+            crate::packaging::SkillTarget::All => {
+                crate::packaging::SkillTarget::SINGLE_TARGETS.to_vec()
+            }
+            t => vec![t],
+        };
+        let mut removed: Vec<serde_json::Value> = Vec::new();
+        for t in targets {
+            if let Some(dest) = t.dest_dir(&home) {
+                let existed = dest.0.exists();
+                if existed && !args.dry_run {
+                    std::fs::remove_dir_all(&dest.0).map_err(|e| CliError::Runtime(e.to_string()))?;
+                }
+                removed.push(serde_json::json!({
+                    "target": t,
+                    "dest": dest.0.to_string_lossy(),
+                    "removed": existed,
+                    "dry_run": args.dry_run,
+                }));
+            }
+        }
+        return Ok(CmdResult::from_json(
+            serde_json::json!({"ok": true, "uninstalled": removed}),
+            args.json,
+        ));
+    }
+    let source = args
+        .source
+        .clone()
+        .ok_or_else(|| CliError::Usage("missing --source <skill dir>".to_string()))?;
+    let outcomes = crate::packaging::install::install_skill(&crate::packaging::SkillInstallOptions {
+        target: args.target,
+        dest: args.dest.clone(),
+        dry_run: args.dry_run,
+        source,
+    })
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let installed: Vec<serde_json::Value> = outcomes
+        .iter()
+        .map(|o| {
+            serde_json::json!({
+                "target": o.target,
+                "dest": o.dest.0.to_string_lossy(),
+                "dry_run": o.dry_run,
+                "removed_stale": o.removed_stale.len(),
+            })
+        })
+        .collect();
+    Ok(CmdResult::from_json(
+        serde_json::json!({"ok": true, "installed": installed}),
+        args.json,
+    ))
+}
+
 pub fn cmd_validate(args: &ValidateArgs) -> Result<CmdResult, CliError> {
     let spec = resolve_path(&args.spec);
     let value = if spec.is_dir() {
@@ -1437,4 +1589,27 @@ mod tests {
         let _ = std::fs::remove_dir_all(&cwd);
         let _ = std::fs::remove_dir_all(&ws);
     }
+
+    // ── E8 (N38): 未知子命令 → 最近似建议(additive,不破坏 golden invalid-choice 行) ──
+    #[test]
+    fn e8_unknown_subcommand_suggests_nearest_known_command() {
+        // 'statu' typo → status; 'add-agen' → add-agent.
+        assert_eq!(nearest_subcommand("statu"), Some("status"));
+        assert_eq!(nearest_subcommand("add-agen"), Some("add-agent"));
+        assert_eq!(nearest_subcommand("start-agnet"), Some("start-agent"));
+    }
+
+    #[test]
+    fn e8_unknown_subcommand_no_suggestion_when_far() {
+        // 完全无关的串不应误配出任何建议。
+        assert_eq!(nearest_subcommand("zzzzzzzzzz"), None);
+        assert_eq!(nearest_subcommand("x"), None);
+    }
+
+    #[test]
+    fn e8_levenshtein_basic() {
+        assert_eq!(levenshtein("kitten", "sitting"), 3);
+        assert_eq!(levenshtein("status", "status"), 0);
+        assert_eq!(levenshtein("statu", "status"), 1);
+    }
 }