From b1eaa1b6e9573d5b4d4f53bc3d82f8b57fed226f Mon Sep 17 00:00:00 2001 From: AB-UK Date: Thu, 19 Mar 2026 13:24:48 +0000 Subject: [PATCH] Reworked agent UI. Artist management form. --- .../workflows/docker-publish-agent-dev.yml | 50 +++ .../workflows/docker-publish-player-dev.yml | 50 +++ .../migrations/0004_release_types_hidden.sql | 12 + furumi-agent/prompts/normalize.txt | 23 +- furumi-agent/src/db.rs | 165 +++++++++- furumi-agent/src/ingest/mod.rs | 32 +- furumi-agent/src/ingest/normalize.rs | 25 +- furumi-agent/src/web/admin.html | 293 ++++++++++++++++-- furumi-agent/src/web/api.rs | 111 +++++++ furumi-agent/src/web/mod.rs | 11 +- furumi-web-player/src/db.rs | 7 +- 11 files changed, 741 insertions(+), 38 deletions(-) create mode 100644 .github/workflows/docker-publish-agent-dev.yml create mode 100644 .github/workflows/docker-publish-player-dev.yml create mode 100644 furumi-agent/migrations/0004_release_types_hidden.sql diff --git a/.github/workflows/docker-publish-agent-dev.yml b/.github/workflows/docker-publish-agent-dev.yml new file mode 100644 index 0000000..0c0a54b --- /dev/null +++ b/.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 diff --git a/.github/workflows/docker-publish-player-dev.yml b/.github/workflows/docker-publish-player-dev.yml new file mode 100644 index 0000000..9894e78 --- /dev/null +++ b/.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 diff --git a/furumi-agent/migrations/0004_release_types_hidden.sql b/furumi-agent/migrations/0004_release_types_hidden.sql new file mode 100644 index 0000000..6435756 --- /dev/null +++ b/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; diff --git a/furumi-agent/prompts/normalize.txt b/furumi-agent/prompts/normalize.txt index 6702e39..1a54c21 100644 --- a/furumi-agent/prompts/normalize.txt +++ b/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" diff --git a/furumi-agent/src/db.rs b/furumi-agent/src/db.rs index 8ef0a08..3fe06e8 100644 --- a/furumi-agent/src/db.rs +++ b/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, + 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, pub norm_genre: Option, pub norm_featured_artists: Option, // JSON array + pub norm_release_type: Option, pub confidence: Option, pub llm_notes: Option, pub error_message: Option, @@ -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) -> Result { +pub async fn upsert_album(pool: &PgPool, artist_id: i64, name: &str, year: Option, release_type: &str) -> Result { 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, #[serde(default)] pub featured_artists: Vec, + pub release_type: Option, pub confidence: Option, pub notes: Option, } @@ -526,13 +534,13 @@ pub async fn delete_pending(pool: &PgPool, id: Uuid) -> Result Result, 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, 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, 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, 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, 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 Result, 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) -> Result, 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, + 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, + pub duration_secs: Option, + 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, + pub album_name: Option, +} + +pub async fn get_artist_albums(pool: &PgPool, artist_id: i64) -> Result, 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, 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, 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, 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 Result, 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 = sqlx::query_as("SELECT * FROM albums WHERE artist_id = $1 ORDER BY year NULLS LAST, name") .bind(id).fetch_all(pool).await?; diff --git a/furumi-agent/src/ingest/mod.rs b/furumi-agent/src/ingest/mod.rs index 091877b..b4e7fca 100644 --- a/furumi-agent/src/ingest/mod.rs +++ b/furumi-agent/src/ingest/mod.rs @@ -132,8 +132,8 @@ async fn reprocess_pending(state: &Arc) -> anyhow::Result { 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, 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 = 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 { diff --git a/furumi-agent/src/ingest/normalize.rs b/furumi-agent/src/ingest/normalize.rs index ef3f031..bd8020c 100644 --- a/furumi-agent/src/ingest/normalize.rs +++ b/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, // 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, @@ -14,8 +21,9 @@ pub async fn normalize( hints: &crate::db::PathHints, similar_artists: &[SimilarArtist], similar_albums: &[SimilarAlbum], + folder_ctx: Option<&FolderContext>, ) -> anyhow::Result { - 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 { genre: Option, #[serde(default)] featured_artists: Vec, + release_type: Option, confidence: Option, notes: Option, } @@ -216,6 +238,7 @@ fn parse_response(response: &str) -> anyhow::Result { track_number: parsed.track_number, genre: parsed.genre, featured_artists: parsed.featured_artists, + release_type: parsed.release_type, confidence: parsed.confidence, notes: parsed.notes, }) diff --git a/furumi-agent/src/web/admin.html b/furumi-agent/src/web/admin.html index d0384de..54f8e72 100644 --- a/furumi-agent/src/web/admin.html +++ b/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; } @@ -740,7 +771,7 @@ async function loadLibAlbums() { let html = ``; for (const a of data.items) { html += ` - + @@ -768,18 +799,30 @@ async function loadLibArtists() { el.innerHTML = '
No artists found
'; } else { let html = `
AlbumArtistYearTracksEdit
${esc(a.name)}${esc(a.name)} ${releaseBadge(a.release_type)} ${a.hidden?'Hidden':''} ${esc(a.artist_name)} ${a.year ?? ''} ${a.track_count}
- - - + + + + + + + + `; for (const a of data.items) { - html += ` + const dim = 'style="color:var(--text-muted);text-align:center"'; + html += ` - - - - + + + + + + + + `; } el.innerHTML = html + '
IDNameAlbumsTracksActionsIDNameLPSngEPCmpLiveTrkActions
${a.id}${esc(a.name)}${a.album_count}${a.track_count}${a.hidden?'H':''}${esc(a.name)}${a.album_count||''}${a.single_count||''}${a.ep_count||''}${a.compilation_count||''}${a.live_count||''}${a.track_count||''} + +
'; @@ -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) {
- +
`; @@ -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) {
- +
@@ -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 `${labels[t]||t||'Album'}`; +} + +// --- 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 => ` +
+ ${t.track_number??''} + ${esc(t.title)} + ${fmtDuration(t.duration_secs)} + + +
`).join(''); + + const releaseTypes = ['album','single','ep','compilation','live']; + const typeOpts = releaseTypes.map(rt => ``).join(''); + + return `
+
+ + ${esc(alb.name)} + ${alb.year ? `${alb.year}` : ''} + ${releaseBadge(alb.release_type)} + ${alb.hidden?'Hidden':''} + + +
+
+
`; + } + + const albumsHtml = mainAlbums.map(renderAlbumBlock).join('') || '
No albums
'; + const singlesHtml = singles.map(renderAlbumBlock).join('') || '
No singles/EPs
'; + + const appHtml = appearances.map(ap => ` +
+ ${esc(ap.primary_artist_name)} — ${esc(ap.track_title)}${ap.album_name?` (${esc(ap.album_name)})`:''} + +
`).join('') || '
No appearances
'; + + document.getElementById('modal').className = 'modal modal-wide'; + document.getElementById('modal').innerHTML = ` +
+

