Reworked agent UI. Artist management form.

.github/workflows/docker-publish-agent-dev.yml

@@ -0,0 +1,50 @@
+name: Publish Metadata Agent Image (dev)
+
+on:
+  push:
+    branches:
+      - DEV
+
+env:
+  REGISTRY: docker.io
+  IMAGE_NAME: ${{ secrets.DOCKERHUB_USERNAME }}/furumi-metadata-agent
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Determine version and tags
+        id: info
+        run: |
+          IMAGE="${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}"
+          SHORT_SHA="$(echo '${{ github.sha }}' | cut -c1-7)"
+          echo "tags=${IMAGE}:dev" >> "$GITHUB_OUTPUT"
+          echo "version=dev-${SHORT_SHA}" >> "$GITHUB_OUTPUT"
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: Dockerfile.agent
+          push: true
+          tags: ${{ steps.info.outputs.tags }}
+          build-args: |
+            FURUMI_VERSION=${{ steps.info.outputs.version }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/docker-publish-player-dev.yml

@@ -0,0 +1,50 @@
+name: Publish Web Player Image (dev)
+
+on:
+  push:
+    branches:
+      - DEV
+
+env:
+  REGISTRY: docker.io
+  IMAGE_NAME: ${{ secrets.DOCKERHUB_USERNAME }}/furumi-web-player
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Determine version and tags
+        id: info
+        run: |
+          IMAGE="${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}"
+          SHORT_SHA="$(echo '${{ github.sha }}' | cut -c1-7)"
+          echo "tags=${IMAGE}:dev" >> "$GITHUB_OUTPUT"
+          echo "version=dev-${SHORT_SHA}" >> "$GITHUB_OUTPUT"
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: Dockerfile.web-player
+          push: true
+          tags: ${{ steps.info.outputs.tags }}
+          build-args: |
+            FURUMI_VERSION=${{ steps.info.outputs.version }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

furumi-agent/migrations/0004_release_types_hidden.sql

@@ -0,0 +1,12 @@
+ALTER TABLE albums
+    ADD COLUMN IF NOT EXISTS release_type TEXT NOT NULL DEFAULT 'album',
+    ADD COLUMN IF NOT EXISTS hidden BOOLEAN NOT NULL DEFAULT FALSE;
+
+ALTER TABLE tracks
+    ADD COLUMN IF NOT EXISTS hidden BOOLEAN NOT NULL DEFAULT FALSE;
+
+ALTER TABLE artists
+    ADD COLUMN IF NOT EXISTS hidden BOOLEAN NOT NULL DEFAULT FALSE;
+
+ALTER TABLE pending_tracks
+    ADD COLUMN IF NOT EXISTS norm_release_type TEXT;

furumi-agent/prompts/normalize.txt

@@ -70,12 +70,33 @@ You are a music metadata normalization assistant. Your job is to take raw metada
    - 0.5-0.8: Some guesswork involved, human review recommended.
    - Below 0.5: Significant uncertainty, definitely needs review.
 
+12. **Release type**: Determine the type of release based on all available evidence.
+
+   Allowed values (use exactly one, lowercase):
+   - `album`: Full-length release, typically 4+ tracks
+   - `single`: One or two tracks released as a single, OR folder/tag explicitly says "Single", "Сингл"
+   - `ep`: Short release, typically 3-6 tracks, OR folder/path contains "EP" or "ЕП"
+   - `compilation`: Best-of, greatest hits, anthology, сборник, compilation
+   - `live`: Live recording, concert, live album — folder or tags contain "Live", "Concert", "Концерт"
+
+   Determination rules (in priority order):
+   - If the folder path contains keywords like "Single", "Сингл", "single" → `single`
+   - If the folder path contains "EP", "ЕП", "ep" (case-insensitive) → `ep`
+   - If the folder path contains "Live", "Concert", "Концерт", "live" → `live`
+   - If the folder path contains "Compilation", "сборник", "Anthology", "Greatest Hits" → `compilation`
+   - If album name contains these keywords → apply same logic
+   - If track count in folder is 1–2 → likely `single`
+   - If track count in folder is 3–6 and no other evidence → likely `ep`
+   - If track count is 7+ → likely `album`
+   - When in doubt with 3–6 tracks, prefer `ep` over `album` only if EP indicators present, otherwise `album`
+
 ## Response format
 
 You MUST respond with a single JSON object, no markdown fences, no extra text:
 
-{"artist": "...", "album": "...", "title": "...", "year": 2000, "track_number": 1, "genre": "...", "featured_artists": ["...", "..."], "confidence": 0.95, "notes": "brief explanation of changes made"}
+{"artist": "...", "album": "...", "title": "...", "year": 2000, "track_number": 1, "genre": "...", "featured_artists": [], "release_type": "album", "confidence": 0.95, "notes": "brief explanation of changes made"}
 
 - Use null for fields you cannot determine.
 - Use an empty array [] for "featured_artists" if there are no featured artists.
 - The "notes" field should briefly explain what you changed and why.
+- "release_type" must be exactly one of: "album", "single", "ep", "compilation", "live"

furumi-agent/src/db.rs

@@ -25,6 +25,7 @@ pub async fn migrate(pool: &PgPool) -> Result<(), sqlx::migrate::MigrateError> {
 pub struct Artist {
     pub id: i64,
     pub name: String,
+    pub hidden: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
@@ -33,6 +34,8 @@ pub struct Album {
     pub artist_id: i64,
     pub name: String,
     pub year: Option<i32>,
+    pub release_type: String,
+    pub hidden: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
@@ -64,6 +67,7 @@ pub struct PendingTrack {
     pub norm_track_number: Option<i32>,
     pub norm_genre: Option<String>,
     pub norm_featured_artists: Option<String>,  // JSON array
+    pub norm_release_type: Option<String>,
     pub confidence: Option<f64>,
     pub llm_notes: Option<String>,
     pub error_message: Option<String>,
@@ -172,6 +176,7 @@ pub async fn update_pending_normalized(
            norm_year = $6, norm_track_number = $7, norm_genre = $8,
            norm_featured_artists = $9,
            confidence = $10, llm_notes = $11, error_message = $12,
+           norm_release_type = $13,
            updated_at = NOW()
            WHERE id = $1"#,
     )
@@ -187,6 +192,7 @@ pub async fn update_pending_normalized(
     .bind(norm.confidence)
     .bind(&norm.notes)
     .bind(error_message)
+    .bind(&norm.release_type)
     .execute(pool)
     .await?;
     Ok(())
@@ -254,18 +260,19 @@ pub async fn upsert_artist(pool: &PgPool, name: &str) -> Result<i64, sqlx::Error
     Ok(row.0)
 }
 
-pub async fn upsert_album(pool: &PgPool, artist_id: i64, name: &str, year: Option<i32>) -> Result<i64, sqlx::Error> {
+pub async fn upsert_album(pool: &PgPool, artist_id: i64, name: &str, year: Option<i32>, release_type: &str) -> Result<i64, sqlx::Error> {
     let slug = generate_slug();
     let row: (i64,) = sqlx::query_as(
-        r#"INSERT INTO albums (artist_id, name, year, slug)
-           VALUES ($1, $2, $3, $4)
-           ON CONFLICT (artist_id, name) DO UPDATE SET year = COALESCE(EXCLUDED.year, albums.year)
+        r#"INSERT INTO albums (artist_id, name, year, slug, release_type)
+           VALUES ($1, $2, $3, $4, $5)
+           ON CONFLICT (artist_id, name) DO UPDATE SET year = COALESCE(EXCLUDED.year, albums.year), release_type = EXCLUDED.release_type
            RETURNING id"#
     )
     .bind(artist_id)
     .bind(name)
     .bind(year)
     .bind(&slug)
+    .bind(release_type)
     .fetch_one(pool)
     .await?;
     Ok(row.0)
@@ -343,7 +350,7 @@ pub async fn approve_and_finalize(
     let artist_id = upsert_artist(pool, artist_name).await?;
 
     let album_id = match pt.norm_album.as_deref() {
-        Some(album_name) => Some(upsert_album(pool, artist_id, album_name, pt.norm_year).await?),
+        Some(album_name) => Some(upsert_album(pool, artist_id, album_name, pt.norm_year, pt.norm_release_type.as_deref().unwrap_or("album")).await?),
         None => None,
     };
 
@@ -480,6 +487,7 @@ pub struct NormalizedFields {
     pub genre: Option<String>,
     #[serde(default)]
     pub featured_artists: Vec<String>,
+    pub release_type: Option<String>,
     pub confidence: Option<f64>,
     pub notes: Option<String>,
 }
@@ -526,13 +534,13 @@ pub async fn delete_pending(pool: &PgPool, id: Uuid) -> Result<bool, sqlx::Error
 }
 
 pub async fn list_artists_all(pool: &PgPool) -> Result<Vec<Artist>, sqlx::Error> {
-    sqlx::query_as::<_, Artist>("SELECT id, name FROM artists ORDER BY name")
+    sqlx::query_as::<_, Artist>("SELECT id, name, hidden FROM artists ORDER BY name")
         .fetch_all(pool)
         .await
 }
 
 pub async fn list_albums_by_artist(pool: &PgPool, artist_id: i64) -> Result<Vec<Album>, sqlx::Error> {
-    sqlx::query_as::<_, Album>("SELECT id, artist_id, name, year FROM albums WHERE artist_id = $1 ORDER BY year, name")
+    sqlx::query_as::<_, Album>("SELECT id, artist_id, name, year, release_type, hidden FROM albums WHERE artist_id = $1 ORDER BY year, name")
         .bind(artist_id)
         .fetch_all(pool)
         .await
@@ -603,6 +611,8 @@ pub struct AlbumRow {
     pub artist_name: String,
     pub year: Option<i32>,
     pub track_count: i64,
+    pub release_type: String,
+    pub hidden: bool,
 }
 
 #[derive(Debug, Serialize, sqlx::FromRow)]
@@ -610,7 +620,12 @@ pub struct ArtistRow {
     pub id: i64,
     pub name: String,
     pub album_count: i64,
+    pub single_count: i64,
+    pub ep_count: i64,
+    pub compilation_count: i64,
+    pub live_count: i64,
     pub track_count: i64,
+    pub hidden: bool,
 }
 
 pub async fn search_tracks(
@@ -657,13 +672,13 @@ pub async fn search_albums(
 ) -> Result<Vec<AlbumRow>, sqlx::Error> {
     sqlx::query_as::<_, AlbumRow>(
         r#"SELECT a.id, a.name, ar.name AS artist_name, a.year,
-                  COUNT(t.id) AS track_count
+                  COUNT(t.id) AS track_count, a.release_type, a.hidden
            FROM albums a
            JOIN artists ar ON ar.id = a.artist_id
            LEFT JOIN tracks t ON t.album_id = a.id
            WHERE ($1 = '' OR a.name ILIKE '%' || $1 || '%')
              AND ($2 = '' OR ar.name ILIKE '%' || $2 || '%')
-           GROUP BY a.id, a.name, ar.name, a.year
+           GROUP BY a.id, a.name, ar.name, a.year, a.release_type, a.hidden
            ORDER BY ar.name, a.year NULLS LAST, a.name
            LIMIT $3 OFFSET $4"#,
     )
@@ -690,13 +705,18 @@ pub async fn search_artists_lib(
 ) -> Result<Vec<ArtistRow>, sqlx::Error> {
     sqlx::query_as::<_, ArtistRow>(
         r#"SELECT ar.id, ar.name,
-                  COUNT(DISTINCT al.id) AS album_count,
-                  COUNT(DISTINCT ta.track_id) AS track_count
+                  COUNT(DISTINCT CASE WHEN al.release_type = 'album'       THEN al.id END) AS album_count,
+                  COUNT(DISTINCT CASE WHEN al.release_type = 'single'      THEN al.id END) AS single_count,
+                  COUNT(DISTINCT CASE WHEN al.release_type = 'ep'          THEN al.id END) AS ep_count,
+                  COUNT(DISTINCT CASE WHEN al.release_type = 'compilation' THEN al.id END) AS compilation_count,
+                  COUNT(DISTINCT CASE WHEN al.release_type = 'live'        THEN al.id END) AS live_count,
+                  COUNT(DISTINCT ta.track_id) AS track_count,
+                  ar.hidden
            FROM artists ar
            LEFT JOIN albums al ON al.artist_id = ar.id
            LEFT JOIN track_artists ta ON ta.artist_id = ar.id AND ta.role = 'primary'
            WHERE ($1 = '' OR ar.name ILIKE '%' || $1 || '%')
-           GROUP BY ar.id, ar.name
+           GROUP BY ar.id, ar.name, ar.hidden
            ORDER BY ar.name
            LIMIT $2 OFFSET $3"#,
     )
@@ -853,6 +873,11 @@ pub async fn get_album_cover(pool: &PgPool, album_id: i64) -> Result<Option<(Str
     Ok(row)
 }
 
+pub async fn get_artist_by_id(pool: &PgPool, id: i64) -> Result<Option<Artist>, sqlx::Error> {
+    sqlx::query_as::<_, Artist>("SELECT id, name, hidden FROM artists WHERE id=$1")
+        .bind(id).fetch_optional(pool).await
+}
+
 pub async fn search_albums_for_artist(pool: &PgPool, q: &str, artist_id: Option<i64>) -> Result<Vec<(i64, String)>, sqlx::Error> {
     if let Some(aid) = artist_id {
         let rows: Vec<(i64, String)> = sqlx::query_as(
@@ -867,6 +892,120 @@ pub async fn search_albums_for_artist(pool: &PgPool, q: &str, artist_id: Option<
     }
 }
 
+pub async fn set_track_hidden(pool: &PgPool, id: i64, hidden: bool) -> Result<(), sqlx::Error> {
+    sqlx::query("UPDATE tracks SET hidden=$2 WHERE id=$1").bind(id).bind(hidden).execute(pool).await?;
+    Ok(())
+}
+
+pub async fn set_album_hidden(pool: &PgPool, id: i64, hidden: bool) -> Result<(), sqlx::Error> {
+    sqlx::query("UPDATE albums SET hidden=$2 WHERE id=$1").bind(id).bind(hidden).execute(pool).await?;
+    Ok(())
+}
+
+pub async fn set_artist_hidden(pool: &PgPool, id: i64, hidden: bool) -> Result<(), sqlx::Error> {
+    sqlx::query("UPDATE artists SET hidden=$2 WHERE id=$1").bind(id).bind(hidden).execute(pool).await?;
+    Ok(())
+}
+
+pub async fn set_album_release_type(pool: &PgPool, id: i64, release_type: &str) -> Result<(), sqlx::Error> {
+    sqlx::query("UPDATE albums SET release_type=$2 WHERE id=$1").bind(id).bind(release_type).execute(pool).await?;
+    Ok(())
+}
+
+pub async fn rename_artist_name(pool: &PgPool, id: i64, name: &str) -> Result<(), sqlx::Error> {
+    sqlx::query("UPDATE artists SET name=$2 WHERE id=$1").bind(id).bind(name).execute(pool).await?;
+    Ok(())
+}
+
+// Full artist data for admin form
+
+#[derive(Debug, Serialize, sqlx::FromRow)]
+pub struct ArtistAlbumRow {
+    pub id: i64,
+    pub name: String,
+    pub year: Option<i32>,
+    pub release_type: String,
+    pub hidden: bool,
+    pub track_count: i64,
+}
+
+#[derive(Debug, Serialize, sqlx::FromRow)]
+pub struct ArtistAlbumTrack {
+    pub id: i64,
+    pub title: String,
+    pub track_number: Option<i32>,
+    pub duration_secs: Option<f64>,
+    pub hidden: bool,
+}
+
+#[derive(Debug, Serialize, sqlx::FromRow)]
+pub struct AppearanceRow {
+    pub track_id: i64,
+    pub track_title: String,
+    pub primary_artist_id: i64,
+    pub primary_artist_name: String,
+    pub album_id: Option<i64>,
+    pub album_name: Option<String>,
+}
+
+pub async fn get_artist_albums(pool: &PgPool, artist_id: i64) -> Result<Vec<ArtistAlbumRow>, sqlx::Error> {
+    sqlx::query_as::<_, ArtistAlbumRow>(
+        r#"SELECT a.id, a.name, a.year, a.release_type, a.hidden,
+                  COUNT(t.id) AS track_count
+           FROM albums a
+           LEFT JOIN tracks t ON t.album_id = a.id
+           WHERE a.artist_id = $1
+           GROUP BY a.id, a.name, a.year, a.release_type, a.hidden
+           ORDER BY a.year NULLS LAST, a.name"#
+    ).bind(artist_id).fetch_all(pool).await
+}
+
+pub async fn get_album_tracks_admin(pool: &PgPool, album_id: i64) -> Result<Vec<ArtistAlbumTrack>, sqlx::Error> {
+    sqlx::query_as::<_, ArtistAlbumTrack>(
+        "SELECT id, title, track_number, duration_secs, hidden FROM tracks WHERE album_id=$1 ORDER BY track_number NULLS LAST, title"
+    ).bind(album_id).fetch_all(pool).await
+}
+
+pub async fn get_artist_appearances(pool: &PgPool, artist_id: i64) -> Result<Vec<AppearanceRow>, sqlx::Error> {
+    sqlx::query_as::<_, AppearanceRow>(
+        r#"SELECT ta.track_id, t.title AS track_title,
+                  ta_p.artist_id AS primary_artist_id, ar_p.name AS primary_artist_name,
+                  t.album_id, al.name AS album_name
+           FROM track_artists ta
+           JOIN tracks t ON t.id = ta.track_id
+           JOIN track_artists ta_p ON ta_p.track_id = t.id AND ta_p.role = 'primary'
+           JOIN artists ar_p ON ar_p.id = ta_p.artist_id
+           LEFT JOIN albums al ON al.id = t.album_id
+           WHERE ta.artist_id = $1 AND ta.role = 'featured'
+           ORDER BY ar_p.name, al.name NULLS LAST, t.title"#
+    ).bind(artist_id).fetch_all(pool).await
+}
+
+pub async fn add_track_appearance(pool: &PgPool, track_id: i64, artist_id: i64) -> Result<(), sqlx::Error> {
+    sqlx::query(
+        "INSERT INTO track_artists (track_id, artist_id, role) VALUES ($1, $2, 'featured') ON CONFLICT DO NOTHING"
+    ).bind(track_id).bind(artist_id).execute(pool).await?;
+    Ok(())
+}
+
+pub async fn remove_track_appearance(pool: &PgPool, track_id: i64, artist_id: i64) -> Result<(), sqlx::Error> {
+    sqlx::query(
+        "DELETE FROM track_artists WHERE track_id=$1 AND artist_id=$2 AND role='featured'"
+    ).bind(track_id).bind(artist_id).execute(pool).await?;
+    Ok(())
+}
+
+pub async fn search_tracks_for_feat(pool: &PgPool, q: &str) -> Result<Vec<(i64, String, String)>, sqlx::Error> {
+    // Returns (track_id, track_title, primary_artist_name)
+    sqlx::query_as::<_, (i64, String, String)>(
+        r#"SELECT t.id, t.title, ar.name FROM tracks t
+           JOIN track_artists ta ON ta.track_id=t.id AND ta.role='primary'
+           JOIN artists ar ON ar.id=ta.artist_id
+           WHERE t.title ILIKE '%'||$1||'%' OR ar.name ILIKE '%'||$1||'%'
+           ORDER BY ar.name, t.title LIMIT 15"#
+    ).bind(q).fetch_all(pool).await
+}
+
 // =================== Artist Merges ===================
 
 #[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
@@ -951,7 +1090,7 @@ pub async fn get_pending_merges_for_processing(pool: &PgPool) -> Result<Vec<Uuid
 pub async fn get_artists_full_data(pool: &PgPool, ids: &[i64]) -> Result<Vec<ArtistFullData>, sqlx::Error> {
     let mut result = Vec::new();
     for &id in ids {
-        let artist: Artist = sqlx::query_as("SELECT id, name FROM artists WHERE id = $1")
+        let artist: Artist = sqlx::query_as("SELECT id, name, hidden FROM artists WHERE id = $1")
             .bind(id).fetch_one(pool).await?;
         let albums: Vec<Album> = sqlx::query_as("SELECT * FROM albums WHERE artist_id = $1 ORDER BY year NULLS LAST, name")
             .bind(id).fetch_all(pool).await?;

furumi-agent/src/ingest/mod.rs

@@ -132,8 +132,8 @@ async fn reprocess_pending(state: &Arc<AppState>) -> anyhow::Result<usize> {
             Vec::new()
         };
 
-        // LLM normalization
-        match normalize::normalize(state, &raw_meta, &hints, &similar_artists, &similar_albums).await {
+        // LLM normalization (no folder context available for reprocessing from DB)
+        match normalize::normalize(state, &raw_meta, &hints, &similar_artists, &similar_albums, None).await {
             Ok(normalized) => {
                 let confidence = normalized.confidence.unwrap_or(0.0);
                 let status = if confidence >= state.config.confidence_threshold {
@@ -428,9 +428,35 @@ async fn process_file(state: &Arc<AppState>, file_path: &std::path::Path) -> any
         tracing::info!(file = filename, matches = ?names, "Found similar albums in DB");
     }
 
+    // Build folder context for the LLM
+    let audio_extensions = ["flac", "mp3", "ogg", "wav", "aac", "m4a", "opus", "wma", "ape", "alac"];
+    let folder_ctx = {
+        let folder = file_path.parent().unwrap_or(file_path);
+        let mut folder_files: Vec<String> = std::fs::read_dir(folder)
+            .ok()
+            .map(|rd| {
+                rd.filter_map(|e| e.ok())
+                  .filter_map(|e| {
+                      let name = e.file_name().to_string_lossy().into_owned();
+                      let ext = name.rsplit('.').next().unwrap_or("").to_lowercase();
+                      if audio_extensions.contains(&ext.as_str()) { Some(name) } else { None }
+                  })
+                  .collect()
+            })
+            .unwrap_or_default();
+        folder_files.sort();
+        let track_count = folder_files.len();
+        let folder_path = folder
+            .strip_prefix(&state.config.inbox_dir)
+            .unwrap_or(folder)
+            .to_string_lossy()
+            .into_owned();
+        normalize::FolderContext { folder_path, folder_files, track_count }
+    };
+
     // Call LLM for normalization
     tracing::info!(file = filename, model = %state.config.ollama_model, "Sending to LLM for normalization...");
-    match normalize::normalize(state, &raw_meta, &hints, &similar_artists, &similar_albums).await {
+    match normalize::normalize(state, &raw_meta, &hints, &similar_artists, &similar_albums, Some(&folder_ctx)).await {
         Ok(normalized) => {
             let confidence = normalized.confidence.unwrap_or(0.0);
             let status = if confidence >= state.config.confidence_threshold {

furumi-agent/src/ingest/normalize.rs

@@ -7,6 +7,13 @@ use crate::web::AppState;
 
 use super::metadata::RawMetadata;
 
+#[derive(Debug)]
+pub struct FolderContext {
+    pub folder_path: String,      // path relative to inbox_dir (e.g. "Kunteynir/Синглы/Пьюк")
+    pub folder_files: Vec<String>, // audio filenames in the same folder
+    pub track_count: usize,        // number of audio files in folder
+}
+
 /// Build the user message with all context and call Ollama for normalization.
 pub async fn normalize(
     state: &Arc<AppState>,
@@ -14,8 +21,9 @@ pub async fn normalize(
     hints: &crate::db::PathHints,
     similar_artists: &[SimilarArtist],
     similar_albums: &[SimilarAlbum],
+    folder_ctx: Option<&FolderContext>,
 ) -> anyhow::Result<NormalizedFields> {
-    let user_message = build_user_message(raw, hints, similar_artists, similar_albums);
+    let user_message = build_user_message(raw, hints, similar_artists, similar_albums, folder_ctx);
 
     let response = call_ollama(
         &state.config.ollama_url,
@@ -34,6 +42,7 @@ fn build_user_message(
     hints: &crate::db::PathHints,
     similar_artists: &[SimilarArtist],
     similar_albums: &[SimilarAlbum],
+    folder_ctx: Option<&FolderContext>,
 ) -> String {
     let mut msg = String::from("## Raw metadata from file tags\n");
 
@@ -88,6 +97,18 @@ fn build_user_message(
         }
     }
 
+    if let Some(ctx) = folder_ctx {
+        msg.push_str("\n## Folder context\n");
+        msg.push_str(&format!("Folder path: \"{}\"\n", ctx.folder_path));
+        msg.push_str(&format!("Track count in folder: {}\n", ctx.track_count));
+        if !ctx.folder_files.is_empty() {
+            msg.push_str("Files in folder:\n");
+            for f in &ctx.folder_files {
+                msg.push_str(&format!("  - {}\n", f));
+            }
+        }
+    }
+
     msg
 }
 
@@ -201,6 +222,7 @@ fn parse_response(response: &str) -> anyhow::Result<NormalizedFields> {
         genre: Option<String>,
         #[serde(default)]
         featured_artists: Vec<String>,
+        release_type: Option<String>,
         confidence: Option<f64>,
         notes: Option<String>,
     }
@@ -216,6 +238,7 @@ fn parse_response(response: &str) -> anyhow::Result<NormalizedFields> {
         track_number: parsed.track_number,
         genre: parsed.genre,
         featured_artists: parsed.featured_artists,
+        release_type: parsed.release_type,
         confidence: parsed.confidence,
         notes: parsed.notes,
     })

furumi-agent/src/web/admin.html

@@ -162,6 +162,37 @@ details.llm-expand pre { background: var(--bg-card); border: 1px solid var(--bor
 .pagination button:hover:not(:disabled) { border-color: var(--accent); color: var(--text); }
 .pagination button.active { background: var(--accent); border-color: var(--accent); color: #fff; }
 .pagination button:disabled { opacity: 0.3; cursor: default; }
+
+/* Release type badges */
+.release-badge { font-size: 9px; font-weight: 700; text-transform: uppercase; padding: 1px 5px; border-radius: 3px; letter-spacing: 0.04em; }
+.rb-album      { background: #1e2740; color: var(--text-dim); }
+.rb-single     { background: #1e3a2e; color: #6ee7b7; }
+.rb-ep         { background: #2e1e3a; color: #c4b5fd; }
+.rb-compilation{ background: #3a2e1e; color: #fcd34d; }
+.rb-live       { background: #3a1e1e; color: #fca5a5; }
+.hidden-badge  { font-size: 9px; font-weight: 700; text-transform: uppercase; padding: 1px 5px; border-radius: 3px; background: #1a1a1a; color: #555; letter-spacing: 0.04em; }
+
+/* Artist admin form */
+.artist-section { margin-top: 14px; }
+.artist-section-title { font-size: 11px; font-weight: 600; color: var(--text-muted); text-transform: uppercase; letter-spacing: 0.05em; margin-bottom: 6px; display: flex; align-items: center; gap: 8px; }
+.album-block { border: 1px solid var(--border); border-radius: 6px; margin-bottom: 8px; overflow: hidden; }
+.album-block-header { display: flex; align-items: center; gap: 8px; padding: 7px 10px; background: var(--bg-card); cursor: pointer; }
+.album-block-header img { width: 36px; height: 36px; border-radius: 3px; object-fit: cover; flex-shrink: 0; }
+.album-block-header .ab-name { flex: 1; font-size: 12px; font-weight: 500; }
+.album-block-header .ab-year { font-size: 10px; color: var(--text-muted); flex-shrink: 0; }
+.album-block-body { display: none; padding: 0; }
+.album-block-body.open { display: block; }
+.album-track-row { display: flex; align-items: center; gap: 8px; padding: 4px 10px; border-top: 1px solid var(--border); font-size: 11px; background: var(--bg-base); }
+.album-track-row.hidden-track { opacity: 0.45; }
+.album-track-row .atr-num { color: var(--text-muted); width: 22px; text-align: right; flex-shrink: 0; }
+.album-track-row .atr-title { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.album-track-row .atr-dur { color: var(--text-muted); font-size: 10px; flex-shrink: 0; }
+.appearance-row { display: flex; align-items: center; gap: 8px; padding: 4px 0; font-size: 12px; border-bottom: 1px solid var(--border); }
+.appearance-row:last-child { border-bottom: none; }
+.btn-hide   { background: #1e293b; color: var(--text-muted); border: none; padding: 2px 7px; border-radius: 3px; cursor: pointer; font-size: 10px; font-family: inherit; }
+.btn-hide:hover { background: #334155; }
+.btn-show   { background: #052e16; color: var(--success); border: none; padding: 2px 7px; border-radius: 3px; cursor: pointer; font-size: 10px; font-family: inherit; }
+.btn-show:hover { background: #065f46; }
 </style>
 </head>
 <body>
@@ -740,7 +771,7 @@ async function loadLibAlbums() {
     let html = `<table><tr><th>Album</th><th>Artist</th><th style="width:50px">Year</th><th style="width:60px">Tracks</th><th style="width:50px">Edit</th></tr>`;
     for (const a of data.items) {
       html += `<tr>
-        <td><span style="display:inline-flex;align-items:center;gap:5px"><img src="${API}/albums/${a.id}/cover" style="width:20px;height:20px;border-radius:2px;object-fit:cover;flex-shrink:0" onerror="this.style.display='none'"><span>${esc(a.name)}</span></span></td>
+        <td><span style="display:inline-flex;align-items:center;gap:5px"><img src="${API}/albums/${a.id}/cover" style="width:20px;height:20px;border-radius:2px;object-fit:cover;flex-shrink:0" onerror="this.style.display='none'"><span>${esc(a.name)}</span></span> ${releaseBadge(a.release_type)} ${a.hidden?'<span class="hidden-badge">Hidden</span>':''}</td>
         <td>${esc(a.artist_name)}</td>
         <td>${a.year ?? ''}</td>
         <td style="color:var(--text-muted)">${a.track_count}</td>
@@ -768,18 +799,30 @@ async function loadLibArtists() {
     el.innerHTML = '<div class="empty">No artists found</div>';
   } else {
     let html = `<table><tr>
-      <th style="width:30px"></th><th style="width:50px">ID</th><th>Name</th>
-      <th style="width:60px">Albums</th><th style="width:60px">Tracks</th>
-      <th style="width:80px">Actions</th>
+      <th style="width:30px"></th><th style="width:40px">ID</th><th>Name</th>
+      <th style="width:46px" title="Albums">LP</th>
+      <th style="width:42px" title="Singles">Sng</th>
+      <th style="width:34px" title="EPs">EP</th>
+      <th style="width:40px" title="Compilations">Cmp</th>
+      <th style="width:36px" title="Live">Live</th>
+      <th style="width:46px" title="Tracks">Trk</th>
+      <th style="width:60px">Actions</th>
     </tr>`;
     for (const a of data.items) {
-      html += `<tr>
+      const dim = 'style="color:var(--text-muted);text-align:center"';
+      html += `<tr ${a.hidden?'style="opacity:0.5"':''}>
         <td><input type="checkbox" class="cb" ${selectedArtists.has(a.id)?'checked':''} onchange="toggleSelectArtist(${a.id},this.checked)"></td>
         <td style="color:var(--text-muted)">${a.id}</td>
-        <td class="editable" ondblclick="inlineEditArtist(this,${a.id})">${esc(a.name)}</td>
-        <td style="color:var(--text-muted)">${a.album_count}</td>
-        <td style="color:var(--text-muted)">${a.track_count}</td>
-        <td class="actions"><button class="btn btn-edit" onclick="editArtist(${a.id},'${esc(a.name)}')">Rename</button></td>
+        <td>${a.hidden?'<span class="hidden-badge" style="margin-right:4px">H</span>':''}${esc(a.name)}</td>
+        <td ${dim}>${a.album_count||''}</td>
+        <td ${dim}>${a.single_count||''}</td>
+        <td ${dim}>${a.ep_count||''}</td>
+        <td ${dim}>${a.compilation_count||''}</td>
+        <td ${dim}>${a.live_count||''}</td>
+        <td ${dim}>${a.track_count||''}</td>
+        <td class="actions">
+          <button class="btn btn-edit" onclick="openArtistForm(${a.id})">Edit</button>
+        </td>
       </tr>`;
     }
     el.innerHTML = html + '</table>';
@@ -844,10 +887,11 @@ async function editArtist(id, currentName) {
 }
 
 // --- Track edit modal ---
-async function openTrackEdit(id) {
+async function openTrackEdit(id, returnCb) {
   const t = await api(`/tracks/${id}`);
   if (!t) return;
 
+  editReturnCallback = returnCb || null;
   editFeatured = [...(t.featured_artists || [])];
 
   document.getElementById('modal').className = 'modal';
@@ -899,7 +943,7 @@ async function openTrackEdit(id) {
     </div>
 
     <div class="modal-actions">
-      <button class="btn btn-cancel" onclick="closeModal()">Cancel</button>
+      <button class="btn btn-cancel" onclick="cancelTrackEdit()">Cancel</button>
       <button class="btn btn-primary" onclick="saveTrackEdit(${t.id})">Save</button>
     </div>
   `;
@@ -908,6 +952,7 @@ async function openTrackEdit(id) {
 }
 
 let teArtistTimer = null, teAlbumTimer = null;
+let editReturnCallback = null;
 
 function onTeArtistSearch(q) {
   clearTimeout(teArtistTimer);
@@ -973,12 +1018,21 @@ async function saveTrackEdit(id) {
     featured_artists: editFeatured,
   };
   await api(`/tracks/${id}`, { method: 'PUT', headers: {'Content-Type':'application/json'}, body: JSON.stringify(body) });
-  closeModal();
-  if (currentTab === 'tracks') loadLibTracks();
+  const cb = editReturnCallback;
+  editReturnCallback = null;
+  if (cb) { cb(); } else { closeModal(); if (currentTab === 'tracks') loadLibTracks(); }
+}
+
+function cancelTrackEdit() {
+  const cb = editReturnCallback;
+  editReturnCallback = null;
+  if (cb) { cb(); } else { closeModal(); }
 }
 
 // --- Album edit modal ---
-async function openAlbumEdit(id) {
+let albumEditReturnCallback = null;
+async function openAlbumEdit(id, returnCb) {
+  albumEditReturnCallback = returnCb || null;
   const d = await api(`/albums/${id}/full`);
   if (!d) return;
 
@@ -1023,7 +1077,7 @@ async function openAlbumEdit(id) {
     </ul>
 
     <div class="modal-actions">
-      <button class="btn btn-cancel" onclick="closeModal()">Cancel</button>
+      <button class="btn btn-cancel" onclick="cancelAlbumEdit()">Cancel</button>
       <button class="btn btn-edit" onclick="saveAlbumReorder(${id})">Save Order</button>
       <button class="btn btn-primary" onclick="saveAlbumEdit(${id})">Save Album</button>
     </div>
@@ -1073,6 +1127,12 @@ function selectAeArtist(id, name) {
   document.getElementById('ae-artist-dropdown').classList.remove('open');
 }
 
+function cancelAlbumEdit() {
+  const cb = albumEditReturnCallback;
+  albumEditReturnCallback = null;
+  if (cb) { cb(); } else { closeModal(); }
+}
+
 async function saveAlbumEdit(id) {
   const artistId = parseInt(document.getElementById('ae-artist-id').value);
   if (!artistId) { alert('Please select an artist from the dropdown'); return; }
@@ -1082,7 +1142,9 @@ async function saveAlbumEdit(id) {
     artist_id: artistId,
   };
   await api(`/albums/${id}/edit`, { method: 'PUT', headers: {'Content-Type':'application/json'}, body: JSON.stringify(body) });
-  if (currentTab === 'albums') loadLibAlbums();
+  const cb = albumEditReturnCallback;
+  albumEditReturnCallback = null;
+  if (cb) { cb(); } else { closeModal(); if (currentTab === 'albums') loadLibAlbums(); }
 }
 
 async function saveAlbumReorder(id) {
@@ -1094,8 +1156,11 @@ async function saveAlbumReorder(id) {
 }
 
 async function openTrackEditFromAlbum(trackId, albumId) {
-  closeModal();
-  await openTrackEdit(trackId);
+  const parentCb = albumEditReturnCallback;
+  await openTrackEdit(trackId, () => openAlbumEdit(albumId, parentCb));
+}
+function openTrackEditForArtist(trackId, artistId) {
+  openTrackEdit(trackId, () => openArtistForm(artistId));
 }
 
 // --- Helpers ---
@@ -1329,6 +1394,198 @@ async function retryMerge(id) {
   loadMerges();
 }
 
+// --- Release badge helper ---
+function releaseBadge(t) {
+  const labels = {album:'Album',single:'Single',ep:'EP',compilation:'Comp',live:'Live'};
+  return `<span class="release-badge rb-${t||'album'}">${labels[t]||t||'Album'}</span>`;
+}
+
+// --- Artist full admin form ---
+async function openArtistForm(id) {
+  const d = await api(`/artists/${id}/full`);
+  if (!d) return;
+  const { artist, albums, appearances } = d;
+
+  // Separate albums by type
+  const mainAlbums = albums.filter(a => a.release_type === 'album' || a.release_type === 'compilation' || a.release_type === 'live');
+  const singles = albums.filter(a => a.release_type === 'single' || a.release_type === 'ep');
+
+  function renderAlbumBlock(alb) {
+    const hiddenCls = alb.hidden ? ' style="opacity:0.55"' : '';
+    const tracks = (alb.tracks || []).map(t => `
+      <div class="album-track-row ${t.hidden?'hidden-track':''}" data-tid="${t.id}">
+        <span class="atr-num">${t.track_number??''}</span>
+        <span class="atr-title">${esc(t.title)}</span>
+        <span class="atr-dur">${fmtDuration(t.duration_secs)}</span>
+        <button class="btn btn-edit" style="font-size:10px;padding:2px 6px" onclick="openTrackEditForArtist(${t.id},${id})">Edit</button>
+        <button data-hidden="${t.hidden}" onclick="toggleTrackHidden(${t.id},this)">${t.hidden?'Show':'Hide'}</button>
+      </div>`).join('');
+
+    const releaseTypes = ['album','single','ep','compilation','live'];
+    const typeOpts = releaseTypes.map(rt => `<option value="${rt}" ${alb.release_type===rt?'selected':''}>${rt.charAt(0).toUpperCase()+rt.slice(1)}</option>`).join('');
+
+    return `<div class="album-block" id="album-block-${alb.id}"${hiddenCls}>
+      <div class="album-block-header" onclick="toggleAlbumBlock(${alb.id})">
+        <img src="${API}/albums/${alb.id}/cover" onerror="this.style.display='none'">
+        <span class="ab-name">${esc(alb.name)}</span>
+        ${alb.year ? `<span class="ab-year">${alb.year}</span>` : ''}
+        ${releaseBadge(alb.release_type)}
+        ${alb.hidden?'<span class="hidden-badge">Hidden</span>':''}
+        <select onclick="event.stopPropagation()" onchange="changeReleaseType(${alb.id},this.value)" style="background:var(--bg-base);border:1px solid var(--border);border-radius:3px;color:var(--text);font-size:10px;padding:2px 4px;font-family:inherit">${typeOpts}</select>
+        <button data-hidden="${alb.hidden}" onclick="event.stopPropagation();toggleAlbumHidden(${alb.id},this)">${alb.hidden?'Show':'Hide'}</button>
+      </div>
+      <div class="album-block-body" id="album-body-${alb.id}"></div>
+    </div>`;
+  }
+
+  const albumsHtml = mainAlbums.map(renderAlbumBlock).join('') || '<div style="color:var(--text-muted);font-size:12px;padding:4px 0">No albums</div>';
+  const singlesHtml = singles.map(renderAlbumBlock).join('') || '<div style="color:var(--text-muted);font-size:12px;padding:4px 0">No singles/EPs</div>';
+
+  const appHtml = appearances.map(ap => `
+    <div class="appearance-row">
+      <span style="flex:1">${esc(ap.primary_artist_name)} — <strong>${esc(ap.track_title)}</strong>${ap.album_name?` <span style="color:var(--text-muted)">(${esc(ap.album_name)})</span>`:''}</span>
+      <button class="btn btn-reject" style="font-size:10px;padding:2px 6px" onclick="removeAppearance(${id},${ap.track_id},this)">Remove</button>
+    </div>`).join('') || '<div style="color:var(--text-muted);font-size:12px;padding:4px 0">No appearances</div>';
+
+  document.getElementById('modal').className = 'modal modal-wide';
+  document.getElementById('modal').innerHTML = `
+    <div style="display:flex;align-items:center;gap:10px;margin-bottom:12px">
+      <h2 style="flex:1;margin:0">${esc(artist.name)}</h2>
+      ${artist.hidden?'<span class="hidden-badge" style="font-size:11px">Hidden</span>':''}
+      <button data-hidden="${artist.hidden}" onclick="toggleArtistHidden(${id},this)">${artist.hidden?'Unhide Artist':'Hide Artist'}</button>
+      <button class="btn btn-edit" onclick="promptRenameArtist(${id})">Rename</button>
+    </div>
+
+    <div class="artist-section">
+      <div class="artist-section-title">Albums &amp; Compilations <span style="color:var(--text-dim);font-weight:400">(${mainAlbums.length})</span></div>
+      ${albumsHtml}
+    </div>
+
+    <div class="artist-section">
+      <div class="artist-section-title">Singles &amp; EPs <span style="color:var(--text-dim);font-weight:400">(${singles.length})</span></div>
+      ${singlesHtml}
+    </div>
+
+    <div class="artist-section">
+      <div class="artist-section-title">Appearances (feat.) <span style="color:var(--text-dim);font-weight:400">(${appearances.length})</span></div>
+      <div id="appearances-list">${appHtml}</div>
+      <div style="margin-top:8px;display:flex;gap:6px;align-items:center">
+        <div style="position:relative;flex:1">
+          <input id="feat-track-search" placeholder="Search track to add appearance…" autocomplete="off"
+                 oninput="onFeatTrackSearch(${id},this.value)" style="width:100%;background:var(--bg-card);border:1px solid var(--border);border-radius:5px;padding:6px 9px;color:var(--text);font-family:inherit;font-size:12px">
+          <div class="artist-dropdown" id="feat-track-dropdown"></div>
+        </div>
+      </div>
+    </div>
+
+    <div class="modal-actions">
+      <button class="btn btn-cancel" onclick="closeModal()">Close</button>
+    </div>
+  `;
+
+  // Fill album body content and restore open state
+  for (const alb of albums) {
+    const body = document.getElementById(`album-body-${alb.id}`);
+    if (!body) continue;
+    const tracks = (alb.tracks || []).map(t => `
+      <div class="album-track-row ${t.hidden?'hidden-track':''}" data-tid="${t.id}">
+        <span class="atr-num">${t.track_number??''}</span>
+        <span class="atr-title">${esc(t.title)}</span>
+        <span class="atr-dur">${fmtDuration(t.duration_secs)}</span>
+        <button class="btn btn-edit" style="font-size:10px;padding:2px 6px" onclick="openTrackEditForArtist(${t.id},${id})">Edit</button>
+        <button data-hidden="${t.hidden}" onclick="toggleTrackHidden(${t.id},this)">${t.hidden?'Show':'Hide'}</button>
+      </div>`).join('');
+    body.innerHTML = tracks;
+    if (openAlbumBlocks.has(alb.id)) body.classList.add('open');
+  }
+
+  openModal();
+}
+
+const openAlbumBlocks = new Set();
+
+function toggleAlbumBlock(id) {
+  const body = document.getElementById(`album-body-${id}`);
+  if (!body) return;
+  body.classList.toggle('open');
+  if (body.classList.contains('open')) openAlbumBlocks.add(id);
+  else openAlbumBlocks.delete(id);
+}
+
+async function toggleTrackHidden(id, btn) {
+  const hidden = btn.dataset.hidden !== 'true'; // toggle
+  await api(`/tracks/${id}/hidden`, { method:'PUT', headers:{'Content-Type':'application/json'}, body: JSON.stringify({hidden}) });
+  btn.dataset.hidden = String(hidden);
+  btn.textContent = hidden ? 'Show' : 'Hide';
+  const row = btn.closest('.album-track-row');
+  if (row) row.classList.toggle('hidden-track', hidden);
+}
+
+async function toggleAlbumHidden(id, btn) {
+  const hidden = btn.dataset.hidden !== 'true'; // toggle
+  await api(`/albums/${id}/hidden`, { method:'PUT', headers:{'Content-Type':'application/json'}, body: JSON.stringify({hidden}) });
+  btn.dataset.hidden = String(hidden);
+  btn.textContent = hidden ? 'Show' : 'Hide';
+  const block = btn.closest('.album-block');
+  if (block) block.style.opacity = hidden ? '0.55' : '';
+  const header = block?.querySelector('.album-block-header');
+  let badge = header?.querySelector('.hidden-badge');
+  if (hidden && !badge) { badge = document.createElement('span'); badge.className='hidden-badge'; badge.textContent='Hidden'; header.insertBefore(badge, btn); }
+  else if (!hidden && badge) badge.remove();
+}
+
+async function toggleArtistHidden(id, btn) {
+  const hidden = btn.dataset.hidden !== 'true'; // toggle
+  await api(`/artists/${id}/hidden`, { method:'PUT', headers:{'Content-Type':'application/json'}, body: JSON.stringify({hidden}) });
+  btn.dataset.hidden = String(hidden);
+  btn.textContent = hidden ? 'Unhide Artist' : 'Hide Artist';
+}
+
+async function changeReleaseType(id, type) {
+  await api(`/albums/${id}/release_type`, { method:'PUT', headers:{'Content-Type':'application/json'}, body: JSON.stringify({release_type: type}) });
+}
+
+async function promptRenameArtist(id) {
+  const name = prompt('New artist name:');
+  if (!name) return;
+  await api(`/artists/${id}/rename`, { method:'PUT', headers:{'Content-Type':'application/json'}, body: JSON.stringify({name}) });
+  // refresh
+  closeModal();
+  openArtistForm(id);
+}
+
+let featTrackTimer = null;
+function onFeatTrackSearch(artistId, q) {
+  clearTimeout(featTrackTimer);
+  const dd = document.getElementById('feat-track-dropdown');
+  if (q.length < 2) { dd.classList.remove('open'); return; }
+  featTrackTimer = setTimeout(async () => {
+    const results = await api(`/tracks/search?q=${encodeURIComponent(q)}`);
+    if (!results || !results.length) { dd.classList.remove('open'); return; }
+    dd.innerHTML = results.map(t =>
+      `<div class="artist-option" onclick="addAppearance(${artistId},${t.id},'${esc(t.artist_name+' — '+t.title)}')">${esc(t.artist_name)} — ${esc(t.title)}</div>`
+    ).join('');
+    dd.classList.add('open');
+  }, 250);
+}
+
+async function addAppearance(artistId, trackId, label) {
+  await api(`/artists/${artistId}/appearances`, { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({track_id: trackId}) });
+  document.getElementById('feat-track-search').value = '';
+  document.getElementById('feat-track-dropdown').classList.remove('open');
+  // Add row to appearances list
+  const list = document.getElementById('appearances-list');
+  const row = document.createElement('div');
+  row.className = 'appearance-row';
+  row.innerHTML = `<span style="flex:1">${esc(label)}</span><button class="btn btn-reject" style="font-size:10px;padding:2px 6px" onclick="removeAppearance(${artistId},${trackId},this)">Remove</button>`;
+  list.appendChild(row);
+}
+
+async function removeAppearance(artistId, trackId, btn) {
+  await api(`/artists/${artistId}/appearances/${trackId}`, { method:'DELETE' });
+  btn.closest('.appearance-row').remove();
+}
+
 // --- Init ---
 loadStats();
 loadQueue();

furumi-agent/src/web/api.rs

@@ -143,6 +143,7 @@ pub async fn update_queue_item(
         track_number: body.norm_track_number,
         genre: body.norm_genre,
         featured_artists: body.featured_artists,
+        release_type: None,
         confidence: Some(1.0), // manual edit = full confidence
         notes: Some("Manually edited".to_owned()),
     };
@@ -574,6 +575,116 @@ pub async fn search_albums_for_artist(State(state): State<S>, Query(q): Query<Al
     }
 }
 
+// --- Artist full admin form ---
+
+pub async fn get_artist_full(State(state): State<S>, Path(id): Path<i64>) -> impl IntoResponse {
+    let artist = match db::get_artist_by_id(&state.pool, id).await {
+        Ok(Some(a)) => a,
+        Ok(None) => return error_response(StatusCode::NOT_FOUND, "not found"),
+        Err(e) => return error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    };
+    let (albums, appearances) = tokio::join!(
+        db::get_artist_albums(&state.pool, id),
+        db::get_artist_appearances(&state.pool, id),
+    );
+    // For each album, load tracks
+    let albums = match albums {
+        Ok(a) => a,
+        Err(e) => return error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    };
+    let mut albums_with_tracks = Vec::new();
+    for album in albums {
+        let tracks = db::get_album_tracks_admin(&state.pool, album.id).await.unwrap_or_default();
+        albums_with_tracks.push(serde_json::json!({
+            "id": album.id, "name": album.name, "year": album.year,
+            "release_type": album.release_type, "hidden": album.hidden,
+            "track_count": album.track_count, "tracks": tracks,
+        }));
+    }
+    (StatusCode::OK, Json(serde_json::json!({
+        "artist": artist,
+        "albums": albums_with_tracks,
+        "appearances": appearances.unwrap_or_default(),
+    }))).into_response()
+}
+
+#[derive(Deserialize)]
+pub struct SetHiddenBody { pub hidden: bool }
+
+pub async fn set_track_hidden(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<SetHiddenBody>) -> impl IntoResponse {
+    match db::set_track_hidden(&state.pool, id, b.hidden).await {
+        Ok(()) => StatusCode::NO_CONTENT.into_response(),
+        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    }
+}
+
+pub async fn set_album_hidden(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<SetHiddenBody>) -> impl IntoResponse {
+    match db::set_album_hidden(&state.pool, id, b.hidden).await {
+        Ok(()) => StatusCode::NO_CONTENT.into_response(),
+        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    }
+}
+
+pub async fn set_artist_hidden(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<SetHiddenBody>) -> impl IntoResponse {
+    match db::set_artist_hidden(&state.pool, id, b.hidden).await {
+        Ok(()) => StatusCode::NO_CONTENT.into_response(),
+        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    }
+}
+
+#[derive(Deserialize)]
+pub struct SetReleaseTypeBody { pub release_type: String }
+
+pub async fn set_album_release_type(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<SetReleaseTypeBody>) -> impl IntoResponse {
+    let valid = ["album","single","ep","compilation","live"];
+    if !valid.contains(&b.release_type.as_str()) {
+        return error_response(StatusCode::BAD_REQUEST, "invalid release_type");
+    }
+    match db::set_album_release_type(&state.pool, id, &b.release_type).await {
+        Ok(()) => StatusCode::NO_CONTENT.into_response(),
+        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    }
+}
+
+#[derive(Deserialize)]
+pub struct RenameArtistBody { pub name: String }
+
+pub async fn rename_artist_api(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<RenameArtistBody>) -> impl IntoResponse {
+    match db::rename_artist_name(&state.pool, id, &b.name).await {
+        Ok(()) => StatusCode::NO_CONTENT.into_response(),
+        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    }
+}
+
+#[derive(Deserialize)]
+pub struct AddAppearanceBody { pub track_id: i64 }
+
+pub async fn add_appearance(State(state): State<S>, Path(artist_id): Path<i64>, Json(b): Json<AddAppearanceBody>) -> impl IntoResponse {
+    match db::add_track_appearance(&state.pool, b.track_id, artist_id).await {
+        Ok(()) => StatusCode::NO_CONTENT.into_response(),
+        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    }
+}
+
+pub async fn remove_appearance(State(state): State<S>, Path((artist_id, track_id)): Path<(i64, i64)>) -> impl IntoResponse {
+    match db::remove_track_appearance(&state.pool, track_id, artist_id).await {
+        Ok(()) => StatusCode::NO_CONTENT.into_response(),
+        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    }
+}
+
+#[derive(Deserialize)]
+pub struct SearchTracksQuery { #[serde(default)] pub q: String }
+
+pub async fn search_tracks_feat(State(state): State<S>, Query(q): Query<SearchTracksQuery>) -> impl IntoResponse {
+    match db::search_tracks_for_feat(&state.pool, &q.q).await {
+        Ok(rows) => (StatusCode::OK, Json(serde_json::to_value(
+            rows.iter().map(|(id, title, artist)| serde_json::json!({"id": id, "title": title, "artist_name": artist})).collect::<Vec<_>>()
+        ).unwrap())).into_response(),
+        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    }
+}
+
 // --- Helpers ---
 
 fn error_response(status: StatusCode, message: &str) -> axum::response::Response {

furumi-agent/src/web/mod.rs

@@ -2,7 +2,7 @@ pub mod api;
 
 use std::sync::Arc;
 
-use axum::{Router, routing::{get, post, put}};
+use axum::{Router, routing::{delete, get, post, put}};
 use sqlx::PgPool;
 
 use crate::config::Args;
@@ -32,12 +32,21 @@ pub fn build_router(state: Arc<AppState>) -> Router {
         .route("/artists", get(api::list_artists))
         .route("/artists/:id", put(api::update_artist))
         .route("/artists/:id/albums", get(api::list_albums))
+        .route("/artists/:id/full", get(api::get_artist_full))
+        .route("/artists/:id/hidden", put(api::set_artist_hidden))
+        .route("/artists/:id/rename", put(api::rename_artist_api))
+        .route("/artists/:id/appearances", post(api::add_appearance))
+        .route("/artists/:id/appearances/:track_id", delete(api::remove_appearance))
+        .route("/tracks/search", get(api::search_tracks_feat))
         .route("/tracks/:id", get(api::get_track).put(api::update_track))
+        .route("/tracks/:id/hidden", put(api::set_track_hidden))
         .route("/albums/search", get(api::search_albums_for_artist))
         .route("/albums/:id/cover", get(api::album_cover))
         .route("/albums/:id/full", get(api::get_album_full))
         .route("/albums/:id/reorder", put(api::reorder_album_tracks))
         .route("/albums/:id/edit", put(api::update_album_full))
+        .route("/albums/:id/hidden", put(api::set_album_hidden))
+        .route("/albums/:id/release_type", put(api::set_album_release_type))
         .route("/albums/:id", put(api::update_album))
         .route("/merges", get(api::list_merges).post(api::create_merge))
         .route("/merges/:id", get(api::get_merge).put(api::update_merge))

furumi-web-player/src/db.rs

@@ -92,6 +92,7 @@ pub async fn list_artists(pool: &PgPool) -> Result<Vec<ArtistListItem>, sqlx::Er
            FROM artists ar
            LEFT JOIN albums al ON al.artist_id = ar.id
            LEFT JOIN tracks t ON t.artist_id = ar.id
+           WHERE NOT ar.hidden
            GROUP BY ar.id, ar.slug, ar.name
            HAVING COUNT(DISTINCT t.id) > 0
            ORDER BY ar.name"#
@@ -116,8 +117,10 @@ pub async fn list_albums_by_artist(pool: &PgPool, artist_slug: &str) -> Result<V
            EXISTS(SELECT 1 FROM album_images ai WHERE ai.album_id = al.id AND ai.image_type = 'cover') AS has_cover
            FROM albums al
            JOIN artists ar ON al.artist_id = ar.id
-           LEFT JOIN tracks t ON t.album_id = al.id
+           LEFT JOIN tracks t ON t.album_id = al.id AND NOT t.hidden
            WHERE ar.slug = $1
+             AND NOT al.hidden
+             AND EXISTS (SELECT 1 FROM tracks t2 WHERE t2.album_id = al.id AND NOT t2.hidden)
            GROUP BY al.id, al.slug, al.name, al.year
            ORDER BY al.year NULLS LAST, al.name"#
     )
@@ -135,6 +138,7 @@ pub async fn list_tracks_by_album(pool: &PgPool, album_slug: &str) -> Result<Vec
            JOIN artists ar ON t.artist_id = ar.id
            LEFT JOIN albums al ON t.album_id = al.id
            WHERE al.slug = $1
+             AND NOT t.hidden
            ORDER BY t.track_number NULLS LAST, t.title"#
     )
     .bind(album_slug)
@@ -221,6 +225,7 @@ pub async fn list_all_tracks_by_artist(pool: &PgPool, artist_slug: &str) -> Resu
            JOIN artists ar ON t.artist_id = ar.id
            LEFT JOIN albums al ON t.album_id = al.id
            WHERE ar.slug = $1
+             AND NOT t.hidden
            ORDER BY al.year NULLS LAST, al.name, t.track_number NULLS LAST, t.title"#
     )
     .bind(artist_slug)