Show restored Skill progress in CLI

Author: czyt

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cc-switchy"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2021"
 rust-version = "1.95"
 

Cargo.toml

@@ -40,8 +40,19 @@ pub struct SyncService {
     pub cancellation: CancellationToken,
 }
 
+struct SyncRunDetails {
+    outcome: SyncOutcome,
+    restored_skills: usize,
+}
+
 impl SyncService {
     pub async fn run(&mut self, request: SyncRequest) -> Result<SyncOutcome, AppError> {
+        self.run_with_details(request)
+            .await
+            .map(|details| details.outcome)
+    }
+
+    async fn run_with_details(&mut self, request: SyncRequest) -> Result<SyncRunDetails, AppError> {
         let started = Instant::now();
         let result = self.run_inner(request, started).await;
         if let Err(error) = &result {
@@ -64,7 +75,7 @@ impl SyncService {
         &mut self,
         request: SyncRequest,
         started: Instant,
-    ) -> Result<SyncOutcome, AppError> {
+    ) -> Result<SyncRunDetails, AppError> {
         let source = self
             .catalog
             .resolve(request.source_name.as_deref())?
@@ -94,7 +105,9 @@ impl SyncService {
             Arc::clone(&self.progress),
             backup_config,
         );
-        let restored = restore.apply(snapshot, &lock, &source_name)?;
+        let restored = restore.apply_with_details(snapshot, &lock, &source_name)?;
+        let restored_skills = restored.restored_skills;
+        let restored = restored.outcome;
 
         let settings_path = self.paths.cc_switch_dir.join("settings.json");
         let mut settings = DeviceSettings::load(&settings_path)?;
@@ -131,12 +144,15 @@ impl SyncService {
             snapshot_id: snapshot_id.clone(),
         });
 
-        Ok(SyncOutcome {
-            source_name,
-            snapshot_id,
-            backup_dir: restored.backup_dir,
-            projection,
-            duration,
+        Ok(SyncRunDetails {
+            outcome: SyncOutcome {
+                source_name,
+                snapshot_id,
+                backup_dir: restored.backup_dir,
+                projection,
+                duration,
+            },
+            restored_skills,
         })
     }
 }
@@ -158,9 +174,14 @@ pub async fn run_cli(
         progress,
         cancellation,
     };
-    let outcome = service.run(SyncRequest { source_name }).await?;
-    println!("{}", render_outcome(translator, &outcome));
-    Ok(outcome)
+    let details = service
+        .run_with_details(SyncRequest { source_name })
+        .await?;
+    println!(
+        "{}",
+        render_outcome(translator, &details.outcome, details.restored_skills)
+    );
+    Ok(details.outcome)
 }
 
 pub struct CliProgress {
@@ -293,39 +314,53 @@ impl ProgressSink for CliProgress {
             return;
         };
         if self.tty {
-            let terminal = matches!(
-                event,
-                ProgressEvent::Completed { .. }
-                    | ProgressEvent::Failed { .. }
-                    | ProgressEvent::Warning { .. }
-            );
-            if terminal {
-                eprintln!("\r\x1b[2K{line}");
-            } else {
+            if rewrites_current_line(&event) {
                 eprint!("\r\x1b[2K{line}");
                 let _ = std::io::stderr().flush();
+            } else {
+                eprintln!("\r\x1b[2K{line}");
             }
         } else {
             eprintln!("{line}");
         }
     }
 
+    fn emit_restored_skills(&self, total: usize) {
+        let line = format!(
+            "{}: {total}",
+            Translator::new(self.language)
+                .text(MessageKey::ProgressRestoringSkills, &MessageArgs::default(),)
+        );
+        if self.tty {
+            eprintln!("\r\x1b[2K{line}");
+        } else {
+            eprintln!("{line}");
+        }
+    }
+
     fn emit_skill(&self, agent: String, skill: String, completed: usize, total: usize) {
         let line = format!(
             "{}: {agent} · {skill} {completed}/{total}",
             Translator::new(self.language)
                 .text(MessageKey::ProgressApplyingSkills, &MessageArgs::default())
         );
         if self.tty {
-            eprint!("\r\x1b[2K{line}");
-            let _ = std::io::stderr().flush();
+            eprintln!("\r\x1b[2K{line}");
         } else {
             eprintln!("{line}");
         }
     }
 }
 
-fn render_outcome(translator: &Translator, outcome: &SyncOutcome) -> String {
+fn rewrites_current_line(event: &ProgressEvent) -> bool {
+    matches!(event, ProgressEvent::Downloading { .. })
+}
+
+fn render_outcome(
+    translator: &Translator,
+    outcome: &SyncOutcome,
+    restored_skills: usize,
+) -> String {
     let mut args = MessageArgs::default();
     args.0.insert("source", outcome.source_name.clone());
     args.0.insert("snapshot", outcome.snapshot_id.clone());
@@ -337,6 +372,7 @@ fn render_outcome(translator: &Translator, outcome: &SyncOutcome) -> String {
         "applied",
         outcome.projection.applied_agents.len().to_string(),
     );
+    args.0.insert("skills", restored_skills.to_string());
     args.0
         .insert("warnings", outcome.projection.warnings.len().to_string());
     let backup = outcome.backup_dir.as_ref().map_or_else(
@@ -425,3 +461,24 @@ fn set_private_file(path: &Path) -> Result<(), AppError> {
 fn set_private_file(_path: &Path) -> Result<(), AppError> {
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::rewrites_current_line;
+    use crate::progress::ProgressEvent;
+
+    #[test]
+    fn tty_rewrites_only_download_progress() {
+        assert!(rewrites_current_line(&ProgressEvent::Downloading {
+            artifact: "db.sql".to_string(),
+            downloaded: 1,
+            total: 2,
+        }));
+        assert!(!rewrites_current_line(&ProgressEvent::RestoringSkills));
+        assert!(!rewrites_current_line(&ProgressEvent::ApplyingSkills {
+            agent: "Codex".to_string(),
+            completed: 1,
+            total: 1,
+        }));
+    }
+}

src/commands/sync.rs

@@ -227,6 +227,7 @@ impl Translator {
         let snapshot = || message_arg(_args, "snapshot");
         let duration = || message_arg(_args, "duration");
         let applied = || message_arg(_args, "applied");
+        let skills = || message_arg(_args, "skills");
         let warnings = || message_arg(_args, "warnings");
         let backup = || message_arg(_args, "backup");
         let agent = || message_arg(_args, "agent");
@@ -291,10 +292,11 @@ impl Translator {
             (Language::ZhCn, MessageKey::ProgressCompleted) => "同步完成",
             (Language::ZhCn, MessageKey::SyncSummary) => {
                 return format!(
-                    "同步成功\n来源：{}\n快照：{}\n耗时：{}\n应用步骤：{}\n警告：{}\n备份：{}",
+                    "同步成功\n来源：{}\n快照：{}\n耗时：{}\n恢复 Skills：{}\n应用步骤：{}\n警告：{}\n备份：{}",
                     source(),
                     snapshot(),
                     duration(),
+                    skills(),
                     applied(),
                     warnings(),
                     backup()
@@ -583,10 +585,11 @@ impl Translator {
             (Language::Auto | Language::EnUs, MessageKey::ProgressCompleted) => "Sync completed",
             (Language::Auto | Language::EnUs, MessageKey::SyncSummary) => {
                 return format!(
-                    "Sync succeeded\nSource: {}\nSnapshot: {}\nDuration: {}\nApplied steps: {}\nWarnings: {}\nBackup: {}",
+                    "Sync succeeded\nSource: {}\nSnapshot: {}\nDuration: {}\nRestored Skills: {}\nApplied steps: {}\nWarnings: {}\nBackup: {}",
                     source(),
                     snapshot(),
                     duration(),
+                    skills(),
                     applied(),
                     warnings(),
                     backup()

src/i18n.rs

@@ -58,6 +58,10 @@ pub enum ProgressEvent {
 pub trait ProgressSink: Send + Sync {
     fn emit(&self, event: ProgressEvent);
 
+    fn emit_restored_skills(&self, _total: usize) {
+        self.emit(ProgressEvent::RestoringSkills);
+    }
+
     fn emit_skill(&self, agent: String, _skill: String, completed: usize, total: usize) {
         self.emit(ProgressEvent::ApplyingSkills {
             agent,

src/progress.rs

@@ -58,6 +58,11 @@ pub struct RestoreOutcome {
     pub skills_path: PathBuf,
 }
 
+pub(crate) struct RestoreDetails {
+    pub outcome: RestoreOutcome,
+    pub restored_skills: usize,
+}
+
 pub struct RestoreService {
     paths: AppPaths,
     progress: Arc<dyn ProgressSink>,
@@ -80,9 +85,19 @@ impl RestoreService {
     pub fn apply(
         &self,
         snapshot: DownloadedSnapshot,
-        _lock: &SyncLockGuard,
+        lock: &SyncLockGuard,
         source: &str,
     ) -> Result<RestoreOutcome, AppError> {
+        self.apply_with_details(snapshot, lock, source)
+            .map(|details| details.outcome)
+    }
+
+    pub(crate) fn apply_with_details(
+        &self,
+        snapshot: DownloadedSnapshot,
+        _lock: &SyncLockGuard,
+        source: &str,
+    ) -> Result<RestoreDetails, AppError> {
         let result = self.apply_inner(&snapshot, source);
         cleanup_downloaded_files(&snapshot);
         result
@@ -92,9 +107,10 @@ impl RestoreService {
         &self,
         snapshot: &DownloadedSnapshot,
         source: &str,
-    ) -> Result<RestoreOutcome, AppError> {
+    ) -> Result<RestoreDetails, AppError> {
         let skills_path = resolve_skills_path(&self.paths)?;
         let prepared_skills = prepare_skills(&snapshot.skills_zip_path)?;
+        let restored_skills = count_skill_directories(prepared_skills.extracted_dir.path())?;
         let database_path = self.paths.cc_switch_dir.join("cc-switch.db");
         let prepared_database = prepare_database(
             &snapshot.db_sql_path,
@@ -115,7 +131,7 @@ impl RestoreService {
             None
         };
 
-        self.progress.emit(ProgressEvent::RestoringSkills);
+        self.progress.emit_restored_skills(restored_skills);
         if let Err(restore_error) =
             install_prepared_skills(prepared_skills.extracted_dir.path(), &skills_path)
         {
@@ -151,14 +167,34 @@ impl RestoreService {
             )));
         }
 
-        Ok(RestoreOutcome {
-            backup_dir: backup.map(|backup| backup.backup_dir),
-            database_path,
-            skills_path,
+        Ok(RestoreDetails {
+            outcome: RestoreOutcome {
+                backup_dir: backup.map(|backup| backup.backup_dir),
+                database_path,
+                skills_path,
+            },
+            restored_skills,
         })
     }
 }
 
+fn count_skill_directories(root: &Path) -> Result<usize, AppError> {
+    let mut count = 0;
+    for entry in fs::read_dir(root).map_err(|error| AppError::io(root, error))? {
+        let entry = entry.map_err(|error| AppError::io(root, error))?;
+        let path = entry.path();
+        if entry
+            .file_type()
+            .map_err(|error| AppError::io(&path, error))?
+            .is_dir()
+            && path.join("SKILL.md").is_file()
+        {
+            count += 1;
+        }
+    }
+    Ok(count)
+}
+
 fn rollback_unavailable(error: AppError) -> AppError {
     AppError::Restore(format!(
         "{error}; rollback unavailable because backups are disabled"

src/restore/service.rs

@@ -398,10 +398,14 @@ fn redirected_cli_prints_stage_lines_summary_and_exit_codes() {
         .code(2)
         .stdout(predicate::str::contains("Sync succeeded"))
         .stdout(predicate::str::contains("Source: home"))
+        .stdout(predicate::str::contains("Restored Skills: 1"))
         .stderr(predicate::str::contains("Acquiring the sync lock"))
         .stderr(predicate::str::contains("Downloading db.sql"))
+        .stderr(predicate::str::contains("Restoring Skills: 1"))
         .stderr(predicate::str::contains("Applying providers"))
-        .stderr(predicate::str::contains("Codex · Demo"));
+        .stderr(predicate::str::contains(
+            "Applying Skills: Codex · Demo 1/1",
+        ));
     manifest.assert_calls(1);
     database.assert_calls(1);
     skills.assert_calls(1);