feat(src-tauri): 添加和更新仓库相关功能

更新了 build.yml 工作流；在 src-tauri 目录下添加和更新了多个命令和领域相关文件；在 src/components 目录下添加了 CreateTagDialog.tsx, TagList.tsx 和 Textarea.tsx 组件；更新了 src/store/repoStore.ts 和 src/types/index.ts 文件。

Author: ikun-Lg

.github/workflows/build.yml

@@ -13,40 +13,36 @@ permissions:
   contents: write
 
 jobs:
-  tag-version:
+  create-tag:
     if: github.event_name == 'push' && github.ref == 'refs/heads/main' && !contains(github.event.head_commit.message, '[skip-release]')
     runs-on: ubuntu-latest
     outputs:
-      tag: ${{ steps.tag.outputs.tag }}
+      new_tag: ${{ steps.create_tag.outputs.tag }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
-      - name: Get version from tauri.conf.json
+      - name: Get version
         id: version
         run: |
           VERSION=$(jq -r '.version' src-tauri/tauri.conf.json)
           echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "Version: $VERSION"
 
       - name: Create and push tag
-        id: tag
+        id: create_tag
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          VERSION="${{ steps.version.outputs.version }}"
-          TAG="v$VERSION"
-          echo "tag=$TAG" >> $GITHUB_OUTPUT
+          TAG="v${{ steps.version.outputs.version }}"
+          echo "Creating tag: $TAG"
           git tag -f "$TAG"
           git push origin "$TAG" --force
+          echo "tag=$TAG" >> $GITHUB_OUTPUT
 
   build:
-    needs: tag-version
-    if: |
-      always() &&
-      (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/') || needs.tag-version.result == 'success')
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
     strategy:
       fail-fast: false
       matrix:
@@ -93,7 +89,3 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           args: ${{ matrix.args }}
-          releaseTag: ${{ needs.tag-version.outputs.tag || github.ref_name }}
-          releaseBody: 'See the assets to download and install this version.'
-          releaseDraft: false
-          prerelease: false

src-tauri/src/commands/mod.rs

@@ -3,7 +3,7 @@ pub mod commit;
 pub mod stash;
 pub mod clone;
 
-pub use repo::{scan_repositories, get_repo_status, get_branch_info, get_commit_history, get_local_branches, switch_branch, publish_branch, push_branch, get_git_username, delete_branch, rename_branch, create_branch, get_file_diff, merge_branch, fetch_remote, pull_branch};
+pub use repo::{scan_repositories, get_repo_status, get_branch_info, get_commit_history, get_local_branches, switch_branch, publish_branch, push_branch, get_git_username, delete_branch, rename_branch, create_branch, get_file_diff, merge_branch, fetch_remote, pull_branch, get_tags, create_tag, delete_tag, push_tag, delete_remote_tag};
 pub use commit::{stage_files, unstage_files, stage_all, unstage_all, commit, revoke_latest_commit, batch_commit, generate_commit_message, review_code};
 pub use stash::{get_stash_list, stash_save, stash_apply, stash_pop, stash_drop};
 pub use clone::clone_repository;

src-tauri/src/commands/repo.rs

@@ -1,4 +1,4 @@
-use crate::domain::{RepositoryInfo, RepoStatus, StatusItem, BranchInfo, CommitInfo, LocalBranch};
+use crate::domain::{RepositoryInfo, RepoStatus, StatusItem, BranchInfo, CommitInfo, LocalBranch, TagInfo};
 use crate::error::{AppError, Result};
 use git2::{Repository, StatusOptions};
 use ignore::WalkBuilder;
@@ -917,3 +917,206 @@ fn pull_branch_impl(
 
     Ok(())
 }
+
+/// Get all tags for a repository
+#[tauri::command]
+pub async fn get_tags(path: String) -> std::result::Result<Vec<TagInfo>, String> {
+    let repo = Repository::open(&path).map_err(|e| e.to_string())?;
+    get_tags_impl(&repo).map_err(|e| e.to_string())
+}
+
+fn get_tags_impl(repo: &Repository) -> Result<Vec<TagInfo>> {
+    let tag_names = repo.tag_names(None)?;
+    let mut tags = Vec::new();
+
+    for name in tag_names.iter().flatten() {
+        if let Ok(obj) = repo.revparse_single(name) {
+            let mut message: Option<String> = None;
+            let mut tagger: Option<String> = None;
+            let mut date: Option<i64> = None;
+
+            // Check if it's an annotated tag
+            if let Some(tag) = obj.as_tag() {
+                message = tag.message().map(|s| s.to_string());
+                if let Some(sig) = tag.tagger() {
+                    tagger = sig.name().map(|s| s.to_string());
+                    date = Some(sig.when().seconds());
+                }
+            } else if let Ok(_commit) = obj.peel_to_commit() {
+                // Lightweight tag points directly to commit
+            }
+
+            // Target commit SHA
+            let target = obj.peel_to_commit()?.id().to_string();
+
+            tags.push(TagInfo {
+                name: name.to_string(),
+                message,
+                target,
+                tagger,
+                date,
+            });
+        }
+    }
+    
+    // Sort tags by date (descending) or name
+    tags.sort_by(|a, b| {
+        // Prefer date if available
+        match (a.date, b.date) {
+            (Some(da), Some(db)) => db.cmp(&da), // Descending
+            _ => b.name.cmp(&a.name), // Fallback to name
+        }
+    });
+
+    Ok(tags)
+}
+
+/// Create a new tag
+#[tauri::command]
+pub async fn create_tag(
+    path: String,
+    name: String,
+    message: Option<String>,
+    target: Option<String>,
+) -> std::result::Result<(), String> {
+    let repo = Repository::open(&path).map_err(|e| e.to_string())?;
+    create_tag_impl(&repo, &name, message, target).map_err(|e| e.to_string())
+}
+
+fn create_tag_impl(repo: &Repository, name: &str, message: Option<String>, target: Option<String>) -> Result<()> {
+    // Get the target object
+    let obj = if let Some(oid_str) = target {
+        repo.find_object(git2::Oid::from_str(&oid_str)?, None)?
+    } else {
+        repo.head()?.peel(git2::ObjectType::Any)?
+    };
+
+    if let Some(msg) = message {
+        // Annotated tag
+        let signature = repo.signature()?;
+        repo.tag(name, &obj, &signature, &msg, false)?;
+    } else {
+        // Lightweight tag
+        repo.tag_lightweight(name, &obj, false)?;
+    }
+
+    Ok(())
+}
+
+/// Delete a tag
+#[tauri::command]
+pub async fn delete_tag(path: String, name: String) -> std::result::Result<(), String> {
+    let repo = Repository::open(&path).map_err(|e| e.to_string())?;
+    repo.tag_delete(&name).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+/// Push a tag to remote
+#[tauri::command]
+pub async fn push_tag(
+    path: String,
+    tag_name: String,
+    remote: String,
+    username: Option<String>,
+    password: Option<String>,
+) -> std::result::Result<(), String> {
+    let repo = Repository::open(&path).map_err(|e| e.to_string())?;
+    push_tag_impl(&repo, &tag_name, &remote, username, password).map_err(|e| e.to_string())
+}
+
+fn push_tag_impl(
+    repo: &Repository,
+    tag_name: &str,
+    remote: &str,
+    username: Option<String>,
+    password: Option<String>,
+) -> Result<()> {
+    let mut remote_obj = repo.find_remote(remote)
+        .map_err(|_| AppError::InvalidInput(format!("Remote '{}' not found", remote)))?;
+
+    // Refspec for pushing a tag
+    let refspec = format!("refs/tags/{}:refs/tags/{}", tag_name, tag_name);
+
+    let config = repo.config()?;
+    let auth_username = username.clone();
+    let auth_password = password.clone();
+
+    let mut callbacks = git2::RemoteCallbacks::new();
+    callbacks.credentials(move |url, username_from_url, allowed_types| {
+        let default_username = username_from_url.unwrap_or("git");
+        if let (Some(user), Some(pass)) = (&auth_username, &auth_password) {
+            return git2::Cred::userpass_plaintext(user, pass);
+        }
+        if allowed_types.contains(git2::CredentialType::SSH_KEY) {
+            git2::Cred::ssh_key_from_agent(default_username)
+        } else if allowed_types.contains(git2::CredentialType::USER_PASS_PLAINTEXT) {
+            git2::Cred::credential_helper(&config, url, Some(default_username))
+        } else if allowed_types.contains(git2::CredentialType::DEFAULT) {
+            git2::Cred::credential_helper(&config, url, Some(default_username))
+        } else {
+            Err(git2::Error::from_str("no authentication method available"))
+        }
+    });
+
+    let mut push_options = git2::PushOptions::new();
+    push_options.remote_callbacks(callbacks);
+
+    remote_obj.push(&[&refspec], Some(&mut push_options))?;
+
+    Ok(())
+}
+
+/// Delete a remote tag
+#[tauri::command]
+pub async fn delete_remote_tag(
+    path: String,
+    tag_name: String,
+    remote: String,
+    username: Option<String>,
+    password: Option<String>,
+) -> std::result::Result<(), String> {
+    let repo = Repository::open(&path).map_err(|e| e.to_string())?;
+    delete_remote_tag_impl(&repo, &tag_name, &remote, username, password).map_err(|e| e.to_string())
+}
+
+fn delete_remote_tag_impl(
+    repo: &Repository,
+    tag_name: &str,
+    remote: &str,
+    username: Option<String>,
+    password: Option<String>,
+) -> Result<()> {
+    let mut remote_obj = repo.find_remote(remote)
+        .map_err(|_| AppError::InvalidInput(format!("Remote '{}' not found", remote)))?;
+
+    // Refspec for deleting a remote ref
+    let refspec = format!(":refs/tags/{}", tag_name);
+
+    let config = repo.config()?;
+    let auth_username = username.clone();
+    let auth_password = password.clone();
+
+    let mut callbacks = git2::RemoteCallbacks::new();
+    callbacks.credentials(move |url, username_from_url, allowed_types| {
+        let default_username = username_from_url.unwrap_or("git");
+        if let (Some(user), Some(pass)) = (&auth_username, &auth_password) {
+            return git2::Cred::userpass_plaintext(user, pass);
+        }
+        if allowed_types.contains(git2::CredentialType::SSH_KEY) {
+            git2::Cred::ssh_key_from_agent(default_username)
+        } else if allowed_types.contains(git2::CredentialType::USER_PASS_PLAINTEXT) {
+            git2::Cred::credential_helper(&config, url, Some(default_username))
+        } else if allowed_types.contains(git2::CredentialType::DEFAULT) {
+            git2::Cred::credential_helper(&config, url, Some(default_username))
+        } else {
+            Err(git2::Error::from_str("no authentication method available"))
+        }
+    });
+
+    let mut push_options = git2::PushOptions::new();
+    push_options.remote_callbacks(callbacks);
+
+    remote_obj.push(&[&refspec], Some(&mut push_options))?;
+
+    Ok(())
+}

src-tauri/src/domain/mod.rs

@@ -1,5 +1,5 @@
 pub mod repository;
 pub mod status;
 
-pub use repository::{BranchInfo, BatchCommitResult, BatchFailure, CommitInfo, LocalBranch, RepositoryInfo, StashInfo};
+pub use repository::{BranchInfo, BatchCommitResult, BatchFailure, CommitInfo, LocalBranch, RepositoryInfo, StashInfo, TagInfo};
 pub use status::{CommitSuggestion, CommitType, RepoStatus, StatusItem};

src-tauri/src/domain/repository.rs

@@ -66,3 +66,13 @@ pub struct StashInfo {
     pub message: String,
     pub id: String,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TagInfo {
+    pub name: String,
+    pub message: Option<String>,
+    pub target: String,
+    pub tagger: Option<String>,
+    pub date: Option<i64>,
+}

src-tauri/src/lib.rs

@@ -46,6 +46,12 @@ pub fn run() {
             stash_drop,
             // Clone command
             clone_repository,
+            // Tag commands
+            get_tags,
+            create_tag,
+            delete_tag,
+            push_tag,
+            delete_remote_tag,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");