feat: Add tagger information to tags and enable code browsing by tag (#1532) (#1550)

* feat: Add tagger information to tags and enable code browsing by tag

Signed-off-by: Ruizhi Huang <[email protected]>

format code

Signed-off-by: Ruizhi Huang <[email protected]>

fix problems

Signed-off-by: Ruizhi Huang <[email protected]>

cargo fmt

Signed-off-by: Ruizhi Huang <[email protected]>

* fix: mr -> cl

Signed-off-by: Ruizhi Huang <[email protected]>

fix: mr -> cl

Signed-off-by: Ruizhi Huang <[email protected]>

* fix reviews

Signed-off-by: Ruizhi Huang <[email protected]>

fix errors and restore generated.ts

Signed-off-by: Ruizhi Huang <[email protected]>

---------

Signed-off-by: Ruizhi Huang <[email protected]>
Co-authored-by: Quanyi Ma <[email protected]>

Author: 231220075

ceres/src/api_service/mod.rs

@@ -170,8 +170,12 @@ pub trait ApiHandler: Send + Sync {
         }
     }
 
-    async fn get_tree_info(&self, path: &Path) -> Result<Vec<TreeBriefItem>, GitError> {
-        match self.search_tree_by_path(path).await? {
+    async fn get_tree_info(
+        &self,
+        path: &Path,
+        refs: Option<&str>,
+    ) -> Result<Vec<TreeBriefItem>, GitError> {
+        match self.search_tree_by_path_with_refs(path, refs).await? {
             Some(tree) => {
                 let items = tree
                     .tree_items
@@ -189,14 +193,61 @@ pub trait ApiHandler: Send + Sync {
         }
     }
 
-    async fn get_tree_commit_info(&self, path: PathBuf) -> Result<Vec<TreeCommitItem>, GitError> {
-        let item_to_commit_map = self.item_to_commit_map(path).await?;
+    async fn get_tree_commit_info(
+        &self,
+        path: PathBuf,
+        refs: Option<&str>,
+    ) -> Result<Vec<TreeCommitItem>, GitError> {
+        // If refs provided, resolve to commit and list items from that commit's tree at path,
+        // attaching the same commit info to each item for consistent, minimal behavior.
+        let maybe = refs.unwrap_or("").trim();
+        if !maybe.is_empty() {
+            // Resolve commit from refs (SHA or tag)
+            let is_hex_sha1 = |s: &str| s.len() == 40 && s.chars().all(|c| c.is_ascii_hexdigit());
+            let mut commit_hash = String::new();
+            if is_hex_sha1(maybe) {
+                commit_hash = maybe.to_string();
+            } else if let Ok(Some(tag)) = self.get_tag(None, maybe.to_string()).await {
+                commit_hash = tag.object_id;
+            }
 
+            if !commit_hash.is_empty() {
+                if let Some(commit) = self.get_commit_by_hash(&commit_hash).await {
+                    // Use refs-aware tree search
+                    if let Some(tree) = self.search_tree_by_path_with_refs(&path, refs).await? {
+                        let mut items: Vec<TreeCommitItem> = tree
+                            .tree_items
+                            .into_iter()
+                            .map(|item| TreeCommitItem::from((item, Some(commit.clone()))))
+                            .collect();
+                        items.sort_by(|a, b| {
+                            a.content_type
+                                .cmp(&b.content_type)
+                                .then(a.name.cmp(&b.name))
+                        });
+                        return Ok(items);
+                    } else {
+                        // path not found under this refs
+                        return Ok(vec![]);
+                    }
+                } else {
+                    return Err(GitError::CustomError(
+                        "Invalid refs: commit not found".to_string(),
+                    ));
+                }
+            } else {
+                return Err(GitError::CustomError(
+                    "Invalid refs: tag or commit not found".to_string(),
+                ));
+            }
+        }
+
+        // No refs provided: fallback to existing behavior
+        let item_to_commit_map = self.item_to_commit_map(path).await?;
         let mut items: Vec<TreeCommitItem> = item_to_commit_map
             .into_iter()
             .map(TreeCommitItem::from)
             .collect();
-        // sort with type and name
         items.sort_by(|a, b| {
             a.content_type
                 .cmp(&b.content_type)
@@ -210,6 +261,15 @@ pub trait ApiHandler: Send + Sync {
         path: PathBuf,
     ) -> Result<HashMap<TreeItem, Option<Commit>>, GitError>;
 
+    /// Refs-aware version; default fallback to refs-unaware implementation
+    async fn item_to_commit_map_with_refs(
+        &self,
+        path: PathBuf,
+        _refs: Option<&str>,
+    ) -> Result<HashMap<TreeItem, Option<Commit>>, GitError> {
+        self.item_to_commit_map(path).await
+    }
+
     // Tag related operations shared across mono/import implementations.
     /// Create a tag in the repository context represented by `repo_path`.
     /// Returns TagInfo on success.
@@ -251,8 +311,12 @@ pub trait ApiHandler: Send + Sync {
     /// the dir's hash as same as old,file's hash is the content hash
     /// may think about change dir'hash as the content
     /// for now,only change the file's hash
-    async fn get_tree_content_hash(&self, path: PathBuf) -> Result<Vec<TreeHashItem>, GitError> {
-        match self.search_tree_by_path(&path).await? {
+    async fn get_tree_content_hash(
+        &self,
+        path: PathBuf,
+        refs: Option<&str>,
+    ) -> Result<Vec<TreeHashItem>, GitError> {
+        match self.search_tree_by_path_with_refs(&path, refs).await? {
             Some(tree) => {
                 let mut items: Vec<TreeHashItem> = tree
                     .tree_items
@@ -277,8 +341,9 @@ pub trait ApiHandler: Send + Sync {
         &self,
         path: PathBuf,
         dir_name: &str,
+        refs: Option<&str>,
     ) -> Result<Vec<TreeHashItem>, GitError> {
-        match self.search_tree_by_path(&path).await? {
+        match self.search_tree_by_path_with_refs(&path, refs).await? {
             Some(tree) => {
                 let items: Vec<TreeHashItem> = tree
                     .tree_items
@@ -384,6 +449,66 @@ pub trait ApiHandler: Send + Sync {
         Ok(Some(search_tree))
     }
 
+    /// Get root tree for a given refs (commit SHA or tag name). If refs is None/empty, use default root.
+    async fn get_root_tree_for_refs(&self, refs: Option<&str>) -> Result<Tree, GitError> {
+        let maybe = refs.unwrap_or("").trim();
+        if maybe.is_empty() {
+            return Ok(self.get_root_tree().await);
+        }
+        let is_hex_sha1 = maybe.len() == 40 && maybe.chars().all(|c| c.is_ascii_hexdigit());
+        let mut commit_hash = String::new();
+        if is_hex_sha1 {
+            commit_hash = maybe.to_string();
+        } else if let Ok(Some(tag)) = self.get_tag(None, maybe.to_string()).await {
+            commit_hash = tag.object_id;
+        }
+
+        if commit_hash.is_empty() {
+            return Err(GitError::CustomError(
+                "Invalid refs: tag or commit not found".to_string(),
+            ));
+        }
+        if let Some(commit) = self.get_commit_by_hash(&commit_hash).await {
+            Ok(self.get_tree_by_hash(&commit.tree_id.to_string()).await)
+        } else {
+            Err(GitError::CustomError(
+                "Invalid refs: commit not found".to_string(),
+            ))
+        }
+    }
+
+    /// Refs-aware tree search using a resolved root from refs
+    async fn search_tree_by_path_with_refs(
+        &self,
+        path: &Path,
+        refs: Option<&str>,
+    ) -> Result<Option<Tree>, GitError> {
+        let relative_path = self
+            .strip_relative(path)
+            .map_err(|e| GitError::CustomError(e.to_string()))?;
+        let root_tree = self.get_root_tree_for_refs(refs).await?;
+        let mut search_tree = root_tree.clone();
+        for component in relative_path.components() {
+            if component != Component::RootDir {
+                let target_name = component.as_os_str().to_str().unwrap();
+                let search_res = search_tree
+                    .tree_items
+                    .iter()
+                    .find(|x| x.name == target_name);
+                if let Some(search_res) = search_res {
+                    if !search_res.is_tree() {
+                        return Ok(None);
+                    }
+                    let res = self.get_tree_by_hash(&search_res.id.to_string()).await;
+                    search_tree = res.clone();
+                } else {
+                    return Ok(None);
+                }
+            }
+        }
+        Ok(Some(search_tree))
+    }
+
     /// Searches for a tree in the Git repository by its path, creating intermediate trees if necessary,
     /// and returns the trees involved in the update process.
     ///

mono/src/api/router/preview_router.rs

@@ -154,7 +154,9 @@ async fn get_tree_info(
     for part in parts {
         let path = part.as_ref();
         let handler = state.api_handler(path).await?;
-        let tree_items = handler.get_tree_info(path).await?;
+        let tree_items = handler
+            .get_tree_info(path, Some(query.refs.as_str()))
+            .await?;
         file_tree.insert(
             part,
             FileTreeItem {
@@ -167,7 +169,7 @@ async fn get_tree_info(
     let tree_items = state
         .api_handler(query.path.as_ref())
         .await?
-        .get_tree_info(query.path.as_ref())
+        .get_tree_info(query.path.as_ref(), Some(query.refs.as_str()))
         .await?;
     Ok(Json(CommonResult::success(Some(TreeResponse {
         file_tree,
@@ -194,7 +196,7 @@ async fn get_tree_commit_info(
     let data = state
         .api_handler(query.path.as_ref())
         .await?
-        .get_tree_commit_info(query.path.into())
+        .get_tree_commit_info(query.path.into(), Some(query.refs.as_str()))
         .await?;
     Ok(Json(CommonResult::success(Some(data))))
 }
@@ -218,7 +220,7 @@ async fn get_tree_content_hash(
     let data = state
         .api_handler(query.path.as_ref())
         .await?
-        .get_tree_content_hash(query.path.into())
+        .get_tree_content_hash(query.path.into(), Some(query.refs.as_str()))
         .await?;
     Ok(Json(CommonResult::success(Some(data))))
 }
@@ -250,7 +252,7 @@ async fn get_tree_dir_hash(
     let data = state
         .api_handler(parent_path.as_ref())
         .await?
-        .get_tree_dir_hash(parent_path.into(), target_name)
+        .get_tree_dir_hash(parent_path.into(), target_name, Some(query.refs.as_str()))
         .await?;
 
     Ok(Json(CommonResult::success(Some(data))))

moon/apps/web/components/CodeView/CodeTable.tsx

@@ -6,6 +6,7 @@ import { useMemo } from 'react'
 import { FolderIcon } from '@heroicons/react/20/solid'
 import { formatDistance, fromUnixTime } from 'date-fns'
 import { usePathname, useRouter } from 'next/navigation'
+import { useSearchParams } from 'next/navigation'
 import RTable from './Table'
 import { columnsType, DirectoryType } from './Table/type'
 import Markdown from 'react-markdown'
@@ -19,9 +20,11 @@ export interface DataType {
   date: number
 }
 
-const CodeTable = ({ directory, loading, readmeContent, onCommitInfoChange}: any) => {
+const CodeTable = ({ directory, loading, readmeContent }: any) => {
   const router = useRouter()
   const pathname = usePathname()
+  const searchParams = useSearchParams()
+  const refs = searchParams?.get('refs') || undefined
   let real_path = pathname?.replace('/tree', '')
 
   const markdownContentStyle = {
@@ -83,7 +86,7 @@ const CodeTable = ({ directory, loading, readmeContent, onCommitInfoChange}: any
       }
       pathParts?.push(encodeURIComponent(record.name))
 
-      newPath = `/${pathParts?.join('/')}`
+      newPath = `/${pathParts?.join('/')}${refs ? `?refs=${encodeURIComponent(refs)}` : ''}`
       router.push(newPath)
     } else {
       let newPath: string
@@ -95,9 +98,8 @@ const CodeTable = ({ directory, loading, readmeContent, onCommitInfoChange}: any
       }
       pathParts?.push(encodeURIComponent(record.name))
 
-      newPath = `/${pathParts?.join('/')}`
+      newPath = `/${pathParts?.join('/')}${refs ? `?refs=${encodeURIComponent(refs)}` : ''}`
 
-      onCommitInfoChange?.(newPath);
       router.push(newPath)
     }
   }

moon/apps/web/components/CodeView/Tags/MonoTagList.tsx

@@ -1,11 +1,13 @@
 import { useMemo, useState, useEffect } from 'react'
-import { Button, DotsHorizontal, Link, LinkIcon, TrashIcon, UIText } from '@gitmono/ui'
+import { Avatar, Button, DotsHorizontal, Link, LinkIcon, TrashIcon, UIText } from '@gitmono/ui'
 import { DropdownMenu } from '@gitmono/ui/DropdownMenu'
 import { buildMenuItems } from '@gitmono/ui/Menu'
 import { useCopyToClipboard } from '@gitmono/ui/src/hooks'
 
 import { TagResponse } from '@gitmono/types'
+import { MemberHovercard } from '@/components/InlinePost/MemberHovercard'
 import { useDeleteMonoTag } from '@/hooks/useDeleteMonoTag'
+import { formatDistanceToNow } from 'date-fns'
 
 interface Props {
   tags: TagResponse[]
@@ -45,6 +47,37 @@ function InnerRow({ tag, onDelete }: { tag: TagResponse; onDelete?: () => void }
     return tag.message || `${tag.object_type} ${tag.object_id.substring(0, 8)}`
   }, [tag])
 
+  const creator = useMemo(() => {
+    // tagger format examples: "Alice <[email protected]>", "[email protected]", "unknown"
+    const t = (tag.tagger || '').trim()
+
+    if (!t) return { name: 'unknown', email: undefined as string | undefined }
+    const m = t.match(/^(.*)\s*<([^>]+)>$/)
+
+    if (m) {
+      const name = m[1].trim() || m[2].split('@')[0]
+
+      return { name, email: m[2] }
+    }
+    if (t.includes('@')) {
+      return { name: t.split('@')[0], email: t }
+    }
+    return { name: t, email: undefined as string | undefined }
+  }, [tag.tagger])
+
+  const username = useMemo(() => {
+    if (creator.email) return creator.email.split('@')[0]
+    return creator.name || ''
+  }, [creator])
+
+  const createdRelative = useMemo(() => {
+    try {
+      return formatDistanceToNow(new Date(tag.created_at), { addSuffix: true })
+    } catch {
+      return ''
+    }
+  }, [tag.created_at])
+
   const href = `/code/tags/${encodeURIComponent(tag.name)}`
 
   return (
@@ -62,6 +95,15 @@ function InnerRow({ tag, onDelete }: { tag: TagResponse; onDelete?: () => void }
             {subtitle}
           </UIText>
         )}
+        <MemberHovercard username={username} role='member'>
+          <div className='mt-0.5 flex items-center gap-1.5 relative z-[1]'>
+            <Avatar size='xs' name={creator.name} />
+            <UIText quaternary size='text-[12px]' className='line-clamp-1'>
+              Created by {creator.name}
+              {createdRelative ? ` · ${createdRelative}` : ''}
+            </UIText>
+          </div>
+        </MemberHovercard>
       </div>
 
       <div className='hidden flex-none items-center gap-0.5 lg:flex'>

moon/apps/web/components/CodeView/Tags/NewMonoTagDialog.tsx

@@ -16,6 +16,7 @@ import {
 } from '@gitmono/ui'
 
 import { useCreateMonoTag } from '@/hooks/useCreateMonoTag'
+import { useGetCurrentUser } from '@/hooks/useGetCurrentUser'
 import { useGetLatestCommit } from '../../../hooks/useGetLatestCommit'
 import { useGetTreeCommitInfo } from '@/hooks/useGetTreeCommitInfo'
 import React from 'react'
@@ -35,6 +36,7 @@ export default function NewMonoTagDialog({ open, onOpenChange, onCreated }: Prop
   const [pickerQuery, setPickerQuery] = useState('')
 
   const { mutateAsync, isPending } = useCreateMonoTag()
+  const { data: currentUser } = useGetCurrentUser()
   const { data: latestCommit, isLoading: latestLoading } = useGetLatestCommit('/')
   const { data: treeCommitResp, isLoading: listLoading, isFetching: listFetching } = useGetTreeCommitInfo('/')
 
@@ -75,7 +77,9 @@ export default function NewMonoTagDialog({ open, onOpenChange, onCreated }: Prop
         name: name.trim(),
         message: message || undefined,
         target: resolvedTarget,
-        path_context: '/'
+        path_context: '/',
+        tagger_email: currentUser?.email || undefined,
+        tagger_name: currentUser?.display_name || currentUser?.username || undefined
       })
 
       if (onCreated && result?.data) {