${esc(artist.name)}

+ ${artist.hidden?'Hidden':''} + + +
+ +
+
Albums & Compilations (${mainAlbums.length})
+ ${albumsHtml} +
+ +
+
Singles & EPs (${singles.length})
+ ${singlesHtml} +
+ +
+
Appearances (feat.) (${appearances.length})
+
${appHtml}
+
+
+ +
+
+
+
+ +
+ +
+ `; + + // 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 => ` +
+ ${t.track_number??''} + ${esc(t.title)} + ${fmtDuration(t.duration_secs)} + + +
`).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 => + `
${esc(t.artist_name)} — ${esc(t.title)}
` + ).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 = `${esc(label)}`; + 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(); diff --git a/furumi-agent/src/web/api.rs b/furumi-agent/src/web/api.rs index 197147d..d7e2cca 100644 --- a/furumi-agent/src/web/api.rs +++ b/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, Query(q): Query, Path(id): Path) -> 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, Path(id): Path, Json(b): Json) -> 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, Path(id): Path, Json(b): Json) -> 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, Path(id): Path, Json(b): Json) -> 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, Path(id): Path, Json(b): Json) -> 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, Path(id): Path, Json(b): Json) -> 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, Path(artist_id): Path, Json(b): Json) -> 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, 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, Query(q): Query) -> 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::>() + ).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 { diff --git a/furumi-agent/src/web/mod.rs b/furumi-agent/src/web/mod.rs index f7a19c0..6d6ede1 100644 --- a/furumi-agent/src/web/mod.rs +++ b/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) -> 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)) diff --git a/furumi-web-player/src/db.rs b/furumi-web-player/src/db.rs index c3adca8..f33fac6 100644 --- a/furumi-web-player/src/db.rs +++ b/furumi-web-player/src/db.rs @@ -92,6 +92,7 @@ pub async fn list_artists(pool: &PgPool) -> Result, 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 Result 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)