Compare commits

...
Author SHA1 Message Date
Andrew BeveridgeandClaude Opus 4.5 97f1a7640b feat: add production debug script template for agents
Add infrastructure for ad-hoc production testing:
- Debug script template at frontend/e2e/helpers/debug-prod-template.mjs
- Gitignore patterns for test-*.local.* and debug-*.local.* files
- Documentation in CLAUDE.md, TESTING.md, and DEVELOPMENT.md

This allows agents to quickly test production issues when asked to
"test it yourself in prod" without risking token exposure in commits.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-20 10:15:25 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 2d687064b8 feat(admin): improve job detail page and fix Files tab (#317)
## Summary
- Fix Files tab showing 0 files when file_urls contains relative paths
(not `gs://` URIs)
- Add timing stats (total time, processing time, waiting time) to job
info grid
- Combine Config and Metadata into single "Overview" tab for better
space usage
- Make timeline wrap on narrow screens instead of causing overflow

## Changes
**Backend:**
- `_extract_files_recursive` now handles both `gs://` URIs and relative
paths starting with `jobs/`
- Added error handling to prevent 500 errors when file extraction fails

**Frontend:**
- Added `getJobTimingStats()` to calculate total/processing/waiting
times
- Reorganized tabs: Overview (Config + Metadata side-by-side), Files,
Debug
- Timeline uses `flex-wrap` with `gap-y-2` for responsive wrapping
- Layout uses `min-w-0 overflow-hidden` to prevent sidebar overflow

## Test plan
- [x] Backend tests pass (`pytest
backend/tests/test_admin_job_files.py`)
- [ ] Verify Files tab shows files for jobs with relative paths in
file_urls
- [ ] Verify timing stats display correctly
- [ ] Verify timeline wraps on narrow screens

🤖 Generated with [Claude Code](https://claude.com/claude-code)

@coderabbitai ignore

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-20 10:00:32 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 df446ed2ba feat(admin): redesign job detail page for efficiency (#316)
## Summary

Redesigns the admin job detail page to be more efficient for admin use,
minimizing scrolling and making actions immediately accessible.

**Key changes:**
- Sticky action toolbar at top with reset buttons (Start, Audio, Lyrics,
Inst.), Delete Outputs, Delete Job, and Logs button
- Horizontal timeline with timestamps below each stage and consistent
labeling
- Labeled metadata grid (User, Source, Created, Updated, Progress,
Theme)
- Logs moved to modal with level filtering and search
- Content organized into tabs (Files, Config, Metadata, Debug)
- Debug data (State Data, File URLs, Raw Job Data) collapsed by default

## Test plan

- [x] Build passes (`npm run build`)
- [ ] Manual testing of job detail page layout
- [ ] Verify action buttons work (reset, delete outputs, delete job)
- [ ] Verify logs modal opens, scrolls, filters correctly
- [ ] Verify timeline displays stages with timestamps
- [ ] Verify metadata labels are clear

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.ai/code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 23:03:11 -08:00
Andrew Beveridge ☄️andClaude c3eb794d7d fix: prevent Cloud Run from killing workers during parallel processing (#315)
## Summary
- Fix bug where Cloud Run could shut down prematurely when one parallel
worker completed while another was still running
- Add WorkerRegistry to track active workers per job
- Add shutdown handler that waits for workers to complete before
allowing container termination

## Background
Job `9ed3b0a1` failed because Cloud Run shut down at 05:31:06
immediately after the audio worker completed, while the lyrics
correction worker was still processing. Workers run in BackgroundTasks,
and when one completes, Cloud Run sees no active requests and can
terminate the container.

## Changes
- **New `backend/workers/registry.py`**: WorkerRegistry class that
tracks active workers
- **Updated `backend/workers/audio_worker.py`**: Register/unregister
with registry
- **Updated `backend/workers/lyrics_worker.py`**: Register/unregister
with registry
- **Updated `backend/main.py`**: Shutdown handler waits for workers (10
min timeout)
- **New tests**: 11 unit tests for WorkerRegistry
- **Docs**: Updated ARCHITECTURE.md, LESSONS-LEARNED.md, README.md

## Test plan
- [x] Unit tests pass (11 new tests for WorkerRegistry)
- [x] All 220 worker-related tests pass
- [x] All 7 main.py tests pass
- [ ] E2E happy path test after deployment

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude <noreply@anthropic.com>
2026-01-19 22:35:41 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 a5fb5114f2 Add E2E test selectors for instrumental selection (#314)
## Summary
- Add `.selection-option` class and `data-testid` to SelectionOptions
buttons for E2E test compatibility
- Add `id="submit-btn"` to InstrumentalSelector submit button
- Fix missing `completeReview` method in LyricsAnalyzer ApiClient
interface (TypeScript fix)

## Test plan
- [x] Backend tests pass (1593 passed)
- [x] TypeScript compiles without errors
- [x] E2E happy path test passes (production config)

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-20 05:25:16 +00:00
Andrew Beveridge ☄️andClaude f18a7f32e3 Fix lyrics review "Complete Review" button (405 error) (#313)
## Summary
- Fix HTTP method mismatch: `submitCorrections` was using PUT but
backend expects POST, causing 405 errors
- Add missing `completeReview()` call to trigger video rendering after
saving corrections

## Changes
- `api.ts`: Change `submitCorrections` method from PUT to POST
- `api.ts`: Add `completeReview` to `LyricsReviewApiClient` interface
and implementation
- `LyricsAnalyzer.tsx`: Call `apiClient.completeReview()` after saving
corrections

## Test plan
- [x] Frontend build passes (TypeScript types verified)
- [x] API tests pass (25 tests including completeReview)
- [x] Backend tests pass (1593 passed)
- [x] Manually verified endpoints work via curl:
  - `POST /api/jobs/{id}/corrections` → 422 (not 405)
  - `POST /api/jobs/{id}/complete-review` → 200 success

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude <noreply@anthropic.com>
2026-01-19 18:37:47 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 b16bdb024b Fix: hash-based navigation from job list (#312)
## Summary
- Fix bug where clicking "Review Lyrics" or "Select Instrumental" from
the job list showed "Page not found" but reloading worked
- Changed from Next.js `Link` to regular `<a>` tags for hash-based URLs

## Root Cause
Next.js `Link` uses `history.pushState` for client-side navigation,
which doesn't trigger the `hashchange` event. The client.tsx component's
hash state wasn't updating when navigating.

## Solution
Use regular `<a>` tags for hash URLs (`/app/jobs#/{jobId}/review`). When
clicking an `<a>` tag with a hash URL on the same page, the browser:
1. Updates the hash without reloading
2. Fires the `hashchange` event
3. Our listener updates state
4. Component re-renders with correct route

## Test plan
- [x] Unit tests pass
- [ ] Manual test: Click "Review Lyrics" from job list - should navigate
correctly

🤖 Generated with [Claude Code](https://claude.com/claude-code)

@coderabbitai ignore

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-20 01:14:45 +00:00
Andrew Beveridge ☄️andClaude Opus 4.5 a1f9da2fb5 Implement hash-based routing for job review/instrumental pages (#311)
## Summary
- Switch from path-based routing (`/app/jobs/{id}/review`) to hash-based
routing (`/app/jobs#/{id}/review`)
- Eliminates the need for SPA redirect workarounds on static hosts
- URLs now correctly reflect the current view and survive page reload

## Benefits
- **Clean URLs**: URL always shows which job is being viewed
- **Reload works**: Browser hash is preserved, no sessionStorage needed
- **Simpler code**: Removed 100+ lines of SPA redirect logic
- **Universal compatibility**: Works on any static host

## Changes
**Frontend:**
- `client.tsx`: Parse route from URL hash instead of path/sessionStorage
- `JobCard.tsx`: Update link hrefs to hash-based format
- Remove SPA redirect script injection
- Remove Cloudflare rewrite rules (no longer needed)

**Backend:**
- `job_notification_service.py`: Update email URLs to new format
- Updated tests

## URL Format
- Old: `https://gen.nomadkaraoke.com/app/jobs/26391a79/review`
- New: `https://gen.nomadkaraoke.com/app/jobs#/26391a79/review`

Note: Local mode still uses path-based routing for compatibility with
dev server.

## Test plan
- [x] Frontend build passes
- [x] Frontend tests pass (JobCard)
- [x] Backend tests pass (job_notification_service)
- [ ] Manual: Click "Review Lyrics" button - navigates to hash URL
- [ ] Manual: Reload page - stays on same view
- [ ] Manual: Email link works with new format

@coderabbitai ignore

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 16:36:26 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 6394b33fbb Fix auth flash and card padding (#310)
## Summary
- Fix "Sign in required" flash during SPA redirect by waiting for
zustand hydration
- Add vertical padding to Card component for better spacing

## Changes
- **auth.ts**: Add `hasHydrated` flag and `onRehydrateStorage` handler
- **client.tsx**: Wait for `hasHydrated` before showing
"not_authenticated"
- **card.tsx**: Add `py-6` to Card component

## Test plan
- [x] Build passes
- [ ] Navigate to lyrics review - no more "Sign in required" flash
- [ ] Dashboard cards have proper vertical padding

@coderabbitai ignore

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 16:08:41 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 b2befccd5b Fix page reload on lyrics review (#309)
## Summary
Fixes the page reload issue on the lyrics review page by preserving
sessionStorage across refreshes.

## Problem
After PR #308, the lyrics review page worked on initial navigation but
page reload showed "Page not found". This happened because:
1. `history.replaceState()` was used to update the URL to
`/app/jobs/{id}/review/`
2. But Next.js internal router reverted this back to `/app/jobs/`
3. The sessionStorage was cleared immediately on read, so reload had no
stored path to restore

## Solution
- Keep sessionStorage value across reloads (don't clear it on read)
- On page reload: browser requests `/app/jobs/`, 404.html redirects
back, and we re-read the stored path from sessionStorage
- Clear sessionStorage only when navigating to a different job (prevents
stale redirects)

## Test plan
- [x] Build succeeds
- [ ] Navigate to lyrics review page (initial load works)
- [ ] Reload the page (should still show lyrics review)
- [ ] Navigate to a different job's review (should load new job, not old
one)

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 15:38:19 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 bf7653773a Fix lyrics review: logo path, API endpoints, and SPA routing (#308)
## Summary
Comprehensive fix for the lyrics review page that addresses three
categories of issues:

### 1. Logo 404 Fix
- Changed logo src from `/static/nomad-karaoke-logo.svg` to
`/nomad-karaoke-logo.svg`

### 2. API Endpoint Fixes (causing audio/video 404s)
The frontend was calling wrong API paths after the backend migration to
`/api/review/` prefix:

| Endpoint | Before (broken) | After (fixed) |
|----------|-----------------|---------------|
| Audio URL | `/api/audio/{hash}` | `/api/review/{jobId}/audio/{hash}` |
| Generate preview | `/api/jobs/{jobId}/preview-video` |
`/api/review/{jobId}/preview-video` |
| Preview video URL | `/api/preview-video/{hash}` |
`/api/review/{jobId}/preview-video/{hash}` |

### 3. SPA Routing Fix (enabling page reload)
- Added `history.replaceState()` call after restoring the redirect path
from sessionStorage
- This updates the browser's URL bar to show the actual route (e.g.,
`/app/jobs/abc123/review/`)
- Enables page reload to work correctly - browser re-requests the
correct URL which triggers the SPA redirect flow again

## Test plan
- [x] Build succeeds
- [ ] Logo displays on lyrics review page
- [ ] Audio loads and plays in lyrics review
- [ ] Preview video generation works
- [ ] Page reload works on lyrics review page
- [ ] Direct navigation to `/app/jobs/{id}/review/` works

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 15:20:01 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 a7de863121 Fix frontend SPA routing and lyrics review API endpoint (#307)
## Summary
- Fixed GitHub Pages SPA routing for dynamic routes like
`/app/jobs/{jobId}/review`
- Fixed API endpoint for lyrics review - was calling wrong endpoint (GET
on POST-only route)

## Changes
1. **SPA redirect mechanism** - `404.html` stores the path in
sessionStorage and redirects to `/app/jobs/` where the client component
restores the route
2. **API endpoint fix** - Changed `getCorrectionData()` from
`/api/jobs/{jobId}/corrections` (POST-only) to
`/api/review/{jobId}/correction-data` (correct GET endpoint)

## Testing
- Verified SPA redirect flow works in production
- Verified lyrics review page loads correctly when authenticated

## Test plan
- [x] Build succeeds
- [ ] CI passes
- [ ] Click "Review Lyrics" button on job 26391a79 loads lyrics review
page

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 14:42:24 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 63a14ce920 fix(frontend): Parse route from stored path instead of updating URL (#306)
@coderabbitai ignore

## Summary
- Fixes SPA redirect restoration where Next.js was reverting
`history.replaceState()` calls
- Instead of updating the URL bar (which gets reverted), we now parse
the route directly from the stored sessionStorage path
- The URL will stay at `/app/jobs/` after redirect restoration, but the
correct content renders

## Why
Previous fix (#305) used `history.replaceState()` to update the URL
after SPA redirect restoration, but Next.js reverts any replaceState
calls that don't match its internal router state. This caused the URL to
flash back to `/app/jobs/` and show "Page not found".

## Test plan
- Navigate to `https://gen.nomadkaraoke.com/app/jobs/26391a79/review/`
- Should redirect via 404.html → /app/jobs/ but render the lyrics review
UI
- URL will show `/app/jobs/` but content should be correct

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 13:47:18 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 c17d10cff0 fix(frontend): Fix race condition in SPA redirect restoration (#305)
## Summary
Fixes the race condition that was causing the "Page not found" error
when accessing dynamic job URLs.

## Problem
Discovered via Playwright debugging that React on 404.html was executing
`checkAndRestoreRedirect()` **before** the `window.location.replace()`
redirect completed. This cleared sessionStorage prematurely, so when the
new page loaded at `/app/jobs/`, the redirect path was already gone.

Debug trace:
```
[SessionStorage] SET: spa-redirect-path = /app/jobs/26391a79/review/
[SessionStorage] GET: spa-redirect-path = /app/jobs/26391a79/review/  <-- React on 404.html reads it
[SessionStorage] REMOVE: spa-redirect-path  <-- React clears it before redirect!
[History] replaceState: /app/jobs/26391a79/review/
[History] replaceState: /app/jobs/  <-- Then redirect happens, but sessionStorage is empty
```

## Solution
Only check sessionStorage when we're at the redirect target URL
(`/app/jobs/`), not when we're still on the original 404 page.

```typescript
const pathname = window.location.pathname
if (pathname !== '/app/jobs/' && pathname !== '/app/jobs') {
  return false  // Don't touch sessionStorage if we're not at the target
}
```

## Test plan
- [x] Unit tests pass (181 tests)
- [x] Build succeeds
- [ ] Verified via Playwright debugging

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 13:21:05 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 b669108010 fix(frontend): Fix infinite redirect loop in SPA routing (#304)
## Summary
Fixes the infinite redirect loop introduced in #303.

## Problem
The previous SPA routing fix used `router.replace()` which triggers a
full page navigation in Next.js static export mode. This caused GitHub
Pages to serve 404.html again, creating an infinite loop.

## Solution
- Remove `router.replace()` entirely
- Use `history.replaceState()` to update the URL without navigation
- Parse route directly from `window.location.pathname` after restore
- Use `useState` lazy initializer for synchronous redirect detection to
avoid flash of "invalid route" UI

## Flow (corrected)
```
User visits /app/jobs/26391a79/review/
    ↓
GitHub Pages serves 404.html
    ↓
Script stores path in sessionStorage, redirects to /app/jobs/
    ↓
JobRouterClient renders, useState initializer checks sessionStorage
    ↓
If found: removes it, calls history.replaceState(), returns true
    ↓
parseRouteFromPathname() parses jobId/routeType from window.location
    ↓
Component renders with correct route (no loop!)
```

## Test plan
- [x] Frontend unit tests pass (181 tests)
- [x] Build succeeds
- [ ] Manual: Verify `/app/jobs/{id}/review` loads without infinite loop

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 12:47:56 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 eaa4bc8415 fix(frontend): Add SPA routing for dynamic job URLs on GitHub Pages (#303)
## Summary
- Fix 404 errors for dynamic job URLs (e.g.,
`/app/jobs/26391a79/review/`) after frontend consolidation
- Implement SPA redirect pattern for GitHub Pages static export
- Add post-build script that injects redirect logic into 404.html
- Add path restoration in JobRouterClient via sessionStorage

## Problem
The frontend consolidation introduced a catch-all route
`/app/jobs/[[...slug]]` for dynamic job IDs. With Next.js static export
on GitHub Pages, only pre-rendered paths work. Dynamic paths like
`/app/jobs/26391a79/review/` resulted in 404s because they're not
pre-generated at build time.

## Solution
Implemented the SPA redirect pattern:
1. **404.html script** - Detects `/app/jobs/*` URLs, stores path in
sessionStorage, redirects to `/app/jobs/`
2. **JobRouterClient** - On mount, reads sessionStorage and navigates to
the correct route

Flow:
```
User visits /app/jobs/26391a79/review/
    ↓
GitHub Pages serves 404.html (path doesn't exist as static file)
    ↓
Injected script detects /app/jobs/* pattern
    ↓
Stores path in sessionStorage, redirects to /app/jobs/
    ↓
JobRouterClient loads, reads sessionStorage
    ↓
Navigates to /app/jobs/26391a79/review/ with correct component
```

## Test plan
- [x] All backend tests pass (1593 tests)
- [x] All frontend unit tests pass (181 tests)
- [x] Build succeeds with post-build script injection
- [ ] Manual: Verify `/app/jobs/{id}/review` loads correctly in
production

## Files Changed
- `frontend/scripts/spa-redirect-404.js` - Post-build script to inject
redirect
- `frontend/app/app/jobs/[[...slug]]/client.tsx` - Path restoration
logic
- `frontend/package.json` - Updated build script
- `frontend/public/_redirects` - For potential Cloudflare Pages
migration

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 12:31:51 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 503a0281ae fix(video-worker): Remove duplicate PACKAGING state transition (#302)
## Summary

Removes redundant state transition call that caused "Invalid state
transition: packaging -> packaging" errors in production logs.

## Changes

- Removed duplicate `job_manager.transition_to_state()` call in
`generate_video_orchestrated()`
- The orchestrator already handles this transition in
`_run_distribution()` at line 472
- Jobs completed successfully despite the error (state machine
gracefully rejects invalid transitions)
- This fix eliminates unnecessary error noise in production logs

## Testing

- [x] Unit tests pass (1593 passed)
- [x] No E2E test changes needed (internal fix only)

## Review

- [x] Local CodeRabbit review completed
- [x] No issues found

## Root Cause

When using the orchestrator pipeline (`USE_NEW_ORCHESTRATOR=true`):
1. `video_worker_orchestrator.py:472` transitions to PACKAGING in
`_run_distribution()`
2. `video_worker.py:325` also tried to transition to PACKAGING after
distribution
3. The second call failed because job was already in PACKAGING state

@coderabbitai ignore

---
🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 11:38:16 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 0b9ca514b6 fix(cli): Fix --no-video flag to properly skip all video rendering (#301)
## Summary
- Fix `--no-video` flag to properly skip all video rendering throughout
the pipeline
- Previously the flag only affected finalisation; now it skips title/end
screens in prep and preview video in review UI
- When `--no-video` is set, artist/title are extracted from directory
name instead of video filename
- Skip video file requirements in finalisation when flag is set

## Changes
- `gen_cli.py`: Pass `render_video=not args.no_video` to KaraokePrep
- `karaoke_gen.py`: Check `self.render_video` before creating title/end
screen videos
- `lyrics_processor.py`: Set `allow_preview_video=self.render_video` in
OutputConfig
- `config.py`: Add `allow_preview_video` field to OutputConfig
- `server.py`: Check `allow_preview_video` before generating preview
video
- `karaoke_finalise.py`: Extract artist/title from directory name when
no_video=True, skip video file requirements

## Test plan
- [x] Added unit tests for --no-video flag in
`tests/unit/test_karaoke_finalise_no_video.py`
- [x] Added assertion in `test_gen_cli.py` for render_video passthrough
- [x] Updated existing tests to match new behavior
- [x] All 1593 tests pass

<!-- @coderabbitai ignore -->

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 10:00:11 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 404c6e6133 fix: make lyrics_transcriber a subpackage of karaoke_gen (#299)
## Summary
Fixes the deployment failure from PR #297 by making lyrics_transcriber a
proper subpackage of karaoke_gen instead of a separate vendored library.

### Changes
- Move `libs/lyrics_transcriber/` to `karaoke_gen/lyrics_transcriber/`
- Update all imports from `from lyrics_transcriber.X` to `from
karaoke_gen.lyrics_transcriber.X`
- Simplify Dockerfile (no separate `libs/` COPY needed)
- Update pyproject.toml to remove separate package entry
- Update test mocks and logger names

### Why this is better
- Cleaner project structure - one package containing everything
- Simpler Dockerfile - just COPY karaoke_gen/
- No confusion about vendored vs internal code

## Test plan
- [x] `poetry install` succeeds
- [x] All imports work correctly
- [x] All 2614 tests pass
- [ ] Backend deployment succeeds

@coderabbitai ignore

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 16:53:34 +00:00
Shimpei TakamatsuandAndrew Beveridge ☄️ f3ee9e05f3 feat(cli): Add --no-video flag for CDG/TXT-only generation (#288)
## Summary
- Add `--no-video` flag to skip video encoding and distribution features
- Allows CDG/TXT-only generation for faster processing (~15-20 min saved
on full songs)
- Skips: final video encoding, remuxing, YouTube upload, Discord,
rclone, brand code organization
- Still runs: audio separation, transcription, CDG/TXT package
generation

Addresses #278

## Test plan
- [x] Unit tests for `--no-video` flag handling
- [x] Integration test: `test_full_cli_integration_no_video`
- [x] Manual testing on macOS with Local Whisper

## Known Behaviors

**Preview and prep phase videos still generated:**
- Preview video (360p) - needed for Transcription Review UI (~few
seconds)
- Prep phase video (4K) - `(With Vocals).mkv` (~several seconds)
- The `--no-video` flag specifically skips **finalisation phase
encoding** (~15-20 min for full songs)

**Output format requirements:**
- When using `--no-video`, specify at least one of: `--enable_cdg` or
`--enable_txt`
- Without these, command completes but generates no output packages

## Usage Examples

```bash
# CDG only
karaoke-gen --no-video --enable_cdg audio.flac "Artist" "Title"

# CDG + TXT
karaoke-gen --no-video --enable_cdg --enable_txt audio.flac "Artist" "Title"

# With auto-download
karaoke-gen --no-video --enable_cdg --auto-download "Artist" "Title"
```

## Questions for Reviewers

1. **Video generation behavior:** Is the current behavior (generating
preview and prep phase videos) acceptable, or should we document it more
prominently in the help text?

2. **Output format requirements:** Should we add validation to require
at least one of `--enable_cdg` or `--enable_txt` when `--no-video` is
specified, or is the current behavior (completing with no output
packages) acceptable?


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **New Features**
* Added `--no-video` flag to skip video encoding and distribution steps,
enabling faster CDG/TXT-only package generation.

* **Documentation**
  * Updated README with usage example for the new `--no-video` option.

* **Tests**
* Added comprehensive integration and unit tests for the no-video
workflow.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: Andrew Beveridge ☄️ <andrew@beveridge.uk>
2026-01-19 08:20:15 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 a52ea006cb refactor: deprecate python-lyrics-transcriber, consolidate into karaoke-gen (#297)
## Summary
- Moved lyrics_transcriber from lyrics_transcriber_temp/ to libs/
- Removed obsolete standalone package files
- Updated pyproject.toml paths
- Archived python-lyrics-transcriber repo

## Test plan
- [x] poetry install succeeds
- [x] Backend tests pass (2614)
- [x] python-lyrics-transcriber archived

@coderabbitai ignore

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 08:13:52 -08:00
Andrew Beveridge ☄️andClaude 5286d7832a feat(frontend): show admin button for all jobs regardless of status (#295)
## Summary
- Admin button now visible on all jobs in Recent Jobs list, not just
completed jobs
- Allows admins to quickly access job detail page for any job in any
status (pending, processing, failed, etc.)

## Changes
- `JobCard.tsx`: Render `OutputLinks` for admins regardless of job
status
- `OutputLinks.tsx`: Separate admin link from output-dependent actions
(Email button still requires outputs)

## Test plan
- [x] Backend tests pass (1595 passed)
- [x] Frontend tests pass (181 passed)
- [x] Build succeeds
- [x] CodeRabbit review passed

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude <noreply@anthropic.com>
2026-01-19 00:55:49 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 4a0e7d4a34 fix(ci): Remove old frontend build steps after consolidation (#296)
@coderabbitai ignore

## Summary

Fixes the deployment failure that occurred after PR #267 was merged. The
CI workflow still referenced the old lyrics review (Vite) and
instrumental review (static HTML) frontend directories that were deleted
during the frontend consolidation.

## Changes

- Removed "Enable Yarn (for lyrics frontend)" step
- Removed "Build Lyrics Review Frontend (Vite)" section
- Removed "Copy Instrumental Review UI" section
- Added comment explaining the consolidation

## Test plan

- [ ] CI Gate passes (verifying the workflow syntax is correct)
- [ ] Frontend deploys successfully to GitHub Pages

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 00:41:01 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 d9484cfbaf feat(frontend): Consolidate lyrics and instrumental review UIs into main frontend (#267)
## Summary

Consolidate three separate frontends into a single unified Next.js
application that serves both cloud deployment and local CLI modes.

### Key Changes
- **Unified Frontend**: One Next.js app serves cloud
(gen.nomadkaraoke.com) and local CLI (karaoke-gen)
- **Delete Old Code**: Removed ~70k lines of legacy frontend code
- **UI Fixes**: Edit Modal, Instrumental Review, word timing, and more
- **Simplified URLs**: Direct routes (`/app/jobs/{id}/review`) instead
of complex query strings

## Changes

### Frontend Consolidation
- Add `/app/jobs/{id}/review` route for lyrics review
- Add `/app/jobs/{id}/instrumental` route for instrumental selection
- Migrate lyrics review components from MUI to Radix/Tailwind
- Convert vanilla JS instrumental review to React components
- Add local mode detection (`frontend/lib/local-mode.ts`)

### Local CLI Integration
- Package Next.js static export in `karaoke_gen/nextjs_frontend/out/`
- Update lyrics and instrumental review servers to serve unified
frontend
- Add cloud-compatible API routes (`/api/jobs/local/*`)
- Add SPA routing with Turbopack chunk injection workaround

### Deletions
- Remove `lyrics_transcriber_temp/lyrics_transcriber/frontend/` (~14k
lines)
- Remove `karaoke_gen/instrumental_review/static/index.html`

### Backend Updates
- Simplify email notification URLs to use consolidated routes
- Remove E2E bypass key (no longer needed)
- Update job notification service for new URL format

### UI Fixes
- Edit Modal: width, spacebar handler (Tap To Sync), footer layout
- Word highlight: purple color instead of grey
- Add word timing calculation
- Replace all words functionality
- Instrumental review: smooth 60fps playhead animation
- Success screen with countdown before window close

## Testing
- [x] All 1021 backend tests pass
- [x] All 181 frontend unit tests pass
- [x] Local CLI flow verified end-to-end
- [x] Lyrics review UI functional in browser
- [x] Instrumental review UI functional in browser

## Review
- [x] CodeRabbit CLI review completed locally (manual review due to file
count)
- [x] No security issues found
- [x] Test failures fixed

@coderabbitai ignore

---
🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-19 00:29:10 -08:00
Andrew Beveridge ☄️andClaude b5ca8c0c26 docs: add observability section with Cloud Trace guidance (#294)
## Summary
- Document key traced spans and what they measure
- Add investigation workflow for slow/failed operations
- Include debugging scripts reference
- Show how to add new traces to code

This documentation enables future agents to effectively use Cloud Trace
for investigating production issues.

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude <noreply@anthropic.com>
2026-01-18 23:39:06 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 19ccfb1234 fix(infra): Disable CPU throttling and add comprehensive tracing (#293)
## Summary
- Fix Cloud Run CPU throttling that was causing E2E test timeouts
(lyrics processing taking 8+ minutes instead of ~30 seconds)
- Add comprehensive OpenTelemetry tracing to lyrics_transcriber library
for Cloud Trace visibility
- Add time-based progress logging for long-running operations

## Changes
- Add `--no-cpu-throttling` flag to Cloud Run deployment
- Create `lyrics_transcriber/utils/tracing.py` module with span
utilities
- Add tracing spans to `anchor_sequence.py`, `corrector.py`, and
`agentic/agent.py`
- Add progress logging every 30 seconds during anchor search
- Safely extract word IDs to avoid potential KeyError
- Sanitize error messages in span attributes
- Update LESSONS-LEARNED.md with insights on CPU throttling and progress
logging

## Test plan
- [x] All 1595 tests pass
- [x] CodeRabbit review completed (2 issues fixed)
- [ ] After merge, verify anchor search completes in < 60 seconds via
Cloud Logging
- [ ] Verify traces appear in Cloud Trace for lyrics processing

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-18 18:17:54 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 6fa81457bd fix(e2e): Add bypass key to skip beta enrollment rate limit in tests (#291)
## Summary

- Add E2E bypass mechanism to skip IP-based rate limiting during
automated testing
- E2E Happy Path test was failing at beta enrollment because GitHub
Actions runners share IPs and hit the 1 enrollment per IP per 24h limit
- Backend now accepts `X-E2E-Bypass-Key` header to skip IP rate limiting
(keeps all other validations)

## Changes

| File | Change |
|------|--------|
| `infrastructure/modules/secrets.py` | Add `e2e-bypass-key` secret |
| `backend/config.py` | Add `e2e_bypass_key` config setting |
| `backend/api/routes/users.py` | Add bypass header check before IP rate
limit |
| `frontend/e2e/production/happy-path-real-user.spec.ts` | Add route
interception to inject bypass header |
| `.github/workflows/e2e-happy-path.yml` | Add `E2E_BYPASS_KEY` env var
|
| `.github/workflows/ci.yml` | Add secret to Cloud Run deploy and
happy-path job |

## Test plan

- [x] Backend unit tests pass locally (1595 passed)
- [ ] CI tests pass
- [ ] After merge, trigger E2E Happy Path test and verify it passes Step
2 (Beta Enrollment)
- [ ] Check backend logs for "E2E bypass key validated" message

## Security

- Secret stored in GCP Secret Manager (managed by Pulumi)
- Only valid key bypasses rate limit - invalid keys are logged as
warnings
- All other abuse prevention checks remain active (email validation, IP
blocking, normalized email dedup)

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-18 14:12:01 -08:00
Andrew Beveridge ☄️andClaude Opus 4.5 ea9a5ae66b feat(infra): Add VPC connector for Cloud Run to reach flacfetch internal IP (#290)
## Summary
- Adds VPC Serverless Connector so Cloud Run can reach flacfetch via
internal IP
- Fixes E2E prod test failures after PR #289 restricted flacfetch
firewall to Cloudflare IPs only
- Updates `flacfetch-api-url` secret to use internal IP (10.128.0.41)

## Changes
| File | Change |
|------|--------|
| `infrastructure/modules/networking.py` | New module with VPC connector
|
| `infrastructure/modules/secrets.py` | Added internal URL secret
version function |
| `infrastructure/modules/__init__.py` | Export networking module |
| `infrastructure/__main__.py` | Wire up VPC connector + secret version
|
| `.github/workflows/ci.yml` | Add `--vpc-connector` flags to deploy |

## Test plan
- [x] `pulumi preview` shows 3 new resources
- [x] `pulumi up` deployed successfully
- [x] Verified `flacfetch-api-url` secret contains internal IP
- [x] Updated Cloud Run with VPC connector
- [x] Tested audio search API - returns results successfully

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-18 21:25:31 +00:00
Andrew Beveridge ☄️andClaude Opus 4.5 b90ef4135e fix: restrict flacfetch API to Cloudflare IPs only (#289)
## Summary
- Split flacfetch firewall into two separate rules
- BitTorrent ports (51413) remain open for peer connections
- HTTP API (8080) now restricted to Cloudflare IP ranges only

This prevents direct access/abuse of the flacfetch API while allowing
access through the Cloudflare proxy at
`https://flacfetch.nomadkaraoke.com`.

## Changes
- Added `CLOUDFLARE_IP_RANGES` constant with all 15 Cloudflare IPv4
ranges
- Split `create_flacfetch_firewall()` to return two firewall rules
- Updated `__main__.py` to handle the tuple return

## Verification
- ✓ `https://flacfetch.nomadkaraoke.com/health/deep` works via
Cloudflare
- ✓ `http://104.198.214.26:8080/health/deep` is blocked (direct access)

**Already applied to prod via Pulumi** - this PR syncs git with reality.

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-17 13:07:19 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 45dbfcff7f fix(dashboard): Remove double scroll and fix slow download loading (#287)
## Summary
- Remove nested scroll container from jobs list - page now scrolls
naturally without two competing scroll areas
- Eliminate slow "Loading downloads..." by using job data directly
instead of making 2 API calls per completed job

## Test plan
- [x] Frontend tests pass (98 tests)
- [ ] Manual: Verify dashboard scrolls smoothly without nested scroll
behavior
- [ ] Manual: Verify completed jobs show download buttons instantly (no
"Loading downloads..." delay)

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-15 20:50:12 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 0204d810c2 fix(ci): Use IAP tunneling for encoding worker restart (#286)
## Summary
- Fixed encoding worker not getting updated after deployments
- The SSH restart was silently failing due to SSH key propagation delays

## Root Cause
The previous fix (PR #254) used `gcloud compute ssh` with `|| true`:
- Each CI run generates a new SSH key
- Key must propagate to VM via project metadata
- SSH often times out before propagation completes
- `|| true` hid all failures, making it appear to work

Evidence: CI logs showed "Waiting for SSH key to propagate" followed
immediately by "✅ Encoding worker restart triggered" with no actual SSH
command output.

## Changes
- Use `--tunnel-through-iap` flag for IAP tunneling
- IAP works directly with service account credentials (no SSH keys)
- Remove `|| true` to surface any failures
- Add verification step that checks encoder version after restart
- Report warning if versions don't match (but don't fail build)

## Test plan
- [x] Verified IAP tunneling works locally
- [x] Service account has `roles/iap.tunnelResourceAccessor`
- [ ] CI run will verify the fix works end-to-end

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-15 17:59:56 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 40f11c3f19 fix(gce): Pass instrumental_selection through orchestrator to GCE encoder (#285)
## Summary
- Fix bug where orchestrator path did not pass `instrumental_selection`
to GCE encoder, causing it to default to `clean` even when user selected
`with_backing`
- Add `instrumental_selection` field to `OrchestratorConfig` and
`EncodingInput` dataclasses
- Add 6 regression tests to prevent recurrence
- Document lesson learned about fixing both sides of dual code paths

## Problem
PR #271 fixed the GCE worker to READ `instrumental_selection` from
config, but only verified the legacy path (`video_worker.py`
`_encode_via_gce`) which was already SENDING it. The orchestrator path
(`encoding_interface.py`) was never updated to send it. Since
`USE_NEW_ORCHESTRATOR=true` is the production default, the bug
persisted.

## Root Cause Analysis
Two code paths exist for GCE encoding:

| Path | File | `instrumental_selection` sent? |
|------|------|-------------------------------|
| Legacy | `video_worker.py` → `_encode_via_gce()` | ✅ Yes |
| Orchestrator | `video_worker_orchestrator.py` →
`encoding_interface.py` | ❌ No (bug!) |

PR #271 only fixed the **receiving side** (GCE worker reads selection)
but missed the **sending side** (orchestrator doesn't send it).

## Solution
1. Add `instrumental_selection` field to `OrchestratorConfig` dataclass
2. Add `instrumental_selection` field to `EncodingInput` dataclass
3. Pass `instrumental_selection` in
`create_orchestrator_config_from_job()`
4. Pass `instrumental_selection` in orchestrator's `_run_encoding()`
5. Include `instrumental_selection` in `GCEEncodingBackend.encode()`
config

## Test plan
- [x] Added `test_create_config_passes_instrumental_selection`
regression test
- [x] Added `TestInstrumentalSelectionEndToEnd` test class with 5
integration tests
- [x] All new tests pass locally
- [ ] Deploy and verify affected job (a16c96f2) would use correct
instrumental

## Lesson Learned
Added to `LESSONS-LEARNED.md`:
> **Fix Both Sides of Dual Code Paths**: When fixing a bug in a system
with multiple code paths (e.g., legacy vs orchestrator), verify ALL
paths are fixed. Write integration tests that cover each path.

@coderabbitai ignore

---
🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-15 16:10:47 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 ac811d598b fix(auth): Remove token expiry for review/instrumental tokens (#284)
## Summary
- Remove 48-hour expiry from review and instrumental tokens
- Tokens are job-scoped (low risk) and become useless when job completes
anyway
- Frontend: prefer full auth token from localStorage for audio elements
(defense-in-depth)

## Problem
Users were getting 401 errors on review/instrumental pages when tokens
expired after 48 hours:
- `https://gen.nomadkaraoke.com/instrumental/?...` - audio wouldn't load
- `https://gen.nomadkaraoke.com/lyrics/?...` - page wouldn't load

## Root Cause
Both `review_token` and `instrumental_token` had 48-hour expiry, but
users often don't complete reviews within that window.

## Solution
Since these tokens are:
1. **Job-scoped** - can only access one specific job
2. **Non-destructive** - only used for reviewing/selecting, not creating
or deleting
3. **Naturally expiring** - become useless once job completes

There's no security benefit to expiring them. Removed expiry and added
frontend fallback to use full auth token when available.

## Test plan
- [x] Backend tests pass (1590 passed)
- [x] Frontend tests pass (181 passed)
- [x] Cleared expiry on affected jobs in prod - user to verify pages
work
- [ ] Verify instrumental review page loads:
https://gen.nomadkaraoke.com/instrumental/?baseApiUrl=https%3A%2F%2Fapi.nomadkaraoke.com%2Fapi%2Fjobs%2F7b5b21c1&instrumentalToken=Fh_RdPJz-PZ1jxOaJrwBVHufw_4OhtuN4PAWtIMLB0o
- [ ] Verify lyrics review page loads:
https://gen.nomadkaraoke.com/lyrics//?baseApiUrl=https%3A%2F%2Fapi.nomadkaraoke.com%2Fapi%2Freview%2F8a5b3822&reviewToken=wSvPSoG537CKv45DNw_lSgQggTU2D-818UYIp64MRSE

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-15 15:47:32 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 9426c8427e feat(infra): make GitHub runners org-wide (#283)
## Summary
- Change GitHub Actions runner registration from repository-level to
organization-level
- All 20 runners will now be available to any repo in the `nomadkaraoke`
org, not just karaoke-gen

## Changes
- Update registration API endpoint from
`/repos/nomadkaraoke/karaoke-gen/...` to `/orgs/nomadkaraoke/...`
- Update runner URL from `https://github.com/nomadkaraoke/karaoke-gen`
to `https://github.com/nomadkaraoke`
- Document `admin:org` PAT scope requirement in README (existing PAT
already has this scope)

## Test plan
- [ ] Merge PR and let Pulumi update infrastructure
- [ ] Restart runner VMs to re-register at org level
- [ ] Verify runners appear at
https://github.com/organizations/nomadkaraoke/settings/actions/runners
- [ ] Test workflow runs from another nomadkaraoke repo

## Post-deployment steps
After merge, restart VMs to re-register:
```bash
for i in {1..20}; do
  gcloud compute instances reset github-runner-$i --zone=us-central1-a
done
```

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-14 22:11:42 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 0a2f99bc5d chore: trigger deployment (#282)
Empty commit to trigger fresh deployment after GitHub Pages artifact
conflict.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

## Release Notes

* **New Features**
* Enhanced authentication flow with automatic fallback between multiple
authentication methods, preventing logged-in users from being
interrupted when temporary credentials expire and improving access
continuity.

* **Documentation**
* Updated lessons learned guide with best practices for authentication
token management, including recommended prioritization strategies and
fallback approaches for standalone applications.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-13 11:27:07 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 1686c2afc6 fix(instrumental): Use localStorage auth token when available (#281)
## Summary

Fixes 401 errors on the instrumental selection page when users return
after the 48-hour magic link token has expired.

- The instrumental review page now checks localStorage for user auth
token before falling back to the URL token
- Logged-in users will always be able to access their jobs' instrumental
selection

## Changes

- Added `fullAuthToken` check from
`localStorage.getItem('karaoke_access_token')`
- Created `authFetch()` helper with priority: full auth (Bearer header)
> instrumental token (query param)
- Updated all 5 fetch calls to use `authFetch()`
- Added lesson learned to documentation

## Testing

- [x] All 98 tests pass (`make test`)
- [x] CodeRabbit CLI review completed locally

## Review

- [x] Local CodeRabbit review completed
- [x] Review feedback addressed (none found)

@coderabbitai ignore

---
🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-13 10:48:19 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 49fef0d209 fix(admin): Fix impersonate button not working due to AuthResult subscripting (#280)
## Summary

- Fixed impersonate button returning 500 error due to incorrect
AuthResult access
- Backend was using `auth_data[0]` but AuthResult doesn't support
subscripting
- Added loading indicator and error feedback for better UX

## Changes

### Backend
- Changed `auth_data[0]` to `auth_data.user_email` in impersonate
endpoint
- Fixed type hint from `Tuple[str, UserType, int]` to `AuthResult`
- Updated test mocks to return `AuthResult` instead of tuple

### Frontend
- Added loading spinner on impersonate button during API call
- Added toast notification when impersonation fails (previously silent
failure)
- Added E2E test for impersonate button click functionality

## Test plan

- [x] Backend unit tests pass (1590 passed)
- [x] Frontend E2E tests pass (98 passed)
- [x] Impersonation-specific tests pass
- [ ] Manual test: Click impersonate button in admin panel
- [ ] Verify redirect to /app as impersonated user
- [ ] Verify impersonation banner shows

🤖 Generated with [Claude Code](https://claude.ai/code)

@coderabbitai ignore

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-13 05:29:26 +00:00
Andrew Beveridge ☄️andClaude Opus 4.5 0c4e946bb8 fix(gce): Use version sort for wheel selection in encoding worker (#277)
## Summary
- Fixed encoding worker startup script to use version sort (`sort -V`)
instead of time sort (`ls -t`) when selecting the wheel to install
- All wheels download simultaneously with identical timestamps, so time
sort picked arbitrarily (0.99.9) instead of the latest (0.105.0)
- Fixed zone references in CLAUDE.md and infrastructure/README.md
(us-central1-a → us-central1-c)
- Added lesson learned about version sorting for artifact selection

## Test plan
- [x] Shell script syntax validated
- [x] Manually verified fix on running VM - worker now reports version
0.105.0
- [ ] Future restarts will correctly select highest version wheel

🤖 Generated with [Claude Code](https://claude.com/claude-code)

@coderabbitai ignore

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-11 10:39:31 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 082d36a3c9 fix(pwa): Add service worker file that was gitignored (#276)
## Summary
- Adds the service worker file that was previously gitignored
- Updates gitignore to allow sw.js (hand-written) while still ignoring
auto-generated PWA files

## Context
The sw.js service worker file was created in PR #274 but was blocked
from being tracked by a gitignore rule meant for auto-generated PWA
files. Without this file, push notifications cannot work because the
browser has no service worker to receive push events.

## Test plan
- [ ] CI passes
- [ ] `curl https://gen.nomadkaraoke.com/sw.js` returns JavaScript after
deploy

@coderabbitai ignore

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-10 18:14:51 -05:00
Andrew Beveridge ☄️andClaude Opus 4.5 402eb9d86b fix(docker): Add missing backend directory to Dockerfile.base (#275)
## Summary
- Fixes Docker base image build failure by adding missing `backend`
directory to COPY command

## Context
The `backend` package was previously added to `pyproject.toml` packages
list but `Dockerfile.base` wasn't updated to copy the directory. This
caused the editable install to fail with:

```
ValueError: /app/backend does not contain any element
```

This was discovered when the push notifications PR (#274) triggered a
base image rebuild.

## Test plan
- [ ] CI passes (specifically Deploy - Backend job should succeed now)

@coderabbitai ignore

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-10 17:38:26 -05:00
798 changed files with 21041 additions and 243896 deletions

No files matched your search

@@ -0,0 +1,204 @@
# Plan: Deprecate python-lyrics-transcriber and Consolidate into karaoke-gen
**Created:** 2026-01-19
**Branch:** feat/sess-20260117-1643-deprecate-lyrics-transcriber
**Status:** Draft
## Overview
The python-lyrics-transcriber project was originally a standalone PyPI package. It was vendored into karaoke-gen as `lyrics_transcriber_temp/` to enable faster iteration. Now that the frontend has been consolidated into karaoke-gen (lyrics review UI is part of the main frontend), maintaining lyrics-transcriber as a separate project no longer makes sense.
This plan covers:
1. Updating the python-lyrics-transcriber README to redirect to karaoke-gen
2. Archiving the GitHub repo
3. Deprecating the PyPI package (via README update published as final version)
4. Reorganizing vendored code to a permanent location in karaoke-gen
5. Cleaning up unnecessary files (pyproject.toml, docs/, tests/, etc. that only made sense for a standalone package)
## Requirements
- [ ] python-lyrics-transcriber GitHub repo README updated with deprecation notice
- [ ] python-lyrics-transcriber GitHub repo archived
- [ ] Final PyPI release with deprecation notice in README
- [ ] Vendored code moved from `lyrics_transcriber_temp/` to `libs/lyrics_transcriber/`
- [ ] Unnecessary package files removed (pyproject.toml, poetry.lock, .github/, docs/, tests/, scripts/, specs/, .cursor/, .specify/)
- [ ] All import paths continue to work (Python allows `libs/lyrics_transcriber/lyrics_transcriber/` path)
- [ ] Tests pass after reorganization
- [ ] karaoke-gen pyproject.toml updated for new path
## Technical Approach
### New Path Structure
Move the vendored code to `libs/lyrics_transcriber/`:
```
karaoke-gen/
├── libs/
│ └── lyrics_transcriber/ # Just the Python package (was lyrics_transcriber_temp/lyrics_transcriber/)
│ ├── __init__.py
│ ├── cli/
│ ├── core/
│ ├── correction/
│ ├── lyrics/
│ ├── output/
│ ├── review/
│ ├── storage/
│ ├── transcribers/
│ ├── types.py
│ └── utils/
├── karaoke_gen/
├── backend/
├── frontend/
└── ...
```
### Why `libs/lyrics_transcriber/` instead of alternatives?
1. **`libs/`** - Clear convention for vendored/embedded libraries, separate from main codebase
2. **Single level** - `lyrics_transcriber` directly under `libs/`, not nested (no `libs/lyrics_transcriber/lyrics_transcriber/`)
3. **Clean imports** - `from karaoke_gen.lyrics_transcriber.core import ...` continues to work with proper Poetry config
### pyproject.toml Changes
```toml
packages = [
{ include = "karaoke_gen" },
{ include = "lyrics_transcriber", from = "libs" }, # Changed from lyrics_transcriber_temp
{ include = "backend" }
]
include = [
"karaoke_gen/nextjs_frontend/out",
"karaoke_gen/nextjs_frontend/out/**/*",
"libs/lyrics_transcriber/output/fonts/*", # Updated path
"libs/lyrics_transcriber/output/cdgmaker/images/*",
"libs/lyrics_transcriber/output/cdgmaker/transitions/*"
]
```
### Files to Remove from Vendored Code
From current `lyrics_transcriber_temp/`:
- `pyproject.toml` - Package config for standalone release
- `poetry.lock` - Lock file for standalone package
- `README.md` - Will be replaced by deprecation notice
- `LICENSE` - Keep MIT license in karaoke-gen root (already there)
- `Dockerfile` - Standalone container build
- `.github/` - CI/CD for standalone package
- `.cursor/` - Cursor AI config
- `.specify/` - Specify config
- `.gitignore` - Not needed (karaoke-gen has its own)
- `docs/` - Old documentation (karaoke-gen has consolidated docs)
- `scripts/` - Development scripts for standalone package
- `specs/` - Specification files
- `tests/` - Tests will need to be migrated or removed (see Testing Strategy)
**Keep only:** The actual `lyrics_transcriber/` Python package directory.
## Implementation Steps
### Phase 1: Update and Archive External Project (Manual Steps)
1. [ ] Clone python-lyrics-transcriber repo locally
2. [ ] Create deprecation notice README:
```markdown
# python-lyrics-transcriber (DEPRECATED)
**This project has been deprecated and archived.**
The lyrics transcription functionality has been consolidated into [karaoke-gen](https://github.com/nomadkaraoke/karaoke-gen).
## Migration
For karaoke video generation with synchronized lyrics:
- Use [karaoke-gen](https://github.com/nomadkaraoke/karaoke-gen) - the complete solution
- Web app: https://gen.nomadkaraoke.com
## Historical Context
This library was originally developed as a standalone tool for creating synchronized
lyrics files. It has now been integrated into the karaoke-gen platform which provides
a complete end-to-end solution for karaoke video generation.
The last standalone version was 0.81.0. No further releases will be made to PyPI.
```
3. [ ] Publish final PyPI version (0.82.0) with deprecation notice
4. [ ] Archive the GitHub repository via `gh repo archive nomadkaraoke/python-lyrics-transcriber`
### Phase 2: Reorganize Vendored Code in karaoke-gen
5. [ ] Create `libs/` directory
6. [ ] Move `lyrics_transcriber_temp/lyrics_transcriber/` to `libs/lyrics_transcriber/`
7. [ ] Remove `lyrics_transcriber_temp/` directory (with all its extra files)
8. [ ] Update `pyproject.toml` packages and include paths
9. [ ] Update the one script that references `lyrics_transcriber_temp` directly:
- `scripts/benchmark_encoding.py` line 232: change `from lyrics_transcriber_temp.lyrics_transcriber.output.video` to `from karaoke_gen.lyrics_transcriber.output.video`
### Phase 3: Verify and Test
10. [ ] Run `poetry install` to verify package configuration
11. [ ] Run `make test` to ensure all tests pass
12. [ ] Verify imports work:
```python
from karaoke_gen.lyrics_transcriber.core.controller import LyricsControllerResult
from karaoke_gen.lyrics_transcriber.output.generator import OutputGenerator
from karaoke_gen.lyrics_transcriber.types import CorrectionResult
```
### Phase 4: Handle Tests from lyrics_transcriber
13. [ ] Evaluate lyrics_transcriber tests:
- **74 test files** in `lyrics_transcriber_temp/tests/`
- These test the internal lyrics_transcriber library functionality
- Decision: Move critical tests to `tests/unit/lyrics_transcriber/` in karaoke-gen
- Skip integration/performance/manual tests that were for standalone development
## Files to Create/Modify
| File | Action | Description |
|------|--------|-------------|
| `libs/lyrics_transcriber/` | Create (move) | New location for lyrics_transcriber package |
| `lyrics_transcriber_temp/` | Delete | Remove old vendored location |
| `pyproject.toml` | Modify | Update package paths |
| `scripts/benchmark_encoding.py` | Modify | Update import path |
| `tests/unit/lyrics_transcriber/` | Create | Migrate critical tests (optional) |
## Testing Strategy
### Immediate Testing
- Run `make test` after reorganization - all existing tests must pass
- Verify Poetry can build/install the package correctly
### Test Migration Decision
The vendored `lyrics_transcriber_temp/tests/` contains 74 test files covering:
- `unit/correction/` - Correction logic tests (important)
- `unit/lyrics/` - Lyrics provider tests
- `unit/review/` - Review server tests (less relevant - frontend consolidated)
- `integration/` - Integration tests
- `performance/` - Performance benchmarks
**Recommendation:** Migrate a subset of critical unit tests, particularly:
- `test_corrector.py` - Core correction logic
- `test_anchor_sequence*.py` - Anchor sequence matching
- Handler tests in `handlers/`
This keeps karaoke-gen's test suite focused while preserving coverage of critical functionality.
## Open Questions
- [x] Should lyrics_transcriber tests be migrated? **Recommendation: Migrate critical unit tests only**
- [x] What's the best path for vendored code? **Answer: `libs/lyrics_transcriber/`**
- [ ] Should we publish a final deprecation release to PyPI before archiving? **Recommended: Yes, with deprecation notice**
## Rollback Plan
If issues arise:
1. Git revert the consolidation commits
2. `lyrics_transcriber_temp/` can be restored from git history
3. The external python-lyrics-transcriber repo can be unarchived if needed
## Notes
- The import paths like `from karaoke_gen.lyrics_transcriber.core import ...` will continue to work unchanged
- Only the internal project structure changes, not the API
- This is primarily a cleanup/organization task with some external repo admin work
+42 -41
View File
@@ -252,6 +252,7 @@ jobs:
TESTMAIL_NAMESPACE: ${{ secrets.TESTMAIL_NAMESPACE }}
E2E_TEST_TOKEN: ${{ secrets.E2E_TEST_TOKEN }}
E2E_ADMIN_TOKEN: ${{ secrets.E2E_ADMIN_TOKEN }}
E2E_BYPASS_KEY: ${{ secrets.E2E_BYPASS_KEY }}
run: |
echo "Starting E2E Happy Path Test against Production"
echo "Time: $(date)"
@@ -865,51 +866,23 @@ jobs:
cache: 'npm'
cache-dependency-path: frontend/package-lock.json
- name: Enable Yarn (for lyrics frontend)
run: corepack enable
# ===== Build Main Frontend (Next.js) =====
- name: Install main frontend dependencies
# ===== Build Unified Frontend (Next.js) =====
# NOTE: Lyrics review and instrumental review UIs were consolidated into
# the main Next.js frontend (PR #267, Jan 2025). The unified frontend
# serves all three UIs from a single codebase at:
# - / (main app)
# - /app/jobs/{id}/lyrics (lyrics review)
# - /app/jobs/{id}/instrumental (instrumental review)
- name: Install frontend dependencies
working-directory: frontend
run: npm ci --legacy-peer-deps
- name: Build main frontend (Next.js static export)
- name: Build frontend (Next.js static export)
working-directory: frontend
env:
NEXT_PUBLIC_API_URL: https://api.nomadkaraoke.com
run: npm run build
# ===== Build Lyrics Review Frontend (Vite) =====
- name: Cache Yarn dependencies (lyrics frontend)
uses: actions/cache@v4
with:
path: lyrics_transcriber_temp/lyrics_transcriber/frontend/node_modules
key: yarn-lyrics-${{ runner.os }}-${{ hashFiles('lyrics_transcriber_temp/lyrics_transcriber/frontend/yarn.lock') }}
restore-keys: |
yarn-lyrics-${{ runner.os }}-
- name: Install lyrics frontend dependencies
working-directory: lyrics_transcriber_temp/lyrics_transcriber/frontend
run: yarn install --frozen-lockfile
- name: Build lyrics frontend (Vite)
working-directory: lyrics_transcriber_temp/lyrics_transcriber/frontend
env:
# Set base path for subpath deployment
VITE_BASE_PATH: /lyrics/
run: yarn build --base=/lyrics/
- name: Copy lyrics frontend to main output
run: |
mkdir -p frontend/out/lyrics
cp -r lyrics_transcriber_temp/lyrics_transcriber/frontend/dist/* frontend/out/lyrics/
# ===== Copy Instrumental Review UI (Static HTML) =====
- name: Copy instrumental review UI to main output
run: |
mkdir -p frontend/out/instrumental
cp karaoke_gen/instrumental_review/static/index.html frontend/out/instrumental/
- name: Setup Pages
uses: actions/configure-pages@v4
@@ -1022,9 +995,34 @@ jobs:
- name: Restart GCE Encoding Worker
run: |
echo "🔄 Restarting encoding worker to pick up new wheel..."
gcloud compute ssh encoding-worker --zone=us-central1-c --project=nomadkaraoke \
--command="sudo systemctl restart encoding-worker" || true
echo "✅ Encoding worker restart triggered"
# Use IAP tunneling - works directly with service account credentials
# (avoids SSH key propagation delays that cause silent failures)
gcloud compute ssh encoding-worker \
--zone=us-central1-c \
--project=nomadkaraoke \
--tunnel-through-iap \
--command="sudo systemctl restart encoding-worker"
echo "⏳ Waiting for service to start..."
sleep 15
# Verify the restart worked by checking the wheel version
NEW_VERSION=$(gcloud compute ssh encoding-worker \
--zone=us-central1-c \
--project=nomadkaraoke \
--tunnel-through-iap \
--command="curl -s http://localhost:8080/health | grep -o '\"wheel_version\":\"[^\"]*\"' | cut -d'\"' -f4")
EXPECTED_VERSION=$(cat pyproject.toml | grep 'version = ' | head -1 | cut -d'"' -f2)
if [ "$NEW_VERSION" = "$EXPECTED_VERSION" ]; then
echo "✅ Encoding worker restarted successfully (v$NEW_VERSION)"
else
echo "⚠️ Version mismatch: encoder has v$NEW_VERSION, expected v$EXPECTED_VERSION"
echo " This may indicate the restart failed or the wheel wasn't downloaded"
# Don't fail the build - the encoder will still work, just with old version
fi
- name: Configure Docker for Artifact Registry
run: gcloud auth configure-docker ${{ env.REGISTRY }} --quiet
@@ -1166,13 +1164,16 @@ jobs:
--memory 16Gi \
--cpu 8 \
--cpu-boost \
--no-cpu-throttling \
--execution-environment gen2 \
--timeout 1800 \
--concurrency 1 \
--max-instances 50 \
--min-instances 4 \
--vpc-connector projects/nomadkaraoke/locations/us-central1/connectors/cloud-run-connector \
--vpc-egress private-ranges-only \
--set-env-vars "GOOGLE_CLOUD_PROJECT=${{ env.PROJECT_ID }},GCS_BUCKET_NAME=karaoke-gen-storage-${{ env.PROJECT_ID }},FIRESTORE_COLLECTION=jobs,ENVIRONMENT=production,AUDIO_SEPARATOR_API_URL=https://nomadkaraoke--audio-separator-api.modal.run,KARAOKE_GEN_VERSION=$VERSION,DEFAULT_DROPBOX_PATH=/MediaUnsynced/Karaoke/Tracks-Organized,DEFAULT_GDRIVE_FOLDER_ID=1laRKAyxo0v817SstfM5XkpbWiNKNAMSX,ENABLE_CLOUD_TASKS=true,CLOUD_RUN_SERVICE_URL=https://api.nomadkaraoke.com,GCP_REGION=us-central1,DEFAULT_ENABLE_YOUTUBE_UPLOAD=true,DEFAULT_BRAND_PREFIX=NOMAD,USE_GCE_ENCODING=true,USE_GCE_PREVIEW_ENCODING=true,ENABLE_PUSH_NOTIFICATIONS=true" \
--set-secrets "AUDIOSHAKE_API_TOKEN=audioshake-api-key:latest,GENIUS_API_TOKEN=genius-api-key:latest,SPOTIFY_COOKIE_SP_DC=spotify-cookie:latest,RAPIDAPI_KEY=rapidapi-key:latest,DEFAULT_DISCORD_WEBHOOK_URL=discord-releases-webhook:latest,ADMIN_TOKENS=admin-tokens:latest,RED_API_KEY=red-api-key:latest,RED_API_URL=red-api-url:latest,OPS_API_KEY=ops-api-key:latest,OPS_API_URL=ops-api-url:latest,FLACFETCH_API_URL=flacfetch-api-url:latest,FLACFETCH_API_KEY=flacfetch-api-key:latest,SENDGRID_API_KEY=sendgrid-api-key:latest,STRIPE_SECRET_KEY=stripe-secret-key:latest,STRIPE_WEBHOOK_SECRET=stripe-webhook-secret:latest,LANGFUSE_PUBLIC_KEY=langfuse-public-key:latest,LANGFUSE_SECRET_KEY=langfuse-secret-key:latest,LANGFUSE_HOST=langfuse-host:latest,ENCODING_WORKER_URL=encoding-worker-url:latest,ENCODING_WORKER_API_KEY=encoding-worker-api-key:latest,VAPID_PUBLIC_KEY=vapid-public-key:latest,VAPID_PRIVATE_KEY=vapid-private-key:latest"
--set-secrets "AUDIOSHAKE_API_TOKEN=audioshake-api-key:latest,GENIUS_API_TOKEN=genius-api-key:latest,SPOTIFY_COOKIE_SP_DC=spotify-cookie:latest,RAPIDAPI_KEY=rapidapi-key:latest,DEFAULT_DISCORD_WEBHOOK_URL=discord-releases-webhook:latest,ADMIN_TOKENS=admin-tokens:latest,RED_API_KEY=red-api-key:latest,RED_API_URL=red-api-url:latest,OPS_API_KEY=ops-api-key:latest,OPS_API_URL=ops-api-url:latest,FLACFETCH_API_URL=flacfetch-api-url:latest,FLACFETCH_API_KEY=flacfetch-api-key:latest,SENDGRID_API_KEY=sendgrid-api-key:latest,STRIPE_SECRET_KEY=stripe-secret-key:latest,STRIPE_WEBHOOK_SECRET=stripe-webhook-secret:latest,LANGFUSE_PUBLIC_KEY=langfuse-public-key:latest,LANGFUSE_SECRET_KEY=langfuse-secret-key:latest,LANGFUSE_HOST=langfuse-host:latest,ENCODING_WORKER_URL=encoding-worker-url:latest,ENCODING_WORKER_API_KEY=encoding-worker-api-key:latest,VAPID_PUBLIC_KEY=vapid-public-key:latest,VAPID_PRIVATE_KEY=vapid-private-key:latest,E2E_BYPASS_KEY=e2e-bypass-key:latest"
- name: Verify deployment and version
run: |
+1
View File
@@ -74,6 +74,7 @@ jobs:
TESTMAIL_NAMESPACE: ${{ secrets.TESTMAIL_NAMESPACE }}
E2E_TEST_TOKEN: ${{ inputs.use_test_token && secrets.E2E_TEST_TOKEN || '' }}
E2E_ADMIN_TOKEN: ${{ secrets.E2E_ADMIN_TOKEN }}
E2E_BYPASS_KEY: ${{ secrets.E2E_BYPASS_KEY }}
DEBUG_MODE: ${{ inputs.debug_mode || 'false' }}
run: |
echo "Starting E2E Happy Path Test"
+1 -2
View File
@@ -58,8 +58,7 @@ frontend/.eslintcache
# Storybook
frontend/storybook-static/
# PWA files
frontend/**/public/sw.js
# PWA auto-generated files (our sw.js is hand-written and should be tracked)
frontend/**/public/workbox-*.js
frontend/**/public/swe-worker-*.js
+26 -2
View File
@@ -60,6 +60,30 @@ This single command:
**All tests must pass.** Don't dismiss failures as "pre-existing" - investigate and fix them.
### Testing in Production (for Agents)
When asked to "test it yourself in prod" or verify a fix in production:
```bash
# Get admin token
export KARAOKE_ADMIN_TOKEN=$(gcloud secrets versions access latest --secret=admin-tokens --project=nomadkaraoke | cut -d',' -f1)
# Option 1: Use the debug template directly
cd frontend && node e2e/helpers/debug-prod-template.mjs
# Option 2: Copy template for customization (gitignored)
cp frontend/e2e/helpers/debug-prod-template.mjs frontend/test-my-issue.local.mjs
# Edit the script, then run it
node test-my-issue.local.mjs
# Option 3: Run existing production E2E tests
KARAOKE_ADMIN_TOKEN=$KARAOKE_ADMIN_TOKEN npx playwright test e2e/production/admin-dashboard.spec.ts
```
Files matching `test-*.local.*` and `debug-*.local.*` are gitignored - you can hardcode tokens in them safely.
See `docs/TESTING.md` § "Ad-Hoc Production Debugging" for full details.
### Version Bumping
- Bump `tool.poetry.version` in `pyproject.toml` for code changes
- Skip for docs-only changes
@@ -105,11 +129,11 @@ EOF
### GCE Encoding Worker
```bash
# SSH to restart service (clears in-memory job queue)
gcloud compute ssh encoding-worker --zone=us-central1-a --project=nomadkaraoke \
gcloud compute ssh encoding-worker --zone=us-central1-c --project=nomadkaraoke \
--command="sudo systemctl restart encoding-worker"
# Check health
gcloud compute ssh encoding-worker --zone=us-central1-a --project=nomadkaraoke \
gcloud compute ssh encoding-worker --zone=us-central1-c --project=nomadkaraoke \
--command="curl -s http://localhost:8080/health"
```
+3
View File
@@ -159,6 +159,9 @@ karaoke-gen --style_params_json="./styles.json" "Artist" "Title"
# Generate CDG and TXT packages
karaoke-gen --enable_cdg --enable_txt "Artist" "Title"
# Skip video encoding (CDG/TXT only, faster)
karaoke-gen --no-video --enable_cdg "Artist" "Title"
# YouTube upload
karaoke-gen --enable_youtube_upload --youtube_description_file="./desc.txt" "Artist" "Title"
+2 -3
View File
@@ -22,10 +22,9 @@ WORKDIR /app
COPY backend /app/backend
# Copy and reinstall karaoke_gen from local source
# This ensures new modules (like style_loader.py) are included without rebuilding base image
# Note: lyrics_transcriber is vendored in lyrics_transcriber_temp/ and bundled via pyproject.toml
# This ensures new modules are included without rebuilding base image
# Note: lyrics_transcriber is now a subpackage of karaoke_gen
COPY karaoke_gen /app/karaoke_gen
COPY lyrics_transcriber_temp /app/lyrics_transcriber_temp
COPY pyproject.toml README.md LICENSE /app/
RUN pip install --no-cache-dir -e .
+1
View File
@@ -54,6 +54,7 @@ WORKDIR /app
COPY pyproject.toml README.md LICENSE /app/
COPY karaoke_gen /app/karaoke_gen
COPY lyrics_transcriber_temp /app/lyrics_transcriber_temp
COPY backend /app/backend
# Install all Python dependencies (the slow part - cached in base image)
RUN pip install --no-cache-dir --upgrade pip && \
+39 -23
View File
@@ -808,23 +808,35 @@ def _extract_files_recursive(
expiration_minutes=expiration_minutes,
)
files.extend(nested_files)
elif isinstance(value, str) and value.startswith("gs://"):
# GCS path - generate signed URL
try:
signed_url = storage.generate_signed_url(value, expiration_minutes=expiration_minutes)
# Extract filename from path
name = value.split("/")[-1] if "/" in value else value
files.append(FileInfo(
name=name,
path=value,
download_url=signed_url,
category=category,
file_key=key,
))
except Exception as e:
# Log but don't fail - file might not exist
logger.warning(f"Failed to generate signed URL for {value}: {e}")
# Skip non-GCS values (e.g., youtube URLs, video IDs)
elif isinstance(value, str):
# Check if it's a GCS path (gs:// URI or relative path starting with "jobs/")
# Skip non-GCS values like YouTube URLs, video IDs, etc.
blob_path = None
if value.startswith("gs://"):
# Full GCS URI - extract blob path after bucket name
# Format: gs://bucket-name/path/to/file
parts = value.replace("gs://", "").split("/", 1)
if len(parts) > 1:
blob_path = parts[1]
elif value.startswith("jobs/"):
# Relative path within bucket - use directly
blob_path = value
if blob_path:
try:
signed_url = storage.generate_signed_url(blob_path, expiration_minutes=expiration_minutes)
# Extract filename from path
name = blob_path.split("/")[-1] if "/" in blob_path else blob_path
files.append(FileInfo(
name=name,
path=value,
download_url=signed_url,
category=category,
file_key=key,
))
except Exception as e:
# Log but don't fail - file might not exist
logger.warning(f"Failed to generate signed URL for {value}: {e}")
return files
@@ -858,10 +870,14 @@ async def get_job_files(
raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
# Extract all files with signed URLs
storage = StorageService()
file_urls = job.file_urls or {}
files = _extract_files_recursive(file_urls, storage)
try:
storage = StorageService()
file_urls = job.file_urls or {}
files = _extract_files_recursive(file_urls, storage)
except Exception as e:
# Log but don't fail - return empty list if file extraction fails
logger.error(f"Failed to extract files for job {job_id}: {e}")
files = []
return JobFilesResponse(
job_id=job.job_id,
@@ -1509,7 +1525,7 @@ class ImpersonateUserResponse(BaseModel):
@router.post("/users/{email}/impersonate", response_model=ImpersonateUserResponse)
async def impersonate_user(
email: str,
auth_data: Tuple[str, UserType, int] = Depends(require_admin),
auth_data: AuthResult = Depends(require_admin),
user_service: UserService = Depends(get_user_service),
):
"""
@@ -1531,7 +1547,7 @@ async def impersonate_user(
user_email: The impersonated user's email
message: Success message
"""
admin_email = auth_data[0]
admin_email = auth_data.user_email or "unknown"
target_email = email.lower()
# Cannot impersonate yourself
+3 -3
View File
@@ -33,9 +33,9 @@ from backend.services.auth_service import UserType
from backend.config import get_settings
# LyricsTranscriber imports for preview generation
from lyrics_transcriber.types import CorrectionResult
from lyrics_transcriber.core.config import OutputConfig
from lyrics_transcriber.correction.operations import CorrectionOperations
from karaoke_gen.lyrics_transcriber.types import CorrectionResult
from karaoke_gen.lyrics_transcriber.core.config import OutputConfig
from karaoke_gen.lyrics_transcriber.correction.operations import CorrectionOperations
# Import from the unified style loader
from karaoke_gen.style_loader import load_styles_from_gcs
+14 -3
View File
@@ -858,8 +858,19 @@ async def enroll_beta_tester(
detail="Access denied from this location"
)
# 3. Check IP-based enrollment rate limit (1 per 24h per IP)
if ip_address:
# 3. Check for E2E test bypass (allows automated testing to skip IP rate limit)
from backend.config import settings
e2e_bypass_key = http_request.headers.get("X-E2E-Bypass-Key")
skip_ip_rate_limit = False
if e2e_bypass_key and settings.e2e_bypass_key:
if e2e_bypass_key == settings.e2e_bypass_key:
logger.info(f"Beta enrollment: E2E bypass key validated for {_mask_email(email)}")
skip_ip_rate_limit = True
else:
logger.warning(f"Beta enrollment: Invalid E2E bypass key attempted for {_mask_email(email)}")
# 4. Check IP-based enrollment rate limit (1 per 24h per IP)
if ip_address and not skip_ip_rate_limit:
allowed, remaining, message = rate_limit_service.check_beta_ip_limit(ip_address)
if not allowed:
logger.warning(f"Beta enrollment rejected - IP rate limit: {ip_address} - {message}")
@@ -868,7 +879,7 @@ async def enroll_beta_tester(
detail="Too many beta enrollments from your location. Please try again tomorrow."
)
# 4. Check for duplicate enrollment via normalized email
# 5. Check for duplicate enrollment via normalized email
normalized_email = email_validation.normalize_email(email)
if normalized_email != email:
# Check if normalized version is already enrolled
+3
View File
@@ -111,6 +111,9 @@ class Settings(BaseSettings):
rate_limit_youtube_uploads_per_day: int = int(os.getenv("RATE_LIMIT_YOUTUBE_UPLOADS_PER_DAY", "10"))
# Maximum beta enrollments from same IP per day (0 = unlimited)
rate_limit_beta_ip_per_day: int = int(os.getenv("RATE_LIMIT_BETA_IP_PER_DAY", "1"))
# E2E test bypass key for rate limiting (set via secret in production)
e2e_bypass_key: str = os.getenv("E2E_BYPASS_KEY", "")
default_youtube_description: str = os.getenv(
"DEFAULT_YOUTUBE_DESCRIPTION",
"Karaoke video created with Nomad Karaoke (https://nomadkaraoke.com)\n\n"
+18 -2
View File
@@ -15,6 +15,7 @@ from backend.services.nltk_preloader import preload_all_nltk_resources
from backend.services.langfuse_preloader import preload_langfuse_handler
from backend.middleware.audit_logging import AuditLoggingMiddleware
from backend.middleware.tenant import TenantMiddleware
from backend.workers.registry import worker_registry
from backend.version import VERSION
@@ -100,8 +101,23 @@ async def lifespan(app: FastAPI):
logger.error(f"Credential validation failed: {e}")
yield
# Shutdown
# Shutdown - wait for any active workers to complete before terminating
# This prevents Cloud Run from killing workers mid-processing
logger.info("Shutdown requested, checking for active workers...")
if worker_registry.has_active_workers():
active = worker_registry.get_active_workers()
logger.info(f"Active workers found: {active}")
logger.info("Waiting for workers to complete (timeout: 600s)...")
completed = await worker_registry.wait_for_completion(timeout=600) # 10 min max
if not completed:
logger.error(
"Shutdown timeout - some workers may not have completed cleanly. "
f"Remaining workers: {worker_registry.get_active_workers()}"
)
else:
logger.info("No active workers, proceeding with shutdown")
logger.info("Shutting down karaoke generation backend")
+4
View File
@@ -40,6 +40,9 @@ class EncodingInput:
# Output directory
output_dir: str = ""
# Instrumental selection (clean, with_backing, or custom)
instrumental_selection: str = "clean"
# Additional options
options: Dict[str, Any] = field(default_factory=dict)
@@ -328,6 +331,7 @@ class GCEEncodingBackend(EncodingBackend):
"formats": ["mp4_4k_lossless", "mp4_4k_lossy", "mkv_4k", "mp4_720p"],
"artist": input_config.artist,
"title": input_config.title,
"instrumental_selection": input_config.instrumental_selection,
}
# Submit and wait for completion
+9 -9
View File
@@ -374,22 +374,22 @@ class JobManager:
updates['progress'] = progress
# Generate review token when entering AWAITING_REVIEW state
# Tokens don't expire - they're job-scoped so low risk, and natural expiry happens when job completes
if new_status == JobStatus.AWAITING_REVIEW:
from backend.api.dependencies import generate_review_token, get_review_token_expiry
from backend.api.dependencies import generate_review_token
review_token = generate_review_token()
review_token_expires = get_review_token_expiry(hours=48) # 48 hour expiry
updates['review_token'] = review_token
updates['review_token_expires_at'] = review_token_expires
logger.info(f"Generated review token for job {job_id}, expires in 48 hours")
updates['review_token_expires_at'] = None # No expiry - token is job-scoped
logger.info(f"Generated review token for job {job_id} (no expiry)")
# Generate instrumental token when entering AWAITING_INSTRUMENTAL_SELECTION state
# Tokens don't expire - they're job-scoped so low risk, and natural expiry happens when job completes
if new_status == JobStatus.AWAITING_INSTRUMENTAL_SELECTION:
from backend.api.dependencies import generate_review_token, get_review_token_expiry
from backend.api.dependencies import generate_review_token
instrumental_token = generate_review_token() # Reuse same token generator
instrumental_token_expires = get_review_token_expiry(hours=48) # 48 hour expiry
updates['instrumental_token'] = instrumental_token
updates['instrumental_token_expires_at'] = instrumental_token_expires
logger.info(f"Generated instrumental token for job {job_id}, expires in 48 hours")
updates['instrumental_token_expires_at'] = None # No expiry - token is job-scoped
logger.info(f"Generated instrumental token for job {job_id} (no expiry)")
# If we have state_data_updates, merge them with existing state_data
merged_state_data = None
+4 -21
View File
@@ -53,30 +53,13 @@ class JobNotificationService:
def _build_review_url(self, job_id: str, audio_hash: Optional[str] = None, review_token: Optional[str] = None) -> str:
"""Build the lyrics review URL for a job."""
import urllib.parse
review_ui_url = os.getenv("REVIEW_UI_URL", f"{self.frontend_url}/lyrics/")
base_api_url = f"{self.backend_url}/api/review/{job_id}"
encoded_api_url = urllib.parse.quote(base_api_url, safe='')
url = f"{review_ui_url}?baseApiUrl={encoded_api_url}"
if audio_hash:
url += f"&audioHash={urllib.parse.quote(audio_hash, safe='')}"
if review_token:
url += f"&reviewToken={urllib.parse.quote(review_token, safe='')}"
return url
# Use hash-based routing for static hosting compatibility
return f"{self.frontend_url}/app/jobs#/{job_id}/review"
def _build_instrumental_url(self, job_id: str, instrumental_token: Optional[str] = None) -> str:
"""Build the instrumental selection URL for a job."""
base_api_url = f"{self.backend_url}/api/jobs/{job_id}"
import urllib.parse
encoded_api_url = urllib.parse.quote(base_api_url, safe='')
url = f"{self.frontend_url}/instrumental/?baseApiUrl={encoded_api_url}"
if instrumental_token:
url += f"&instrumentalToken={urllib.parse.quote(instrumental_token, safe='')}"
return url
# Use hash-based routing for static hosting compatibility
return f"{self.frontend_url}/app/jobs#/{job_id}/instrumental"
async def send_job_completion_email(
self,
+1 -1
View File
@@ -120,7 +120,7 @@ class PackagingService:
)
self.logger.info("Generating CDG and MP3 files")
from lyrics_transcriber.output.cdg import CDGGenerator
from karaoke_gen.lyrics_transcriber.output.cdg import CDGGenerator
output_dir = os.path.dirname(output_zip_path) or os.getcwd()
generator = CDGGenerator(output_dir=output_dir, logger=self.logger)
+18 -3
View File
@@ -11,6 +11,7 @@ from fastapi import FastAPI
from backend.api.routes.admin import router
from backend.api.dependencies import require_admin
from backend.services.user_service import get_user_service
from backend.services.auth_service import AuthResult, UserType
from backend.models.user import User, Session
@@ -20,15 +21,29 @@ app.include_router(router, prefix="/api")
def get_mock_admin():
"""Override for require_admin dependency - returns admin user."""
return ("admin@nomadkaraoke.com", "admin", 1)
"""Override for require_admin dependency - returns admin AuthResult."""
return AuthResult(
is_valid=True,
user_type=UserType.ADMIN,
remaining_uses=-1,
message="Admin session valid",
user_email="admin@nomadkaraoke.com",
is_admin=True,
)
def get_mock_regular_user():
"""Override for require_admin dependency - returns regular user (should fail)."""
# This simulates what happens when a non-admin tries to access
# In reality, require_admin raises 403, but we test the logic
return ("user@example.com", "user", 0)
return AuthResult(
is_valid=True,
user_type=UserType.LIMITED,
remaining_uses=5,
message="User session valid",
user_email="user@example.com",
is_admin=False,
)
@pytest.fixture
+24 -58
View File
@@ -3,7 +3,6 @@ Unit tests for job notification service.
"""
import pytest
from unittest.mock import Mock, patch, AsyncMock
import urllib.parse
from backend.services.job_notification_service import (
JobNotificationService,
@@ -20,82 +19,55 @@ class TestURLBuilding:
"""Test basic review URL building."""
service = JobNotificationService()
service.frontend_url = "https://gen.nomadkaraoke.com"
service.backend_url = "https://api.nomadkaraoke.com"
url = service._build_review_url("job-123")
assert "gen.nomadkaraoke.com/lyrics/" in url
assert "baseApiUrl=" in url
# The API URL should be URL-encoded
assert urllib.parse.quote("https://api.nomadkaraoke.com/api/review/job-123", safe='') in url
assert url == "https://gen.nomadkaraoke.com/app/jobs#/job-123/review"
def test_build_review_url_with_audio_hash(self):
"""Test review URL with audio hash parameter."""
def test_build_review_url_ignores_legacy_params(self):
"""Test review URL ignores legacy audio_hash and review_token params."""
service = JobNotificationService()
service.frontend_url = "https://gen.nomadkaraoke.com"
service.backend_url = "https://api.nomadkaraoke.com"
url = service._build_review_url("job-123", audio_hash="abc123")
# Legacy params are still accepted but not used in the URL
url = service._build_review_url("job-123", audio_hash="abc123", review_token="token456")
assert "audioHash=abc123" in url
# URL should be the simple consolidated route
assert url == "https://gen.nomadkaraoke.com/app/jobs#/job-123/review"
# No query params
assert "?" not in url
def test_build_review_url_with_review_token(self):
"""Test review URL with review token parameter."""
def test_build_review_url_preserves_job_id_characters(self):
"""Test that job ID is used directly in URL path."""
service = JobNotificationService()
service.frontend_url = "https://gen.nomadkaraoke.com"
service.backend_url = "https://api.nomadkaraoke.com"
url = service._build_review_url("job-123", review_token="token456")
# Note: job IDs with slashes would be unusual in real usage
url = service._build_review_url("abc-def-123")
assert "reviewToken=token456" in url
def test_build_review_url_with_all_params(self):
"""Test review URL with all parameters."""
service = JobNotificationService()
service.frontend_url = "https://gen.nomadkaraoke.com"
service.backend_url = "https://api.nomadkaraoke.com"
url = service._build_review_url(
"job-123",
audio_hash="hash789",
review_token="token456"
)
assert "baseApiUrl=" in url
assert "audioHash=hash789" in url
assert "reviewToken=token456" in url
def test_build_review_url_encodes_special_chars(self):
"""Test that special characters in job ID are encoded."""
service = JobNotificationService()
service.frontend_url = "https://gen.nomadkaraoke.com"
service.backend_url = "https://api.nomadkaraoke.com"
url = service._build_review_url("job/with/slashes")
# The baseApiUrl parameter should have encoded slashes
assert "%2F" in url
assert url == "https://gen.nomadkaraoke.com/app/jobs#/abc-def-123/review"
def test_build_instrumental_url_basic(self):
"""Test basic instrumental URL building."""
service = JobNotificationService()
service.frontend_url = "https://gen.nomadkaraoke.com"
service.backend_url = "https://api.nomadkaraoke.com"
url = service._build_instrumental_url("job-123")
assert "gen.nomadkaraoke.com/instrumental/" in url
assert "baseApiUrl=" in url
assert url == "https://gen.nomadkaraoke.com/app/jobs#/job-123/instrumental"
def test_build_instrumental_url_with_token(self):
"""Test instrumental URL with token parameter."""
def test_build_instrumental_url_ignores_legacy_params(self):
"""Test instrumental URL ignores legacy instrumental_token param."""
service = JobNotificationService()
service.frontend_url = "https://gen.nomadkaraoke.com"
service.backend_url = "https://api.nomadkaraoke.com"
# Legacy param is still accepted but not used in the URL
url = service._build_instrumental_url("job-123", instrumental_token="inst-token")
assert "instrumentalToken=inst-token" in url
# URL should be the simple consolidated route
assert url == "https://gen.nomadkaraoke.com/app/jobs#/job-123/instrumental"
# No query params
assert "?" not in url
class TestCompletionEmail:
@@ -325,7 +297,6 @@ class TestActionReminderEmail:
"""Test that lyrics reminder includes correct review URL."""
service = JobNotificationService()
service.frontend_url = "https://gen.nomadkaraoke.com"
service.backend_url = "https://api.nomadkaraoke.com"
service.email_service = Mock()
service.email_service.send_action_reminder.return_value = True
service.template_service = Mock()
@@ -336,22 +307,18 @@ class TestActionReminderEmail:
job_id="job-123",
user_email="user@example.com",
action_type="lyrics",
audio_hash="hash123",
review_token="token456",
)
# Verify the review URL was passed to template
call_kwargs = service.template_service.render_action_needed_lyrics.call_args.kwargs
review_url = call_kwargs.get('review_url')
assert "audioHash=hash123" in review_url
assert "reviewToken=token456" in review_url
assert review_url == "https://gen.nomadkaraoke.com/app/jobs#/job-123/review"
@pytest.mark.asyncio
async def test_send_instrumental_reminder_includes_url(self):
"""Test that instrumental reminder includes correct URL."""
service = JobNotificationService()
service.frontend_url = "https://gen.nomadkaraoke.com"
service.backend_url = "https://api.nomadkaraoke.com"
service.email_service = Mock()
service.email_service.send_action_reminder.return_value = True
service.template_service = Mock()
@@ -362,13 +329,12 @@ class TestActionReminderEmail:
job_id="job-123",
user_email="user@example.com",
action_type="instrumental",
instrumental_token="inst-token",
)
# Verify the instrumental URL was passed to template
call_kwargs = service.template_service.render_action_needed_instrumental.call_args.kwargs
instrumental_url = call_kwargs.get('instrumental_url')
assert "instrumentalToken=inst-token" in instrumental_url
assert instrumental_url == "https://gen.nomadkaraoke.com/app/jobs#/job-123/instrumental"
class TestGetCompletionMessage:
+1 -1
View File
@@ -201,7 +201,7 @@ class TestPackagingServiceCDGPackage:
assert result[1] == mp3_file
assert result[2] == cdg_file
@patch("lyrics_transcriber.output.cdg.CDGGenerator")
@patch("karaoke_gen.lyrics_transcriber.output.cdg.CDGGenerator")
def test_create_cdg_package_with_generator(self, mock_cdg_generator_class):
"""Test CDG package creation using CDGGenerator."""
with tempfile.TemporaryDirectory() as tmpdir:
+1 -1
View File
@@ -204,7 +204,7 @@ class TestAddLyricsEndpoint:
def test_add_lyrics_uses_correction_operations(self):
"""Verify CorrectionOperations.add_lyrics_source is available."""
from lyrics_transcriber.correction.operations import CorrectionOperations
from karaoke_gen.lyrics_transcriber.correction.operations import CorrectionOperations
# The method should exist
assert hasattr(CorrectionOperations, 'add_lyrics_source')
@@ -845,3 +845,192 @@ class TestCreateOrchestratorConfigFromJob:
)
assert config.instrumental_audio_path == "/tmp/test/Test Artist - Test Title (Instrumental User).mp3"
def test_create_config_passes_instrumental_selection(self):
"""Test that instrumental_selection is passed through to OrchestratorConfig.
This is a REGRESSION TEST for the bug where orchestrator -> GCE encoding
path did not pass instrumental_selection, causing GCE worker to default
to 'clean' even when user selected 'with_backing'.
The bug was:
- PR #271 fixed GCE worker to READ instrumental_selection from config
- But the orchestrator path (encoding_interface.py) was never updated to SEND it
- The legacy path (video_worker.py _encode_via_gce) was already correct
- So the bug only manifested when USE_NEW_ORCHESTRATOR=true (the default)
See: fix(gce): Respect user's instrumental selection in GCE encoding worker (#271)
"""
job = MagicMock()
job.job_id = "test-123"
job.artist = "Test Artist"
job.title = "Test Title"
job.state_data = {"instrumental_selection": "with_backing"} # User selected backing vocals
job.enable_cdg = False
job.enable_txt = False
job.enable_youtube_upload = False
job.brand_prefix = None
job.discord_webhook_url = None
job.youtube_description_template = None
job.dropbox_path = None
job.gdrive_folder_id = None
job.keep_brand_code = None
job.existing_instrumental_gcs_path = None
config = create_orchestrator_config_from_job(
job=job,
temp_dir="/tmp/test",
)
# CRITICAL: instrumental_selection must be passed to OrchestratorConfig
# If this fails, the GCE worker will default to 'clean' and ignore user's selection
assert config.instrumental_selection == "with_backing", \
"instrumental_selection must be passed from job.state_data to OrchestratorConfig"
# Also verify the instrumental path uses "Backing" not "Clean"
assert "Backing" in config.instrumental_audio_path, \
"When with_backing is selected, instrumental path should contain 'Backing'"
class TestInstrumentalSelectionEndToEnd:
"""End-to-end tests for instrumental selection flow.
These tests verify that instrumental_selection flows correctly from:
job.state_data -> OrchestratorConfig -> EncodingInput -> GCE encoding_config
This test class was added after discovering that PR #271 only fixed the
GCE worker (receiving side) but not the orchestrator (sending side),
causing the bug to persist in production where USE_NEW_ORCHESTRATOR=true.
"""
def test_encoding_input_has_instrumental_selection_field(self):
"""Test that EncodingInput dataclass includes instrumental_selection.
Without this field, the orchestrator cannot pass the selection to
the encoding backend.
"""
from backend.services.encoding_interface import EncodingInput
# Test with explicit selection
input_with_backing = EncodingInput(
title_video_path="/path/title.mov",
karaoke_video_path="/path/karaoke.mov",
instrumental_audio_path="/path/audio.flac",
instrumental_selection="with_backing",
)
assert input_with_backing.instrumental_selection == "with_backing"
# Test default value
input_default = EncodingInput(
title_video_path="/path/title.mov",
karaoke_video_path="/path/karaoke.mov",
instrumental_audio_path="/path/audio.flac",
)
assert input_default.instrumental_selection == "clean", \
"Default instrumental_selection should be 'clean' for backward compatibility"
def test_orchestrator_config_has_instrumental_selection_field(self):
"""Test that OrchestratorConfig includes instrumental_selection."""
config = OrchestratorConfig(
job_id="test-job",
artist="Test Artist",
title="Test Title",
title_video_path="/path/title.mov",
karaoke_video_path="/path/karaoke.mov",
instrumental_audio_path="/path/audio.flac",
instrumental_selection="with_backing",
)
assert config.instrumental_selection == "with_backing"
# Test default
config_default = OrchestratorConfig(
job_id="test-job",
artist="Test Artist",
title="Test Title",
title_video_path="/path/title.mov",
karaoke_video_path="/path/karaoke.mov",
instrumental_audio_path="/path/audio.flac",
)
assert config_default.instrumental_selection == "clean"
def test_gce_encoding_config_includes_instrumental_selection(self):
"""Test that GCEEncodingBackend passes instrumental_selection to encoding_config.
This is the CRITICAL test that would have caught the bug in PR #271.
The GCE worker reads config.get("instrumental_selection", "clean"),
so if we don't send it, it defaults to 'clean' regardless of user selection.
"""
from backend.services.encoding_interface import EncodingInput, GCEEncodingBackend
backend = GCEEncodingBackend(dry_run=True)
# Create input with 'with_backing' selection
encoding_input = EncodingInput(
title_video_path="/path/title.mov",
karaoke_video_path="/path/karaoke.mov",
instrumental_audio_path="/path/audio.flac",
artist="Test Artist",
title="Test Title",
instrumental_selection="with_backing",
options={
"job_id": "test-123",
"input_gcs_path": "gs://bucket/jobs/test-123/",
"output_gcs_path": "gs://bucket/jobs/test-123/finals/",
},
)
# We can't easily test the actual encoding_config dict without mocking
# the service, but we can verify the input has the right value
assert encoding_input.instrumental_selection == "with_backing"
# The fix ensures GCEEncodingBackend.encode() includes this in encoding_config:
# encoding_config = {
# ...
# "instrumental_selection": input_config.instrumental_selection,
# }
@pytest.mark.asyncio
async def test_orchestrator_passes_instrumental_selection_to_encoding(self):
"""Test full flow: orchestrator creates EncodingInput with instrumental_selection.
This integration test verifies the complete path:
OrchestratorConfig.instrumental_selection -> EncodingInput.instrumental_selection
"""
config = OrchestratorConfig(
job_id="test-job",
artist="Test Artist",
title="Test Title",
title_video_path="/path/title.mov",
karaoke_video_path="/path/karaoke.mov",
instrumental_audio_path="/path/audio.flac",
output_dir="/output",
instrumental_selection="with_backing",
)
orchestrator = VideoWorkerOrchestrator(config)
# Capture the EncodingInput that gets passed to the backend
captured_input = None
async def capture_encode(encoding_input):
nonlocal captured_input
captured_input = encoding_input
from backend.services.encoding_interface import EncodingOutput
return EncodingOutput(
success=True,
lossless_4k_mp4_path="/output/lossless.mp4",
encoding_time_seconds=1.0,
encoding_backend="mock",
)
with patch.object(orchestrator, "_get_encoding_backend") as mock_get:
mock_backend = MagicMock()
mock_backend.name = "mock"
mock_backend.encode = capture_encode
mock_get.return_value = mock_backend
await orchestrator._run_encoding()
# CRITICAL ASSERTION: instrumental_selection must be passed through
assert captured_input is not None, "encode() should have been called"
assert captured_input.instrumental_selection == "with_backing", \
"Orchestrator must pass instrumental_selection to EncodingInput"
+131
View File
@@ -0,0 +1,131 @@
"""Tests for the worker registry module."""
import asyncio
import pytest
from backend.workers.registry import WorkerRegistry
@pytest.fixture
def registry():
"""Create a fresh WorkerRegistry for each test."""
return WorkerRegistry()
class TestWorkerRegistry:
"""Test cases for WorkerRegistry."""
@pytest.mark.asyncio
async def test_register_adds_worker(self, registry):
"""Register should add worker to active workers."""
await registry.register("job-123", "audio")
assert registry.has_active_workers()
active = registry.get_active_workers()
assert "job-123" in active
assert "audio" in active["job-123"]
@pytest.mark.asyncio
async def test_unregister_removes_worker(self, registry):
"""Unregister should remove worker from active workers."""
await registry.register("job-123", "audio")
await registry.unregister("job-123", "audio")
assert not registry.has_active_workers()
assert "job-123" not in registry.get_active_workers()
@pytest.mark.asyncio
async def test_multiple_workers_same_job(self, registry):
"""Multiple workers can be registered for the same job."""
await registry.register("job-123", "audio")
await registry.register("job-123", "lyrics")
active = registry.get_active_workers()
assert "job-123" in active
assert active["job-123"] == {"audio", "lyrics"}
@pytest.mark.asyncio
async def test_partial_unregister_keeps_other_workers(self, registry):
"""Unregistering one worker should keep others active."""
await registry.register("job-123", "audio")
await registry.register("job-123", "lyrics")
await registry.unregister("job-123", "audio")
assert registry.has_active_workers()
active = registry.get_active_workers()
assert "job-123" in active
assert active["job-123"] == {"lyrics"}
@pytest.mark.asyncio
async def test_multiple_jobs(self, registry):
"""Workers from different jobs are tracked separately."""
await registry.register("job-123", "audio")
await registry.register("job-456", "lyrics")
active = registry.get_active_workers()
assert "job-123" in active
assert "job-456" in active
@pytest.mark.asyncio
async def test_unregister_nonexistent_worker(self, registry):
"""Unregistering a worker that doesn't exist should not error."""
await registry.unregister("nonexistent-job", "audio")
assert not registry.has_active_workers()
@pytest.mark.asyncio
async def test_wait_for_completion_no_workers(self, registry):
"""Wait should return immediately when no workers are active."""
result = await registry.wait_for_completion(timeout=1.0)
assert result is True
@pytest.mark.asyncio
async def test_wait_for_completion_workers_finish(self, registry):
"""Wait should complete when workers finish."""
await registry.register("job-123", "audio")
# Create a task that unregisters after a delay
async def unregister_after_delay():
await asyncio.sleep(0.2)
await registry.unregister("job-123", "audio")
asyncio.create_task(unregister_after_delay())
result = await registry.wait_for_completion(timeout=5.0)
assert result is True
@pytest.mark.asyncio
async def test_wait_for_completion_timeout(self, registry):
"""Wait should return False on timeout."""
await registry.register("job-123", "audio")
# Short timeout, worker never unregisters
result = await registry.wait_for_completion(timeout=0.1)
assert result is False
@pytest.mark.asyncio
async def test_concurrent_registration(self, registry):
"""Concurrent registrations should be thread-safe."""
job_ids = [f"job-{i}" for i in range(10)]
async def register_worker(job_id):
await registry.register(job_id, "audio")
# Register all workers concurrently
await asyncio.gather(*[register_worker(job_id) for job_id in job_ids])
active = registry.get_active_workers()
assert len(active) == 10
for job_id in job_ids:
assert job_id in active
@pytest.mark.asyncio
async def test_get_active_workers_returns_copy(self, registry):
"""get_active_workers should return a copy, not the internal state."""
await registry.register("job-123", "audio")
active = registry.get_active_workers()
active["job-123"].add("fake-worker")
# Internal state should not be affected
internal = registry.get_active_workers()
assert "fake-worker" not in internal.get("job-123", set())
+2 -2
View File
@@ -560,7 +560,7 @@ class TestRenderVideoWorkerCountdownPadding:
def test_countdown_processor_has_process_method(self):
"""Test that CountdownProcessor has the process method (main API)."""
from lyrics_transcriber.output.countdown_processor import CountdownProcessor
from karaoke_gen.lyrics_transcriber.output.countdown_processor import CountdownProcessor
countdown_processor = CountdownProcessor(cache_dir="/tmp")
assert hasattr(countdown_processor, 'process')
@@ -568,7 +568,7 @@ class TestRenderVideoWorkerCountdownPadding:
def test_countdown_processor_constants(self):
"""Test that CountdownProcessor has expected constants."""
from lyrics_transcriber.output.countdown_processor import CountdownProcessor
from karaoke_gen.lyrics_transcriber.output.countdown_processor import CountdownProcessor
# Verify the constants exist (these control countdown behavior)
assert hasattr(CountdownProcessor, 'COUNTDOWN_TEXT')
+10 -2
View File
@@ -26,6 +26,7 @@ from backend.services.job_manager import JobManager
from backend.services.storage_service import StorageService
from backend.config import get_settings
from backend.workers.worker_logging import create_job_logger, setup_job_logging, job_logging_context
from backend.workers.registry import worker_registry
from backend.services.tracing import job_span, add_span_event, add_span_attribute
from backend.services.metrics import metrics
@@ -264,7 +265,11 @@ async def process_audio_separation(job_id: str) -> bool:
logger.info(f"[job:{job_id}] WORKER_START worker=audio")
job_log.info("=== AUDIO WORKER STARTED ===")
job_log.info(f"Job ID: {job_id}")
# Register with worker registry to prevent premature container shutdown
# This ensures Cloud Run waits for this worker to complete before terminating
await worker_registry.register(job_id, "audio")
# Set up log capture for AudioProcessor
log_handler = setup_job_logging(job_id, "audio", *AUDIO_WORKER_LOGGERS)
job_log.info(f"Log handler attached for {len(AUDIO_WORKER_LOGGERS)} loggers")
@@ -411,13 +416,16 @@ async def process_audio_separation(job_id: str) -> bool:
return False
finally:
# Unregister from worker registry to signal completion
await worker_registry.unregister(job_id, "audio")
# Remove log handler to avoid duplicate logging on future runs
for logger_name in AUDIO_WORKER_LOGGERS:
try:
logging.getLogger(logger_name).removeHandler(log_handler)
except Exception:
pass
# Cleanup temporary directory
if os.path.exists(temp_dir):
shutil.rmtree(temp_dir)
+10 -2
View File
@@ -35,6 +35,7 @@ from backend.services.storage_service import StorageService
from backend.services.lyrics_cache_service import LyricsCacheService
from backend.workers.worker_logging import create_job_logger, setup_job_logging, job_logging_context
from backend.workers.style_helper import load_style_config
from backend.workers.registry import worker_registry
from backend.services.tracing import job_span, add_span_event, add_span_attribute
from backend.services.metrics import metrics
@@ -164,7 +165,11 @@ async def process_lyrics_transcription(job_id: str) -> bool:
logger.info(f"[job:{job_id}] WORKER_START worker=lyrics")
job_log.info("=== LYRICS WORKER STARTED ===")
job_log.info(f"Job ID: {job_id}")
# Register with worker registry to prevent premature container shutdown
# This ensures Cloud Run waits for this worker to complete before terminating
await worker_registry.register(job_id, "lyrics")
# Set up log capture for LyricsTranscriber and its dependencies
# This ensures logs from the lyrics_transcriber library are also captured
log_handler = setup_job_logging(job_id, "lyrics", *LYRICS_WORKER_LOGGERS)
@@ -460,13 +465,16 @@ async def process_lyrics_transcription(job_id: str) -> bool:
return False
finally:
# Unregister from worker registry to signal completion
await worker_registry.unregister(job_id, "lyrics")
# Remove log handler to avoid duplicate logging on future runs
for logger_name in LYRICS_WORKER_LOGGERS:
try:
logging.getLogger(logger_name).removeHandler(log_handler)
except Exception:
pass
# Cleanup temporary directory (only if it was created)
if temp_dir and os.path.exists(temp_dir):
shutil.rmtree(temp_dir)
+132
View File
@@ -0,0 +1,132 @@
"""
Worker registry for tracking active background workers.
This module provides coordination to prevent Cloud Run from shutting down
while workers are still processing. Without this, when one worker completes
and returns (ending the HTTP request), Cloud Run has no reason to keep the
container alive, even if other workers are still running.
Key insight: Workers run in BackgroundTasks, which are tied to the HTTP
request lifecycle. When the request completes, Cloud Run can terminate
the container, even if BackgroundTasks are still running.
This registry:
1. Tracks which workers are active for each job
2. Provides a shutdown hook that waits for workers to complete
3. Has timeout protection to prevent infinite hangs
"""
import asyncio
import logging
import time
from collections import defaultdict
from typing import Dict, Set
logger = logging.getLogger(__name__)
class WorkerRegistry:
"""Track active workers to prevent premature container shutdown."""
def __init__(self):
self._active_workers: Dict[str, Set[str]] = defaultdict(set) # job_id -> {worker_types}
self._lock = asyncio.Lock()
async def register(self, job_id: str, worker_type: str) -> None:
"""Register a worker as active.
Args:
job_id: The job ID this worker is processing
worker_type: Type of worker (e.g., 'audio', 'lyrics')
"""
async with self._lock:
self._active_workers[job_id].add(worker_type)
logger.info(
f"[job:{job_id}] Worker registered: {worker_type}, "
f"active workers for job: {self._active_workers[job_id]}"
)
async def unregister(self, job_id: str, worker_type: str) -> None:
"""Unregister a worker when complete.
Args:
job_id: The job ID this worker was processing
worker_type: Type of worker (e.g., 'audio', 'lyrics')
"""
async with self._lock:
self._active_workers[job_id].discard(worker_type)
remaining = self._active_workers.get(job_id, set())
if not remaining:
# Clean up empty entries
self._active_workers.pop(job_id, None)
logger.info(
f"[job:{job_id}] Worker unregistered: {worker_type}, "
f"no workers remaining for job"
)
else:
logger.info(
f"[job:{job_id}] Worker unregistered: {worker_type}, "
f"remaining workers: {remaining}"
)
def has_active_workers(self) -> bool:
"""Check if any workers are still active.
Returns:
True if any workers are registered as active
"""
return len(self._active_workers) > 0
def get_active_workers(self) -> Dict[str, Set[str]]:
"""Get a snapshot of all active workers.
Returns:
Dict mapping job_id to set of active worker types (deep copy)
"""
# Return a deep copy to prevent external modification of internal state
return {job_id: set(workers) for job_id, workers in self._active_workers.items()}
async def wait_for_completion(self, timeout: float = 600) -> bool:
"""Wait for all workers to complete, with timeout.
This is called during shutdown to ensure workers finish before
the container terminates.
Args:
timeout: Maximum seconds to wait (default 10 minutes)
Returns:
True if all workers completed, False if timeout was reached
"""
start = time.time()
poll_interval = 1.0 # Check every second
last_log_time = 0
while self.has_active_workers():
elapsed = time.time() - start
if elapsed > timeout:
active = self.get_active_workers()
logger.warning(
f"Worker completion timeout after {timeout}s, "
f"active workers: {active}"
)
return False
# Log progress every 10 seconds
elapsed_int = int(elapsed)
if elapsed_int >= last_log_time + 10:
last_log_time = elapsed_int
active = self.get_active_workers()
logger.info(
f"Waiting for workers to complete... "
f"elapsed={elapsed:.0f}s, active={active}"
)
await asyncio.sleep(poll_interval)
elapsed = time.time() - start
logger.info(f"All workers completed (waited {elapsed:.1f}s)")
return True
# Global registry instance - imported by workers and main.py
worker_registry = WorkerRegistry()
+8 -8
View File
@@ -36,10 +36,10 @@ from backend.workers.worker_logging import create_job_logger, setup_job_logging,
from backend.services.tracing import job_span, add_span_event, add_span_attribute
# Import from lyrics_transcriber (submodule)
from lyrics_transcriber.output.generator import OutputGenerator
from lyrics_transcriber.output.countdown_processor import CountdownProcessor
from lyrics_transcriber.types import CorrectionResult
from lyrics_transcriber.core.config import OutputConfig
from karaoke_gen.lyrics_transcriber.output.generator import OutputGenerator
from karaoke_gen.lyrics_transcriber.output.countdown_processor import CountdownProcessor
from karaoke_gen.lyrics_transcriber.types import CorrectionResult
from karaoke_gen.lyrics_transcriber.core.config import OutputConfig
# Import from the unified style loader
from karaoke_gen.style_loader import load_styles_from_gcs
@@ -51,10 +51,10 @@ logger = logging.getLogger(__name__)
# Loggers to capture for render video worker
RENDER_VIDEO_WORKER_LOGGERS = [
"lyrics_transcriber.output",
"lyrics_transcriber.output.generator",
"lyrics_transcriber.output.video",
"lyrics_transcriber.output.ass",
"karaoke_gen.lyrics_transcriber.output",
"karaoke_gen.lyrics_transcriber.output.generator",
"karaoke_gen.lyrics_transcriber.output.video",
"karaoke_gen.lyrics_transcriber.output.ass",
]
+1 -7
View File
@@ -322,13 +322,7 @@ async def generate_video_orchestrated(job_id: str) -> bool:
)
# Upload generated files to GCS
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.PACKAGING,
progress=95,
message="Uploading final files"
)
# Note: State transition to PACKAGING is handled by the orchestrator in _run_distribution()
with job_span("upload-results", job_id):
await _upload_results(job_id, job_manager, storage, temp_dir, {
'final_video': result.final_video,
@@ -69,6 +69,9 @@ class OrchestratorConfig:
# Keep existing brand code (for re-processing)
keep_brand_code: Optional[str] = None
# Instrumental selection (clean, with_backing, or custom)
instrumental_selection: str = "clean"
# Encoding backend preference
encoding_backend: str = "auto" # "auto", "local", "gce"
@@ -347,6 +350,7 @@ class VideoWorkerOrchestrator:
title=self.config.title,
brand_code=self.config.keep_brand_code,
output_dir=self.config.output_dir,
instrumental_selection=self.config.instrumental_selection,
options={
"job_id": self.config.job_id,
"input_gcs_path": input_gcs_path,
@@ -734,6 +738,9 @@ def create_orchestrator_config_from_job(
# Keep existing brand code
keep_brand_code=getattr(job, 'keep_brand_code', None),
# Instrumental selection (for GCE encoding)
instrumental_selection=instrumental_selection,
# Encoding backend - auto selects GCE if available
encoding_backend="auto",
+3 -3
View File
@@ -65,7 +65,7 @@ class JobLogHandler(logging.Handler):
lyrics_logger.addHandler(handler)
# Also capture logs from lyrics_transcriber package itself
lt_logger = logging.getLogger("lyrics_transcriber")
lt_logger = logging.getLogger("karaoke_gen.lyrics_transcriber")
lt_logger.addHandler(handler)
"""
@@ -235,7 +235,7 @@ def setup_job_logging(job_id: str, worker_name: str, *logger_names: str) -> JobL
Args:
job_id: Job ID
worker_name: Worker name
*logger_names: Names of loggers to capture (e.g., "lyrics_transcriber", "karaoke_gen")
*logger_names: Names of loggers to capture (e.g., "karaoke_gen.lyrics_transcriber", "karaoke_gen")
Returns:
The JobLogHandler (can be removed later if needed)
@@ -246,7 +246,7 @@ def setup_job_logging(job_id: str, worker_name: str, *logger_names: str) -> JobL
job_id,
"lyrics",
"karaoke_gen.lyrics_processor",
"lyrics_transcriber", # Capture LyricsTranscriber logs
"karaoke_gen.lyrics_transcriber", # Capture LyricsTranscriber logs
)
# IMPORTANT: Use job_logging_context for proper isolation
+31 -1
View File
@@ -45,11 +45,13 @@
• Create job in Firestore
• Trigger parallel workers
2. PARALLEL PROCESSING
2. PARALLEL PROCESSING (with Worker Registry coordination)
┌─────────────────┐ ┌─────────────────┐
│ Audio Worker │ │ Lyrics Worker │
│ Modal API │ │ AudioShake │
│ 2-stage sep │ │ Auto-correct │
│ ↓ register() │ │ ↓ register() │
│ ↓ unregister() │ │ ↓ unregister() │
└────────┬────────┘ └────────┬────────┘
└──────────┬───────────┘
▼
@@ -217,6 +219,34 @@ The Video Worker uses an orchestrator pattern to ensure all features work regard
| `template_service.py` | GCS-backed email templates |
| `job_notification_service.py` | Email orchestration (completion, reminders) |
## Worker Coordination
Workers run in parallel via FastAPI BackgroundTasks. To prevent Cloud Run from terminating the container when one worker completes while another is still running, workers register with a global `WorkerRegistry`.
```text
┌─────────────────────────────────────────────────────────────────┐
│ WorkerRegistry │
│ │
│ register(job_id, "audio") unregister(job_id, "audio") │
│ register(job_id, "lyrics") unregister(job_id, "lyrics") │
│ │
│ has_active_workers() → bool │
│ wait_for_completion(timeout) → bool │
└─────────────────────────────────────────────────────────────────┘
```
**Flow**:
1. Worker starts → `await worker_registry.register(job_id, "audio")`
2. Worker does work in try block
3. Worker completes → `await worker_registry.unregister(job_id, "audio")` in finally block
**Shutdown Handler** (in `main.py` lifespan):
- On shutdown signal, checks `worker_registry.has_active_workers()`
- If workers active, calls `wait_for_completion(timeout=600)` (10 min max)
- Logs which workers are still running for debugging
**Why needed**: Without this, when the audio worker's BackgroundTask completes, Cloud Run sees the container as idle (no active requests) and may terminate it, killing the still-running lyrics worker.
## Multitenancy
The platform supports white-label B2B portals where business customers get their own branded karaoke generation experience.
+89
View File
@@ -76,6 +76,8 @@ For faster iteration, run subsets:
TESTING.md covers: test types, CI requirements, Playwright usage, mocking guidelines, and coverage enforcement.
**For ad-hoc production debugging**, see the "Ad-Hoc Production Debugging" section in TESTING.md. Use the template at `frontend/e2e/helpers/debug-prod-template.mjs`.
## Deployment
### Automatic (CI/CD)
@@ -194,6 +196,93 @@ karaoke-gen/
└── scripts/ # Dev scripts
```
## Observability & Debugging
The backend exports OpenTelemetry traces to Google Cloud Trace. Use these for investigating production issues.
### Accessing Cloud Trace
**Cloud Console (easiest for browsing):**
```
https://console.cloud.google.com/traces/list?project=nomadkaraoke
```
**CLI queries:**
```bash
# List recent traces (requires `gcloud alpha` for trace commands)
# Easier to use the Console UI for trace browsing
# Find traces by job_id in logs, then correlate with Cloud Trace
gcloud logging read 'resource.type="cloud_run_revision" textPayload=~"JOB_ID"' \
--project=nomadkaraoke --limit=50
```
### Key Traced Spans
| Span Name | What It Measures | Key Attributes |
|-----------|------------------|----------------|
| `lyrics_corrector.run` | Full lyrics correction pipeline | `word_count`, `reference_count` |
| `lyrics_corrector.find_anchors_and_gaps` | Anchor sequence matching | `anchor_count`, `gap_count` |
| `lyrics_corrector.process_corrections` | Agentic correction processing | `gap_count`, `total_proposals` |
| `anchor_search.find_anchors` | N-gram parallel processing | `transcription.text_length`, `timeout_seconds` |
| `agentic.propose_for_gap` | AI gap classification | `gap_id`, `word_count`, `gap_category` |
| `add-lyrics` | Adding reference lyrics | `job_id`, `source` |
| `generate-preview-video` | Video preview generation | `job_id`, `use_gce` |
### Investigating Slow Operations
1. **Find the trace**: Go to Cloud Trace console, filter by time range around the failure
2. **Look at waterfall**: Identify which span took longest
3. **Check attributes**: Each span has metadata (word counts, durations, etc.)
4. **Correlate with logs**: Use timestamp and job_id to find related logs
### Example Investigation Workflow
```bash
# 1. Find job failures in logs
gcloud logging read 'resource.type="cloud_run_revision" severity>=ERROR' \
--project=nomadkaraoke --limit=20 --format="table(timestamp,textPayload)"
# 2. Get timeline for specific job
./scripts/debug-job.sh <job_id>
# 3. Check anchor search progress (time-based logging every 30s)
gcloud logging read 'resource.type="cloud_run_revision" "ANCHOR SEARCH: Progress"' \
--project=nomadkaraoke --limit=20
# 4. Open Cloud Trace to see detailed timing breakdown
# Filter traces by time window when the job ran
```
### Debugging Scripts
| Script | Purpose |
|--------|---------|
| `./scripts/debug-job.sh <job_id>` | Show job status, timeline, logs, GCS files |
| `./scripts/get_job.py <job_id>` | Fetch raw job data from Firestore |
| `./scripts/fetch_job_logs.py <job_id>` | Download all logs for a job to local file |
### Adding New Traces
When adding new operations that may need investigation:
```python
from karaoke_gen.lyrics_transcriber.utils.tracing import create_span, add_span_attribute
with create_span("operation_name", {"initial": "attributes"}) as span:
# ... do work ...
if span:
span.set_attribute("result_count", len(results))
```
For backend code:
```python
from backend.services.tracing import create_span
with create_span("operation_name", {"job_id": job_id}) as span:
# ... do work ...
```
## Troubleshooting
### Emulators Won't Start
+19
View File
@@ -39,6 +39,9 @@ When UI removes options, backend must apply sensible defaults. Don't rely on eac
### Centralize Job Creation Logic
When multiple code paths create jobs (file upload, audio search, webhooks), use a shared service for default resolution. The made-for-you webhook handler diverged from regular job creation, missing CDG/TXT defaults because it didn't call the shared `resolve_cdg_txt_defaults()` function. Fix: Create `job_defaults_service.py` with centralized helpers used by ALL job creation paths.
### Fix Both Sides of Dual Code Paths
When fixing a bug in a system with multiple code paths (e.g., legacy vs orchestrator, local vs cloud), verify ALL paths are fixed. PR #271 fixed the GCE worker to READ `instrumental_selection` but only checked the legacy path which was already SENDING it. The orchestrator path (production default) wasn't sending it. **Pattern**: If a component receives config from multiple callers, check ALL callers when fixing the receiving side. Write integration tests that cover each path.
### Defense in Depth
Enforce critical requirements at multiple layers (e.g., reject at creation in JobManager + safety net at processing time).
@@ -48,6 +51,9 @@ HTTP calls to services that can restart (VMs, containers) need retry logic with
### Cross-Domain localStorage
Auth tokens in localStorage are domain-isolated. Keep auth on a single domain or use cookies with `domain=.example.com`.
### Standalone HTML Pages Need Auth Fallback
Standalone HTML pages (like instrumental review) that use magic link tokens should also check localStorage for user auth tokens. Priority: full auth token (doesn't expire) > magic link token (expires). This prevents logged-in users from being blocked when their magic link expires.
### Tab Visibility Refresh
Use `visibilitychange` event for immediate refresh when user returns to tab, not just polling intervals.
@@ -72,6 +78,15 @@ Sanitize user input (artist/title) to ASCII for HTTP headers. Smart quotes, em d
### Fonts in Docker
Base Docker images have no fonts. Install `fonts-noto-core`, `fonts-noto-cjk` for video rendering.
### Cloud Run CPU Throttling Kills Background Tasks
Cloud Run throttles CPU to near-zero when the main request handler returns, even if background tasks are running. This caused lyrics processing (running as a FastAPI background task) to slow from 17-52 seconds to 8+ minutes, and instances being terminated mid-processing. **Fix**: Add `--no-cpu-throttling` flag to `gcloud run deploy`. Keep `--cpu-boost` for faster cold starts. **Diagnosis**: Look for "Application shutdown" in logs during long operations, and compare processing times (27x slowdown is a telltale sign).
### Cloud Run Premature Shutdown with Parallel Workers
When multiple workers run in parallel via BackgroundTasks, Cloud Run can shut down when one worker completes, killing others mid-processing. This happens because each worker endpoint returns quickly after spawning its BackgroundTask - when the audio worker's task completes, Cloud Run sees the container as idle. **Fix**: Implement a `WorkerRegistry` that tracks active workers per job. Register at worker start, unregister in finally block. Add shutdown handler in FastAPI lifespan that calls `worker_registry.wait_for_completion(timeout=600)` before allowing shutdown. **Pattern**: `backend/workers/registry.py` provides the global registry; workers import and call `await worker_registry.register(job_id, "audio")` / `unregister()`.
### Add Progress Logging for Long Operations
Operations over ~30 seconds should log progress periodically (time-based, not count-based). Count-based logging like "log every 20 items" can miss entirely if items complete slowly. Time-based logging (every 30s) ensures visibility regardless of processing speed.
---
### AuthResult Has Tuple Unpacking But Not Subscripting
@@ -148,6 +163,9 @@ Use `pulumi up --skip-preview --yes` when CI service account can't run preview.
### Docker Disk Management
Self-hosted runners need aggressive disk cleanup. Use threshold-based (70%) not age-based cleanup.
### Version Sort for Artifact Selection
When downloading multiple versioned files (wheels, tarballs), use `sort -V | tail -1` not `ls -t | head -1`. Files downloaded simultaneously have the same timestamp, so time-based sorting picks arbitrarily. Version sorting (`sort -V`) correctly identifies the highest semantic version.
---
## Performance Patterns
@@ -240,3 +258,4 @@ When mocking tenant middleware, patch both the middleware import path AND the se
3. **Design for async human review upfront** - Avoided rearchitecting later
4. **Keep docs minimal and current** - Less documentation, always accurate
5. **Check gitignore early for new directories** - Especially frontend `lib/` dirs
+4
View File
@@ -42,12 +42,16 @@
## Recent Changes
- **Worker Coordination Fix** (2026-01-20): Fixed bug where Cloud Run could shut down prematurely when one parallel worker completed while another was still running. Added `WorkerRegistry` to track active workers per job. Workers register at start and unregister in finally block. FastAPI lifespan shutdown handler now waits up to 10 minutes for active workers to complete before allowing container termination. Fixes job failures where lyrics worker was killed mid-processing after audio worker completed. See [ARCHITECTURE.md](ARCHITECTURE.md#worker-coordination) and [LESSONS-LEARNED.md](LESSONS-LEARNED.md#cloud-run-premature-shutdown-with-parallel-workers).
- **Admin Delete Outputs** (2026-01-10): Added admin button to delete all distributed outputs (YouTube, Dropbox, Google Drive) for a job while preserving the job record. Use case: fix quality issues by deleting outputs, resetting to `awaiting_review`, correcting lyrics, and re-generating. The brand code is freed for reuse when Dropbox folder is deleted. New endpoint: `POST /api/admin/jobs/{job_id}/delete-outputs`. UI: Delete Outputs button in admin job detail page, "Outputs Deleted" badge when flag is set. See [API.md](API.md#delete-job-outputs).
- **Rate Limiting & Abuse Prevention** (2026-01-09): Added per-user rate limiting (5 jobs/day default), system-wide YouTube upload limits (10/day), and beta enrollment abuse prevention. Features: email normalization (Gmail alias detection), disposable domain blocklist (130+ domains), blocked email/IP lists, IP-based enrollment rate limiting (1 per 24h), and admin UI for managing blocklists and user overrides at `/admin/rate-limits`. Admins can grant users bypass permissions or custom limits. All limits configurable via environment variables. See [API.md](API.md#rate-limits).
- **Fast Preview Video Option** (2026-01-10): Added toggle in lyrics review UI to render preview videos with black background (~10s) instead of theme background image (~30-60s). Default is now black background for faster iteration during review. Users can enable theme background via checkbox when they want to verify the final look. See [API.md](API.md#generate-preview).
- **Frontend Consolidation** (2026-01-09): Consolidated three separate frontends into a single Next.js application. Previously: (1) Main frontend (Next.js + Tailwind), (2) Lyrics Review (React + Vite + MUI, ~14k lines), and (3) Instrumental Review (vanilla HTML/JS, ~1.7k lines) were deployed separately. Now all UIs are unified in the main frontend at `/app/jobs/{id}/review` and `/app/jobs/{id}/instrumental`. Benefits: single deployment to Cloudflare Pages, no external redirects during user workflows, unified design system (Radix/Tailwind), simpler authentication via job ownership model. See [archive/2026-01-09-frontend-consolidation-plan.md](archive/2026-01-09-frontend-consolidation-plan.md) and [tasks/](tasks/).
- **Admin Login Token for Made-For-You Orders** (2026-01-10): Added one-click admin login via email. When a made-for-you order is placed, the admin notification email now includes a direct link with an embedded login token (`?admin_token=TOKEN`). Clicking this link auto-authenticates the admin and opens the job directly - no manual login required. Tokens expire after 24 hours. Also added: BCC to `done@nomadkaraoke.com` on all job completion emails, fixed timezone display (EST→ET for DST correctness). See [API.md](API.md#verify-magic-link).
- **Made-For-You Audio Selection Flow** (2026-01-08, **fixed 2026-01-09**): Refactored made-for-you order processing to pause at audio selection like regular search jobs. New flow: customer places order → admin receives notification email → admin selects audio source in UI → job processes under admin ownership → on completion, ownership transfers to customer → customer receives delivery email. Added model fields (`made_for_you`, `customer_email`, `customer_notes`), professional email templates for order confirmation and admin notification, intermediate email suppression (no lyrics/instrumental reminders to customer during processing), and ownership transfer on job completion. Distribution defaults (Dropbox, YouTube, GDrive, brand prefix) are now properly applied from server settings. **Bug fix (2026-01-09)**: Fixed webhook handler that was not setting `made_for_you=True`, not using admin ownership, not storing `customer_email`/`customer_notes`, and not pausing at audio selection. Added 17 comprehensive unit tests for the webhook handler. See [API.md](API.md#made-for-you-order-flow) and [LESSONS-LEARNED.md](LESSONS-LEARNED.md#test-webhook-handlers-with-unit-tests-not-just-integration-tests).
+80
View File
@@ -402,6 +402,86 @@ The production tests cover:
- Final encoding and download
- Admin dashboard functionality
## Ad-Hoc Production Debugging (for Agents)
When asked to "test it yourself in prod" or debug a specific production issue, use the debug script template:
### Quick Start
```bash
# Copy the template (the .local suffix is gitignored)
cp frontend/e2e/helpers/debug-prod-template.mjs frontend/test-my-issue.local.mjs
# Edit the script to customize what you're testing
# You can hardcode tokens in .local files - they won't be committed
# Run it
cd frontend && node test-my-issue.local.mjs
```
### With Environment Variables (Preferred)
```bash
# Get admin token from Secret Manager
export KARAOKE_ADMIN_TOKEN=$(gcloud secrets versions access latest --secret=admin-tokens --project=nomadkaraoke | cut -d',' -f1)
# Run the template directly
cd frontend && node e2e/helpers/debug-prod-template.mjs
# Or with a specific job
DEBUG_JOB_ID=abc123 node e2e/helpers/debug-prod-template.mjs
```
### What the Template Provides
- Playwright browser automation against production
- Auth token injection (via localStorage)
- Console error capture
- HTTP error capture (4xx, 5xx responses)
- Screenshot capability
- Customizable debug steps
### Gitignore Patterns
Files matching these patterns are gitignored in `frontend/`:
- `test-*.local.*` - Ad-hoc test scripts
- `debug-*.local.*` - Debug scripts
**Never commit tokens.** Use env vars or `.local` files only.
### When to Use What
| Scenario | Approach |
|----------|----------|
| Quick one-off debugging | Copy template → `.local` file |
| Reusable production test | Add to `e2e/production/` with env var auth |
| Regression test (mocked) | Add to `e2e/regression/` |
### Example: Debug a Specific Job's Review Page
```javascript
// frontend/test-review-debug.local.mjs
import { chromium } from 'playwright';
const TOKEN = 'your-token-here'; // OK in .local files
const JOB_ID = '26391a79';
async function debug() {
const browser = await chromium.launch({ headless: false }); // See the browser
const page = await browser.newContext().then(c => c.newPage());
await page.addInitScript(t => localStorage.setItem('karaoke_access_token', t), TOKEN);
await page.goto(`https://gen.nomadkaraoke.com/app/jobs/${JOB_ID}/review/`);
// Debug interactively - the browser stays open
await page.pause(); // Opens Playwright inspector
await browser.close();
}
debug();
```
## Running Tests Locally
```bash
+2 -2
View File
@@ -285,7 +285,7 @@ async def process_audio_separation_task(job_id: str):
```python
# backend/workers/lyrics_worker.py
from karaoke_gen.lyrics_processor import LyricsProcessor
from lyrics_transcriber.transcriber import LyricsTranscriber
from karaoke_gen.lyrics_transcriber.transcriber import LyricsTranscriber
import os
async def process_lyrics_transcription_task(job_id: str):
@@ -735,7 +735,7 @@ async def encode_videos_task(job_id: str):
**Implementation:**
```python
# backend/workers/packaging_worker.py
from lyrics_transcriber.output.cdg import CDGGenerator
from karaoke_gen.lyrics_transcriber.output.cdg import CDGGenerator
from lyrics_converter import convert_lrc_to_txt
async def generate_cdg_package(job_id: str, work_dir: str):
+3 -3
View File
@@ -246,9 +246,9 @@ import logging
import tempfile
from typing import Optional
from lyrics_transcriber.output.generator import OutputGenerator
from lyrics_transcriber.correction.corrector import CorrectionResult
from lyrics_transcriber.core.config import OutputConfig
from karaoke_gen.lyrics_transcriber.output.generator import OutputGenerator
from karaoke_gen.lyrics_transcriber.correction.corrector import CorrectionResult
from karaoke_gen.lyrics_transcriber.core.config import OutputConfig
from backend.services.job_manager import job_manager
from backend.services.storage_service import storage
@@ -175,8 +175,8 @@ config = LyricsTranscriberConfig(
**Key Insight:** Uses `OutputGenerator` from LyricsTranscriber library:
```python
from lyrics_transcriber.output.generator import OutputGenerator
from lyrics_transcriber.correction.corrector import CorrectionResult
from karaoke_gen.lyrics_transcriber.output.generator import OutputGenerator
from karaoke_gen.lyrics_transcriber.correction.corrector import CorrectionResult
# Load corrected data (from human review)
correction_result = CorrectionResult.from_dict(corrections_data)
@@ -382,9 +382,9 @@ POST /api/jobs/{job_id}/select-instrumental
### Example: Using OutputGenerator
```python
from lyrics_transcriber.output.generator import OutputGenerator
from lyrics_transcriber.correction.corrector import CorrectionResult
from lyrics_transcriber.core.config import OutputConfig
from karaoke_gen.lyrics_transcriber.output.generator import OutputGenerator
from karaoke_gen.lyrics_transcriber.correction.corrector import CorrectionResult
from karaoke_gen.lyrics_transcriber.core.config import OutputConfig
# 1. Load corrected data from GCS (after human review)
corrections_data = download_json_from_gcs(f"jobs/{job_id}/corrections_updated.json")
@@ -181,7 +181,7 @@ You can also detect from LRC files:
To disable countdown for a specific transcription:
```python
from lyrics_transcriber.core.config import OutputConfig
from karaoke_gen.lyrics_transcriber.core.config import OutputConfig
output_config = OutputConfig(
# ... other options
@@ -0,0 +1,360 @@
# Frontend Consolidation Plan
**Date**: 2026-01-09
**Branch**: `feat/sess-20260109-1931-consolidate-frontends`
**Approach**: Big bang migration
## Goal
Consolidate three separate frontends into a single Next.js application:
| Current | Lines | Location | After |
|---------|-------|----------|-------|
| Main karaoke-gen | ~10k | `frontend/` | Keep, extend |
| Lyrics Review | ~14,300 | `lyrics_transcriber_temp/.../frontend/` | Migrate to `frontend/` |
| Instrumental Review | ~1,700 | `karaoke_gen/instrumental_review/static/` | Migrate to `frontend/` |
**Benefits**:
- Single deployment (Cloudflare Pages only)
- Seamless UX (no external redirects)
- Unified codebase and build system
- Consistent design system (Radix + Tailwind)
## Current Architecture
```
┌─────────────────────────────────────────────────────────────┐
│ gen.nomadkaraoke.com (Cloudflare Pages) │
│ └── Next.js main frontend │
│ ├── /app → Job dashboard │
│ ├── /admin → Admin panel │
│ └── Opens external URLs for review... │
└─────────────────────────────────────────────────────────────┘
│ │
▼ ▼
┌───────────────────────┐ ┌───────────────────────┐
│ GitHub Pages │ │ Backend (Cloud Run) │
│ Lyrics Review (Vite) │ │ Instrumental (static) │
│ MUI + Emotion │ │ Vanilla HTML/JS │
└───────────────────────┘ └───────────────────────┘
```
## Target Architecture
```
┌─────────────────────────────────────────────────────────────┐
│ gen.nomadkaraoke.com (Cloudflare Pages) │
│ └── Next.js unified frontend │
│ ├── /app → Job dashboard │
│ ├── /app/jobs/[id]/review → Lyrics review (embedded) │
│ ├── /app/jobs/[id]/instrumental → Instrumental select │
│ └── /admin → Admin panel │
└─────────────────────────────────────────────────────────────┘
│
▼
┌───────────────────────┐
│ Backend (Cloud Run) │
│ API only (no static) │
└───────────────────────┘
```
## Migration Phases
### Phase 1: Setup & Routing Structure
**Tasks**:
1. Create new Next.js routes:
- `frontend/app/app/jobs/[id]/review/page.tsx`
- `frontend/app/app/jobs/[id]/instrumental/page.tsx`
2. Update JobCard navigation to use internal routes instead of external URLs
3. Add temporary wrapper components that will host migrated content
**Files to create**:
```
frontend/app/app/jobs/[id]/
├── review/
│ └── page.tsx # Lyrics review route
└── instrumental/
└── page.tsx # Instrumental selection route
```
### Phase 2: Migrate Lyrics Review Components
**Source**: `lyrics_transcriber_temp/lyrics_transcriber/frontend/src/`
**Components to migrate** (in dependency order):
#### Tier 1: Core utilities (keep as-is, move location)
- `types.ts` → `frontend/lib/lyrics-review/types.ts`
- `validation.ts` → `frontend/lib/lyrics-review/validation.ts`
- `api.ts` → integrate into `frontend/lib/api.ts`
#### Tier 2: Shared utilities
- `components/shared/utils/*.ts` → `frontend/lib/lyrics-review/utils/`
- `components/shared/types.ts` → merge with types.ts
- `components/shared/constants.ts` → `frontend/lib/lyrics-review/constants.ts`
#### Tier 3: Base components (MUI → Radix/Tailwind)
- `AudioPlayer.tsx` - Audio playback with waveform
- `Word.tsx` - Individual word display
- `HighlightedText.tsx` - Text highlighting
- `SourceSelector.tsx` - Source selection dropdown
#### Tier 4: View components
- `TranscriptionView.tsx` - Main transcription display
- `ReferenceView.tsx` - Reference lyrics panel
- `DurationTimelineView.tsx` - Timeline visualization
- `EditWordList.tsx` - Word list editor
- `TimelineEditor.tsx` - Timeline editing
#### Tier 5: Modal components
- `FindReplaceModal.tsx`
- `ReviewChangesModal.tsx`
- `SegmentDetailsModal.tsx`
- `ReplaceAllLyricsModal.tsx`
- `TimingOffsetModal.tsx`
- `AddLyricsModal.tsx`
- `ModeSelectionModal.tsx`
- `CorrectionAnnotationModal.tsx`
- `AIFeedbackModal.tsx`
#### Tier 6: Lyrics Synchronizer
- `LyricsSynchronizer/index.tsx`
- `LyricsSynchronizer/TimelineCanvas.tsx`
- `LyricsSynchronizer/SyncControls.tsx`
- `LyricsSynchronizer/UpcomingWordsBar.tsx`
#### Tier 7: Main container
- `LyricsAnalyzer.tsx` - Main orchestrator component
- `AppHeader.tsx` - Header (merge with existing)
- `Header.tsx` - Review header
#### Tier 8: Metrics/Dashboard
- `CorrectionMetrics.tsx`
- `AgenticCorrectionMetrics.tsx`
- `MetricsDashboard.tsx`
- `PreviewVideoSection.tsx`
**Target structure**:
```
frontend/
├── components/
│ └── lyrics-review/
│ ├── LyricsAnalyzer.tsx # Main container
│ ├── AudioPlayer.tsx
│ ├── TranscriptionView.tsx
│ ├── ReferenceView.tsx
│ ├── TimelineEditor.tsx
│ ├── modals/
│ │ ├── FindReplaceModal.tsx
│ │ ├── ReviewChangesModal.tsx
│ │ └── ...
│ ├── synchronizer/
│ │ ├── index.tsx
│ │ ├── TimelineCanvas.tsx
│ │ └── ...
│ └── shared/
│ ├── Word.tsx
│ └── ...
└── lib/
└── lyrics-review/
├── types.ts
├── validation.ts
├── constants.ts
└── utils/
```
### Phase 3: Migrate Instrumental Review
**Source**: `karaoke_gen/instrumental_review/static/index.html`
**Conversion approach**: Extract from single HTML file to React components
**Components to create**:
```
frontend/components/instrumental-review/
├── InstrumentalSelector.tsx # Main container
├── WaveformViewer.tsx # Audio waveform display
├── StemPlayer.tsx # Individual stem playback
├── MuteRegionEditor.tsx # Custom mute region UI
├── InstrumentalOptions.tsx # Selection options
└── AudioUpload.tsx # Custom instrumental upload
```
**Key features to preserve**:
- Waveform visualization
- A/B comparison between instrumentals
- Custom mute region editing
- Custom instrumental upload
- Keyboard shortcuts
### Phase 4: API Client Consolidation
**Current state**: 3 separate API clients
- `frontend/lib/api.ts` - Main app
- `lyrics_transcriber_temp/.../api.ts` - Lyrics review (LiveApiClient)
- Vanilla fetch in `index.html` - Instrumental
**Target**: Single unified API client in `frontend/lib/api.ts`
**New endpoints to add**:
```typescript
// Lyrics review
getCorrectionData(jobId: string, token: string): Promise<CorrectionData>
submitCorrections(jobId: string, token: string, corrections: Corrections): Promise<void>
getMetadata(jobId: string): Promise<Metadata>
generatePreview(jobId: string, corrections: Corrections): Promise<PreviewResponse>
// Instrumental review
getInstrumentalAnalysis(jobId: string, token: string): Promise<Analysis>
getWaveformData(jobId: string, numPoints: number): Promise<WaveformData>
selectInstrumental(jobId: string, token: string, selection: Selection): Promise<void>
uploadCustomInstrumental(jobId: string, token: string, file: File): Promise<void>
createCustomInstrumental(jobId: string, token: string, muteRegions: MuteRegion[]): Promise<void>
getAudioStream(jobId: string, stemType: string): string // Returns URL
```
### Phase 5: Design System Migration
**MUI → Radix/Tailwind component mapping**:
| MUI Component | Radix/Tailwind Equivalent |
|---------------|---------------------------|
| `Button` | `components/ui/button.tsx` |
| `Dialog` | `components/ui/dialog.tsx` |
| `TextField` | `components/ui/input.tsx` |
| `Select` | `components/ui/select.tsx` |
| `Slider` | `components/ui/slider.tsx` |
| `Tabs` | `components/ui/tabs.tsx` |
| `IconButton` | Button with icon variant |
| `Tooltip` | `components/ui/tooltip.tsx` |
| `CircularProgress` | `components/ui/spinner.tsx` |
| `Snackbar` | `sonner` toast |
| `Box` | `<div>` with Tailwind |
| `Typography` | Tailwind text classes |
| `Paper` | `Card` component |
| `Accordion` | `components/ui/accordion.tsx` |
**Theme mapping** (MUI → Tailwind CSS variables):
- `theme.palette.primary` → `--primary`
- `theme.palette.secondary` → `--secondary`
- `theme.palette.background` → `--background`
- `theme.spacing()` → Tailwind spacing scale
### Phase 6: Navigation & State Updates
**JobCard.tsx changes**:
```typescript
// Before (external URLs)
const reviewUrl = `${reviewUiUrl}/?baseApiUrl=${encodedApiUrl}&reviewToken=${token}&audioHash=${hash}`
window.open(reviewUrl, '_blank')
// After (internal routes)
router.push(`/app/jobs/${job.job_id}/review`)
```
**Token handling**:
- Review tokens currently passed via URL params
- Move to: Server-side session or secure cookie
- Or: Keep in URL but validate on server
### Phase 7: Testing Strategy
**Update existing E2E tests**:
- `frontend/e2e/lyrics-review-only.spec.ts` - Update URLs
- `frontend/e2e/instrumental-selection-only.spec.ts` - Update URLs
- Happy path tests should work unchanged (test user flow, not URLs)
**New tests to add**:
- Route parameter validation
- Token validation
- Component-level tests for migrated components
### Phase 8: Cleanup
**Delete**:
- `lyrics_transcriber_temp/lyrics_transcriber/frontend/` (entire directory)
- `karaoke_gen/instrumental_review/static/index.html`
- GitHub Pages deployment workflow (if exists)
**Update**:
- Remove `NEXT_PUBLIC_REVIEW_UI_URL` env var
- Update backend to stop serving instrumental static files
- Update documentation
## Risk Mitigation
| Risk | Mitigation |
|------|------------|
| Large scope | Detailed component inventory; test each phase |
| MUI→Tailwind bugs | Visual regression tests; side-by-side comparison |
| Broken functionality | E2E tests cover critical paths |
| Performance regression | Lighthouse CI; bundle size monitoring |
## Estimated Component Count
| Category | Count | Complexity |
|----------|-------|------------|
| Core types/utils | 8 | Low (copy) |
| Base components | 4 | Medium |
| View components | 5 | High |
| Modals | 9 | Medium |
| Synchronizer | 4 | High |
| Metrics | 4 | Medium |
| Instrumental | 5 (new) | Medium |
| **Total** | **39** | |
## Success Criteria
1. All existing functionality works through new internal routes
2. No external frontend deployments required
3. E2E tests pass
4. Visual parity with current UI (or better)
5. No performance regression
6. Single `npm run build` produces complete frontend
## Decisions Made
### Authentication: Job Ownership Model
**Decision**: Use job ownership for access control (no URL tokens needed)
**Implementation**:
- User must be logged in to access `/app/jobs/[id]/review` or `/app/jobs/[id]/instrumental`
- Backend validates: `job.user_email === current_user.email` OR `current_user.role === 'admin'`
- Simplifies URLs: `/app/jobs/abc123/review` instead of `?reviewToken=xyz&audioHash=...`
- Email notification links go to `/app/jobs/{id}/review` - user logs in if needed
**Backend changes needed**:
- Update `/api/review/{job_id}/*` endpoints to check job ownership instead of token
- Update `/api/jobs/{job_id}/instrumental-*` endpoints similarly
- Keep token-based auth as fallback for backward compatibility (deprecate later)
### Audio Streaming
**Decision**: Keep as-is - stream directly from backend API
- Frontend calls `api.nomadkaraoke.com/api/jobs/{id}/audio-stream/{stem}`
- No need to proxy through Next.js
### Preview Video
**Decision**: Keep as-is - generated on-demand by backend
- Frontend POSTs corrections, backend returns preview URL
## Next Steps
1. [x] Resolve authentication question → Job ownership
2. [ ] Create route structure (Phase 1)
3. [ ] Migrate core types/utils (Phase 2, Tier 1-2)
4. [ ] Migrate base components (Tier 3)
5. [ ] Migrate view components (Tier 4)
6. [ ] Migrate modals (Tier 5)
7. [ ] Migrate synchronizer (Tier 6)
8. [ ] Migrate main container (Tier 7)
9. [ ] Convert instrumental review (Phase 3)
10. [ ] Update API client (Phase 4)
11. [ ] Update navigation (Phase 6)
12. [ ] Update tests (Phase 7)
13. [ ] Cleanup old code (Phase 8)
@@ -0,0 +1,181 @@
# Consolidated Frontend Testing Guide
This document explains how to test the consolidated Next.js frontend against the old standalone React/Vite frontends to ensure feature parity.
## Background
The lyrics review and instrumental review UIs are being migrated from standalone React/Vite/MUI frontends to a consolidated Next.js/Tailwind/shadcn frontend. This guide helps agents verify all functionality works correctly by comparing the old and new code paths.
## Directory Structure
- **Old code path**: `/Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen`
- **New code path**: `/Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen-consolidate-frontends`
## Setting Up Test Jobs
### Option 1: Run Old and New Side-by-Side (Recommended)
This allows you to compare behavior between old and new UIs simultaneously.
#### Terminal 1: Old Code Path (Port 8000)
```bash
cd /Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen
source venv/bin/activate
karaoke-gen \
--style_params_json="/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/karaoke-prep-styles-nomad.json" \
--enable_cdg \
--enable_txt \
/Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen/input/waterloo30sec.flac \
ABBA Waterloo
```
This will start the lyrics review server on port 8000.
**Old Lyrics Review UI URL:**
```
http://localhost:8000/?baseApiUrl=http%3A%2F%2Flocalhost%3A8000%2Fapi&audioHash=3d965459b4d5ee0c2b4478ba1fd2a000
```
#### Terminal 2: New Code Path (Port 8001)
```bash
cd /Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen-consolidate-frontends
source venv/bin/activate
LYRICS_REVIEW_PORT=8001 karaoke-gen \
--style_params_json="/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/karaoke-prep-styles-nomad.json" \
--enable_cdg \
--enable_txt \
/Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen/input/waterloo30sec.flac \
ABBA Waterloo
```
**New Lyrics Review UI URL:**
```
http://localhost:8001/app/jobs/local/review
```
### Option 2: Single Test (New Code Path Only)
If you only need to test the new UI:
```bash
cd /Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen-consolidate-frontends
source venv/bin/activate
karaoke-gen \
--style_params_json="/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/karaoke-prep-styles-nomad.json" \
--enable_cdg \
--enable_txt \
/Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen/input/waterloo30sec.flac \
ABBA Waterloo
```
**New Lyrics Review UI URL:**
```
http://localhost:8000/app/jobs/local/review
```
## Rebuilding Frontend After Code Changes
When you make changes to the frontend code in `frontend/`, you need to rebuild the static export for the local Python server to serve.
```bash
cd /Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen-consolidate-frontends/frontend
npm run build
```
This builds the Next.js static export to `karaoke_gen/nextjs_frontend/out/`.
After rebuilding, simply **reload the browser** at the review UI URL to see your changes.
## Key Files
### Frontend Components (New Code Path)
- `frontend/app/app/jobs/[[...slug]]/page.tsx` - Route handler for lyrics/instrumental review
- `frontend/app/app/jobs/[[...slug]]/client.tsx` - Main client component
- `frontend/components/lyrics-review/LyricsAnalyzer.tsx` - Main lyrics review component
- `frontend/components/lyrics-review/Header.tsx` - Header with metrics and controls
- `frontend/components/lyrics-review/modals/ReviewChangesModal.tsx` - Preview video modal
- `frontend/components/lyrics-review/PreviewVideoSection.tsx` - Video preview component
- `frontend/lib/local-mode.ts` - Local mode detection logic
### Old Frontend (for reference)
- `lyrics_transcriber_temp/lyrics_transcriber/frontend/` - Old React/Vite/MUI frontend
- `lyrics_transcriber_temp/lyrics_transcriber/review/server.py` - Python review server
### E2E Tests
- `frontend/e2e/regression/lyrics-review.spec.ts` - Comprehensive E2E tests (20 tests)
## Running E2E Tests
```bash
cd /Users/andrew/Projects/nomadkaraoke/karaoke-gen-multiagent/karaoke-gen-consolidate-frontends/frontend
# Run all lyrics-review tests
E2E_PORT=3001 npm run test:e2e -- --grep "lyrics-review"
# Run with UI for debugging
E2E_PORT=3001 npm run test:e2e:ui -- --grep "lyrics-review"
```
Note: Use port 3001 if another Next.js app is running on port 3000.
## Functionality Checklist
### Lyrics Review UI
- [ ] Page loads with transcription data
- [ ] Metrics display (Total Words, Corrections Made, etc.)
- [ ] Transcription view shows word-level segments
- [ ] Reference lyrics panel works
- [ ] Handlers panel shows correction handlers with toggles
- [ ] Audio player loads and plays audio
- [ ] Audio player controls (play/pause, seek, skip)
- [ ] Time display shows current/total time
- [ ] Edit mode selector (highlight/split/replace)
- [ ] Undo/redo buttons work
- [ ] Find/replace modal opens
- [ ] Timing offset adjustment works
- [ ] Preview Video button opens modal
- [ ] Preview video generates and plays in modal
- [ ] "Complete Review" submits corrections
- [ ] Mobile responsive layout
### Instrumental Review UI
- [ ] Page loads with instrumental options
- [ ] Waveform visualization displays
- [ ] Audio playback for each option
- [ ] Selection between clean/backing vocals versions
- [ ] Submit selection works
## Known Issues / Fixed Issues
### Fixed in This Session
1. **Preview Video Modal** - The modal was showing stats only without video preview. Fixed by integrating `PreviewVideoSection` component.
2. **Local Mode Detection** - Dev/testing ports (3000-3002) weren't recognized as local mode. Fixed by adding `DEV_TESTING_PORTS` to `local-mode.ts`.
3. **Audio Hash Sourcing** - Audio player wasn't loading because `audioHash` was undefined. Fixed to use `correctionData.metadata?.audio_hash`.
## Commits in This Branch
Recent commits on `feat/sess-20260109-1931-consolidate-frontends`:
- `ab6b11fa` - fix(lyrics-review): Add video preview to ReviewChangesModal
- `a729e027` - feat(e2e): Make test port configurable and fix E2E tests
- `a4877861` - feat(lyrics-review): Fix audioHash sourcing and add E2E tests
- `4feb687a` - fix(lyrics-review): Match styling with old MUI-based UI
- `f94318b8` - feat: Unify local CLI frontend with Next.js app
## Next Steps
1. Test all functionality in the checklist above
2. Compare behavior with old UI for any discrepancies
3. Fix any issues found
4. Run full E2E test suite
5. Create PR when ready
+76
View File
@@ -0,0 +1,76 @@
# Frontend Consolidation Tasks
This directory contains task documents for the frontend consolidation project.
## Overview
We're consolidating 3 frontends into 1:
- Main karaoke-gen frontend (keep, extend)
- Lyrics Review frontend (migrate from MUI → Tailwind)
- Instrumental Review frontend (convert from vanilla HTML → React)
## Task Status
| Task | Description | Status | Assignee |
|------|-------------|--------|----------|
| TASK-001 | Lyrics Review Migration | Ready | - |
| TASK-002 | Instrumental Review Migration | Ready | - |
## Execution Order
Tasks can be executed **in parallel** - they're independent:
```
┌─────────────────────────────────────────────────────────────┐
│ Phase 1 (Complete) │
│ Route structure + JobCard navigation + placeholders │
└─────────────────────────────────────────────────────────────┘
│
┌───────────────┴───────────────┐
▼ ▼
┌─────────────────────────┐ ┌─────────────────────────┐
│ TASK-001 │ │ TASK-002 │
│ Lyrics Review (~14k) │ │ Instrumental (~1.7k) │
│ Multiple sessions │ │ Single session │
│ recommended │ │ │
└─────────────────────────┘ └─────────────────────────┘
│ │
└───────────────┬───────────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ Final Integration │
│ - Update E2E tests │
│ - Remove old frontends │
│ - Update documentation │
└─────────────────────────────────────────────────────────────┘
```
## For Agent Sessions
When starting a new agent session:
1. Read the relevant task document
2. Work in the same worktree: `/Users/andrew/Projects/karaoke-gen-multiagent/karaoke-gen-consolidate-frontends`
3. Follow the migration order specified in the task
4. Verify build passes after each tier/milestone
5. Update task status when complete
## Files Reference
- **Plan**: `docs/archive/2026-01-09-frontend-consolidation-plan.md`
- **Main worktree**: `karaoke-gen-consolidate-frontends/`
- **Branch**: `feat/sess-20260109-1931-consolidate-frontends`
## Completion Checklist
After all tasks are done:
- [ ] TASK-001 complete (Lyrics Review migrated)
- [ ] TASK-002 complete (Instrumental Review migrated)
- [ ] Build passes: `cd frontend && npm run build`
- [ ] E2E tests updated and passing
- [ ] Old frontend code removed:
- [ ] `lyrics_transcriber_temp/lyrics_transcriber/frontend/`
- [ ] `karaoke_gen/instrumental_review/static/`
- [ ] Documentation updated
- [ ] PR created with `/pr` command
@@ -0,0 +1,329 @@
# Task: Migrate Lyrics Review Components to Main Frontend
**Task ID**: TASK-001
**Status**: Ready for execution
**Estimated scope**: ~14,000 lines, 39 components
**Approach**: Big bang migration from MUI to Radix/Tailwind
## Context
We're consolidating three separate frontends into a single Next.js application. This task focuses on migrating the Lyrics Review frontend (currently React + Vite + MUI) into the main karaoke-gen frontend (Next.js + Radix/Tailwind).
### Current State
- **Source**: `lyrics_transcriber_temp/lyrics_transcriber/frontend/src/`
- **Target**: `frontend/components/lyrics-review/` and `frontend/lib/lyrics-review/`
- **Placeholder exists at**: `frontend/app/app/jobs/[[...slug]]/client.tsx` (search for `LyricsReviewPlaceholder`)
### Goal
Replace `LyricsReviewPlaceholder` with the actual migrated `LyricsAnalyzer` component, fully converted from MUI to Radix/Tailwind.
## Design System Mapping
The main frontend uses **shadcn/ui** (Radix primitives + Tailwind). Available components are in `frontend/components/ui/`.
### MUI → shadcn/Tailwind Mapping
| MUI Component | shadcn Equivalent | Notes |
|---------------|-------------------|-------|
| `Button` | `components/ui/button.tsx` | Use `variant` prop |
| `IconButton` | `Button` with `variant="ghost" size="icon"` | |
| `Dialog` | `components/ui/dialog.tsx` | |
| `TextField` | `components/ui/input.tsx` | |
| `Select` | `components/ui/select.tsx` | |
| `Slider` | `components/ui/slider.tsx` | |
| `Tabs`, `Tab` | `components/ui/tabs.tsx` | |
| `Tooltip` | `components/ui/tooltip.tsx` | |
| `CircularProgress` | `components/ui/spinner.tsx` | |
| `Snackbar` | `sonner` toast (already configured) | Use `toast()` from sonner |
| `Box` | `<div>` with Tailwind classes | |
| `Typography` | Tailwind text classes | `text-sm`, `font-semibold`, etc. |
| `Paper` | `components/ui/card.tsx` | |
| `Accordion` | `components/ui/accordion.tsx` | |
| `Checkbox` | `components/ui/checkbox.tsx` | |
| `Switch` | `components/ui/switch.tsx` | |
| `Menu`, `MenuItem` | `components/ui/dropdown-menu.tsx` | |
| `Popover` | `components/ui/popover.tsx` | |
| `LinearProgress` | `components/ui/progress.tsx` | |
### Theme/Styling Mapping
**MUI Theme → Tailwind CSS Variables:**
```
theme.palette.primary.main → text-primary, bg-primary
theme.palette.secondary.main → text-secondary, bg-secondary
theme.palette.error.main → text-destructive, bg-destructive
theme.palette.background.paper → bg-card
theme.palette.text.primary → text-foreground
theme.palette.text.secondary → text-muted-foreground
theme.spacing(2) → Tailwind spacing (p-2, m-2, gap-2)
```
**MUI sx prop → Tailwind classes:**
```jsx
// Before (MUI)
<Box sx={{ display: 'flex', gap: 2, p: 1, bgcolor: 'background.paper' }}>
// After (Tailwind)
<div className="flex gap-2 p-1 bg-card">
```
**Emotion styled → Tailwind:**
```jsx
// Before (Emotion)
const StyledButton = styled(Button)`
background-color: #1976d2;
&:hover { background-color: #1565c0; }
`;
// After (Tailwind)
<Button className="bg-blue-600 hover:bg-blue-700">
```
## Migration Order (Dependency-Based)
Migrate in this order to minimize broken imports:
### Tier 1: Core Types & Utilities (No UI - copy with minimal changes)
| File | Source | Target | Notes |
|------|--------|--------|-------|
| `types.ts` | `src/types.ts` | `lib/lyrics-review/types.ts` | Copy as-is |
| `validation.ts` | `src/validation.ts` | `lib/lyrics-review/validation.ts` | Copy as-is |
| `shared/types.ts` | `src/components/shared/types.ts` | Merge into `types.ts` | |
| `shared/constants.ts` | `src/components/shared/constants.ts` | `lib/lyrics-review/constants.ts` | |
### Tier 2: Utility Functions (No UI)
| File | Source | Target |
|------|--------|--------|
| `localStorage.ts` | `src/components/shared/utils/localStorage.ts` | `lib/lyrics-review/utils/localStorage.ts` |
| `keyboardHandlers.ts` | `src/components/shared/utils/keyboardHandlers.ts` | `lib/lyrics-review/utils/keyboardHandlers.ts` |
| `segmentOperations.ts` | `src/components/shared/utils/segmentOperations.ts` | `lib/lyrics-review/utils/segmentOperations.ts` |
| `timingUtils.ts` | `src/components/shared/utils/timingUtils.ts` | `lib/lyrics-review/utils/timingUtils.ts` |
| `wordUtils.ts` | `src/components/shared/utils/wordUtils.ts` | `lib/lyrics-review/utils/wordUtils.ts` |
| `referenceLineCalculator.ts` | `src/components/shared/utils/referenceLineCalculator.ts` | `lib/lyrics-review/utils/referenceLineCalculator.ts` |
### Tier 3: Base Components (Simple UI)
| Component | Source | Target | Complexity |
|-----------|--------|--------|------------|
| `Word.tsx` | `src/components/shared/components/Word.tsx` | `components/lyrics-review/shared/Word.tsx` | Low |
| `HighlightedText.tsx` | `src/components/shared/components/HighlightedText.tsx` | `components/lyrics-review/shared/HighlightedText.tsx` | Low |
| `SourceSelector.tsx` | `src/components/shared/components/SourceSelector.tsx` | `components/lyrics-review/shared/SourceSelector.tsx` | Medium |
| `AudioPlayer.tsx` | `src/components/AudioPlayer.tsx` | `components/lyrics-review/AudioPlayer.tsx` | Medium |
### Tier 4: View Components (Complex UI)
| Component | Source | Target | Complexity |
|-----------|--------|--------|------------|
| `TranscriptionView.tsx` | `src/components/TranscriptionView.tsx` | `components/lyrics-review/TranscriptionView.tsx` | High |
| `ReferenceView.tsx` | `src/components/ReferenceView.tsx` | `components/lyrics-review/ReferenceView.tsx` | Medium |
| `DurationTimelineView.tsx` | `src/components/DurationTimelineView.tsx` | `components/lyrics-review/DurationTimelineView.tsx` | Medium |
| `EditWordList.tsx` | `src/components/EditWordList.tsx` | `components/lyrics-review/EditWordList.tsx` | High |
| `TimelineEditor.tsx` | `src/components/TimelineEditor.tsx` | `components/lyrics-review/TimelineEditor.tsx` | High |
### Tier 5: Modal Components
| Component | Source | Target | Complexity |
|-----------|--------|--------|------------|
| `FindReplaceModal.tsx` | `src/components/FindReplaceModal.tsx` | `components/lyrics-review/modals/FindReplaceModal.tsx` | Medium |
| `ReviewChangesModal.tsx` | `src/components/ReviewChangesModal.tsx` | `components/lyrics-review/modals/ReviewChangesModal.tsx` | Medium |
| `SegmentDetailsModal.tsx` | `src/components/SegmentDetailsModal.tsx` | `components/lyrics-review/modals/SegmentDetailsModal.tsx` | Medium |
| `ReplaceAllLyricsModal.tsx` | `src/components/ReplaceAllLyricsModal.tsx` | `components/lyrics-review/modals/ReplaceAllLyricsModal.tsx` | Medium |
| `TimingOffsetModal.tsx` | `src/components/TimingOffsetModal.tsx` | `components/lyrics-review/modals/TimingOffsetModal.tsx` | Low |
| `AddLyricsModal.tsx` | `src/components/AddLyricsModal.tsx` | `components/lyrics-review/modals/AddLyricsModal.tsx` | Medium |
| `ModeSelectionModal.tsx` | `src/components/ModeSelectionModal.tsx` | `components/lyrics-review/modals/ModeSelectionModal.tsx` | Low |
| `CorrectionAnnotationModal.tsx` | `src/components/CorrectionAnnotationModal.tsx` | `components/lyrics-review/modals/CorrectionAnnotationModal.tsx` | Medium |
| `AIFeedbackModal.tsx` | `src/components/AIFeedbackModal.tsx` | `components/lyrics-review/modals/AIFeedbackModal.tsx` | Medium |
### Tier 6: Lyrics Synchronizer (Complex)
| Component | Source | Target | Complexity |
|-----------|--------|--------|------------|
| `index.tsx` | `src/components/LyricsSynchronizer/index.tsx` | `components/lyrics-review/synchronizer/index.tsx` | High |
| `TimelineCanvas.tsx` | `src/components/LyricsSynchronizer/TimelineCanvas.tsx` | `components/lyrics-review/synchronizer/TimelineCanvas.tsx` | High |
| `SyncControls.tsx` | `src/components/LyricsSynchronizer/SyncControls.tsx` | `components/lyrics-review/synchronizer/SyncControls.tsx` | Medium |
| `UpcomingWordsBar.tsx` | `src/components/LyricsSynchronizer/UpcomingWordsBar.tsx` | `components/lyrics-review/synchronizer/UpcomingWordsBar.tsx` | Low |
### Tier 7: Main Container & Supporting
| Component | Source | Target | Complexity |
|-----------|--------|--------|------------|
| `LyricsAnalyzer.tsx` | `src/components/LyricsAnalyzer.tsx` | `components/lyrics-review/LyricsAnalyzer.tsx` | Very High |
| `Header.tsx` | `src/components/Header.tsx` | `components/lyrics-review/Header.tsx` | Medium |
| `EditActionBar.tsx` | `src/components/EditActionBar.tsx` | `components/lyrics-review/EditActionBar.tsx` | Medium |
| `CorrectedWordWithActions.tsx` | `src/components/CorrectedWordWithActions.tsx` | `components/lyrics-review/CorrectedWordWithActions.tsx` | Medium |
| `PreviewVideoSection.tsx` | `src/components/PreviewVideoSection.tsx` | `components/lyrics-review/PreviewVideoSection.tsx` | Medium |
### Tier 8: Metrics & Dashboard
| Component | Source | Target | Complexity |
|-----------|--------|--------|------------|
| `CorrectionMetrics.tsx` | `src/components/CorrectionMetrics.tsx` | `components/lyrics-review/CorrectionMetrics.tsx` | Low |
| `AgenticCorrectionMetrics.tsx` | `src/components/AgenticCorrectionMetrics.tsx` | `components/lyrics-review/AgenticCorrectionMetrics.tsx` | Low |
| `MetricsDashboard.tsx` | `src/components/MetricsDashboard.tsx` | `components/lyrics-review/MetricsDashboard.tsx` | Medium |
## API Integration
The current Lyrics Review frontend has its own API client at `src/api.ts` (LiveApiClient). This needs to be integrated into the main frontend's API client.
### Current API Endpoints Used
```typescript
// From lyrics_transcriber_temp/.../api.ts
GET {baseApiUrl}/correction-data → Get lyrics correction data
POST {baseApiUrl}/corrections → Submit corrections
GET {baseApiUrl}/metadata → Get job metadata
POST {baseApiUrl}/generate-preview → Generate preview video
GET {baseApiUrl}/preview-status → Check preview generation status
```
### Integration Approach
1. Add these endpoints to `frontend/lib/api.ts`
2. Update components to use the main API client instead of LiveApiClient
3. Remove token-based auth (now using job ownership model)
**Add to `frontend/lib/api.ts`:**
```typescript
// Lyrics Review endpoints
async getLyricsReviewData(jobId: string): Promise<CorrectionData> {
const response = await fetch(`${API_BASE_URL}/api/review/${jobId}/correction-data`, {
headers: getAuthHeaders()
});
return handleResponse(response);
},
async submitLyricsCorrections(jobId: string, corrections: CorrectionData): Promise<void> {
const response = await fetch(`${API_BASE_URL}/api/review/${jobId}/corrections`, {
method: 'POST',
headers: { 'Content-Type': 'application/json', ...getAuthHeaders() },
body: JSON.stringify(corrections),
});
return handleResponse(response);
},
async generatePreview(jobId: string, corrections: CorrectionData): Promise<{ status: string }> {
const response = await fetch(`${API_BASE_URL}/api/review/${jobId}/generate-preview`, {
method: 'POST',
headers: { 'Content-Type': 'application/json', ...getAuthHeaders() },
body: JSON.stringify(corrections),
});
return handleResponse(response);
},
async getPreviewStatus(jobId: string): Promise<{ status: string; preview_url?: string }> {
const response = await fetch(`${API_BASE_URL}/api/review/${jobId}/preview-status`, {
headers: getAuthHeaders()
});
return handleResponse(response);
},
```
## Target Directory Structure
```
frontend/
├── components/
│ └── lyrics-review/
│ ├── LyricsAnalyzer.tsx # Main container
│ ├── Header.tsx
│ ├── AudioPlayer.tsx
│ ├── TranscriptionView.tsx
│ ├── ReferenceView.tsx
│ ├── DurationTimelineView.tsx
│ ├── EditWordList.tsx
│ ├── TimelineEditor.tsx
│ ├── EditActionBar.tsx
│ ├── CorrectedWordWithActions.tsx
│ ├── PreviewVideoSection.tsx
│ ├── CorrectionMetrics.tsx
│ ├── AgenticCorrectionMetrics.tsx
│ ├── MetricsDashboard.tsx
│ ├── modals/
│ │ ├── FindReplaceModal.tsx
│ │ ├── ReviewChangesModal.tsx
│ │ ├── SegmentDetailsModal.tsx
│ │ ├── ReplaceAllLyricsModal.tsx
│ │ ├── TimingOffsetModal.tsx
│ │ ├── AddLyricsModal.tsx
│ │ ├── ModeSelectionModal.tsx
│ │ ├── CorrectionAnnotationModal.tsx
│ │ └── AIFeedbackModal.tsx
│ ├── synchronizer/
│ │ ├── index.tsx
│ │ ├── TimelineCanvas.tsx
│ │ ├── SyncControls.tsx
│ │ └── UpcomingWordsBar.tsx
│ └── shared/
│ ├── Word.tsx
│ ├── HighlightedText.tsx
│ └── SourceSelector.tsx
└── lib/
└── lyrics-review/
├── types.ts
├── validation.ts
├── constants.ts
└── utils/
├── localStorage.ts
├── keyboardHandlers.ts
├── segmentOperations.ts
├── timingUtils.ts
├── wordUtils.ts
└── referenceLineCalculator.ts
```
## Acceptance Criteria
1. **Build passes**: `cd frontend && npm run build` succeeds
2. **No MUI imports**: No `@mui/*` or `@emotion/*` imports in migrated code
3. **Placeholder replaced**: `LyricsReviewPlaceholder` in `client.tsx` replaced with actual `LyricsAnalyzer`
4. **Visual parity**: UI looks similar to current (doesn't need to be pixel-perfect)
5. **Functionality works**:
- Can load correction data for a job
- Can edit lyrics (add, delete, modify words)
- Can adjust timing
- Can submit corrections
- Preview video generation works
6. **Tests pass**: Any existing tests continue to pass
## Execution Notes
### Suggested Sub-Tasks
Given the scope, consider breaking this into multiple agent sessions:
1. **Session A**: Tier 1-2 (types, utilities) - Quick, no UI work
2. **Session B**: Tier 3-4 (base + view components) - Medium complexity
3. **Session C**: Tier 5 (modals) - Repetitive, medium complexity
4. **Session D**: Tier 6 (synchronizer) - Complex, self-contained
5. **Session E**: Tier 7-8 + integration - Main container, final assembly
### Common Patterns to Watch For
1. **MUI `sx` prop**: Convert to Tailwind classes
2. **Emotion `styled`**: Convert to Tailwind classes or component variants
3. **MUI theme access**: Replace `theme.palette.*` with Tailwind colors
4. **MUI icons**: Already using Lucide icons (same as main frontend)
5. **MUI `useTheme`**: Remove, use Tailwind dark mode classes
### Testing During Migration
After each tier, verify:
```bash
cd frontend
npm run build # Should pass
npm run dev # Should start without errors
```
## Related Files
- **Plan document**: `docs/archive/2026-01-09-frontend-consolidation-plan.md`
- **Brand style guide**: `docs/BRAND-STYLE-GUIDE.md`
- **Testing guide**: `docs/TESTING.md`
## Questions to Resolve During Execution
1. **Audio waveform**: Current uses a custom canvas implementation. Keep or find Tailwind-compatible library?
2. **Complex canvas components**: TimelineCanvas, TimelineEditor - may need to keep as-is with minimal styling changes
3. **Keyboard shortcuts**: Current uses custom hook - ensure it works in Next.js context
@@ -0,0 +1,349 @@
# Task: Migrate Instrumental Review to Main Frontend
**Task ID**: TASK-002
**Status**: Ready for execution
**Estimated scope**: ~1,700 lines (single HTML file → 5-6 React components)
**Approach**: Convert vanilla HTML/JS to React + Tailwind
## Context
The Instrumental Review UI is currently a single HTML file with embedded JavaScript, served by the backend. This task converts it to React components in the main frontend.
### Current State
- **Source**: `karaoke_gen/instrumental_review/static/index.html` (~1,700 lines)
- **Target**: `frontend/components/instrumental-review/`
- **Placeholder exists at**: `frontend/app/app/jobs/[[...slug]]/client.tsx` (search for `InstrumentalSelectionPlaceholder`)
### Goal
Replace `InstrumentalSelectionPlaceholder` with actual `InstrumentalSelector` component.
## Source File Analysis
The source HTML file contains:
### Embedded CSS (~300 lines)
- CSS variables for theming (already matches main frontend)
- Waveform visualization styles
- Audio player controls
- Mute region editor styles
### Embedded JavaScript (~1,200 lines)
Key functionality:
1. **URL parameter parsing** - Gets `baseApiUrl` and `instrumentalToken`
2. **API calls** - Fetches analysis, waveform data, submits selection
3. **Audio playback** - Multiple audio elements for A/B comparison
4. **Waveform rendering** - Canvas-based visualization
5. **Mute region editing** - Interactive drag-to-select regions
6. **Custom instrumental upload** - File upload with validation
### UI Sections
1. **Header** - Song title, back button
2. **Stem comparison** - Play/pause buttons for each instrumental option
3. **Waveform viewer** - Visual representation of audio
4. **Selection options** - Radio buttons for clean/with_backing/custom
5. **Mute region editor** - Interactive timeline for custom muting
6. **Upload section** - Drag-and-drop file upload
7. **Submit button** - Confirm selection
## Target Structure
```
frontend/components/instrumental-review/
├── InstrumentalSelector.tsx # Main container
├── StemComparison.tsx # A/B comparison audio players
├── WaveformViewer.tsx # Canvas waveform visualization
├── SelectionOptions.tsx # Radio group for selection
├── MuteRegionEditor.tsx # Interactive mute region UI
└── CustomUpload.tsx # File upload component
```
## API Integration
### Current Endpoints Used
```javascript
// From index.html
GET {baseApiUrl}/instrumental-analysis → Get available stems and analysis
GET {baseApiUrl}/waveform-data?num_points=1000 → Get waveform points
POST {baseApiUrl}/select-instrumental → Submit selection choice
POST {baseApiUrl}/upload-instrumental → Upload custom file
POST {baseApiUrl}/create-custom-instrumental → Create with mute regions
GET {baseApiUrl}/audio-stream/{stem_type} → Stream audio for playback
```
### Add to `frontend/lib/api.ts`
```typescript
// Instrumental Review endpoints
async getInstrumentalAnalysis(jobId: string): Promise<InstrumentalAnalysis> {
const response = await fetch(`${API_BASE_URL}/api/jobs/${jobId}/instrumental-analysis`, {
headers: getAuthHeaders()
});
return handleResponse(response);
},
async getWaveformData(jobId: string, numPoints: number = 1000): Promise<WaveformData> {
const response = await fetch(
`${API_BASE_URL}/api/jobs/${jobId}/waveform-data?num_points=${numPoints}`,
{ headers: getAuthHeaders() }
);
return handleResponse(response);
},
async selectInstrumentalOption(
jobId: string,
selection: 'clean' | 'with_backing' | 'custom',
muteRegions?: MuteRegion[]
): Promise<void> {
const body: Record<string, unknown> = { selection };
if (muteRegions) body.mute_regions = muteRegions;
const response = await fetch(`${API_BASE_URL}/api/jobs/${jobId}/select-instrumental`, {
method: 'POST',
headers: { 'Content-Type': 'application/json', ...getAuthHeaders() },
body: JSON.stringify(body),
});
return handleResponse(response);
},
async uploadCustomInstrumental(jobId: string, file: File): Promise<void> {
const formData = new FormData();
formData.append('file', file);
const response = await fetch(`${API_BASE_URL}/api/jobs/${jobId}/upload-instrumental`, {
method: 'POST',
headers: getAuthHeaders(),
body: formData,
});
return handleResponse(response);
},
async createCustomInstrumental(jobId: string, muteRegions: MuteRegion[]): Promise<void> {
const response = await fetch(`${API_BASE_URL}/api/jobs/${jobId}/create-custom-instrumental`, {
method: 'POST',
headers: { 'Content-Type': 'application/json', ...getAuthHeaders() },
body: JSON.stringify({ mute_regions: muteRegions }),
});
return handleResponse(response);
},
getAudioStreamUrl(jobId: string, stemType: string): string {
const token = getAccessToken();
const base = `${API_BASE_URL}/api/jobs/${jobId}/audio-stream/${stemType}`;
return token ? `${base}?token=${encodeURIComponent(token)}` : base;
},
```
### Types to Add
```typescript
// In frontend/lib/types.ts or frontend/lib/api.ts
interface InstrumentalAnalysis {
job_id: string;
artist: string;
title: string;
duration_seconds: number;
available_stems: {
clean: boolean;
with_backing: boolean;
};
backing_vocal_analysis?: {
detected: boolean;
confidence: number;
regions: Array<{ start: number; end: number; confidence: number }>;
};
}
interface WaveformData {
peaks: number[]; // Normalized 0-1
duration_seconds: number;
sample_rate: number;
}
interface MuteRegion {
start: number; // Seconds
end: number; // Seconds
}
```
## Component Specifications
### 1. InstrumentalSelector.tsx (Main Container)
```tsx
interface InstrumentalSelectorProps {
jobId: string;
artist: string;
title: string;
onComplete: () => void; // Called after successful selection
}
```
Responsibilities:
- Fetch analysis and waveform data on mount
- Manage selection state
- Coordinate between child components
- Handle submission
### 2. StemComparison.tsx
```tsx
interface StemComparisonProps {
jobId: string;
availableStems: { clean: boolean; with_backing: boolean };
currentlyPlaying: string | null;
onPlay: (stem: string) => void;
onPause: () => void;
}
```
Features:
- Two audio players (clean, with_backing)
- Play/pause buttons
- A/B toggle
- Volume control (optional)
### 3. WaveformViewer.tsx
```tsx
interface WaveformViewerProps {
peaks: number[];
duration: number;
currentTime: number;
muteRegions?: MuteRegion[];
onSeek?: (time: number) => void;
}
```
Features:
- Canvas-based waveform rendering
- Playback position indicator
- Mute regions overlay (if provided)
- Click to seek
### 4. SelectionOptions.tsx
```tsx
interface SelectionOptionsProps {
value: 'clean' | 'with_backing' | 'custom';
onChange: (value: 'clean' | 'with_backing' | 'custom') => void;
availableStems: { clean: boolean; with_backing: boolean };
backingVocalAnalysis?: BackingVocalAnalysis;
}
```
Features:
- Radio group for selection
- Disabled states for unavailable options
- Help text explaining each option
- AI recommendation badge (if backing vocals detected)
### 5. MuteRegionEditor.tsx
```tsx
interface MuteRegionEditorProps {
duration: number;
regions: MuteRegion[];
onChange: (regions: MuteRegion[]) => void;
waveformPeaks?: number[];
}
```
Features:
- Timeline with waveform background
- Click-drag to create regions
- Drag edges to resize
- Click region to delete
- List of regions with timestamps
### 6. CustomUpload.tsx
```tsx
interface CustomUploadProps {
onUpload: (file: File) => Promise<void>;
isUploading: boolean;
acceptedFormats: string[]; // e.g., ['.flac', '.wav', '.mp3']
}
```
Features:
- Drag-and-drop zone
- File type validation
- Upload progress indicator
- Error handling
## Styling Approach
The source uses CSS variables that match the main frontend:
```css
:root {
--background: #1a1a1a;
--card: #2a2a2a;
--text: #ffffff;
--text-muted: #888888;
--primary: #ff7acc;
--border: #333333;
}
```
Convert to Tailwind classes:
- `background-color: var(--background)` → `bg-background`
- `color: var(--text-muted)` → `text-muted-foreground`
- `border-color: var(--border)` → `border-border`
## Canvas Components
The waveform viewer and mute region editor use `<canvas>`. Keep the canvas logic but:
1. Wrap in React component with proper lifecycle
2. Use refs for canvas access
3. Handle resize with ResizeObserver
4. Clean up event listeners on unmount
## Acceptance Criteria
1. **Build passes**: `cd frontend && npm run build` succeeds
2. **No vanilla JS**: All logic converted to React
3. **Placeholder replaced**: `InstrumentalSelectionPlaceholder` replaced with `InstrumentalSelector`
4. **Functionality works**:
- Can play/pause both instrumental options
- Waveform displays correctly
- Can select between clean/with_backing/custom
- Mute region editor works (create, resize, delete regions)
- Custom upload works
- Selection submits successfully
- Redirects to dashboard after completion
5. **Keyboard shortcuts preserved**:
- Space: Play/pause
- 1/2: Switch between stems
## Execution Notes
This task is self-contained and can be done in a single session. The main complexity is the canvas-based waveform/timeline components.
### Suggested Order
1. Create types and API client additions
2. Build `SelectionOptions.tsx` (simplest, radio group)
3. Build `StemComparison.tsx` (audio elements)
4. Build `WaveformViewer.tsx` (canvas)
5. Build `MuteRegionEditor.tsx` (canvas + interaction)
6. Build `CustomUpload.tsx` (file handling)
7. Build `InstrumentalSelector.tsx` (assemble everything)
8. Integrate into `client.tsx`
### Testing
After completion:
```bash
cd frontend
npm run build
npm run dev
# Navigate to a job in awaiting_instrumental_selection state
```
## Related Files
- **Plan document**: `docs/archive/2026-01-09-frontend-consolidation-plan.md`
- **Source HTML**: `karaoke_gen/instrumental_review/static/index.html`
- **Backend endpoints**: `karaoke_gen/instrumental_review/server.py`
+5
View File
@@ -1 +1,6 @@
playwright-report-prod/
# Local debug scripts (may contain tokens - never commit)
# Use this pattern for ad-hoc testing: test-*.local.{js,cjs,mjs,ts}
test-*.local.*
debug-*.local.*
File diff suppressed because it is too large. Load diff
+1 -1
View File
@@ -149,7 +149,7 @@ export default function AdminLayout({
</Label>
</div>
</header>
<main className="flex-1 p-4 md:p-6">{children}</main>
<main className="flex-1 p-4 md:p-6 min-w-0 overflow-hidden">{children}</main>
</SidebarInset>
</SidebarProvider>
)
@@ -69,7 +69,7 @@ const mockOverrides = {
{
email: "vip@example.com",
bypass_job_limit: true,
custom_daily_job_limit: null,
custom_daily_job_limit: undefined,
reason: "VIP user",
created_by: "admin@nomadkaraoke.com",
created_at: "2025-01-08T15:00:00Z",
@@ -242,7 +242,7 @@ describe("AdminRateLimitsPage", () => {
})
it("adds a disposable domain", async () => {
mockAdminApi.addDisposableDomain.mockResolvedValue({ success: true })
mockAdminApi.addDisposableDomain.mockResolvedValue({ success: true, message: "Operation successful" })
const user = userEvent.setup()
render(<AdminRateLimitsPage />)
@@ -339,7 +339,7 @@ describe("AdminRateLimitsPage", () => {
})
it("creates a new override", async () => {
mockAdminApi.setUserOverride.mockResolvedValue({ success: true })
mockAdminApi.setUserOverride.mockResolvedValue({ success: true, message: "Operation successful" })
const user = userEvent.setup()
render(<AdminRateLimitsPage />)
+20 -2
View File
@@ -70,6 +70,9 @@ export default function AdminUsersPage() {
const [creditReason, setCreditReason] = useState("")
const [addingCredits, setAddingCredits] = useState(false)
// Impersonation state - tracks which user is being impersonated (for loading indicator)
const [impersonatingEmail, setImpersonatingEmail] = useState<string | null>(null)
const loadUsers = useCallback(async () => {
try {
setLoading(true)
@@ -158,6 +161,7 @@ export default function AdminUsersPage() {
return
}
setImpersonatingEmail(user.email)
try {
const success = await startImpersonation(user.email)
if (success) {
@@ -167,6 +171,14 @@ export default function AdminUsersPage() {
})
// Redirect to main app to see the user's view
router.push("/app")
} else {
// startImpersonation returned false - get the error from auth store
const authError = useAuth.getState().error
toast({
title: "Impersonation Failed",
description: authError || "Unable to impersonate user. Please try again.",
variant: "destructive",
})
}
} catch (err: any) {
toast({
@@ -174,6 +186,8 @@ export default function AdminUsersPage() {
description: err.message || "Failed to impersonate user",
variant: "destructive",
})
} finally {
setImpersonatingEmail(null)
}
}
@@ -298,9 +312,13 @@ export default function AdminUsersPage() {
size="icon"
onClick={() => handleImpersonate(user)}
title="Impersonate user"
disabled={user.email === currentUser?.email}
disabled={user.email === currentUser?.email || impersonatingEmail !== null}
>
<LogIn className="w-4 h-4" />
{impersonatingEmail === user.email ? (
<Loader2 className="w-4 h-4 animate-spin" />
) : (
<LogIn className="w-4 h-4" />
)}
</Button>
</div>
</TableCell>
@@ -0,0 +1,432 @@
"use client"
import { useEffect, useState, useCallback } from "react"
import { useParams } from "next/navigation"
import { useAuth } from "@/lib/auth"
import { api, Job, createLyricsReviewApiClient, lyricsReviewApi } from "@/lib/api"
import { Spinner } from "@/components/ui/spinner"
import { Button } from "@/components/ui/button"
import { ArrowLeft, AlertCircle } from "lucide-react"
import Link from "next/link"
import { InstrumentalSelector } from "@/components/instrumental-review"
import { LyricsAnalyzer } from "@/components/lyrics-review"
import { ThemeToggle } from "@/components/ThemeToggle"
import type { CorrectionData } from "@/lib/lyrics-review/types"
import { isLocalMode, createLocalModeJob } from "@/lib/local-mode"
type RouteType = "review" | "instrumental" | "unknown"
type AccessState =
| { status: "loading" }
| { status: "not_authenticated" }
| { status: "not_authorized"; reason: string }
| { status: "job_not_found" }
| { status: "wrong_state"; currentState: string; expectedStates: string[] }
| { status: "invalid_route" }
| { status: "authorized"; job: Job; routeType: RouteType }
| { status: "local_mode"; job: Job; routeType: RouteType }
// Parse route from Next.js slug params (used for local mode with path-based routing)
function parseRouteFromSlug(slug: string[] | undefined): { jobId: string | null; routeType: RouteType } {
if (!slug || slug.length === 0) {
return { jobId: null, routeType: "unknown" }
}
// Expected formats:
// [jobId, "review"] -> /app/jobs/{jobId}/review
// [jobId, "instrumental"] -> /app/jobs/{jobId}/instrumental
if (slug.length === 2) {
const [jobId, action] = slug
if (action === "review") {
return { jobId, routeType: "review" }
}
if (action === "instrumental") {
return { jobId, routeType: "instrumental" }
}
}
return { jobId: null, routeType: "unknown" }
}
// Parse route from URL hash (used for cloud mode)
// Expected format: #/{jobId}/review or #/{jobId}/instrumental
function parseRouteFromHash(hash: string): { jobId: string | null; routeType: RouteType } {
if (!hash || hash.length <= 1) {
return { jobId: null, routeType: "unknown" }
}
// Remove the leading '#' and parse
const hashPath = hash.substring(1)
const match = hashPath.match(/^\/?([^/]+)\/(review|instrumental)\/?$/)
if (match) {
const [, jobId, action] = match
return { jobId, routeType: action as RouteType }
}
return { jobId: null, routeType: "unknown" }
}
function getExpectedStates(routeType: RouteType): string[] {
switch (routeType) {
case "review":
return ["awaiting_review", "in_review"]
case "instrumental":
return ["awaiting_instrumental_selection"]
default:
return []
}
}
export function JobRouterClient() {
const params = useParams()
const slug = params.slug as string[] | undefined
// Track hash for re-renders when hash changes
const [hash, setHash] = useState(() =>
typeof window !== 'undefined' ? window.location.hash : ''
)
// Listen for hash changes
useEffect(() => {
const handleHashChange = () => {
setHash(window.location.hash)
}
window.addEventListener('hashchange', handleHashChange)
return () => window.removeEventListener('hashchange', handleHashChange)
}, [])
// Determine routing mode and parse route
// - Local mode: Use path-based routing from Next.js slug params
// - Cloud mode: Use hash-based routing (e.g., /app/jobs/#/{jobId}/review)
const inLocalMode = isLocalMode()
const { jobId, routeType } = inLocalMode
? parseRouteFromSlug(slug)
: parseRouteFromHash(hash)
const { user, isLoading: authLoading, hasHydrated } = useAuth()
const [accessState, setAccessState] = useState<AccessState>({ status: "loading" })
useEffect(() => {
async function checkAccess() {
// Handle local mode (skip all auth checks)
if (inLocalMode) {
// In local mode, determine route type from URL or default to review
let localRouteType: RouteType = routeType
// If route is unknown but we're in local mode, try to determine from path
if (localRouteType === "unknown") {
const path = typeof window !== 'undefined' ? window.location.pathname : ''
if (path.includes('instrumental')) {
localRouteType = "instrumental"
} else {
localRouteType = "review" // Default to review in local mode
}
}
// Create mock job for local mode
const localJob = createLocalModeJob({ routeType: localRouteType }) as Job
setAccessState({ status: "local_mode", job: localJob, routeType: localRouteType })
return
}
// Cloud mode: Check hash-based route
if (!jobId || routeType === "unknown") {
setAccessState({ status: "invalid_route" })
return
}
// Wait for auth to finish loading and hydration to complete
// This prevents a flash of "Sign in required" before auth state is restored from localStorage
if (authLoading || !hasHydrated) return
// Must be authenticated
if (!user) {
setAccessState({ status: "not_authenticated" })
return
}
try {
// Fetch job details
const job = await api.getJob(jobId)
// Check ownership: user must own the job or be admin
const isOwner = job.user_email === user.email
const isAdmin = user.role === "admin"
if (!isOwner && !isAdmin) {
setAccessState({
status: "not_authorized",
reason: "You don't have permission to access this job"
})
return
}
// Check job is in correct state
const expectedStates = getExpectedStates(routeType)
if (!expectedStates.includes(job.status)) {
setAccessState({
status: "wrong_state",
currentState: job.status,
expectedStates
})
return
}
// All checks passed
setAccessState({ status: "authorized", job, routeType })
} catch (error: unknown) {
// Job not found or API error
if (error && typeof error === "object" && "status" in error && error.status === 404) {
setAccessState({ status: "job_not_found" })
} else {
setAccessState({
status: "not_authorized",
reason: "Failed to load job details"
})
}
}
}
checkAccess()
}, [inLocalMode, jobId, routeType, user, authLoading, hasHydrated])
// Loading state
if (accessState.status === "loading") {
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center">
<Spinner className="w-8 h-8 mx-auto mb-4" />
<p className="text-muted-foreground">Loading...</p>
</div>
</div>
)
}
// Invalid route
if (accessState.status === "invalid_route") {
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center max-w-md p-6">
<AlertCircle className="w-12 h-12 mx-auto mb-4 text-red-500" />
<h1 className="text-xl font-semibold mb-2">Page not found</h1>
<p className="text-muted-foreground mb-4">
The page you&apos;re looking for doesn&apos;t exist.
</p>
<Button variant="outline" asChild>
<Link href="/app">
<ArrowLeft className="w-4 h-4 mr-2" />
Back to dashboard
</Link>
</Button>
</div>
</div>
)
}
// Not authenticated
if (accessState.status === "not_authenticated") {
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center max-w-md p-6">
<AlertCircle className="w-12 h-12 mx-auto mb-4 text-amber-500" />
<h1 className="text-xl font-semibold mb-2">Sign in required</h1>
<p className="text-muted-foreground mb-4">
You need to sign in to access this page.
</p>
<Button asChild>
<Link href="/app">Sign in</Link>
</Button>
</div>
</div>
)
}
// Not authorized
if (accessState.status === "not_authorized") {
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center max-w-md p-6">
<AlertCircle className="w-12 h-12 mx-auto mb-4 text-red-500" />
<h1 className="text-xl font-semibold mb-2">Access denied</h1>
<p className="text-muted-foreground mb-4">{accessState.reason}</p>
<Button variant="outline" asChild>
<Link href="/app">
<ArrowLeft className="w-4 h-4 mr-2" />
Back to dashboard
</Link>
</Button>
</div>
</div>
)
}
// Job not found
if (accessState.status === "job_not_found") {
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center max-w-md p-6">
<AlertCircle className="w-12 h-12 mx-auto mb-4 text-red-500" />
<h1 className="text-xl font-semibold mb-2">Job not found</h1>
<p className="text-muted-foreground mb-4">
The job you&apos;re looking for doesn&apos;t exist or has been deleted.
</p>
<Button variant="outline" asChild>
<Link href="/app">
<ArrowLeft className="w-4 h-4 mr-2" />
Back to dashboard
</Link>
</Button>
</div>
</div>
)
}
// Wrong state
if (accessState.status === "wrong_state") {
const actionName = routeType === "review" ? "lyrics review" : "instrumental selection"
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center max-w-md p-6">
<AlertCircle className="w-12 h-12 mx-auto mb-4 text-amber-500" />
<h1 className="text-xl font-semibold mb-2">Not available</h1>
<p className="text-muted-foreground mb-4">
This job is currently in &quot;{accessState.currentState}&quot; state and is not ready for {actionName}.
</p>
<Button variant="outline" asChild>
<Link href="/app">
<ArrowLeft className="w-4 h-4 mr-2" />
Back to dashboard
</Link>
</Button>
</div>
</div>
)
}
// Authorized or local mode - render the appropriate UI
const { job, routeType: authorizedRouteType } = accessState
if (authorizedRouteType === "review") {
return <LyricsReviewWrapper job={job} isLocalMode={inLocalMode} />
}
if (authorizedRouteType === "instrumental") {
return <InstrumentalSelector job={job} isLocalMode={inLocalMode} />
}
return null
}
// Lyrics Review Component Wrapper
function LyricsReviewWrapper({ job, isLocalMode = false }: { job: Job; isLocalMode?: boolean }) {
const [correctionData, setCorrectionData] = useState<CorrectionData | null>(null)
const [isLoading, setIsLoading] = useState(true)
const [error, setError] = useState<string | null>(null)
// Create the API client for this job
const apiClient = createLyricsReviewApiClient(job.job_id)
// Load correction data
useEffect(() => {
async function loadData() {
try {
setIsLoading(true)
setError(null)
const data = await lyricsReviewApi.getCorrectionData(job.job_id)
setCorrectionData(data)
} catch (err) {
console.error("Failed to load correction data:", err)
setError(err instanceof Error ? err.message : "Failed to load lyrics data")
} finally {
setIsLoading(false)
}
}
loadData()
}, [job.job_id])
// File load handler (opens file picker for local file)
const handleFileLoad = useCallback(() => {
// For now, this is a no-op since we load from API
// Could be extended to allow loading from local files
console.log("File load requested")
}, [])
// Metadata handler
const handleShowMetadata = useCallback(() => {
// Could show a modal with job metadata
console.log("Show metadata requested", job)
}, [job])
if (isLoading) {
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center">
<Spinner className="w-8 h-8 mx-auto mb-4" />
<p className="text-muted-foreground">Loading lyrics data...</p>
</div>
</div>
)
}
if (error || !correctionData) {
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center max-w-md p-6">
<AlertCircle className="w-12 h-12 mx-auto mb-4 text-red-500" />
<h1 className="text-xl font-semibold mb-2">Failed to load lyrics</h1>
<p className="text-muted-foreground mb-4">
{error || "Could not load lyrics data for this job."}
</p>
{!isLocalMode && (
<Button variant="outline" asChild>
<Link href="/app">
<ArrowLeft className="w-4 h-4 mr-2" />
Back to dashboard
</Link>
</Button>
)}
</div>
</div>
)
}
return (
<div className="min-h-screen bg-background">
{/* App Header - matches old frontend's AppHeader */}
<header className="border-b bg-card/80 backdrop-blur-sm sticky top-0 z-50 px-4 py-3">
<div className="flex items-center justify-between">
<div className="flex items-center gap-3">
{!isLocalMode && (
<Button variant="ghost" size="sm" asChild>
<Link href="/app">
<ArrowLeft className="w-4 h-4 mr-2" />
Back
</Link>
</Button>
)}
{/* eslint-disable-next-line @next/next/no-img-element */}
<img
src="/nomad-karaoke-logo.svg"
alt="Nomad Karaoke"
style={{ height: 40 }}
/>
<h1 className="text-lg font-bold">Lyrics Transcription Review</h1>
</div>
<ThemeToggle />
</div>
</header>
<main className="px-4 py-2">
<LyricsAnalyzer
data={correctionData}
onFileLoad={handleFileLoad}
onShowMetadata={handleShowMetadata}
apiClient={apiClient}
isReadOnly={false}
audioHash={correctionData.metadata?.audio_hash || job.audio_hash || job.job_id}
/>
</main>
</div>
)
}
@@ -0,0 +1,16 @@
import { JobRouterClient } from "./client"
// Required for static export with catch-all routes
// Returns params array for paths to pre-render at build time
export async function generateStaticParams(): Promise<{ slug?: string[] }[]> {
return [
{ slug: undefined }, // /app/jobs/
// Local mode paths - pre-rendered for karaoke-gen CLI local review
{ slug: ['local', 'review'] }, // /app/jobs/local/review
{ slug: ['local', 'instrumental'] }, // /app/jobs/local/instrumental
]
}
export default function JobsPage() {
return <JobRouterClient />
}
+1 -1
View File
@@ -236,7 +236,7 @@ function AppPageContent() {
<p>No jobs yet. Create one to get started!</p>
</div>
) : (
<div className="space-y-3 max-h-[500px] overflow-y-auto pr-2">
<div className="space-y-3">
{jobs.map((job) => (
<JobCard key={job.job_id} job={job} onRefresh={loadJobs} />
))}
+13 -4
View File
@@ -10,9 +10,9 @@
=========================================== */
/* Brand Primary Colors */
/* Note: darker pink (#ff5bb8) used as default for better white text contrast */
--brand-pink: #ff5bb8;
--brand-pink-hover: #ff7acc;
/* Note: Using #ff7acc as default to match old UI - softer/lighter pink */
--brand-pink: #ff7acc;
--brand-pink-hover: #ff8fd4;
--brand-pink-glow: rgba(255, 122, 204, 0.4);
--brand-gold: #ffdf6b;
--brand-purple: #8b5cf6;
@@ -66,7 +66,7 @@
--border: var(--card-border);
--input: var(--secondary);
--ring: var(--primary);
--radius: 0.75rem;
--radius: 0.5rem;
}
.light {
@@ -226,4 +226,13 @@
.animate-fade-in {
animation: fade-in 0.3s ease-out forwards;
}
/* Lyrics review flash animation for highlighted words */
@keyframes lyrics-flash {
0%, 100% { opacity: 1; }
50% { opacity: 0.6; background-color: rgba(251, 191, 36, 0.4); }
}
.animate-lyrics-flash {
animation: lyrics-flash 0.5s ease-in-out;
}
}
@@ -12,7 +12,7 @@ jest.mock('@/lib/auth', () => ({
useAuth: jest.fn(),
}))
const mockUseAuth = useAuth as jest.Mock
const mockUseAuth = useAuth as unknown as jest.Mock
// Mock window.location.reload
const mockReload = jest.fn()
@@ -99,9 +99,9 @@ describe('JobCard', () => {
const reviewLink = screen.getByText('Review Lyrics')
expect(reviewLink).toBeInTheDocument()
const href = reviewLink.closest('a')?.getAttribute('href') || ''
expect(href).toContain('gen.nomadkaraoke.com/lyrics')
expect(href).toContain('baseApiUrl=')
expect(href).toContain('reviewToken=test-token-123')
// Uses hash-based routing for static hosting
// Uses <a> tag (not Next.js Link) to ensure hashchange event fires
expect(href).toBe('/app/jobs#/123/review')
})
it('shows audio search button for awaiting_audio_selection status', () => {
@@ -122,9 +122,9 @@ describe('JobCard', () => {
const instrumentalLink = screen.getByText('Select Instrumental')
expect(instrumentalLink).toBeInTheDocument()
const href = instrumentalLink.closest('a')?.getAttribute('href') || ''
expect(href).toContain('/instrumental/')
expect(href).toContain('baseApiUrl=')
expect(href).toContain('instrumentalToken=test-instrumental-token')
// Uses hash-based routing for static hosting
// Uses <a> tag (not Next.js Link) to ensure hashchange event fires
expect(href).toBe('/app/jobs#/123/instrumental')
})
it('does not show Auto badge for regular jobs', () => {
+13 -3
View File
@@ -17,6 +17,7 @@ interface StatsCardProps {
}
loading?: boolean
className?: string
valueClassName?: string
}
export function StatsCard({
@@ -27,6 +28,7 @@ export function StatsCard({
trend,
loading,
className,
valueClassName,
}: StatsCardProps) {
if (loading) {
return (
@@ -53,7 +55,7 @@ export function StatsCard({
{Icon && <Icon className="h-4 w-4 text-muted-foreground" />}
</CardHeader>
<CardContent>
<div className="text-2xl font-bold">{value}</div>
<div className={cn("text-2xl font-bold", valueClassName)}>{value}</div>
{description && (
<p className="text-xs text-muted-foreground mt-1">{description}</p>
)}
@@ -73,12 +75,20 @@ export function StatsCard({
interface StatsGridProps {
children: React.ReactNode
className?: string
columns?: 2 | 3 | 4
}
export function StatsGrid({ children, className }: StatsGridProps) {
export function StatsGrid({ children, className, columns }: StatsGridProps) {
const colsClass = columns === 2
? "md:grid-cols-2"
: columns === 3
? "md:grid-cols-2 lg:grid-cols-3"
: "md:grid-cols-2 lg:grid-cols-4"
return (
<div className={cn(
"grid gap-4 md:grid-cols-2 lg:grid-cols-4",
"grid gap-4",
colsClass,
className
)}>
{children}
@@ -0,0 +1,56 @@
"use client"
import { useRef } from "react"
import { Upload } from "lucide-react"
import { Button } from "@/components/ui/button"
interface CustomUploadProps {
onUpload: (file: File) => Promise<void>
isUploading: boolean
acceptedFormats?: string[]
}
export function CustomUpload({
onUpload,
isUploading,
acceptedFormats = [".flac", ".mp3", ".wav", ".m4a", ".ogg"],
}: CustomUploadProps) {
const inputRef = useRef<HTMLInputElement>(null)
const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
const file = e.target.files?.[0]
if (!file) return
try {
await onUpload(file)
} finally {
// Reset input so same file can be selected again
if (inputRef.current) {
inputRef.current.value = ""
}
}
}
return (
<Button
variant="secondary"
size="sm"
disabled={isUploading}
className="relative h-8 text-xs"
asChild
>
<label className="cursor-pointer">
<Upload className="w-3.5 h-3.5 mr-1.5" />
{isUploading ? "Uploading..." : "Upload"}
<input
ref={inputRef}
type="file"
accept={acceptedFormats.join(",")}
onChange={handleFileChange}
className="absolute inset-0 w-full h-full opacity-0 cursor-pointer"
disabled={isUploading}
/>
</label>
</Button>
)
}
@@ -0,0 +1,678 @@
"use client"
import { useState, useEffect, useRef, useCallback, useMemo } from "react"
import { useRouter } from "next/navigation"
import { Button } from "@/components/ui/button"
import { Spinner } from "@/components/ui/spinner"
import { ArrowLeft, Play, Pause, Check } from "lucide-react"
import Link from "next/link"
import { toast } from "sonner"
import {
api,
type Job,
type InstrumentalAnalysis,
type WaveformData,
type MuteRegion,
type InstrumentalSelectionType,
} from "@/lib/api"
import { StemComparison, type AudioType } from "./StemComparison"
import { WaveformViewer } from "./WaveformViewer"
import { MuteRegionEditor } from "./MuteRegionEditor"
import { SelectionOptions } from "./SelectionOptions"
import { CustomUpload } from "./CustomUpload"
interface InstrumentalSelectorProps {
job: Job
isLocalMode?: boolean
}
type ZoomLevel = 1 | 2 | 4
// Map audio type to stem type for API
const STEM_TYPE_MAP: Record<AudioType, string> = {
original: "original",
backing: "backing_vocals",
clean: "clean_instrumental",
with_backing: "with_backing",
custom: "custom_instrumental",
uploaded: "uploaded_instrumental",
}
function formatTime(seconds: number): string {
if (!Number.isFinite(seconds)) return "0:00"
const mins = Math.floor(seconds / 60)
const secs = Math.floor(seconds % 60)
return `${mins}:${secs.toString().padStart(2, "0")}`
}
export function InstrumentalSelector({ job, isLocalMode = false }: InstrumentalSelectorProps) {
const router = useRouter()
const audioRef = useRef<HTMLAudioElement>(null)
// Data state
const [analysisData, setAnalysisData] = useState<InstrumentalAnalysis | null>(null)
const [waveformData, setWaveformData] = useState<WaveformData | null>(null)
const [isLoading, setIsLoading] = useState(true)
const [error, setError] = useState<string | null>(null)
// Audio state
const [activeAudio, setActiveAudio] = useState<AudioType>("backing")
const [isPlaying, setIsPlaying] = useState(false)
const [currentTime, setCurrentTime] = useState(0)
const [duration, setDuration] = useState(0)
// Selection state
const [selectedOption, setSelectedOption] = useState<InstrumentalSelectionType>("with_backing")
const [muteRegions, setMuteRegions] = useState<MuteRegion[]>([])
const [hasCustom, setHasCustom] = useState(false)
const [hasUploaded, setHasUploaded] = useState(false)
const [uploadedFilename, setUploadedFilename] = useState("")
// UI state
const [zoomLevel, setZoomLevel] = useState<ZoomLevel>(1)
const [isCreatingCustom, setIsCreatingCustom] = useState(false)
const [isUploading, setIsUploading] = useState(false)
const [isSubmitting, setIsSubmitting] = useState(false)
const [isShiftHeld, setIsShiftHeld] = useState(false)
// Derived state
const hasOriginal = analysisData?.has_original ?? false
const hasWithBacking = !!analysisData?.audio_urls.with_backing
const audibleSegments = useMemo(
() => analysisData?.analysis.audible_segments ?? [],
[analysisData?.analysis.audible_segments]
)
// Toggle play/pause - defined early so it can be used in keyboard shortcuts
const togglePlayPause = useCallback(() => {
const audio = audioRef.current
if (!audio) return
if (isPlaying) {
audio.pause()
} else {
audio.play().catch(() => {})
}
}, [isPlaying])
// Fetch data on mount
useEffect(() => {
async function fetchData() {
try {
const [analysis, waveform] = await Promise.all([
api.getInstrumentalAnalysis(job.job_id),
api.getWaveformData(job.job_id),
])
setAnalysisData(analysis)
setWaveformData(waveform)
// Set initial selection based on recommendation
const recommended = analysis.analysis.recommended_selection
setSelectedOption(recommended === "clean" ? "clean" : "with_backing")
// Set duration from waveform data
const dur = waveform.duration_seconds ?? waveform.duration ?? 0
setDuration(dur)
// Check if uploaded instrumental exists
if (analysis.has_uploaded_instrumental) {
setHasUploaded(true)
}
} catch (err) {
setError(err instanceof Error ? err.message : "Failed to load data")
} finally {
setIsLoading(false)
}
}
fetchData()
}, [job.job_id])
// Keyboard shortcuts
useEffect(() => {
const handleKeyDown = (e: KeyboardEvent) => {
// Track shift key
if (e.key === "Shift") {
setIsShiftHeld(true)
}
// Ignore if typing in input
if (
e.target instanceof HTMLInputElement ||
e.target instanceof HTMLTextAreaElement
) {
return
}
if (e.code === "Space") {
e.preventDefault()
togglePlayPause()
}
}
const handleKeyUp = (e: KeyboardEvent) => {
if (e.key === "Shift") {
setIsShiftHeld(false)
}
}
document.addEventListener("keydown", handleKeyDown)
document.addEventListener("keyup", handleKeyUp)
return () => {
document.removeEventListener("keydown", handleKeyDown)
document.removeEventListener("keyup", handleKeyUp)
}
}, [togglePlayPause])
// Audio event handlers - must re-run when loading completes so audio element is available
useEffect(() => {
const audio = audioRef.current
if (!audio) return
const handlePlay = () => setIsPlaying(true)
const handlePause = () => setIsPlaying(false)
const handleEnded = () => setIsPlaying(false)
const handleLoadedMetadata = () => {
if (audio.duration && Number.isFinite(audio.duration)) {
setDuration(audio.duration)
}
}
audio.addEventListener("play", handlePlay)
audio.addEventListener("pause", handlePause)
audio.addEventListener("ended", handleEnded)
audio.addEventListener("loadedmetadata", handleLoadedMetadata)
return () => {
audio.removeEventListener("play", handlePlay)
audio.removeEventListener("pause", handlePause)
audio.removeEventListener("ended", handleEnded)
audio.removeEventListener("loadedmetadata", handleLoadedMetadata)
}
}, [isLoading]) // Re-run when loading completes to attach handlers to audio element
// Smooth playhead animation using requestAnimationFrame
useEffect(() => {
const audio = audioRef.current
if (!audio || !isPlaying) return
let animationId: number
const updateTime = () => {
setCurrentTime(audio.currentTime)
animationId = requestAnimationFrame(updateTime)
}
animationId = requestAnimationFrame(updateTime)
return () => {
cancelAnimationFrame(animationId)
}
}, [isPlaying])
// Get audio URL for current selection
const getAudioUrl = useCallback(() => {
const stemType = STEM_TYPE_MAP[activeAudio]
return api.getAudioStreamUrl(job.job_id, stemType)
}, [job.job_id, activeAudio])
// Handle audio type change
const handleAudioChange = useCallback(
(type: AudioType) => {
const audio = audioRef.current
if (!audio) return
const wasPlaying = !audio.paused
const time = audio.currentTime
audio.pause()
setActiveAudio(type)
// Update audio source
const stemType = STEM_TYPE_MAP[type]
audio.src = api.getAudioStreamUrl(job.job_id, stemType)
audio.addEventListener(
"loadeddata",
() => {
audio.currentTime = time
if (wasPlaying) {
audio.play().catch(() => {})
}
},
{ once: true }
)
},
[job.job_id]
)
// Seek to time
const seekTo = useCallback((time: number, autoPlay = true) => {
const audio = audioRef.current
if (!audio || !Number.isFinite(time)) return
audio.currentTime = time
setCurrentTime(time)
if (autoPlay && audio.paused) {
audio.play().catch(() => {})
}
}, [])
// Mute region management
const addRegion = useCallback((start: number, end: number) => {
setMuteRegions((prev) => {
const newRegions = [...prev, { start_seconds: start, end_seconds: end }]
newRegions.sort((a, b) => a.start_seconds - b.start_seconds)
return mergeOverlappingRegions(newRegions)
})
setHasCustom(false) // Invalidate custom when regions change
}, [])
const removeRegion = useCallback((index: number) => {
setMuteRegions((prev) => prev.filter((_, i) => i !== index))
setHasCustom(false)
}, [])
const clearAllRegions = useCallback(() => {
setMuteRegions([])
setHasCustom(false)
}, [])
const addSegmentAsRegion = useCallback(
(index: number) => {
const segment = audibleSegments[index]
if (segment) {
addRegion(segment.start_seconds, segment.end_seconds)
}
},
[audibleSegments, addRegion]
)
// Create custom instrumental
const handleCreateCustom = useCallback(async () => {
if (muteRegions.length === 0) return
const audio = audioRef.current
const wasPlaying = isPlaying
const time = currentTime
// Pause while creating
if (audio && !audio.paused) {
audio.pause()
}
setIsCreatingCustom(true)
try {
await api.createCustomInstrumental(job.job_id, muteRegions)
setHasCustom(true)
setSelectedOption("custom")
setActiveAudio("custom")
// Update audio source
if (audio) {
audio.src = api.getAudioStreamUrl(job.job_id, "custom_instrumental")
audio.addEventListener(
"loadeddata",
() => {
audio.currentTime = time
if (wasPlaying) {
audio.play().catch(() => {})
}
},
{ once: true }
)
}
toast.success("Custom instrumental created")
} catch (err) {
toast.error(err instanceof Error ? err.message : "Failed to create custom")
// Resume playback on error
if (wasPlaying && audio) {
audio.play().catch(() => {})
}
} finally {
setIsCreatingCustom(false)
}
}, [job.job_id, muteRegions, isPlaying, currentTime])
// Upload custom instrumental
const handleUpload = useCallback(
async (file: File) => {
setIsUploading(true)
try {
const result = await api.uploadCustomInstrumental(job.job_id, file)
setHasUploaded(true)
setUploadedFilename(file.name)
setActiveAudio("uploaded")
setSelectedOption("uploaded")
// Update audio source
const audio = audioRef.current
if (audio) {
const time = audio.currentTime
audio.src = api.getAudioStreamUrl(job.job_id, "uploaded_instrumental")
audio.addEventListener(
"loadeddata",
() => {
audio.currentTime = time
},
{ once: true }
)
}
toast.success(`Uploaded ${file.name} (${result.duration_seconds.toFixed(1)}s)`)
} catch (err) {
toast.error(err instanceof Error ? err.message : "Upload failed")
} finally {
setIsUploading(false)
}
},
[job.job_id]
)
// Success screen state
const [showSuccess, setShowSuccess] = useState(false)
const [countdown, setCountdown] = useState(2)
// Submit selection
const handleSubmit = useCallback(async () => {
setIsSubmitting(true)
try {
await api.selectInstrumental(job.job_id, selectedOption)
if (isLocalMode) {
// In local mode, show success screen with countdown then close
setShowSuccess(true)
setCountdown(2)
} else {
// Redirect to dashboard after short delay (cloud mode)
toast.success("Selection submitted successfully")
setTimeout(() => {
router.push("/app")
}, 1500)
}
} catch (err) {
toast.error(err instanceof Error ? err.message : "Failed to submit selection")
setIsSubmitting(false)
}
}, [job.job_id, selectedOption, router, isLocalMode])
// Countdown effect for success screen
useEffect(() => {
if (!showSuccess) return
const interval = setInterval(() => {
setCountdown((prev) => {
if (prev <= 1) {
clearInterval(interval)
window.close()
return 0
}
return prev - 1
})
}, 1000)
return () => clearInterval(interval)
}, [showSuccess])
// Loading state
if (isLoading) {
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center">
<Spinner className="w-8 h-8 mx-auto mb-4" />
<p className="text-muted-foreground">Loading instrumental analysis...</p>
</div>
</div>
)
}
// Error state
if (error) {
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center max-w-md p-6">
<p className="text-destructive mb-4">{error}</p>
{!isLocalMode && (
<Button variant="outline" asChild>
<Link href="/app">
<ArrowLeft className="w-4 h-4 mr-2" />
Back to dashboard
</Link>
</Button>
)}
</div>
</div>
)
}
// Success screen (local mode)
if (showSuccess) {
const selectionLabels: Record<string, string> = {
clean: "Clean Instrumental",
with_backing: "With Backing Vocals",
custom: "Custom",
uploaded: "Uploaded Instrumental",
original: "Original Audio",
}
const selectionLabel = selectionLabels[selectedOption] || selectedOption
return (
<div className="flex items-center justify-center min-h-screen">
<div className="text-center">
<h2 className="text-2xl font-semibold text-green-500 mb-4">
<Check className="w-8 h-8 inline-block mr-2" />
Selection Submitted
</h2>
<p className="mb-2">
You selected: <strong>{selectionLabel}</strong>
</p>
<p className="text-muted-foreground">
{countdown > 0
? `Closing in ${countdown}s...`
: "You can close this window now."}
</p>
</div>
</div>
)
}
const amplitudes = waveformData?.amplitudes ?? []
return (
<div className="flex flex-col h-screen bg-background p-4 gap-3 overflow-hidden">
{/* Header */}
<header className="flex items-center justify-between flex-shrink-0">
<div className="flex items-center gap-3">
<span className="text-lg font-semibold flex items-center gap-2">
<img
src="https://gen.nomadkaraoke.com/nomad-karaoke-logo.svg"
alt="Nomad Karaoke"
className="h-10"
onError={(e) => {
e.currentTarget.style.display = "none"
}}
/>
Instrumental Review
</span>
<span className="text-sm text-muted-foreground">
{job.artist} {job.artist && job.title ? "-" : ""} {job.title}
</span>
</div>
<div className="flex items-center gap-2">
{audibleSegments.length > 0 && (
<>
<span className="px-2.5 py-1 rounded-full text-xs bg-secondary text-muted-foreground">
{audibleSegments.length} segments
</span>
<span className="px-2.5 py-1 rounded-full text-xs bg-secondary text-muted-foreground">
{analysisData?.analysis.audible_percentage.toFixed(0)}% backing vocals
</span>
</>
)}
<span
className={`px-2.5 py-1 rounded-full text-xs ${
analysisData?.analysis.recommended_selection === "clean"
? "bg-green-500/15 text-green-500"
: "bg-amber-500/15 text-amber-500"
}`}
>
{analysisData?.analysis.recommended_selection === "clean"
? "Clean recommended"
: "Review needed"}
</span>
</div>
</header>
{/* Waveform Player */}
<div className="flex-1 flex flex-col bg-card border border-border rounded-xl overflow-hidden min-h-0">
{/* Toolbar */}
<div className="flex items-center justify-between px-4 py-2.5 bg-secondary border-b border-border gap-3 flex-shrink-0 flex-wrap">
<div className="flex items-center gap-2">
<Button
size="icon"
onClick={togglePlayPause}
className="rounded-full w-8 h-8"
>
{isPlaying ? (
<Pause className="w-4 h-4" />
) : (
<Play className="w-4 h-4 ml-0.5" />
)}
</Button>
<span className="font-mono text-sm min-w-[90px]">
{formatTime(currentTime)}
<span className="text-muted-foreground"> / {formatTime(duration)}</span>
</span>
</div>
<div className="flex items-center gap-1.5">
<StemComparison
activeAudio={activeAudio}
onAudioChange={handleAudioChange}
hasOriginal={hasOriginal}
hasWithBacking={hasWithBacking}
hasCustom={hasCustom}
hasUploaded={hasUploaded}
uploadedFilename={uploadedFilename}
/>
<CustomUpload onUpload={handleUpload} isUploading={isUploading} />
</div>
<div className="flex items-center gap-3">
<div className="flex bg-background rounded-md p-0.5">
{([1, 2, 4] as ZoomLevel[]).map((level) => (
<button
key={level}
type="button"
onClick={() => setZoomLevel(level)}
className={`w-7 h-7 rounded text-xs font-medium transition-colors ${
zoomLevel === level
? "bg-primary text-primary-foreground"
: "text-muted-foreground hover:bg-secondary hover:text-foreground"
}`}
>
{level}x
</button>
))}
</div>
<span className="text-[10px] text-muted-foreground">
<kbd className="px-1.5 py-0.5 bg-background border border-border rounded text-[10px] font-mono">
Shift
</kbd>
+drag
</span>
<kbd className="px-1.5 py-0.5 bg-background border border-border rounded text-[10px] font-mono">
Space
</kbd>
</div>
</div>
{/* Waveform */}
<WaveformViewer
amplitudes={amplitudes}
duration={duration}
currentTime={currentTime}
muteRegions={muteRegions}
audibleSegments={audibleSegments}
zoomLevel={zoomLevel}
onSeek={seekTo}
onRegionCreate={addRegion}
isShiftHeld={isShiftHeld}
/>
{/* Time axis */}
<div className="flex justify-between px-3 py-1 text-[10px] text-muted-foreground bg-black/40 flex-shrink-0">
<span>0:00</span>
<span>{formatTime(duration * 0.25)}</span>
<span>{formatTime(duration * 0.5)}</span>
<span>{formatTime(duration * 0.75)}</span>
<span>{formatTime(duration)}</span>
</div>
</div>
{/* Hidden audio element */}
<audio ref={audioRef} src={getAudioUrl()} className="hidden" />
{/* Bottom section */}
<div className="flex gap-3 flex-shrink-0">
{/* Mute regions panel */}
<MuteRegionEditor
regions={muteRegions}
audibleSegments={audibleSegments}
hasCustom={hasCustom}
isCreatingCustom={isCreatingCustom}
onRemoveRegion={removeRegion}
onClearAll={clearAllRegions}
onCreateCustom={handleCreateCustom}
onSeekTo={seekTo}
onAddSegment={addSegmentAsRegion}
/>
{/* Selection panel */}
<div className="w-[340px] bg-card border border-border rounded-lg p-3 flex flex-col gap-2">
<SelectionOptions
value={selectedOption}
onChange={setSelectedOption}
hasWithBacking={hasWithBacking}
hasOriginal={hasOriginal}
hasCustom={hasCustom}
hasUploaded={hasUploaded}
uploadedFilename={uploadedFilename}
muteRegionsCount={muteRegions.length}
backingVocalAnalysis={analysisData?.analysis}
/>
<Button
id="submit-btn"
onClick={handleSubmit}
disabled={isSubmitting}
className="mt-auto w-full"
>
<Check className="w-4 h-4 mr-2" />
{isSubmitting ? "Submitting..." : "Confirm & Continue"}
</Button>
</div>
</div>
</div>
)
}
// Helper function to merge overlapping regions
function mergeOverlappingRegions(regions: MuteRegion[]): MuteRegion[] {
if (regions.length < 2) return regions
const merged: MuteRegion[] = [regions[0]]
for (let i = 1; i < regions.length; i++) {
const last = merged[merged.length - 1]
const curr = regions[i]
if (curr.start_seconds <= last.end_seconds + 0.5) {
last.end_seconds = Math.max(last.end_seconds, curr.end_seconds)
} else {
merged.push(curr)
}
}
return merged
}
@@ -0,0 +1,127 @@
"use client"
import { Button } from "@/components/ui/button"
import { X } from "lucide-react"
import type { MuteRegion, AudibleSegment } from "@/lib/api"
interface MuteRegionEditorProps {
regions: MuteRegion[]
audibleSegments: AudibleSegment[]
hasCustom: boolean
isCreatingCustom: boolean
onRemoveRegion: (index: number) => void
onClearAll: () => void
onCreateCustom: () => void
onSeekTo: (time: number) => void
onAddSegment: (index: number) => void
}
function formatTime(seconds: number): string {
if (!Number.isFinite(seconds)) return "0:00"
const mins = Math.floor(seconds / 60)
const secs = Math.floor(seconds % 60)
return `${mins}:${secs.toString().padStart(2, "0")}`
}
export function MuteRegionEditor({
regions,
audibleSegments,
hasCustom,
isCreatingCustom,
onRemoveRegion,
onClearAll,
onCreateCustom,
onSeekTo,
onAddSegment,
}: MuteRegionEditorProps) {
const hasRegions = regions.length > 0
const hasSegments = audibleSegments.length > 0
return (
<div className="flex-1 bg-card border border-border rounded-lg p-3 flex flex-col gap-2 max-h-[140px]">
{/* Header */}
<div className="flex items-center justify-between">
<span className="text-sm font-semibold">
Mute Regions {hasRegions && `(${regions.length})`}
</span>
{hasRegions && (
<div className="flex gap-1.5">
<Button
variant="secondary"
size="sm"
onClick={onClearAll}
className="h-7 text-xs"
>
Clear
</Button>
{!hasCustom && (
<Button
size="sm"
onClick={onCreateCustom}
disabled={isCreatingCustom}
className="h-7 text-xs"
>
{isCreatingCustom ? "Creating..." : "Create Custom"}
</Button>
)}
</div>
)}
</div>
{/* Region tags */}
{hasRegions ? (
<div className="flex flex-wrap gap-1.5 overflow-y-auto flex-1">
{regions.map((region, index) => (
<div
key={index}
className="inline-flex items-center gap-1 px-2 py-1 bg-secondary rounded text-xs"
>
<button
type="button"
onClick={() => onSeekTo(region.start_seconds)}
className="hover:text-primary cursor-pointer"
>
{formatTime(region.start_seconds)} - {formatTime(region.end_seconds)}
</button>
<button
type="button"
onClick={() => onRemoveRegion(index)}
className="text-muted-foreground hover:text-destructive ml-1"
>
<X className="w-3 h-3" />
</button>
</div>
))}
</div>
) : (
<div className="text-xs text-muted-foreground">
{hasSegments
? "Click segments below or Shift + drag on waveform"
: "No backing vocals detected - clean instrumental recommended"}
</div>
)}
{/* Quick segment buttons */}
{hasSegments && (
<div className="flex flex-wrap gap-1">
{audibleSegments.slice(0, 8).map((segment, index) => (
<button
key={index}
type="button"
onClick={() => onAddSegment(index)}
title="Add to mute regions"
className="px-1.5 py-0.5 bg-background border border-border rounded text-[10px] text-muted-foreground hover:border-primary hover:text-primary transition-colors"
>
{formatTime(segment.start_seconds)} - {formatTime(segment.end_seconds)}
</button>
))}
{audibleSegments.length > 8 && (
<span className="text-xs text-muted-foreground px-1 py-0.5">
+{audibleSegments.length - 8} more
</span>
)}
</div>
)}
</div>
)
}
@@ -0,0 +1,119 @@
"use client"
import { Label } from "@/components/ui/label"
import { cn } from "@/lib/utils"
import type { InstrumentalSelectionType, BackingVocalAnalysis, MuteRegion } from "@/lib/api"
interface SelectionOptionsProps {
value: InstrumentalSelectionType
onChange: (value: InstrumentalSelectionType) => void
hasWithBacking: boolean
hasOriginal: boolean
hasCustom: boolean
hasUploaded: boolean
uploadedFilename?: string
muteRegionsCount: number
backingVocalAnalysis?: BackingVocalAnalysis
}
interface SelectionOption {
value: InstrumentalSelectionType
label: string
description: string
available: boolean
}
export function SelectionOptions({
value,
onChange,
hasWithBacking,
hasOriginal,
hasCustom,
hasUploaded,
uploadedFilename,
muteRegionsCount,
backingVocalAnalysis,
}: SelectionOptionsProps) {
const options: SelectionOption[] = [
{
value: "clean",
label: "Clean Instrumental",
description: "No backing vocals",
available: true,
},
{
value: "with_backing",
label: "With Backing Vocals",
description: "All backing vocals included",
available: hasWithBacking,
},
{
value: "original",
label: "Original Audio",
description: "Full original with lead vocals",
available: hasOriginal,
},
{
value: "custom",
label: "Custom",
description: `${muteRegionsCount} region${muteRegionsCount !== 1 ? "s" : ""} muted`,
available: hasCustom,
},
{
value: "uploaded",
label: "Uploaded",
description: uploadedFilename || "Custom instrumental file",
available: hasUploaded,
},
]
const availableOptions = options.filter((opt) => opt.available)
return (
<div className="flex flex-col gap-2">
<Label className="text-sm font-semibold">Final Selection</Label>
<div className="flex flex-col gap-2">
{availableOptions.map((option) => (
<button
key={option.value}
type="button"
data-testid={`selection-option-${option.value}`}
onClick={() => onChange(option.value)}
className={cn(
"selection-option flex items-center gap-3 p-3 rounded-lg transition-all text-left",
"bg-secondary hover:bg-secondary/80",
"border-2 border-transparent",
value === option.value && "border-primary bg-primary/10"
)}
>
<div
className={cn(
"w-4 h-4 rounded-full border-2 flex items-center justify-center flex-shrink-0",
value === option.value
? "border-primary"
: "border-muted-foreground"
)}
>
{value === option.value && (
<div className="w-2 h-2 rounded-full bg-primary" />
)}
</div>
<div className="flex-1 min-w-0">
<div className="text-sm font-medium flex items-center gap-2">
{option.label}
{backingVocalAnalysis?.recommended_selection === option.value && (
<span className="text-xs px-1.5 py-0.5 bg-green-500/20 text-green-500 rounded">
Recommended
</span>
)}
</div>
<div className="text-xs text-muted-foreground truncate">
{option.description}
</div>
</div>
</button>
))}
</div>
</div>
)
}
@@ -0,0 +1,63 @@
"use client"
import { cn } from "@/lib/utils"
export type AudioType = "original" | "backing" | "clean" | "with_backing" | "custom" | "uploaded"
interface StemComparisonProps {
activeAudio: AudioType
onAudioChange: (type: AudioType) => void
hasOriginal: boolean
hasWithBacking: boolean
hasCustom: boolean
hasUploaded: boolean
uploadedFilename?: string
}
interface AudioOption {
type: AudioType
label: string
available: boolean
title?: string
}
export function StemComparison({
activeAudio,
onAudioChange,
hasOriginal,
hasWithBacking,
hasCustom,
hasUploaded,
uploadedFilename,
}: StemComparisonProps) {
const options: AudioOption[] = [
{ type: "original", label: "Original", available: hasOriginal },
{ type: "backing", label: "Backing Vocals Only", available: true },
{ type: "clean", label: "Pure Instrumental", available: true },
{ type: "with_backing", label: "Instrumental + Backing", available: hasWithBacking },
{ type: "custom", label: "Custom", available: hasCustom },
{ type: "uploaded", label: "Uploaded", available: hasUploaded, title: uploadedFilename },
]
const availableOptions = options.filter((opt) => opt.available)
return (
<div className="flex flex-wrap gap-1 bg-background rounded-md p-0.5">
{availableOptions.map((option) => (
<button
key={option.type}
type="button"
onClick={() => onAudioChange(option.type)}
title={option.title}
className={cn(
"px-2.5 py-1.5 rounded text-xs font-medium transition-all",
"text-muted-foreground hover:text-foreground",
activeAudio === option.type && "bg-primary text-primary-foreground"
)}
>
{option.label}
</button>
))}
</div>
)
}
@@ -0,0 +1,215 @@
"use client"
import { useRef, useEffect, useCallback } from "react"
import type { MuteRegion, AudibleSegment } from "@/lib/api"
interface WaveformViewerProps {
amplitudes: number[]
duration: number
currentTime: number
muteRegions: MuteRegion[]
audibleSegments: AudibleSegment[]
zoomLevel: number
onSeek: (time: number) => void
onRegionCreate: (start: number, end: number) => void
isShiftHeld: boolean
}
export function WaveformViewer({
amplitudes,
duration,
currentTime,
muteRegions,
audibleSegments,
zoomLevel,
onSeek,
onRegionCreate,
isShiftHeld,
}: WaveformViewerProps) {
const canvasRef = useRef<HTMLCanvasElement>(null)
const containerRef = useRef<HTMLDivElement>(null)
const isDraggingRef = useRef(false)
const dragStartTimeRef = useRef(0)
const dragStartXRef = useRef(0)
// Draw waveform
const drawWaveform = useCallback(() => {
const canvas = canvasRef.current
if (!canvas || !amplitudes.length) return
const ctx = canvas.getContext("2d")
if (!ctx) return
const width = canvas.width
const height = canvas.height
const centerY = height / 2
// Clear with dark background
ctx.fillStyle = "#0d1117"
ctx.fillRect(0, 0, width, height)
// Draw center line
ctx.strokeStyle = "rgba(255, 255, 255, 0.1)"
ctx.setLineDash([4, 4])
ctx.beginPath()
ctx.moveTo(0, centerY)
ctx.lineTo(width, centerY)
ctx.stroke()
ctx.setLineDash([])
// Draw waveform bars
const barWidth = width / amplitudes.length
amplitudes.forEach((amp, i) => {
const x = i * barWidth
const barHeight = Math.max(2, amp * height * 0.9)
const y = centerY - barHeight / 2
const time = (i / amplitudes.length) * duration
// Check if in mute region
const inMuteRegion = muteRegions.some(
(r) => time >= r.start_seconds && time <= r.end_seconds
)
// Check if in audible segment (backing vocals detected)
const inAudibleSegment = audibleSegments.some(
(s) => time >= s.start_seconds && time <= s.end_seconds
)
if (inMuteRegion) {
// Muted regions are very dim
ctx.fillStyle = "rgba(13, 17, 23, 0.8)"
} else if (inAudibleSegment) {
// Pink for detected backing vocals
ctx.fillStyle = "#ec4899"
} else {
// Blue for regular audio
ctx.fillStyle = "#60a5fa"
}
ctx.fillRect(x, y, Math.max(1, barWidth - 0.5), barHeight)
})
}, [amplitudes, duration, muteRegions, audibleSegments])
// Resize canvas
const resizeCanvas = useCallback(() => {
const canvas = canvasRef.current
const container = containerRef.current
if (!canvas || !container) return
canvas.width = container.clientWidth * zoomLevel
canvas.height = container.clientHeight
}, [zoomLevel])
// Handle resize and redraw
useEffect(() => {
resizeCanvas()
drawWaveform()
}, [resizeCanvas, drawWaveform, zoomLevel])
// Handle window resize
useEffect(() => {
const handleResize = () => {
resizeCanvas()
drawWaveform()
}
window.addEventListener("resize", handleResize)
return () => window.removeEventListener("resize", handleResize)
}, [resizeCanvas, drawWaveform])
// Calculate playhead position
const playheadPosition =
duration > 0 && canvasRef.current
? (currentTime / duration) * canvasRef.current.width
: 0
// Handle mouse events for seeking and region selection
const handleMouseDown = (e: React.MouseEvent<HTMLCanvasElement>) => {
const canvas = canvasRef.current
if (!canvas) return
const rect = canvas.getBoundingClientRect()
const x = e.clientX - rect.left
const time = (x / rect.width) * duration
if (!Number.isFinite(duration) || duration <= 0) return
if (e.shiftKey || isShiftHeld) {
// Start region selection
isDraggingRef.current = true
dragStartTimeRef.current = time
dragStartXRef.current = x
} else {
// Seek
onSeek(time)
}
}
const handleMouseMove = (e: React.MouseEvent<HTMLCanvasElement>) => {
if (!isDraggingRef.current) return
// Selection overlay is handled by parent
}
const handleMouseUp = (e: React.MouseEvent<HTMLCanvasElement>) => {
if (!isDraggingRef.current) return
const canvas = canvasRef.current
if (!canvas) return
const rect = canvas.getBoundingClientRect()
const x = e.clientX - rect.left
const time = (x / rect.width) * duration
if (!Number.isFinite(duration) || duration <= 0) {
isDraggingRef.current = false
return
}
const start = Math.min(dragStartTimeRef.current, time)
const end = Math.max(dragStartTimeRef.current, time)
if (end - start > 0.5) {
onRegionCreate(start, end)
}
isDraggingRef.current = false
}
const handleMouseLeave = (e: React.MouseEvent<HTMLCanvasElement>) => {
if (isDraggingRef.current) {
handleMouseUp(e)
}
}
return (
<div
ref={containerRef}
className="relative flex-1 overflow-x-auto overflow-y-hidden bg-[#0d1117] min-h-[120px]"
>
<div
className="relative h-full"
style={{ width: `${zoomLevel * 100}%`, minWidth: "100%" }}
>
<canvas
ref={canvasRef}
className="block h-full cursor-pointer"
onMouseDown={handleMouseDown}
onMouseMove={handleMouseMove}
onMouseUp={handleMouseUp}
onMouseLeave={handleMouseLeave}
/>
{/* Playhead */}
<div
className="absolute top-0 w-0.5 h-full bg-primary pointer-events-none z-10"
style={{
left: `${playheadPosition}px`,
boxShadow: "0 0 8px var(--primary)",
}}
>
<div className="absolute -top-0 -left-1 w-2.5 h-2.5 bg-primary rounded-full" />
</div>
</div>
</div>
)
}
@@ -0,0 +1,6 @@
export { InstrumentalSelector } from "./InstrumentalSelector"
export { SelectionOptions } from "./SelectionOptions"
export { StemComparison } from "./StemComparison"
export { WaveformViewer } from "./WaveformViewer"
export { MuteRegionEditor } from "./MuteRegionEditor"
export { CustomUpload } from "./CustomUpload"
+11 -40
View File
@@ -3,11 +3,12 @@
import { useState } from "react"
import { Job } from "@/lib/api"
import { Button } from "@/components/ui/button"
import { ExternalLink, Zap } from "lucide-react"
import { Zap } from "lucide-react"
import { JobActions } from "./JobActions"
import { OutputLinks } from "./OutputLinks"
import { AudioSearchDialog } from "../audio-search/AudioSearchDialog"
import { getJobStep, formatStepIndicator, getJobProgressPercent } from "@/lib/job-status"
import { useAuth } from "@/lib/auth"
/**
* StatusIndicator component - Shows step-based progress with visual indicator
@@ -74,6 +75,8 @@ interface JobCardProps {
export function JobCard({ job, onRefresh }: JobCardProps) {
const [showAudioSearch, setShowAudioSearch] = useState(false)
const { user } = useAuth()
const isAdmin = user?.role === 'admin'
const createdAt = new Date(job.created_at).toLocaleString()
const isInteractive = job.status === "awaiting_review" ||
@@ -83,34 +86,6 @@ export function JobCard({ job, onRefresh }: JobCardProps) {
const isComplete = job.status === "complete"
const isFailed = job.status === "failed"
// Build review URL for awaiting_review status
const getReviewUrl = () => {
const backendUrl = process.env.NEXT_PUBLIC_API_URL || 'https://api.nomadkaraoke.com'
const reviewUiUrl = process.env.NEXT_PUBLIC_REVIEW_UI_URL || 'https://gen.nomadkaraoke.com/lyrics/'
const baseApiUrl = `${backendUrl}/api/review/${job.job_id}`
const encodedApiUrl = encodeURIComponent(baseApiUrl)
let url = `${reviewUiUrl}/?baseApiUrl=${encodedApiUrl}`
if (job.audio_hash) {
url += `&audioHash=${encodeURIComponent(job.audio_hash)}`
}
if (job.review_token) {
url += `&reviewToken=${encodeURIComponent(job.review_token)}`
}
return url
}
// Build instrumental review URL for awaiting_instrumental_selection status
const getInstrumentalUrl = () => {
const backendUrl = process.env.NEXT_PUBLIC_API_URL || 'https://api.nomadkaraoke.com'
const baseApiUrl = `${backendUrl}/api/jobs/${job.job_id}`
const encodedApiUrl = encodeURIComponent(baseApiUrl)
let url = `/instrumental/?baseApiUrl=${encodedApiUrl}`
if (job.instrumental_token) {
url += `&instrumentalToken=${encodeURIComponent(job.instrumental_token)}`
}
return url
}
// Render primary action button based on status
const renderPrimaryAction = () => {
// For non-interactive jobs in interactive states, show auto-processing message
@@ -126,14 +101,12 @@ export function JobCard({ job, onRefresh }: JobCardProps) {
}
if (job.status === "awaiting_review" || job.status === "in_review") {
// Use <a> instead of Link for hash-based URLs to ensure hashchange event fires
return (
<a
href={getReviewUrl()}
target="_blank"
rel="noopener noreferrer"
href={`/app/jobs#/${job.job_id}/review`}
className="inline-flex items-center gap-1 text-xs px-3 py-1.5 rounded bg-primary-500 hover:bg-primary-600 text-white"
>
<ExternalLink className="w-3 h-3" />
Review Lyrics
</a>
)
@@ -152,14 +125,12 @@ export function JobCard({ job, onRefresh }: JobCardProps) {
}
if (job.status === "awaiting_instrumental_selection") {
// Use <a> instead of Link for hash-based URLs to ensure hashchange event fires
return (
<a
href={getInstrumentalUrl()}
target="_blank"
rel="noopener noreferrer"
href={`/app/jobs#/${job.job_id}/instrumental`}
className="inline-flex items-center gap-1 text-xs px-3 py-1.5 rounded bg-primary-500 hover:bg-primary-600 text-white"
>
<ExternalLink className="w-3 h-3" />
Select Instrumental
</a>
)
@@ -207,10 +178,10 @@ export function JobCard({ job, onRefresh }: JobCardProps) {
</div>
)}
{/* Output links for completed jobs */}
{isComplete && (
{/* Output links for completed jobs, or admin link for admins on any job */}
{(isComplete || isAdmin) && (
<div className="mt-2">
<OutputLinks jobId={job.job_id} />
<OutputLinks job={job} />
</div>
)}
+36 -72
View File
@@ -1,7 +1,7 @@
"use client"
import { useEffect, useState, useRef, useCallback } from "react"
import { api, adminApi } from "@/lib/api"
import { useRef, useCallback, useEffect, useState } from "react"
import { api, adminApi, Job } from "@/lib/api"
import { useTenant } from "@/lib/tenant"
import { Button } from "@/components/ui/button"
import { Download, Loader2, ExternalLink, FolderOpen, Copy, Mail, Settings } from "lucide-react"
@@ -18,14 +18,16 @@ import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
interface OutputLinksProps {
jobId: string
job: Job
}
export function OutputLinks({ jobId }: OutputLinksProps) {
const [downloadUrls, setDownloadUrls] = useState<Record<string, any> | null>(null)
const [youtubeUrl, setYoutubeUrl] = useState<string | null>(null)
const [dropboxUrl, setDropboxUrl] = useState<string | null>(null)
const [isLoading, setIsLoading] = useState(false)
export function OutputLinks({ job }: OutputLinksProps) {
// Use file_urls from job directly - no API call needed
const downloadUrls = job.file_urls || null
// Use state_data from job directly - no API call needed
const youtubeUrl = job.state_data?.youtube_url || null
const dropboxUrl = job.state_data?.dropbox_link || null
const [copiedUrl, setCopiedUrl] = useState<string | null>(null)
const [copiedMessage, setCopiedMessage] = useState(false)
const [isLoadingMessage, setIsLoadingMessage] = useState(false)
@@ -37,6 +39,15 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
const messageTimeoutRef = useRef<NodeJS.Timeout | null>(null)
const emailTimeoutRef = useRef<NodeJS.Timeout | null>(null)
// Cleanup timeouts on unmount
useEffect(() => {
return () => {
if (copyTimeoutRef.current) clearTimeout(copyTimeoutRef.current)
if (messageTimeoutRef.current) clearTimeout(messageTimeoutRef.current)
if (emailTimeoutRef.current) clearTimeout(emailTimeoutRef.current)
}
}, [])
const { user } = useAuth()
const { features } = useTenant()
const isAdmin = user?.role === 'admin'
@@ -45,46 +56,6 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
const showYoutubeLink = features.youtube_upload && youtubeUrl
const showDropboxLink = features.dropbox_upload && dropboxUrl
useEffect(() => {
loadOutputLinks()
}, [jobId])
// Cleanup timeouts on unmount
useEffect(() => {
return () => {
if (copyTimeoutRef.current) {
clearTimeout(copyTimeoutRef.current)
}
if (messageTimeoutRef.current) {
clearTimeout(messageTimeoutRef.current)
}
if (emailTimeoutRef.current) {
clearTimeout(emailTimeoutRef.current)
}
}
}, [])
async function loadOutputLinks() {
setIsLoading(true)
try {
const result = await api.getDownloadUrls(jobId)
setDownloadUrls(result.download_urls)
// Extract YouTube and Dropbox URLs from state_data if available
const job = await api.getJob(jobId)
if (job.state_data?.youtube_url) {
setYoutubeUrl(job.state_data.youtube_url)
}
if (job.state_data?.dropbox_link) {
setDropboxUrl(job.state_data.dropbox_link)
}
} catch (err) {
console.error("Failed to load output links:", err)
} finally {
setIsLoading(false)
}
}
const copyToClipboard = useCallback(async (url: string) => {
// Check if clipboard API is available
if (!navigator?.clipboard?.writeText) {
@@ -118,7 +89,7 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
setIsLoadingMessage(true)
try {
const response = await adminApi.getCompletionMessage(jobId)
const response = await adminApi.getCompletionMessage(job.job_id)
await navigator.clipboard.writeText(response.message)
setCopiedMessage(true)
@@ -136,14 +107,14 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
} finally {
setIsLoadingMessage(false)
}
}, [jobId])
}, [job.job_id])
const handleSendEmail = useCallback(async () => {
if (!emailInput.trim()) return
setIsSendingEmail(true)
try {
await adminApi.sendCompletionEmail(jobId, emailInput.trim(), true)
await adminApi.sendCompletionEmail(job.job_id, emailInput.trim(), true)
setEmailSent(true)
// Clear any existing timeout
@@ -162,16 +133,7 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
} finally {
setIsSendingEmail(false)
}
}, [jobId, emailInput])
if (isLoading) {
return (
<div className="flex items-center gap-2 text-xs" style={{ color: 'var(--text-muted)' }}>
<Loader2 className="w-3 h-3 animate-spin" />
Loading downloads...
</div>
)
}
}, [job.job_id, emailInput])
const hasOutputs = showYoutubeLink || showDropboxLink || (downloadUrls && Object.keys(downloadUrls).length > 0)
@@ -190,7 +152,7 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
return (
<div className="space-y-2">
{/* Links, Downloads, and Admin Tools - all in one row */}
{(hasDownloads || hasExternalLinks) && (
{(hasDownloads || hasExternalLinks || isAdmin) && (
<div className="flex flex-wrap gap-1.5">
{/* Links first */}
{hasExternalLinks && (
@@ -249,7 +211,7 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
<>
{downloadUrls?.finals?.lossy_4k_mp4 && (
<a
href={api.getDownloadUrl(jobId, "finals", "lossy_4k_mp4")}
href={api.getDownloadUrl(job.job_id, "finals", "lossy_4k_mp4")}
className="inline-flex items-center gap-1 text-xs px-3 py-1.5 rounded bg-[var(--brand-pink)] hover:bg-[var(--brand-pink-hover)] text-white transition-colors"
onClick={(e) => e.stopPropagation()}
>
@@ -259,7 +221,7 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
)}
{downloadUrls?.finals?.lossy_720p_mp4 && (
<a
href={api.getDownloadUrl(jobId, "finals", "lossy_720p_mp4")}
href={api.getDownloadUrl(job.job_id, "finals", "lossy_720p_mp4")}
className="inline-flex items-center gap-1 text-xs px-3 py-1.5 rounded bg-[#252525] hover:bg-[#333333] text-[var(--text)] border border-[var(--card-border)] transition-colors"
onClick={(e) => e.stopPropagation()}
>
@@ -269,7 +231,7 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
)}
{downloadUrls?.videos?.with_vocals && (
<a
href={api.getDownloadUrl(jobId, "videos", "with_vocals")}
href={api.getDownloadUrl(job.job_id, "videos", "with_vocals")}
className="inline-flex items-center gap-1 text-xs px-3 py-1.5 rounded bg-[#252525] hover:bg-[#333333] text-[var(--text)] border border-[var(--card-border)] transition-colors"
onClick={(e) => e.stopPropagation()}
>
@@ -279,7 +241,7 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
)}
{downloadUrls?.packages?.cdg_zip && (
<a
href={api.getDownloadUrl(jobId, "packages", "cdg_zip")}
href={api.getDownloadUrl(job.job_id, "packages", "cdg_zip")}
className="inline-flex items-center gap-1 text-xs px-3 py-1.5 rounded bg-[#252525] hover:bg-[#333333] text-[var(--text)] border border-[var(--card-border)] transition-colors"
onClick={(e) => e.stopPropagation()}
>
@@ -289,7 +251,7 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
)}
{downloadUrls?.packages?.txt_zip && (
<a
href={api.getDownloadUrl(jobId, "packages", "txt_zip")}
href={api.getDownloadUrl(job.job_id, "packages", "txt_zip")}
className="inline-flex items-center gap-1 text-xs px-3 py-1.5 rounded bg-[#252525] hover:bg-[#333333] text-[var(--text)] border border-[var(--card-border)] transition-colors"
onClick={(e) => e.stopPropagation()}
>
@@ -300,9 +262,8 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
</>
)}
{/* Admin Tools */}
{/* Admin Email Tools (only when job has outputs) */}
{isAdmin && hasOutputs && (
<>
<div className="flex">
<button
type="button"
@@ -329,8 +290,12 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
)}
</button>
</div>
)}
{/* Admin Link (always visible for admins) */}
{isAdmin && (
<a
href={`/admin/jobs/?id=${jobId}`}
href={`/admin/jobs/?id=${job.job_id}`}
onClick={(e) => e.stopPropagation()}
className="inline-flex items-center gap-1 text-xs px-3 py-1.5 rounded bg-[#252525] hover:bg-[#333333] text-[var(--text)] border border-[var(--card-border)] transition-colors"
title="View job details in admin"
@@ -338,12 +303,11 @@ export function OutputLinks({ jobId }: OutputLinksProps) {
<Settings className="w-3 h-3" />
Admin
</a>
</>
)}
</div>
)}
{!hasOutputs && (
{!hasOutputs && !isAdmin && (
<p className="text-xs" style={{ color: 'var(--text-muted)' }}>No outputs available yet</p>
)}
@@ -0,0 +1,183 @@
'use client'
import { useMemo } from 'react'
import { Card } from '@/components/ui/card'
import { Badge } from '@/components/ui/badge'
import {
Tooltip,
TooltipContent,
TooltipProvider,
TooltipTrigger,
} from '@/components/ui/tooltip'
import { WordCorrection } from '@/lib/lyrics-review/types'
import { cn } from '@/lib/utils'
interface GapCategoryMetric {
category: string
count: number
avgConfidence: number
corrections: WordCorrection[]
}
interface AgenticCorrectionMetricsProps {
corrections: WordCorrection[]
onCategoryClick?: (category: string) => void
onConfidenceFilterClick?: (filter: 'low' | 'high') => void
}
export default function AgenticCorrectionMetrics({
corrections,
onCategoryClick,
onConfidenceFilterClick,
}: AgenticCorrectionMetricsProps) {
const metrics = useMemo(() => {
// Filter only agentic corrections
const agenticCorrections = corrections.filter((c) => c.handler === 'AgenticCorrector')
// Parse category from reason string (format: "reason [CATEGORY] (confidence: XX%)")
const categoryMap = new Map<string, GapCategoryMetric>()
agenticCorrections.forEach((correction) => {
const categoryMatch = correction.reason?.match(/\[([A-Z_]+)\]/)
const category = categoryMatch ? categoryMatch[1] : 'UNKNOWN'
if (!categoryMap.has(category)) {
categoryMap.set(category, {
category,
count: 0,
avgConfidence: 0,
corrections: [],
})
}
const metric = categoryMap.get(category)!
metric.count++
metric.corrections.push(correction)
})
// Calculate average confidence for each category
categoryMap.forEach((metric) => {
const totalConfidence = metric.corrections.reduce((sum, c) => sum + c.confidence, 0)
metric.avgConfidence = totalConfidence / metric.count
})
// Convert to array and sort by count descending
const sortedMetrics = Array.from(categoryMap.values()).sort((a, b) => b.count - a.count)
// Calculate overall stats
const totalCorrections = agenticCorrections.length
const avgConfidence =
totalCorrections > 0
? agenticCorrections.reduce((sum, c) => sum + c.confidence, 0) / totalCorrections
: 0
const lowConfidenceCount = agenticCorrections.filter((c) => c.confidence < 0.6).length
const highConfidenceCount = agenticCorrections.filter((c) => c.confidence >= 0.8).length
return {
categories: sortedMetrics,
totalCorrections,
avgConfidence,
lowConfidenceCount,
highConfidenceCount,
}
}, [corrections])
// Format category name for display
const formatCategory = (category: string): string => {
return category
.split('_')
.map((word) => word.charAt(0) + word.slice(1).toLowerCase())
.join(' ')
}
// Get emoji/icon for category
const getCategoryIcon = (category: string): string => {
const icons: Record<string, string> = {
SOUND_ALIKE: '',
PUNCTUATION_ONLY: '',
BACKGROUND_VOCALS: '',
EXTRA_WORDS: '',
REPEATED_SECTION: '',
COMPLEX_MULTI_ERROR: '',
AMBIGUOUS: '',
NO_ERROR: '',
}
return icons[category] || ''
}
return (
<TooltipProvider>
<Card className="p-2 h-full flex flex-col">
<span className="text-xs text-muted-foreground mb-1">Agentic AI Corrections</span>
{/* Overall stats */}
<div className="mb-2">
<p className="text-xs mb-1">
Total: <strong>{metrics.totalCorrections}</strong>
</p>
<p className="text-xs mb-1">
Avg Confidence: <strong>{(metrics.avgConfidence * 100).toFixed(0)}%</strong>
</p>
{/* Quick filters */}
<div className="flex gap-1 flex-wrap">
<Badge
variant="outline"
className="text-[0.65rem] h-5 cursor-pointer hover:bg-muted/30"
onClick={() => onConfidenceFilterClick?.('low')}
>
Low (&lt;60%): {metrics.lowConfidenceCount}
</Badge>
<Badge
variant="outline"
className="text-[0.65rem] h-5 cursor-pointer hover:bg-muted/30 text-green-600"
onClick={() => onConfidenceFilterClick?.('high')}
>
High (&ge;80%): {metrics.highConfidenceCount}
</Badge>
</div>
</div>
{/* Category breakdown */}
<span className="text-xs text-muted-foreground mb-1">By Category</span>
<div className="flex-1 overflow-auto">
{metrics.categories.map((metric) => (
<Tooltip key={metric.category}>
<TooltipTrigger asChild>
<div
className="mb-1 p-1 rounded cursor-pointer hover:bg-muted/30 transition-colors"
onClick={() => onCategoryClick?.(metric.category)}
>
<div className="flex justify-between items-center">
<div className="flex items-center gap-1">
<span className="text-sm">{getCategoryIcon(metric.category)}</span>
<span className="text-xs">{formatCategory(metric.category)}</span>
</div>
<div className="flex gap-1 items-center">
<span className="text-[0.65rem] text-muted-foreground">
{(metric.avgConfidence * 100).toFixed(0)}%
</span>
<span className="text-xs font-semibold bg-accent px-1 rounded min-w-[24px] text-center">
{metric.count}
</span>
</div>
</div>
</div>
</TooltipTrigger>
<TooltipContent side="right">
<p>
{metric.count} correction{metric.count !== 1 ? 's' : ''} • Avg confidence:{' '}
{(metric.avgConfidence * 100).toFixed(0)}%
</p>
</TooltipContent>
</Tooltip>
))}
{metrics.categories.length === 0 && (
<p className="text-xs text-muted-foreground italic">No agentic corrections</p>
)}
</div>
</Card>
</TooltipProvider>
)
}
@@ -0,0 +1,159 @@
'use client'
import { useEffect, useRef, useState, useCallback } from 'react'
import { Button } from '@/components/ui/button'
import { Slider } from '@/components/ui/slider'
import { Play, Pause } from 'lucide-react'
// Extend Window interface for global audio functions
declare global {
interface Window {
seekAndPlayAudio?: (time: number) => void
toggleAudioPlayback?: () => void
getAudioDuration?: () => number
isAudioPlaying?: boolean
}
}
interface AudioPlayerProps {
audioUrl: string | null
onTimeUpdate?: (time: number) => void
}
export default function AudioPlayer({ audioUrl, onTimeUpdate }: AudioPlayerProps) {
const [isPlaying, setIsPlaying] = useState(false)
const [currentTime, setCurrentTime] = useState(0)
const [duration, setDuration] = useState(0)
const audioRef = useRef<HTMLAudioElement | null>(null)
useEffect(() => {
if (!audioUrl) return
const audio = new Audio(audioUrl)
audioRef.current = audio
let animationFrameId: number
const updateTime = () => {
const time = audio.currentTime
setCurrentTime(time)
onTimeUpdate?.(time)
animationFrameId = requestAnimationFrame(updateTime)
}
audio.addEventListener('play', () => {
setIsPlaying(true)
window.isAudioPlaying = true
updateTime()
})
audio.addEventListener('pause', () => {
setIsPlaying(false)
window.isAudioPlaying = false
cancelAnimationFrame(animationFrameId)
})
audio.addEventListener('ended', () => {
cancelAnimationFrame(animationFrameId)
setIsPlaying(false)
window.isAudioPlaying = false
setCurrentTime(0)
})
audio.addEventListener('loadedmetadata', () => {
setDuration(audio.duration)
})
return () => {
cancelAnimationFrame(animationFrameId)
audio.pause()
audio.src = ''
audioRef.current = null
window.isAudioPlaying = false
}
}, [audioUrl, onTimeUpdate])
const handlePlayPause = () => {
if (!audioRef.current) return
if (isPlaying) {
audioRef.current.pause()
} else {
audioRef.current.play()
}
setIsPlaying(!isPlaying)
}
const handleSeek = (value: number[]) => {
if (!audioRef.current) return
const time = value[0]
audioRef.current.currentTime = time
setCurrentTime(time)
}
const formatTime = (seconds: number) => {
const mins = Math.floor(seconds / 60)
const secs = Math.floor(seconds % 60)
return `${mins}:${secs.toString().padStart(2, '0')}`
}
const seekAndPlay = useCallback((time: number) => {
if (!audioRef.current) return
audioRef.current.currentTime = time
setCurrentTime(time)
audioRef.current.play()
setIsPlaying(true)
}, [])
const togglePlayback = useCallback(() => {
if (!audioRef.current) return
if (isPlaying) {
audioRef.current.pause()
} else {
audioRef.current.play()
}
setIsPlaying(!isPlaying)
}, [isPlaying])
// Expose methods globally
useEffect(() => {
if (!audioUrl) return
window.seekAndPlayAudio = seekAndPlay
window.toggleAudioPlayback = togglePlayback
window.getAudioDuration = () => duration
return () => {
delete window.seekAndPlayAudio
delete window.toggleAudioPlayback
delete window.getAudioDuration
}
}, [audioUrl, seekAndPlay, togglePlayback, duration])
if (!audioUrl) return null
return (
<div className="flex items-center gap-2 bg-card rounded h-8">
<span className="text-xs text-muted-foreground mr-1">Playback:</span>
<Button variant="ghost" size="icon" className="h-7 w-7 p-0.5" onClick={handlePlayPause}>
{isPlaying ? <Pause className="h-4 w-4" /> : <Play className="h-4 w-4" />}
</Button>
<span className="text-xs min-w-[32px]">{formatTime(currentTime)}</span>
<Slider
value={[currentTime]}
min={0}
max={duration || 100}
step={0.1}
onValueChange={handleSeek}
className="w-[100px] mx-1"
/>
<span className="text-xs min-w-[32px]">{formatTime(duration)}</span>
</div>
)
}
@@ -0,0 +1,117 @@
'use client'
import { Button } from '@/components/ui/button'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
import { COLORS } from '@/lib/lyrics-review/constants'
import { cn } from '@/lib/utils'
import { Undo, Edit, CheckCircle } from 'lucide-react'
interface CorrectionInfo {
originalWord: string
handler: string
confidence: number
source: string
reason?: string
}
interface CorrectedWordWithActionsProps {
word: string
originalWord: string
correction: CorrectionInfo
onRevert: () => void
onEdit: () => void
onAccept: () => void
onClick?: () => void
backgroundColor?: string
shouldFlash?: boolean
showActions?: boolean
}
export default function CorrectedWordWithActions({
word,
originalWord,
onRevert,
onEdit,
onAccept,
onClick,
backgroundColor,
shouldFlash,
showActions = true,
}: CorrectedWordWithActionsProps) {
const handleAction = (e: React.MouseEvent, action: () => void) => {
e.stopPropagation()
action()
}
return (
<span
className={cn(
'inline-flex items-center gap-0.5 px-[3px] py-[1px] rounded-sm cursor-pointer relative',
'hover:bg-green-500/35',
shouldFlash && 'animate-pulse'
)}
style={{ backgroundColor: backgroundColor || COLORS.corrected }}
onClick={onClick}
>
{/* Original word label - shown above */}
<span className="absolute -top-3.5 left-0 text-[0.6rem] text-muted-foreground line-through opacity-70 whitespace-nowrap pointer-events-none">
{originalWord}
</span>
{/* Current word */}
<span className="text-[0.85rem] leading-[1.2] font-semibold">{word}</span>
{/* Action buttons */}
{showActions && (
<span className="inline-flex items-center gap-[1px] ml-0.5">
<TooltipProvider delayDuration={200}>
<Tooltip>
<TooltipTrigger asChild>
<Button
size="icon"
variant="ghost"
className="h-5 w-5 min-h-0 min-w-0 p-0.5 bg-slate-800/90 dark:bg-slate-800/90 border border-border hover:bg-slate-700 dark:hover:bg-slate-700 hover:scale-110 transition-transform"
onClick={(e) => handleAction(e, onRevert)}
aria-label="revert correction"
>
<Undo className="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="top">Revert to original</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger asChild>
<Button
size="icon"
variant="ghost"
className="h-5 w-5 min-h-0 min-w-0 p-0.5 bg-slate-800/90 dark:bg-slate-800/90 border border-border hover:bg-slate-700 dark:hover:bg-slate-700 hover:scale-110 transition-transform"
onClick={(e) => handleAction(e, onEdit)}
aria-label="edit correction"
>
<Edit className="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="top">Edit correction</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger asChild>
<Button
size="icon"
variant="ghost"
className="h-5 w-5 min-h-0 min-w-0 p-0.5 bg-slate-800/90 dark:bg-slate-800/90 border border-border hover:bg-slate-700 dark:hover:bg-slate-700 hover:scale-110 transition-transform text-green-500 hidden sm:flex"
onClick={(e) => handleAction(e, onAccept)}
aria-label="accept correction"
>
<CheckCircle className="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent side="top">Accept correction</TooltipContent>
</Tooltip>
</TooltipProvider>
</span>
)}
</span>
)
}
@@ -0,0 +1,176 @@
'use client'
import {
Dialog,
DialogContent,
DialogHeader,
DialogTitle,
DialogFooter,
} from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Badge } from '@/components/ui/badge'
import { Progress } from '@/components/ui/progress'
import { X, ArrowRight } from 'lucide-react'
import { cn } from '@/lib/utils'
interface CorrectionDetailCardProps {
open: boolean
onClose: () => void
originalWord: string
correctedWord: string
category: string | null
confidence: number
reason: string
handler: string
source: string
onRevert: () => void
onEdit: () => void
onAccept: () => void
}
// Format category name for display
const formatCategory = (category: string | null): string => {
if (!category) return 'Unknown'
return category
.split('_')
.map((word) => word.charAt(0) + word.slice(1).toLowerCase())
.join(' ')
}
// Get emoji/icon for category
const getCategoryIcon = (category: string | null): string => {
if (!category) return ''
const icons: Record<string, string> = {
SOUND_ALIKE: '',
PUNCTUATION_ONLY: '',
BACKGROUND_VOCALS: '',
EXTRA_WORDS: '',
REPEATED_SECTION: '',
COMPLEX_MULTI_ERROR: '',
AMBIGUOUS: '',
NO_ERROR: '',
}
return icons[category] || ''
}
// Get confidence variant
const getConfidenceVariant = (confidence: number): 'destructive' | 'secondary' | 'default' => {
if (confidence < 0.6) return 'destructive'
if (confidence < 0.8) return 'secondary'
return 'default'
}
export default function CorrectionDetailCard({
open,
onClose,
originalWord,
correctedWord,
category,
confidence,
reason,
handler,
source,
onRevert,
onEdit,
onAccept,
}: CorrectionDetailCardProps) {
const isMobile = typeof window !== 'undefined' && window.innerWidth < 640
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
<DialogContent className={cn('max-w-md', isMobile && 'max-h-[85vh]')}>
<DialogHeader>
<DialogTitle className="flex justify-between items-center">
<span className="text-lg font-semibold">Correction Details</span>
<Button variant="ghost" size="icon" onClick={onClose} className="h-8 w-8">
<X className="h-4 w-4" />
</Button>
</DialogTitle>
</DialogHeader>
<div className="space-y-4">
{/* Original -> Corrected */}
<div>
<span className="text-xs text-muted-foreground mb-1 block">Change</span>
<div className="flex items-center gap-3">
<div className="flex-1 px-3 py-2 bg-red-100 dark:bg-red-900/30 rounded text-center line-through">
<span className="font-medium">{originalWord}</span>
</div>
<ArrowRight className="h-4 w-4 text-muted-foreground" />
<div className="flex-1 px-3 py-2 bg-green-100 dark:bg-green-900/30 rounded text-center">
<span className="font-semibold">{correctedWord}</span>
</div>
</div>
</div>
{/* Category */}
{category && (
<div>
<span className="text-xs text-muted-foreground mb-1 block">Category</span>
<Badge variant="outline" className="text-sm">
{getCategoryIcon(category)} {formatCategory(category)}
</Badge>
</div>
)}
{/* Confidence */}
<div>
<div className="flex justify-between mb-1">
<span className="text-xs text-muted-foreground">Confidence</span>
<span className="text-xs font-semibold">{(confidence * 100).toFixed(0)}%</span>
</div>
<Progress value={confidence * 100} className="h-2" />
</div>
{/* Reasoning */}
<div>
<span className="text-xs text-muted-foreground mb-1 block">Reasoning</span>
<div className="p-3 bg-muted rounded border text-sm leading-relaxed">{reason}</div>
</div>
{/* Metadata */}
<div className="flex flex-wrap gap-2">
<Badge variant="outline" className="text-xs">
Handler: {handler}
</Badge>
<Badge variant="outline" className="text-xs">
Source: {source}
</Badge>
</div>
</div>
<DialogFooter className={cn('gap-2', isMobile && 'flex-col')}>
<Button
variant="outline"
onClick={() => {
onRevert()
onClose()
}}
className={cn('text-destructive', isMobile && 'w-full h-11')}
>
Revert to Original
</Button>
<Button
variant="outline"
onClick={() => {
onEdit()
onClose()
}}
className={cn(isMobile && 'w-full h-11')}
>
Edit Correction
</Button>
<Button
onClick={() => {
onAccept()
onClose()
}}
className={cn('bg-green-600 hover:bg-green-700', isMobile && 'w-full h-11')}
>
Mark as Correct
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,144 @@
'use client'
import { Card } from '@/components/ui/card'
import { COLORS } from '@/lib/lyrics-review/constants'
import { cn } from '@/lib/utils'
interface MetricProps {
color?: string
label: string
value: string | number
description: string
details?: Array<{ label: string; value: string | number }>
onClick?: () => void
}
function Metric({ color, label, value, description, details, onClick }: MetricProps) {
return (
<Card
className={cn(
'p-2 pt-0 h-full flex flex-col',
onClick && 'cursor-pointer hover:bg-muted/30 transition-colors'
)}
onClick={onClick}
>
<div className="flex items-center gap-1 mb-1 mt-2">
{color && (
<div
className="w-3 h-3 rounded"
style={{ backgroundColor: color }}
/>
)}
<span className="text-xs text-muted-foreground">{label}</span>
</div>
<div className="flex items-baseline gap-1 mb-1">
<span className="text-lg font-semibold">{value}</span>
</div>
<span className="text-xs text-muted-foreground">{description}</span>
{details && (
<div className="mt-1 flex-1 overflow-auto">
{details.map((detail, index) => (
<div key={index} className="flex justify-between mt-1">
<span className="text-xs text-muted-foreground">{detail.label}</span>
<span className="text-xs">{detail.value}</span>
</div>
))}
</div>
)}
</Card>
)
}
interface CorrectionMetricsProps {
// Anchor metrics
anchorCount?: number
multiSourceAnchors?: number
anchorWordCount?: number
// Gap metrics
correctedGapCount?: number
uncorrectedGapCount?: number
uncorrectedGaps?: Array<{
position: string
length: number
}>
// Correction details
replacedCount?: number
addedCount?: number
deletedCount?: number
// Add total words count
totalWords?: number
onMetricClick?: {
anchor?: () => void
corrected?: () => void
uncorrected?: () => void
}
}
export default function CorrectionMetrics({
anchorCount,
multiSourceAnchors = 0,
anchorWordCount = 0,
correctedGapCount = 0,
uncorrectedGapCount = 0,
uncorrectedGaps = [],
replacedCount = 0,
addedCount = 0,
deletedCount = 0,
totalWords = 0,
onMetricClick,
}: CorrectionMetricsProps) {
// Calculate percentages based on word counts
const anchorPercentage = totalWords > 0 ? Math.round((anchorWordCount / totalWords) * 100) : 0
const uncorrectedWordCount = uncorrectedGaps?.reduce((sum, gap) => sum + gap.length, 0) ?? 0
const uncorrectedPercentage =
totalWords > 0 ? Math.round((uncorrectedWordCount / totalWords) * 100) : 0
const correctedWordCount = replacedCount + addedCount
const correctedPercentage =
totalWords > 0 ? Math.round((correctedWordCount / totalWords) * 100) : 0
return (
<div className="h-full flex">
<div className="flex-1 flex flex-row gap-2 h-full">
<div className="flex-1 h-full">
<Metric
color={COLORS.anchor}
label="Anchor Sequences"
value={`${anchorCount ?? '-'} (${anchorPercentage}%)`}
description="Matched sections between transcription and reference"
details={[
{ label: 'Words in Anchors', value: anchorWordCount },
{ label: 'Multi-source Matches', value: multiSourceAnchors },
]}
onClick={onMetricClick?.anchor}
/>
</div>
<div className="flex-1 h-full">
<Metric
color={COLORS.corrected}
label="Corrected Gaps"
value={`${correctedGapCount} (${correctedPercentage}%)`}
description="Successfully corrected sections"
details={[
{ label: 'Words Replaced', value: replacedCount },
{ label: 'Words Added / Deleted', value: `+${addedCount} / -${deletedCount}` },
]}
onClick={onMetricClick?.corrected}
/>
</div>
<div className="flex-1 h-full">
<Metric
color={COLORS.uncorrectedGap}
label="Uncorrected Gaps"
value={`${uncorrectedGapCount} (${uncorrectedPercentage}%)`}
description="Sections that may need manual review"
details={[
{ label: 'Words Uncorrected', value: uncorrectedWordCount },
{ label: 'Number of Gaps', value: uncorrectedGaps.length },
]}
onClick={onMetricClick?.uncorrected}
/>
</div>
</div>
</div>
)
}
@@ -0,0 +1,158 @@
'use client'
import { AlertTriangle } from 'lucide-react'
import { LyricsSegment, WordCorrection, AnchorSequence, GapSequence } from '@/lib/lyrics-review/types'
import { COLORS } from '@/lib/lyrics-review/constants'
import { cn } from '@/lib/utils'
interface DurationTimelineViewProps {
segments: LyricsSegment[]
corrections: WordCorrection[]
anchors: AnchorSequence[]
gaps: GapSequence[]
onWordClick?: (wordId: string) => void
}
export default function DurationTimelineView({
segments,
corrections,
anchors,
gaps,
onWordClick,
}: DurationTimelineViewProps) {
const timeToPosition = (time: number, startTime: number, endTime: number): number => {
const duration = endTime - startTime
if (duration === 0) return 0
const position = ((time - startTime) / duration) * 100
return Math.max(0, Math.min(100, position))
}
const generateTimelineMarks = (startTime: number, endTime: number) => {
const marks = []
const startSecond = Math.floor(startTime)
const endSecond = Math.ceil(endTime)
// Generate marks roughly every 2 seconds for readability
for (let time = startSecond; time <= endSecond; time += 2) {
if (time >= startTime && time <= endTime) {
const position = timeToPosition(time, startTime, endTime)
marks.push(
<div key={time}>
<div
className="absolute w-[1px] h-2 bg-muted-foreground/50 bottom-0"
style={{ left: `${position}%` }}
/>
<div
className="absolute text-[0.65rem] text-muted-foreground bottom-2.5 whitespace-nowrap -translate-x-1/2"
style={{ left: `${position}%` }}
>
{time}s
</div>
</div>
)
}
}
return marks
}
return (
<div className="flex flex-col gap-3 p-2 overflow-x-auto min-w-full">
{segments.map((segment) => {
// Calculate segment time range
const segmentWords = segment.words.filter(
(w) => w.start_time !== null && w.end_time !== null
)
if (segmentWords.length === 0) return null
const startTime = Math.min(...segmentWords.map((w) => w.start_time!))
const endTime = Math.max(...segmentWords.map((w) => w.end_time!))
return (
<div key={segment.id} className="flex flex-col gap-1 min-w-full">
{/* Timeline ruler */}
<div className="relative h-5 border-b border-border mb-1">
{generateTimelineMarks(startTime, endTime)}
</div>
{/* Words bar */}
<div
className="relative h-[60px] flex items-stretch min-w-full bg-background rounded mb-2"
style={{ touchAction: 'pan-y' }}
>
{segment.words.map((word, wordIndex) => {
if (word.start_time === null || word.end_time === null) return null
const leftPosition = timeToPosition(word.start_time, startTime, endTime)
const rightPosition = timeToPosition(word.end_time, startTime, endTime)
const width = rightPosition - leftPosition
const duration = word.end_time - word.start_time
const isLong = duration > 2.0
// Check if this word is corrected
const correction = corrections.find(
(c) => c.corrected_word_id === word.id || c.word_id === word.id
)
// Check if anchor
const isAnchor = anchors.some((a) => a.transcribed_word_ids.includes(word.id))
// Check if uncorrected gap
const isGap =
gaps.some((g) => g.transcribed_word_ids.includes(word.id)) && !correction
// Determine background color
let bgColor = 'hsl(var(--secondary))'
if (isAnchor) bgColor = COLORS.anchor
else if (correction) bgColor = COLORS.corrected
else if (isGap) bgColor = COLORS.uncorrectedGap
return (
<div
key={`${segment.id}-${wordIndex}`}
className={cn(
'absolute h-full flex flex-col justify-center items-center px-1 py-0.5',
'border-r border-white/30 text-[0.75rem] cursor-pointer transition-all',
'hover:opacity-80 hover:scale-[1.02] hover:z-10',
'overflow-hidden text-ellipsis whitespace-nowrap min-w-[20px]',
isLong && 'border-2 border-red-500 shadow-[0_0_4px_rgba(244,67,54,0.5)]'
)}
style={{
left: `${leftPosition}%`,
width: `${width}%`,
backgroundColor: bgColor,
}}
onClick={() => onWordClick?.(word.id)}
>
{isLong && (
<AlertTriangle className="absolute -top-0.5 -right-0.5 h-4 w-4 text-red-500" />
)}
{correction && (
<span className="text-[0.65rem] text-muted-foreground leading-none mb-0.5 line-through opacity-85 font-medium bg-background/80 px-0.5 rounded-sm">
{correction.original_word}
</span>
)}
<span
className={cn(
'leading-tight overflow-hidden text-ellipsis whitespace-nowrap w-full text-center',
correction
? 'text-[0.85rem] font-bold text-green-400'
: 'text-[0.75rem] font-medium'
)}
>
{word.text}
</span>
{duration > 0.1 && (
<span className="text-[0.6rem] text-foreground/60 leading-none mt-0.5 font-semibold">
{duration.toFixed(1)}s
</span>
)}
</div>
)
})}
</div>
</div>
)
})}
</div>
)
}
@@ -0,0 +1,82 @@
'use client'
import { Button } from '@/components/ui/button'
import { Trash2, RotateCcw, History } from 'lucide-react'
import { LyricsSegment } from '@/lib/lyrics-review/types'
import { cn } from '@/lib/utils'
interface EditActionBarProps {
onReset: () => void
onRevertToOriginal?: () => void
onDelete?: () => void
onClose: () => void
onSave: () => void
editedSegment: LyricsSegment | null
originalTranscribedSegment?: LyricsSegment | null
isGlobal?: boolean
}
export default function EditActionBar({
onReset,
onRevertToOriginal,
onDelete,
onClose,
onSave,
editedSegment,
originalTranscribedSegment,
isGlobal = false,
}: EditActionBarProps) {
const isMobile = typeof window !== 'undefined' && window.innerWidth < 640
return (
<div
className={cn(
'flex w-full gap-2',
isMobile ? 'flex-col items-stretch' : 'flex-row items-center'
)}
>
<div
className={cn(
'flex items-center gap-2 flex-wrap',
isMobile ? 'justify-center' : 'justify-start'
)}
>
<Button variant="outline" size={isMobile ? 'sm' : 'default'} onClick={onReset}>
<RotateCcw className="h-4 w-4 mr-1" />
Reset
</Button>
{originalTranscribedSegment && (
<Button variant="outline" size={isMobile ? 'sm' : 'default'} onClick={onRevertToOriginal}>
<History className="h-4 w-4 mr-1" />
Un-Correct
</Button>
)}
{!isGlobal && onDelete && (
<Button
variant="outline"
size={isMobile ? 'sm' : 'default'}
onClick={onDelete}
className="text-destructive hover:text-destructive"
>
<Trash2 className="h-4 w-4 mr-1" />
Delete Segment
</Button>
)}
</div>
<div
className={cn('flex gap-2', isMobile ? 'justify-center ml-0' : 'justify-end ml-auto')}
>
<Button variant="outline" size={isMobile ? 'sm' : 'default'} onClick={onClose}>
Cancel
</Button>
<Button
size={isMobile ? 'sm' : 'default'}
onClick={onSave}
disabled={!editedSegment || editedSegment.words.length === 0}
>
Save
</Button>
</div>
</div>
)
}
@@ -0,0 +1,205 @@
'use client'
import { memo, useRef, useCallback } from 'react'
import { Button } from '@/components/ui/button'
import { Play, XCircle, Hand } from 'lucide-react'
import { Word } from '@/lib/lyrics-review/types'
import TimelineEditor from './TimelineEditor'
import { cn } from '@/lib/utils'
// Separate TapButton component to properly track local press state
const TapButton = memo(function TapButton({
isSpacebarPressed,
onTapStart,
onTapEnd,
}: {
isSpacebarPressed: boolean
onTapStart: () => void
onTapEnd: () => void
}) {
const isPressedRef = useRef(false)
const handleTapStart = useCallback(() => {
isPressedRef.current = true
onTapStart()
}, [onTapStart])
const handleTapEnd = useCallback(() => {
if (isPressedRef.current) {
isPressedRef.current = false
onTapEnd()
}
}, [onTapEnd])
return (
<Button
variant={isSpacebarPressed ? 'secondary' : 'default'}
onTouchStart={(e) => {
e.preventDefault()
handleTapStart()
}}
onTouchEnd={(e) => {
e.preventDefault()
handleTapEnd()
}}
onMouseDown={handleTapStart}
onMouseUp={handleTapEnd}
onMouseLeave={handleTapEnd}
className={cn(
'py-6 text-lg font-bold w-full min-h-[56px] select-none touch-manipulation',
isSpacebarPressed && 'bg-secondary'
)}
>
<Hand className="h-5 w-5 mr-2" />
{isSpacebarPressed ? 'HOLD...' : 'TAP'}
</Button>
)
})
interface EditTimelineSectionProps {
words: Word[]
startTime: number
endTime: number
originalStartTime: number | null
originalEndTime: number | null
currentStartTime: number | null
currentEndTime: number | null
currentTime?: number
isManualSyncing: boolean
syncWordIndex: number
isSpacebarPressed: boolean
onWordUpdate: (index: number, updates: Partial<Word>) => void
onPlaySegment?: (time: number) => void
startManualSync: () => void
isGlobal?: boolean
onTapStart?: () => void
onTapEnd?: () => void
}
export default function EditTimelineSection({
words,
startTime,
endTime,
originalStartTime,
originalEndTime,
currentStartTime,
currentEndTime,
currentTime,
isManualSyncing,
syncWordIndex,
isSpacebarPressed,
onWordUpdate,
onPlaySegment,
startManualSync,
isGlobal = false,
onTapStart,
onTapEnd,
}: EditTimelineSectionProps) {
// Simple mobile detection
const isMobile = typeof window !== 'undefined' && window.innerWidth < 640
// Get current word info for display during manual sync
const currentWordInfo =
isManualSyncing && syncWordIndex >= 0 && syncWordIndex < words.length
? {
index: syncWordIndex + 1,
total: words.length,
text: words[syncWordIndex]?.text || '',
}
: null
return (
<>
{/* Timeline Editor */}
<div className={cn('mb-0', isMobile ? 'h-20' : 'h-[120px]')}>
<TimelineEditor
words={words}
startTime={startTime}
endTime={endTime}
onWordUpdate={onWordUpdate}
currentTime={currentTime}
onPlaySegment={onPlaySegment}
/>
</div>
{/* Time range info and controls */}
<div
className={cn(
'flex items-center justify-between gap-2',
isMobile ? 'flex-col items-stretch mt-2 mb-3' : 'flex-row mt-0 mb-0'
)}
>
{/* Time range info - hidden on mobile to save space */}
{!isMobile && (
<div className="text-xs text-muted-foreground">
<div>
Original Time Range: {originalStartTime?.toFixed(2) ?? 'N/A'} -{' '}
{originalEndTime?.toFixed(2) ?? 'N/A'}
</div>
<div>
Current Time Range: {currentStartTime?.toFixed(2) ?? 'N/A'} -{' '}
{currentEndTime?.toFixed(2) ?? 'N/A'}
</div>
</div>
)}
{/* Controls */}
<div
className={cn(
'flex items-center gap-2',
isMobile ? 'flex-col items-stretch' : 'flex-row'
)}
>
{/* Tap To Sync button */}
<Button
variant={isManualSyncing ? 'outline' : 'default'}
onClick={startManualSync}
className={cn(
isManualSyncing
? 'border-destructive text-destructive hover:bg-destructive/10'
: 'bg-primary'
)}
>
{isManualSyncing ? (
<>
<XCircle className="h-4 w-4 mr-1" />
Cancel
</>
) : (
<>
<Play className="h-4 w-4 mr-1" />
Tap To Sync
</>
)}
</Button>
{/* Current word info during sync */}
{currentWordInfo && (
<div className={cn('text-center', isMobile ? '' : 'text-left')}>
<div className="text-sm">
Word {currentWordInfo.index} of {currentWordInfo.total}:{' '}
<strong>{currentWordInfo.text}</strong>
</div>
<div className="text-xs text-muted-foreground">
{isSpacebarPressed
? 'Holding... Release when word ends'
: isMobile
? 'Tap the button when word starts'
: 'Press spacebar when word starts (tap for short words, hold for long words)'}
</div>
</div>
)}
{/* Mobile TAP button for manual sync */}
{isMobile && isManualSyncing && onTapStart && onTapEnd && (
<TapButton
isSpacebarPressed={isSpacebarPressed}
onTapStart={onTapStart}
onTapEnd={onTapEnd}
/>
)}
</div>
</div>
</>
)
}
@@ -0,0 +1,371 @@
'use client'
import { useState, memo, useMemo } from 'react'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Label } from '@/components/ui/label'
import { Trash2, Split, Wand2 } from 'lucide-react'
import { Word } from '@/lib/lyrics-review/types'
import WordDivider from './WordDivider'
interface EditWordListProps {
words: Word[]
onWordUpdate: (index: number, updates: Partial<Word>) => void
onSplitWord: (index: number) => void
onMergeWords: (index: number) => void
onAddWord: (index?: number) => void
onRemoveWord: (index: number) => void
onReplaceAllWords?: (replacementText: string) => void
onSplitSegment?: (wordIndex: number) => void
onAddSegment?: (beforeIndex: number) => void
onMergeSegment?: (mergeWithNext: boolean) => void
isGlobal?: boolean
}
// Memoized word row component
const WordRow = memo(function WordRow({
word,
index,
onWordUpdate,
onSplitWord,
onRemoveWord,
wordsLength,
onTabNavigation,
isMobile,
}: {
word: Word
index: number
onWordUpdate: (index: number, updates: Partial<Word>) => void
onSplitWord: (index: number) => void
onRemoveWord: (index: number) => void
wordsLength: number
onTabNavigation: (currentIndex: number) => void
isMobile: boolean
}) {
const handleKeyDown = (e: React.KeyboardEvent) => {
if (e.key === 'Tab' && !e.shiftKey) {
e.preventDefault()
onTabNavigation(index)
}
}
return (
<div
className={`flex ${isMobile ? 'flex-col gap-2' : 'flex-row gap-4'} items-${isMobile ? 'stretch' : 'end'} py-1`}
>
{/* Word text field */}
<div className={`flex gap-2 items-end ${isMobile ? '' : 'flex-1'}`}>
<div className="flex-1">
<Label htmlFor={`word-text-${index}`} className="text-xs text-muted-foreground mb-1">
Word {index}
</Label>
<Input
id={`word-text-${index}`}
value={word.text}
onChange={(e) => onWordUpdate(index, { text: e.target.value })}
onKeyDown={handleKeyDown}
className="h-8"
/>
</div>
{/* Action buttons inline with word on mobile */}
{isMobile && (
<>
<Button
variant="ghost"
size="icon"
onClick={() => onSplitWord(index)}
title="Split Word"
className="h-8 w-8 text-primary"
>
<Split className="h-4 w-4" />
</Button>
<Button
variant="ghost"
size="icon"
onClick={() => onRemoveWord(index)}
disabled={wordsLength <= 1}
title="Remove Word"
className="h-8 w-8 text-destructive"
>
<Trash2 className="h-4 w-4" />
</Button>
</>
)}
</div>
{/* Time fields */}
<div
className={`flex gap-2 items-end ${isMobile ? 'justify-start' : 'justify-end'}`}
>
<div className={`${isMobile ? 'w-20' : 'w-24'}`}>
<Label className="text-xs text-muted-foreground mb-1">Start</Label>
<Input
type="number"
value={word.start_time?.toFixed(2) ?? ''}
onChange={(e) => onWordUpdate(index, { start_time: parseFloat(e.target.value) })}
step={0.01}
className="h-8"
/>
</div>
<div className={`${isMobile ? 'w-20' : 'w-24'}`}>
<Label className="text-xs text-muted-foreground mb-1">End</Label>
<Input
type="number"
value={word.end_time?.toFixed(2) ?? ''}
onChange={(e) => onWordUpdate(index, { end_time: parseFloat(e.target.value) })}
step={0.01}
className="h-8"
/>
</div>
{/* Action buttons on desktop only */}
{!isMobile && (
<>
<Button
variant="ghost"
size="icon"
onClick={() => onSplitWord(index)}
title="Split Word"
className="h-8 w-8 text-primary"
>
<Split className="h-4 w-4" />
</Button>
<Button
variant="ghost"
size="icon"
onClick={() => onRemoveWord(index)}
disabled={wordsLength <= 1}
title="Remove Word"
className="h-8 w-8 text-destructive"
>
<Trash2 className="h-4 w-4" />
</Button>
</>
)}
</div>
</div>
)
})
// Memoized word item component
const WordItem = memo(function WordItem({
word,
index,
onWordUpdate,
onSplitWord,
onRemoveWord,
onAddWord,
onMergeWords,
onSplitSegment,
onAddSegment,
onMergeSegment,
wordsLength,
isGlobal,
onTabNavigation,
isMobile,
}: {
word: Word
index: number
onWordUpdate: (index: number, updates: Partial<Word>) => void
onSplitWord: (index: number) => void
onRemoveWord: (index: number) => void
onAddWord: (index: number) => void
onMergeWords: (index: number) => void
onSplitSegment?: (index: number) => void
onAddSegment?: (index: number) => void
onMergeSegment?: (mergeWithNext: boolean) => void
wordsLength: number
isGlobal: boolean
onTabNavigation: (currentIndex: number) => void
isMobile: boolean
}) {
return (
<div key={word.id}>
<WordRow
word={word}
index={index}
onWordUpdate={onWordUpdate}
onSplitWord={onSplitWord}
onRemoveWord={onRemoveWord}
wordsLength={wordsLength}
onTabNavigation={onTabNavigation}
isMobile={isMobile}
/>
{/* Word divider */}
{!isGlobal && (
<WordDivider
onAddWord={() => onAddWord(index)}
onMergeWords={() => onMergeWords(index)}
onSplitSegment={() => onSplitSegment?.(index)}
onAddSegmentAfter={
index === wordsLength - 1 ? () => onAddSegment?.(index + 1) : undefined
}
onMergeSegment={index === wordsLength - 1 ? () => onMergeSegment?.(true) : undefined}
canMerge={index < wordsLength - 1}
isLast={index === wordsLength - 1}
/>
)}
{isGlobal && (
<WordDivider
onAddWord={() => onAddWord(index)}
onMergeWords={index < wordsLength - 1 ? () => onMergeWords(index) : undefined}
canMerge={index < wordsLength - 1}
/>
)}
</div>
)
})
export default function EditWordList({
words,
onWordUpdate,
onSplitWord,
onMergeWords,
onAddWord,
onRemoveWord,
onReplaceAllWords,
onSplitSegment,
onAddSegment,
onMergeSegment,
isGlobal = false,
}: EditWordListProps) {
// Simple mobile detection
const isMobile = typeof window !== 'undefined' && window.innerWidth < 640
const [replacementText, setReplacementText] = useState('')
const [page, setPage] = useState(1)
const pageSize = isGlobal ? 50 : words.length
const handleReplaceAllWords = () => {
if (onReplaceAllWords) {
// Use the callback that handles proper timing
onReplaceAllWords(replacementText)
} else {
// Fallback: just update text of existing words (legacy behavior)
const newWords = replacementText.trim().split(/\s+/)
newWords.forEach((text, index) => {
if (index < words.length) {
onWordUpdate(index, { text })
}
})
}
setReplacementText('')
}
// Pagination
const pageCount = Math.ceil(words.length / pageSize)
const startIndex = (page - 1) * pageSize
const endIndex = Math.min(startIndex + pageSize, words.length)
const visibleWords = useMemo(() => {
return isGlobal ? words.slice(startIndex, endIndex) : words
}, [words, isGlobal, startIndex, endIndex])
// Tab navigation between word fields
const handleTabNavigation = (currentIndex: number) => {
const nextIndex = (currentIndex + 1) % words.length
if (isGlobal && (nextIndex < startIndex || nextIndex >= endIndex)) {
const nextPage = Math.floor(nextIndex / pageSize) + 1
setPage(nextPage)
setTimeout(() => {
focusWordTextField(nextIndex)
}, 50)
} else {
focusWordTextField(nextIndex)
}
}
const focusWordTextField = (index: number) => {
const element = document.getElementById(`word-text-${index}`)
if (element) {
const input = element as HTMLInputElement
input.focus()
input.select()
}
}
return (
<div className="flex flex-col gap-2 flex-grow min-h-0">
{/* Initial divider */}
{!isGlobal && (
<WordDivider
onAddWord={() => onAddWord(-1)}
onAddSegmentBefore={() => onAddSegment?.(0)}
onMergeSegment={() => onMergeSegment?.(false)}
isFirst={true}
/>
)}
{isGlobal && <WordDivider onAddWord={() => onAddWord(-1)} />}
{/* Word list with scrolling */}
<div className="flex flex-col gap-1 flex-grow overflow-y-auto mb-0 pt-2 scrollbar-thin">
{visibleWords.map((word, visibleIndex) => {
const actualIndex = isGlobal ? startIndex + visibleIndex : visibleIndex
return (
<WordItem
key={word.id}
word={word}
index={actualIndex}
onWordUpdate={onWordUpdate}
onSplitWord={onSplitWord}
onRemoveWord={onRemoveWord}
onAddWord={onAddWord}
onMergeWords={onMergeWords}
onSplitSegment={onSplitSegment}
onAddSegment={onAddSegment}
onMergeSegment={onMergeSegment}
wordsLength={words.length}
isGlobal={isGlobal}
onTabNavigation={handleTabNavigation}
isMobile={isMobile}
/>
)
})}
</div>
{/* Pagination controls */}
{isGlobal && pageCount > 1 && (
<div className="flex justify-center items-center gap-2 mb-2">
<Button
variant="outline"
size="sm"
onClick={() => setPage((p) => Math.max(1, p - 1))}
disabled={page === 1}
>
Previous
</Button>
<span className="text-sm">
Page {page} of {pageCount}
</span>
<Button
variant="outline"
size="sm"
onClick={() => setPage((p) => Math.min(pageCount, p + 1))}
disabled={page === pageCount}
>
Next
</Button>
<span className="text-sm text-muted-foreground ml-2">
Words {startIndex + 1}-{endIndex} of {words.length}
</span>
</div>
)}
{/* Replace all words */}
<div className="flex gap-2 mb-1">
<Input
value={replacementText}
onChange={(e) => setReplacementText(e.target.value)}
placeholder="Replace all words"
className="flex-grow"
/>
<Button onClick={handleReplaceAllWords} size="sm" className="whitespace-nowrap">
<Wand2 className="h-4 w-4 mr-1" />
Replace All
</Button>
</div>
</div>
)
}
@@ -0,0 +1,513 @@
'use client'
import { Button } from '@/components/ui/button'
import { Switch } from '@/components/ui/switch'
import { Label } from '@/components/ui/label'
import { Badge } from '@/components/ui/badge'
import { Card } from '@/components/ui/card'
import {
Tooltip,
TooltipContent,
TooltipProvider,
TooltipTrigger,
} from '@/components/ui/tooltip'
import {
Lock,
Upload,
Search,
Edit,
Undo2,
Redo2,
Timer,
RotateCcw,
MessageSquare,
Eye,
CheckCircle2,
XCircle,
} from 'lucide-react'
import { CorrectionData, InteractionMode } from '@/lib/lyrics-review/types'
import ModeSelector from './ModeSelector'
import AudioPlayer from './AudioPlayer'
import { findWordById } from '@/lib/lyrics-review/utils/wordUtils'
import { cn } from '@/lib/utils'
interface ApiClient {
getAudioUrl: (hash: string) => string
}
interface HeaderProps {
isReadOnly: boolean
onFileLoad: () => void
data: CorrectionData
onMetricClick: {
anchor: () => void
corrected: () => void
uncorrected: () => void
}
effectiveMode: InteractionMode
onModeChange: (mode: InteractionMode) => void
apiClient: ApiClient | null
audioHash: string
onTimeUpdate: (time: number) => void
onHandlerToggle: (handler: string, enabled: boolean) => void
isUpdatingHandlers: boolean
onHandlerClick?: (handler: string) => void
onFindReplace?: () => void
onEditAll?: () => void
onUnCorrectAll?: () => void
onResetCorrections?: () => void
onTimingOffset?: () => void
timingOffsetMs?: number
onUndo: () => void
onRedo: () => void
canUndo: boolean
canRedo: boolean
annotationsEnabled?: boolean
onAnnotationsToggle?: (enabled: boolean) => void
reviewMode?: boolean
onReviewModeToggle?: (enabled: boolean) => void
onAcceptAllCorrections?: () => void
onAcceptHighConfidenceCorrections?: () => void
onRevertAllCorrections?: () => void
}
export default function Header({
isReadOnly,
onFileLoad,
data,
onMetricClick,
effectiveMode,
onModeChange,
apiClient,
audioHash,
onTimeUpdate,
onHandlerToggle,
isUpdatingHandlers,
onHandlerClick,
onFindReplace,
onEditAll,
onUnCorrectAll,
onResetCorrections,
onTimingOffset,
timingOffsetMs = 0,
onUndo,
onRedo,
canUndo,
canRedo,
annotationsEnabled = true,
onAnnotationsToggle,
reviewMode = false,
onReviewModeToggle,
onAcceptAllCorrections,
onAcceptHighConfidenceCorrections,
onRevertAllCorrections,
}: HeaderProps) {
const isMobile = typeof window !== 'undefined' && window.innerWidth < 768
// Get handlers with their correction counts
const handlerCounts =
data.corrections?.reduce(
(counts: Record<string, number>, correction) => {
counts[correction.handler] = (counts[correction.handler] || 0) + 1
return counts
},
{} as Record<string, number>
) || {}
// Get available handlers from metadata
const availableHandlers = data.metadata.available_handlers || []
const enabledHandlers = new Set(data.metadata.enabled_handlers || [])
// Check if agentic mode is active
const isAgenticMode = availableHandlers.some(
(h: { id: string }) => h.id === 'AgenticCorrector'
)
// Create a map of gap IDs to their corrections
const gapCorrections = data.corrections.reduce(
(map: Record<string, number>, correction) => {
const gap = data.gap_sequences.find((g) =>
g.transcribed_word_ids.includes(correction.word_id)
)
if (gap) {
map[gap.id] = (map[gap.id] || 0) + 1
}
return map
},
{} as Record<string, number>
)
// Calculate metrics
const correctedGapCount = Object.keys(gapCorrections).length
const uncorrectedGapCount = data.gap_sequences.length - correctedGapCount
// Calculate correction type counts
const replacedCount = data.corrections.filter(
(c) => !c.is_deletion && !c.split_total
).length
const addedCount = data.corrections.filter((c) => c.split_total).length
const deletedCount = data.corrections.filter((c) => c.is_deletion).length
// Calculate additional metrics for detailed display (matching old CorrectionMetrics)
const totalWords = data.metadata.total_words || 0
const anchorWordCount = data.anchor_sequences?.reduce(
(sum, anchor) => sum + (anchor.transcribed_word_ids?.length || 0),
0
) ?? 0
const multiSourceAnchors = data.anchor_sequences?.filter(
(anchor) =>
anchor?.reference_word_ids && Object.keys(anchor.reference_word_ids).length > 1
).length ?? 0
// Calculate uncorrected gaps info
const uncorrectedGaps = data.gap_sequences
.filter((gap) => !gapCorrections[gap.id] && gap.transcribed_word_ids.length > 0)
const uncorrectedWordCount = uncorrectedGaps.reduce(
(sum, gap) => sum + gap.transcribed_word_ids.length,
0
)
// Calculate percentages
const anchorPercentage = totalWords > 0 ? Math.round((anchorWordCount / totalWords) * 100) : 0
const correctedWordCount = replacedCount + addedCount
const correctedPercentage = totalWords > 0 ? Math.round((correctedWordCount / totalWords) * 100) : 0
const uncorrectedPercentage = totalWords > 0 ? Math.round((uncorrectedWordCount / totalWords) * 100) : 0
return (
<TooltipProvider>
<div className="space-y-2">
{/* Read-only indicator */}
{isReadOnly && (
<div className="flex items-center gap-1 text-muted-foreground text-sm mb-2">
<Lock className="h-4 w-4" />
<span>View Only Mode</span>
</div>
)}
{/* Review Mode toggle and Load File button */}
<div className="flex gap-2 justify-end items-center mb-2">
{!isReadOnly && isAgenticMode && onReviewModeToggle && (
<Tooltip>
<TooltipTrigger asChild>
<Badge
variant={reviewMode ? 'default' : 'outline'}
className="cursor-pointer"
onClick={() => onReviewModeToggle(!reviewMode)}
>
<Eye className="h-3 w-3 mr-1" />
{reviewMode ? 'Review Mode' : 'Review Off'}
</Badge>
</TooltipTrigger>
<TooltipContent>
{reviewMode
? 'Hide inline correction actions'
: 'Show inline actions on all corrections for quick review'}
</TooltipContent>
</Tooltip>
)}
{isReadOnly && (
<Button variant="outline" size="sm" onClick={onFileLoad} className={cn(isMobile && 'w-full')}>
<Upload className="h-4 w-4 mr-1" />
Load File
</Button>
)}
</div>
{/* Handler panel and metrics */}
<div className={cn('flex gap-2 mb-2 overflow-hidden', isMobile ? 'flex-col' : 'flex-row', isMobile ? 'h-auto' : 'h-[140px]')}>
{/* Handler panel */}
<Card className={cn('p-2', isMobile ? 'w-full' : 'w-[280px] min-w-[280px]')}>
<h4 className="text-xs text-muted-foreground mb-1">Correction Handlers</h4>
<div className="flex-1 overflow-auto flex flex-col">
{availableHandlers.map((handler: { id: string; name: string; description: string }) => (
<div key={handler.id} className="mb-1">
<Tooltip>
<TooltipTrigger asChild>
<div className="flex items-center gap-2">
<Switch
checked={enabledHandlers.has(handler.id)}
onCheckedChange={(checked) => onHandlerToggle(handler.id, checked)}
disabled={isUpdatingHandlers}
className="scale-75"
/>
<Label
className="text-xs cursor-pointer"
onClick={() => onHandlerClick?.(handler.id)}
>
{handler.name} ({handlerCounts[handler.id] || 0})
</Label>
</div>
</TooltipTrigger>
<TooltipContent>
<p>{handler.description}</p>
</TooltipContent>
</Tooltip>
</div>
))}
</div>
</Card>
{/* Metrics panel - matches old CorrectionMetrics component */}
<div className="flex-1 grid grid-cols-3 gap-2 h-full">
{/* Anchor Sequences */}
<Card
className="p-2 cursor-pointer hover:bg-muted/30 transition-colors flex flex-col overflow-hidden h-full"
onClick={onMetricClick.anchor}
>
<div className="flex items-center gap-1 mb-0.5">
<div className="w-3 h-3 rounded bg-blue-500/25 shrink-0" />
<span className="text-xs text-muted-foreground truncate">Anchor Sequences</span>
</div>
<span className="text-lg font-semibold leading-tight">
{data.metadata.anchor_sequences_count ?? '-'} ({anchorPercentage}%)
</span>
<span className="text-[10px] text-muted-foreground leading-tight">
Matched sections between transcription and reference
</span>
<div className="mt-auto space-y-0 text-[10px]">
<div className="flex justify-between">
<span className="text-muted-foreground">Words in Anchors</span>
<span>{anchorWordCount}</span>
</div>
<div className="flex justify-between">
<span className="text-muted-foreground">Multi-source Matches</span>
<span>{multiSourceAnchors}</span>
</div>
</div>
</Card>
{/* Corrected Gaps */}
<Card
className="p-2 cursor-pointer hover:bg-muted/30 transition-colors flex flex-col overflow-hidden h-full"
onClick={onMetricClick.corrected}
>
<div className="flex items-center gap-1 mb-0.5">
<div className="w-3 h-3 rounded bg-green-500/25 shrink-0" />
<span className="text-xs text-muted-foreground truncate">Corrected Gaps</span>
</div>
<span className="text-lg font-semibold text-green-500 leading-tight">
{correctedGapCount} ({correctedPercentage}%)
</span>
<span className="text-[10px] text-muted-foreground leading-tight">
Successfully corrected sections
</span>
<div className="mt-auto space-y-0 text-[10px]">
<div className="flex justify-between">
<span className="text-muted-foreground">Words Replaced</span>
<span>{replacedCount}</span>
</div>
<div className="flex justify-between">
<span className="text-muted-foreground">Words Added / Deleted</span>
<span>+{addedCount} / -{deletedCount}</span>
</div>
</div>
</Card>
{/* Uncorrected Gaps */}
<Card
className="p-2 cursor-pointer hover:bg-muted/30 transition-colors flex flex-col overflow-hidden h-full"
onClick={onMetricClick.uncorrected}
>
<div className="flex items-center gap-1 mb-0.5">
<div className="w-3 h-3 rounded bg-orange-500/25 shrink-0" />
<span className="text-xs text-muted-foreground truncate">Uncorrected Gaps</span>
</div>
<span className="text-lg font-semibold text-amber-500 leading-tight">
{uncorrectedGapCount} ({uncorrectedPercentage}%)
</span>
<span className="text-[10px] text-muted-foreground leading-tight">
Sections that may need manual review
</span>
<div className="mt-auto space-y-0 text-[10px]">
<div className="flex justify-between">
<span className="text-muted-foreground">Words Uncorrected</span>
<span>{uncorrectedWordCount}</span>
</div>
<div className="flex justify-between">
<span className="text-muted-foreground">Number of Gaps</span>
<span>{uncorrectedGaps.length}</span>
</div>
</div>
</Card>
</div>
</div>
{/* Batch Actions Panel */}
{!isReadOnly && reviewMode && isAgenticMode && data.corrections?.length > 0 && (
<Card className="p-2 mb-2 bg-accent/50">
<div className={cn('flex gap-2', isMobile ? 'flex-col' : 'flex-row items-center justify-between')}>
<span className="text-xs text-muted-foreground">
Batch Actions ({data.corrections.length} corrections)
</span>
<div className="flex gap-2 flex-wrap">
{onAcceptHighConfidenceCorrections && (
<Button
size="sm"
onClick={onAcceptHighConfidenceCorrections}
className="bg-green-600 hover:bg-green-700 text-xs h-7"
>
<CheckCircle2 className="h-3 w-3 mr-1" />
Accept High Confidence ({data.corrections.filter((c) => c.confidence >= 0.8).length})
</Button>
)}
{onAcceptAllCorrections && (
<Button
variant="outline"
size="sm"
onClick={onAcceptAllCorrections}
className="text-xs h-7"
>
<CheckCircle2 className="h-3 w-3 mr-1" />
Accept All
</Button>
)}
{onRevertAllCorrections && (
<Button
variant="outline"
size="sm"
onClick={onRevertAllCorrections}
className="text-destructive text-xs h-7"
>
<XCircle className="h-3 w-3 mr-1" />
Revert All
</Button>
)}
</div>
</div>
</Card>
)}
{/* Control bar */}
<Card className="p-2 mb-2">
<div
className={cn(
'flex gap-2 items-center',
isMobile ? 'flex-col items-start' : 'flex-row'
)}
>
<div className="flex gap-1 flex-wrap items-center flex-1">
<ModeSelector effectiveMode={effectiveMode} onChange={onModeChange} />
{!isReadOnly && onResetCorrections && (
<Tooltip>
<TooltipTrigger asChild>
<Button variant="outline" size="sm" onClick={onResetCorrections} className="h-8 text-xs text-amber-500 border-amber-500/50 hover:border-amber-500 hover:bg-amber-500/10">
<Undo2 className="h-3.5 w-3.5 mr-1" />
Undo All
</Button>
</TooltipTrigger>
<TooltipContent>Undo all your changes</TooltipContent>
</Tooltip>
)}
{!isReadOnly && (
<div className="flex h-8">
<Tooltip>
<TooltipTrigger asChild>
<Button
variant="outline"
size="icon"
onClick={onUndo}
disabled={!canUndo}
className="h-8 w-8"
>
<Undo2 className="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent>Undo</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger asChild>
<Button
variant="outline"
size="icon"
onClick={onRedo}
disabled={!canRedo}
className="h-8 w-8"
>
<Redo2 className="h-3.5 w-3.5" />
</Button>
</TooltipTrigger>
<TooltipContent>Redo</TooltipContent>
</Tooltip>
</div>
)}
{!isReadOnly && (
<Button variant="outline" size="sm" onClick={onFindReplace} className="h-8 text-xs">
<Search className="h-3.5 w-3.5 mr-1" />
Find/Replace
</Button>
)}
{!isReadOnly && onEditAll && (
<Button variant="outline" size="sm" onClick={onEditAll} className="h-8 text-xs">
<Edit className="h-3.5 w-3.5 mr-1" />
Edit All
</Button>
)}
{!isReadOnly && onUnCorrectAll && (
<Tooltip>
<TooltipTrigger asChild>
<Button variant="outline" size="sm" onClick={onUnCorrectAll} className="h-8 text-xs">
<RotateCcw className="h-3.5 w-3.5 mr-1" />
Undo Auto Corrections
</Button>
</TooltipTrigger>
<TooltipContent>Revert only automatic AI corrections (keeps your manual edits)</TooltipContent>
</Tooltip>
)}
{!isReadOnly && onTimingOffset && (
<div className="flex items-center">
<Button
variant="outline"
size="sm"
onClick={onTimingOffset}
className={cn('h-8 text-xs', timingOffsetMs !== 0 && 'border-purple-500 text-purple-500')}
>
<Timer className="h-3.5 w-3.5 mr-1" />
Timing Offset
</Button>
{timingOffsetMs !== 0 && (
<span className="ml-1 text-xs font-bold text-purple-500">
{timingOffsetMs > 0 ? '+' : ''}
{timingOffsetMs}ms
</span>
)}
</div>
)}
{!isReadOnly && onAnnotationsToggle && (
<Tooltip>
<TooltipTrigger asChild>
<Button
variant="outline"
size="sm"
onClick={() => onAnnotationsToggle(!annotationsEnabled)}
className={cn('h-8 text-xs', annotationsEnabled && 'border-primary')}
>
<MessageSquare className="h-3.5 w-3.5 mr-1" />
{annotationsEnabled ? 'Feedback On' : 'Feedback Off'}
</Button>
</TooltipTrigger>
<TooltipContent>
{annotationsEnabled
? 'Click to disable annotation prompts when editing'
: 'Click to enable annotation prompts when editing'}
</TooltipContent>
</Tooltip>
)}
</div>
<AudioPlayer
audioUrl={apiClient ? apiClient.getAudioUrl(audioHash) : null}
onTimeUpdate={onTimeUpdate}
/>
</div>
</Card>
</div>
</TooltipProvider>
)
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,68 @@
'use client'
import { ToggleGroup, ToggleGroupItem } from '@/components/ui/toggle-group'
import {
Tooltip,
TooltipContent,
TooltipProvider,
TooltipTrigger,
} from '@/components/ui/tooltip'
import { Highlighter, Edit, Trash2 } from 'lucide-react'
import { InteractionMode } from '@/lib/lyrics-review/types'
interface ModeSelectorProps {
effectiveMode: InteractionMode
onChange: (mode: InteractionMode) => void
}
export default function ModeSelector({ effectiveMode, onChange }: ModeSelectorProps) {
return (
<TooltipProvider>
<div className="flex items-center gap-1.5 h-8">
<span className="text-[0.75rem] text-muted-foreground">Mode:</span>
<ToggleGroup
type="single"
value={effectiveMode}
onValueChange={(value) => value === 'edit' && onChange(value as InteractionMode)}
className="h-8"
>
<Tooltip>
<TooltipTrigger asChild>
<ToggleGroupItem value="edit" className="h-8 px-2 text-[0.75rem]">
<Edit className="h-3.5 w-3.5 mr-1" />
Edit
</ToggleGroupItem>
</TooltipTrigger>
<TooltipContent>
<p>Default mode; click words to edit that lyrics segment</p>
</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger asChild>
<ToggleGroupItem value="highlight" className="h-8 px-2 text-[0.75rem]" disabled>
<Highlighter className="h-3.5 w-3.5 mr-1" />
Highlight
</ToggleGroupItem>
</TooltipTrigger>
<TooltipContent>
<p>Hold SHIFT and click words to highlight the matching anchor sequence</p>
</TooltipContent>
</Tooltip>
<Tooltip>
<TooltipTrigger asChild>
<ToggleGroupItem value="delete_word" className="h-8 px-2 text-[0.75rem]" disabled>
<Trash2 className="h-3.5 w-3.5 mr-1" />
Delete
</ToggleGroupItem>
</TooltipTrigger>
<TooltipContent>
<p>Hold CTRL and click words to delete them</p>
</TooltipContent>
</Tooltip>
</ToggleGroup>
</div>
</TooltipProvider>
)
}
@@ -0,0 +1,128 @@
'use client'
import { useState, useEffect, RefObject } from 'react'
import { Button } from '@/components/ui/button'
import { Alert, AlertDescription } from '@/components/ui/alert'
import { Loader2 } from 'lucide-react'
import { CorrectionData } from '@/lib/lyrics-review/types'
import { applyOffsetToCorrectionData } from '@/lib/lyrics-review/utils/timingUtils'
interface ApiClient {
generatePreviewVideo: (data: CorrectionData) => Promise<{
status: string
message?: string
preview_hash?: string
}>
getPreviewVideoUrl: (hash: string) => string
}
interface PreviewVideoSectionProps {
apiClient: ApiClient | null
isModalOpen: boolean
updatedData: CorrectionData
videoRef?: RefObject<HTMLVideoElement>
timingOffsetMs?: number
}
export default function PreviewVideoSection({
apiClient,
isModalOpen,
updatedData,
videoRef,
timingOffsetMs = 0,
}: PreviewVideoSectionProps) {
const [previewState, setPreviewState] = useState<{
status: 'loading' | 'ready' | 'error'
videoUrl?: string
error?: string
}>({ status: 'loading' })
// Generate preview when modal opens
useEffect(() => {
if (isModalOpen && apiClient) {
const generatePreview = async () => {
setPreviewState({ status: 'loading' })
try {
// Apply timing offset if needed
const dataToPreview =
timingOffsetMs !== 0
? applyOffsetToCorrectionData(updatedData, timingOffsetMs)
: updatedData
const response = await apiClient.generatePreviewVideo(dataToPreview)
if (response.status === 'error') {
setPreviewState({
status: 'error',
error: response.message || 'Failed to generate preview video',
})
return
}
if (!response.preview_hash) {
setPreviewState({
status: 'error',
error: 'No preview hash received from server',
})
return
}
const videoUrl = apiClient.getPreviewVideoUrl(response.preview_hash)
setPreviewState({
status: 'ready',
videoUrl,
})
} catch (error) {
setPreviewState({
status: 'error',
error: (error as Error).message || 'Failed to generate preview video',
})
}
}
generatePreview()
}
}, [isModalOpen, apiClient, updatedData, timingOffsetMs])
if (!apiClient) return null
return (
<div className="mb-4">
{previewState.status === 'loading' && (
<div className="flex items-center gap-3 p-4">
<Loader2 className="h-5 w-5 animate-spin" />
<span>Generating preview video...</span>
</div>
)}
{previewState.status === 'error' && (
<Alert variant="destructive" className="mb-4">
<AlertDescription className="flex items-center justify-between">
<span>{previewState.error}</span>
<Button
variant="ghost"
size="sm"
onClick={() => setPreviewState({ status: 'loading' })}
>
Retry
</Button>
</AlertDescription>
</Alert>
)}
{previewState.status === 'ready' && previewState.videoUrl && (
<div className="w-full">
<video
ref={videoRef as RefObject<HTMLVideoElement>}
controls
autoPlay
src={previewState.videoUrl}
className="block w-full h-auto"
>
Your browser does not support the video tag.
</video>
</div>
)}
</div>
)
}
@@ -0,0 +1,222 @@
'use client'
import { useMemo } from 'react'
import { Card, CardContent } from '@/components/ui/card'
import { Button } from '@/components/ui/button'
import { Copy } from 'lucide-react'
import { ReferenceViewProps, TranscriptionWordPosition } from '@/lib/lyrics-review/types'
import { calculateReferenceLinePositions } from '@/lib/lyrics-review/utils/referenceLineCalculator'
import { getWordsFromIds } from '@/lib/lyrics-review/utils/wordUtils'
import { SourceSelector } from './shared/SourceSelector'
import { HighlightedText } from './shared/HighlightedText'
export default function ReferenceView({
referenceSources,
anchors,
onElementClick,
onWordClick,
flashingType,
corrected_segments,
currentSource,
onSourceChange,
highlightInfo,
mode,
gaps,
corrections,
onAddLyrics,
}: ReferenceViewProps) {
const availableSources = useMemo(() => Object.keys(referenceSources), [referenceSources])
const effectiveCurrentSource = useMemo(
() => currentSource || (availableSources.length > 0 ? availableSources[0] : ''),
[currentSource, availableSources]
)
const referenceWordPositions = useMemo(() => {
const positions: TranscriptionWordPosition[] = []
const allPositions = new Map<number, TranscriptionWordPosition[]>()
// Map anchor words
anchors?.forEach((anchor) => {
const position = anchor.reference_positions[effectiveCurrentSource]
if (position === undefined) return
if (!allPositions.has(position)) {
allPositions.set(position, [])
}
const referenceWords = getWordsFromIds(
referenceSources[effectiveCurrentSource].segments,
anchor.reference_word_ids[effectiveCurrentSource] || []
)
referenceWords.forEach((word) => {
const wordPosition: TranscriptionWordPosition = {
word: {
id: word.id,
text: word.text,
start_time: word.start_time ?? undefined,
end_time: word.end_time ?? undefined,
},
type: 'anchor',
sequence: anchor,
isInRange: true,
}
allPositions.get(position)!.push(wordPosition)
})
})
// Map gap words
gaps?.forEach((gap) => {
const precedingAnchor = gap.preceding_anchor_id
? anchors?.find((a) => a.id === gap.preceding_anchor_id)
: undefined
const followingAnchor = gap.following_anchor_id
? anchors?.find((a) => a.id === gap.following_anchor_id)
: undefined
const position =
precedingAnchor?.reference_positions[effectiveCurrentSource] ??
followingAnchor?.reference_positions[effectiveCurrentSource]
if (position === undefined) return
const gapPosition = precedingAnchor ? position + 1 : position - 1
if (!allPositions.has(gapPosition)) {
allPositions.set(gapPosition, [])
}
const referenceWords = getWordsFromIds(
referenceSources[effectiveCurrentSource].segments,
gap.reference_word_ids[effectiveCurrentSource] || []
)
referenceWords.forEach((word) => {
const isWordCorrected = corrections?.some(
(correction) =>
correction.reference_positions?.[effectiveCurrentSource]?.toString() === word.id &&
gap.transcribed_word_ids.includes(correction.word_id)
)
const wordPosition: TranscriptionWordPosition = {
word: {
id: word.id,
text: word.text,
start_time: word.start_time ?? undefined,
end_time: word.end_time ?? undefined,
},
type: 'gap',
sequence: gap,
isInRange: true,
isCorrected: isWordCorrected,
}
allPositions.get(gapPosition)!.push(wordPosition)
})
})
// Sort by position and flatten
Array.from(allPositions.entries())
.sort(([a], [b]) => a - b)
.forEach(([, words]) => {
positions.push(...words)
})
return positions
}, [anchors, gaps, effectiveCurrentSource, referenceSources, corrections])
const { linePositions } = useMemo(
() => calculateReferenceLinePositions(corrected_segments, anchors, effectiveCurrentSource),
[corrected_segments, anchors, effectiveCurrentSource]
)
const referenceCorrections = useMemo(() => {
const correctionMap = new Map<string, string>()
corrections?.forEach((correction) => {
const referencePosition = correction.reference_positions?.[effectiveCurrentSource]
if (referencePosition !== undefined) {
correctionMap.set(referencePosition.toString(), correction.corrected_word)
}
})
return correctionMap
}, [corrections, effectiveCurrentSource])
const currentSourceSegments = referenceSources[effectiveCurrentSource]?.segments || []
const copyToClipboard = (text: string) => {
navigator.clipboard.writeText(text)
}
const copyAllReferenceText = () => {
const allText = currentSourceSegments
.map((segment) => segment.words.map((w) => w.text).join(' '))
.join('\n')
copyToClipboard(allText)
}
return (
<Card className="p-2 relative">
<CardContent className="p-0">
<div className="flex justify-between items-center mb-1">
<div className="flex items-center gap-2">
<h3 className="text-sm font-semibold">Reference Lyrics</h3>
<Button
variant="ghost"
size="icon"
className="h-5 w-5 min-h-0 min-w-0 p-0.5"
onClick={copyAllReferenceText}
title="Copy all reference lyrics"
>
<Copy className="h-4 w-4" />
</Button>
</div>
<SourceSelector
availableSources={availableSources}
currentSource={effectiveCurrentSource}
onSourceChange={onSourceChange}
onAddLyrics={onAddLyrics}
/>
</div>
<div className="flex flex-col gap-0.5">
{currentSourceSegments.map((segment, index) => (
<div key={index} className="flex items-start w-full hover:bg-muted/50 transition-colors">
<div className="flex items-center gap-0.5 pr-1">
<Button
variant="ghost"
size="icon"
className="h-[18px] w-[18px] min-h-0 min-w-0 p-[1px]"
onClick={() => copyToClipboard(segment.words.map((w) => w.text).join(' '))}
>
<Copy className="h-3.5 w-3.5" />
</Button>
</div>
<div className="flex-1 min-w-0">
<HighlightedText
wordPositions={referenceWordPositions.filter((wp) =>
segment.words.some((w) => w.id === wp.word.id)
)}
segments={[segment]}
anchors={anchors}
onElementClick={onElementClick}
onWordClick={onWordClick}
flashingType={flashingType}
highlightInfo={highlightInfo}
mode={mode}
isReference={true}
currentSource={effectiveCurrentSource}
linePositions={linePositions}
referenceCorrections={referenceCorrections}
gaps={gaps}
preserveSegments={true}
/>
</div>
</div>
))}
</div>
</CardContent>
</Card>
)
}
@@ -0,0 +1,296 @@
'use client'
import { useRef, useState } from 'react'
import { Word } from '@/lib/lyrics-review/types'
import { cn } from '@/lib/utils'
interface TimelineEditorProps {
words: Word[]
startTime: number
endTime: number
onWordUpdate: (index: number, updates: Partial<Word>) => void
onUnsyncWord?: (index: number) => void
currentTime?: number
onPlaySegment?: (time: number) => void
showPlaybackIndicator?: boolean
}
export default function TimelineEditor({
words,
startTime,
endTime,
onWordUpdate,
onUnsyncWord,
currentTime = 0,
onPlaySegment,
showPlaybackIndicator = true,
}: TimelineEditorProps) {
const containerRef = useRef<HTMLDivElement>(null)
const [dragState, setDragState] = useState<{
wordIndex: number
type: 'move' | 'resize-left' | 'resize-right'
initialX: number
initialTime: number
word: Word
} | null>(null)
const MIN_DURATION = 0.1 // Minimum word duration in seconds
const checkCollision = (
proposedStart: number,
proposedEnd: number,
currentIndex: number,
isResize: boolean
): boolean => {
if (isResize) {
if (currentIndex === words.length - 1) return false
const nextWord = words[currentIndex + 1]
if (!nextWord || nextWord.start_time === null) return false
return proposedEnd > nextWord.start_time
}
return words.some((word, index) => {
if (index === currentIndex) return false
if (word.start_time === null || word.end_time === null) return false
return (
(proposedStart >= word.start_time && proposedStart <= word.end_time) ||
(proposedEnd >= word.start_time && proposedEnd <= word.end_time) ||
(proposedStart <= word.start_time && proposedEnd >= word.end_time)
)
})
}
const timeToPosition = (time: number): number => {
const duration = endTime - startTime
const position = ((time - startTime) / duration) * 100
return Math.max(0, Math.min(100, position))
}
const generateTimelineMarks = () => {
const marks = []
const startSecond = Math.floor(startTime)
const endSecond = Math.ceil(endTime)
for (let time = startSecond; time <= endSecond; time++) {
if (time >= startTime && time <= endTime) {
const position = timeToPosition(time)
marks.push(
<div key={time}>
<div
className="absolute top-5 w-[1px] h-[18px] bg-muted-foreground"
style={{ left: `${position}%` }}
/>
<div
className="absolute top-[5px] -translate-x-1/2 text-[0.8rem] font-bold text-foreground bg-card px-1 rounded-sm"
style={{ left: `${position}%` }}
>
{time}s
</div>
</div>
)
}
}
return marks
}
const handleMouseDown = (
e: React.MouseEvent,
wordIndex: number,
type: 'move' | 'resize-left' | 'resize-right'
) => {
const rect = containerRef.current?.getBoundingClientRect()
if (!rect) return
const word = words[wordIndex]
if (word.start_time === null || word.end_time === null) return
const initialX = e.clientX - rect.left
const initialTime = (initialX / rect.width) * (endTime - startTime)
setDragState({
wordIndex,
type,
initialX,
initialTime,
word,
})
}
const handleMouseMove = (e: React.MouseEvent) => {
if (!dragState || !containerRef.current) return
const rect = containerRef.current.getBoundingClientRect()
const x = e.clientX - rect.left
const width = rect.width
const currentWord = words[dragState.wordIndex]
if (
currentWord.start_time === null ||
currentWord.end_time === null ||
dragState.word.start_time === null ||
dragState.word.end_time === null
)
return
if (dragState.type === 'resize-right') {
const initialWordDuration = dragState.word.end_time - dragState.word.start_time
const initialWordWidth = (initialWordDuration / (endTime - startTime)) * width
const pixelDelta = x - dragState.initialX
const percentageMoved = pixelDelta / initialWordWidth
const timeDelta = initialWordDuration * percentageMoved
const proposedEnd = Math.max(
currentWord.start_time + MIN_DURATION,
dragState.word.end_time + timeDelta
)
if (checkCollision(currentWord.start_time, proposedEnd, dragState.wordIndex, true)) return
onWordUpdate(dragState.wordIndex, {
start_time: currentWord.start_time,
end_time: proposedEnd,
})
} else if (dragState.type === 'resize-left') {
const initialWordDuration = dragState.word.end_time - dragState.word.start_time
const initialWordWidth = (initialWordDuration / (endTime - startTime)) * width
const pixelDelta = x - dragState.initialX
const percentageMoved = pixelDelta / initialWordWidth
const timeDelta = initialWordDuration * percentageMoved
const proposedStart = Math.min(
currentWord.end_time - MIN_DURATION,
dragState.word.start_time + timeDelta
)
if (checkCollision(proposedStart, currentWord.end_time, dragState.wordIndex, true)) return
onWordUpdate(dragState.wordIndex, {
start_time: proposedStart,
end_time: currentWord.end_time,
})
} else if (dragState.type === 'move') {
const pixelsPerSecond = width / (endTime - startTime)
const pixelDelta = x - dragState.initialX
const timeDelta = pixelDelta / pixelsPerSecond
const wordDuration = currentWord.end_time - currentWord.start_time
const proposedStart = dragState.word.start_time + timeDelta
const proposedEnd = proposedStart + wordDuration
if (proposedStart < startTime || proposedEnd > endTime) return
if (checkCollision(proposedStart, proposedEnd, dragState.wordIndex, false)) return
onWordUpdate(dragState.wordIndex, {
start_time: proposedStart,
end_time: proposedEnd,
})
}
}
const handleMouseUp = () => {
setDragState(null)
}
const handleContextMenu = (e: React.MouseEvent, wordIndex: number) => {
e.preventDefault()
e.stopPropagation()
const word = words[wordIndex]
if (word.start_time === null || word.end_time === null) return
if (onUnsyncWord) {
onUnsyncWord(wordIndex)
}
}
const isWordHighlighted = (word: Word): boolean => {
if (!currentTime || word.start_time === null || word.end_time === null) return false
return currentTime >= word.start_time && currentTime <= word.end_time
}
const handleTimelineClick = (e: React.MouseEvent) => {
const rect = containerRef.current?.getBoundingClientRect()
if (!rect || !onPlaySegment) return
const x = e.clientX - rect.left
const clickedPosition = (x / rect.width) * (endTime - startTime) + startTime
onPlaySegment(clickedPosition)
}
return (
<div
ref={containerRef}
className="relative h-[75px] bg-card rounded my-2 px-2 border border-border"
onMouseMove={handleMouseMove}
onMouseUp={handleMouseUp}
onMouseLeave={handleMouseUp}
>
{/* Timeline ruler */}
<div
className="absolute top-0 left-0 right-0 h-10 border-b border-border cursor-pointer"
onClick={handleTimelineClick}
>
{generateTimelineMarks()}
</div>
{/* Playback cursor */}
{showPlaybackIndicator && currentTime >= startTime && currentTime <= endTime && (
<div
className="absolute top-0 w-0.5 h-full bg-destructive pointer-events-none transition-[left] duration-100 z-10"
style={{ left: `${timeToPosition(currentTime)}%` }}
/>
)}
{/* Word blocks */}
{words.map((word, index) => {
if (word.start_time === null || word.end_time === null) return null
const leftPosition = timeToPosition(word.start_time)
const rightPosition = timeToPosition(word.end_time)
const width = rightPosition - leftPosition
return (
<div
key={index}
className={cn(
'absolute h-[30px] top-10 bg-primary rounded text-primary-foreground px-2 py-1',
'cursor-move select-none flex items-center text-sm font-sans transition-colors',
isWordHighlighted(word) && 'bg-purple-500 dark:bg-purple-600'
)}
style={{
left: `${leftPosition}%`,
width: `${width}%`,
maxWidth: `calc(${100 - leftPosition}%)`,
}}
onMouseDown={(e) => {
e.stopPropagation()
handleMouseDown(e, index, 'move')
}}
onContextMenu={(e) => handleContextMenu(e, index)}
>
{/* Left resize handle */}
<div
className="absolute top-0 left-0 w-2.5 h-full cursor-col-resize hover:bg-primary-foreground/20 rounded-l"
onMouseDown={(e) => {
e.stopPropagation()
handleMouseDown(e, index, 'resize-left')
}}
/>
{word.text}
{/* Right resize handle */}
<div
className="absolute top-0 right-0 w-2.5 h-full cursor-col-resize hover:bg-primary-foreground/20 rounded-r"
onMouseDown={(e) => {
e.stopPropagation()
handleMouseDown(e, index, 'resize-right')
}}
/>
</div>
)
})}
</div>
)
}
@@ -0,0 +1,203 @@
'use client'
import { useState } from 'react'
import { Card, CardContent } from '@/components/ui/card'
import { Button } from '@/components/ui/button'
import { ToggleGroup, ToggleGroupItem } from '@/components/ui/toggle-group'
import { Play, Trash2, Type, Clock } from 'lucide-react'
import { HighlightedText } from './shared/HighlightedText'
import { TranscriptionViewProps, TranscriptionWordPosition } from '@/lib/lyrics-review/types'
import { deleteSegment } from '@/lib/lyrics-review/utils/segmentOperations'
import SegmentDetailsModal from './modals/SegmentDetailsModal'
import DurationTimelineView from './DurationTimelineView'
export default function TranscriptionView({
data,
onElementClick,
onWordClick,
flashingType,
flashingHandler,
highlightInfo,
mode,
onPlaySegment,
currentTime = 0,
anchors = [],
onDataChange,
reviewMode = false,
onRevertCorrection,
onEditCorrection,
onAcceptCorrection,
onShowCorrectionDetail,
}: TranscriptionViewProps) {
const [selectedSegmentIndex, setSelectedSegmentIndex] = useState<number | null>(null)
const [viewMode, setViewMode] = useState<'text' | 'duration'>('text')
const handleDeleteSegment = (segmentIndex: number) => {
if (onDataChange) {
const updatedData = deleteSegment(data, segmentIndex)
onDataChange(updatedData)
}
}
return (
<Card className="p-2">
<CardContent className="p-0">
<div className="flex justify-between items-center mb-1">
<h3 className="text-sm font-semibold">Corrected Transcription</h3>
<ToggleGroup
type="single"
value={viewMode}
onValueChange={(value) => value && setViewMode(value as 'text' | 'duration')}
className="h-7"
>
<ToggleGroupItem value="text" aria-label="text view" className="h-7 px-2.5 text-[0.75rem]">
<Type className="h-3.5 w-3.5 mr-1" />
Text
</ToggleGroupItem>
<ToggleGroupItem
value="duration"
aria-label="duration view"
className="h-7 px-2.5 text-[0.75rem]"
>
<Clock className="h-3.5 w-3.5 mr-1.5" />
Timeline
</ToggleGroupItem>
</ToggleGroup>
</div>
{viewMode === 'duration' ? (
<DurationTimelineView
segments={data.corrected_segments}
corrections={data.corrections || []}
anchors={data.anchor_sequences || []}
gaps={data.gap_sequences || []}
onWordClick={(wordId) => {
// Find word in segments
for (const segment of data.corrected_segments) {
const word = segment.words.find((w) => w.id === wordId)
if (word) {
onWordClick?.({
word_id: wordId,
type: 'other',
anchor: undefined,
gap: undefined,
})
break
}
}
}}
/>
) : (
<div className="flex flex-col gap-0.5">
{data.corrected_segments.map((segment, segmentIndex) => {
const segmentWords: TranscriptionWordPosition[] = segment.words.map((word) => {
const correction = data.corrections?.find(
(c) => c.corrected_word_id === word.id || c.word_id === word.id
)
const anchor = data.anchor_sequences?.find((a) =>
a.transcribed_word_ids.includes(word.id)
)
const gap = data.gap_sequences?.find((g) => {
const inTranscribed = g.transcribed_word_ids.includes(word.id)
const inReference = Object.values(g.reference_word_ids).some((ids) =>
ids.includes(word.id)
)
const isCorrection = data.corrections.some(
(c) =>
(c.corrected_word_id === word.id || c.word_id === word.id) &&
g.transcribed_word_ids.includes(c.word_id)
)
return inTranscribed || inReference || isCorrection
})
return {
word: {
id: word.id,
text: word.text,
start_time: word.start_time ?? undefined,
end_time: word.end_time ?? undefined,
},
type: anchor ? 'anchor' : gap ? 'gap' : 'other',
sequence: anchor || gap,
isInRange: true,
isCorrected: Boolean(correction),
}
})
return (
<div
key={segment.id}
className="flex items-start w-full hover:bg-muted/50 transition-colors"
>
{/* Segment controls */}
<div className="flex items-center gap-0.5 min-w-[2.5em] pr-1">
<span
className="text-muted-foreground w-[1.8em] text-right mr-1 select-none font-mono text-[0.8rem] leading-tight cursor-pointer hover:underline"
onClick={() => setSelectedSegmentIndex(segmentIndex)}
>
{segmentIndex}
</span>
<Button
variant="ghost"
size="icon"
className="h-[18px] w-[18px] min-h-0 min-w-0 p-[1px] text-destructive hover:text-destructive"
onClick={() => handleDeleteSegment(segmentIndex)}
title="Delete segment"
>
<Trash2 className="h-3.5 w-3.5" />
</Button>
{segment.start_time !== null && (
<Button
variant="ghost"
size="icon"
className="h-[18px] w-[18px] min-h-0 min-w-0 p-[1px]"
onClick={() => onPlaySegment?.(segment.start_time!)}
title="Play segment"
>
<Play className="h-3.5 w-3.5" />
</Button>
)}
</div>
{/* Text content */}
<div className="flex-1 min-w-0">
<HighlightedText
wordPositions={segmentWords}
anchors={anchors}
onElementClick={onElementClick}
onWordClick={onWordClick}
flashingType={flashingType}
flashingHandler={flashingHandler}
highlightInfo={highlightInfo}
mode={mode}
preserveSegments={true}
currentTime={currentTime}
gaps={data.gap_sequences}
corrections={data.corrections}
reviewMode={reviewMode}
onRevertCorrection={onRevertCorrection}
onEditCorrection={onEditCorrection}
onAcceptCorrection={onAcceptCorrection}
onShowCorrectionDetail={onShowCorrectionDetail}
/>
</div>
</div>
)
})}
</div>
)}
<SegmentDetailsModal
open={selectedSegmentIndex !== null}
onClose={() => setSelectedSegmentIndex(null)}
segment={
selectedSegmentIndex !== null ? data.corrected_segments[selectedSegmentIndex] : null
}
segmentIndex={selectedSegmentIndex}
/>
</CardContent>
</Card>
)
}
@@ -0,0 +1,130 @@
'use client'
import { Button } from '@/components/ui/button'
import { Plus, Merge, Split } from 'lucide-react'
import { cn } from '@/lib/utils'
interface WordDividerProps {
onAddWord: () => void
onMergeWords?: () => void
onAddSegmentBefore?: () => void
onAddSegmentAfter?: () => void
onSplitSegment?: () => void
onMergeSegment?: () => void
canMerge?: boolean
isFirst?: boolean
isLast?: boolean
className?: string
}
export default function WordDivider({
onAddWord,
onMergeWords,
onAddSegmentBefore,
onAddSegmentAfter,
onSplitSegment,
onMergeSegment,
canMerge = false,
isFirst = false,
isLast = false,
className,
}: WordDividerProps) {
return (
<div
className={cn(
'flex items-center justify-center h-auto min-h-[20px] my-0 w-full overflow-hidden',
className
)}
>
<div className="flex items-center gap-2 flex-wrap justify-center px-2 z-10">
<Button
variant="ghost"
size="sm"
onClick={onAddWord}
title="Add Word"
className="h-6 px-2 text-primary text-[0.7rem]"
>
<Plus className="h-4 w-4 mr-1" />
Add Word
</Button>
{isFirst && onAddSegmentBefore && onMergeSegment && (
<>
<Button
variant="ghost"
size="sm"
onClick={onAddSegmentBefore}
title="Add Segment"
className="h-6 px-2 text-green-500 text-[0.7rem]"
>
<Plus className="h-4 w-4 mr-1 rotate-90" />
Add Segment
</Button>
<Button
variant="ghost"
size="sm"
onClick={onMergeSegment}
title="Merge with Previous Segment"
className="h-6 px-2 text-yellow-500 text-[0.7rem]"
>
<Merge className="h-4 w-4 mr-1 rotate-90" />
Merge Segment
</Button>
</>
)}
{onMergeWords && !isLast && (
<Button
variant="ghost"
size="sm"
onClick={onMergeWords}
disabled={!canMerge}
title="Merge Words"
className="h-6 px-2 text-primary text-[0.7rem] disabled:opacity-50"
>
<Merge className="h-4 w-4 mr-1 rotate-90" />
Merge Words
</Button>
)}
{onSplitSegment && !isLast && (
<Button
variant="ghost"
size="sm"
onClick={onSplitSegment}
title="Split Segment"
className="h-6 px-2 text-yellow-500 text-[0.7rem]"
>
<Split className="h-4 w-4 mr-1 rotate-90" />
Split Segment
</Button>
)}
{isLast && onAddSegmentAfter && onMergeSegment && (
<>
<Button
variant="ghost"
size="sm"
onClick={onAddSegmentAfter}
title="Add Segment"
className="h-6 px-2 text-green-500 text-[0.7rem]"
>
<Plus className="h-4 w-4 mr-1 rotate-90" />
Add Segment
</Button>
<Button
variant="ghost"
size="sm"
onClick={onMergeSegment}
title="Merge with Next Segment"
className="h-6 px-2 text-yellow-500 text-[0.7rem]"
>
<Merge className="h-4 w-4 mr-1 rotate-90" />
Merge Segment
</Button>
</>
)}
</div>
</div>
)
}
@@ -0,0 +1,30 @@
// Main components
export { default as LyricsAnalyzer } from './LyricsAnalyzer'
export { default as AudioPlayer } from './AudioPlayer'
export { default as Header } from './Header'
export { default as ModeSelector } from './ModeSelector'
export { default as EditActionBar } from './EditActionBar'
export { default as CorrectionDetailCard } from './CorrectionDetailCard'
export { default as PreviewVideoSection } from './PreviewVideoSection'
export { default as CorrectionMetrics } from './CorrectionMetrics'
export { default as AgenticCorrectionMetrics } from './AgenticCorrectionMetrics'
// View components
export { default as TranscriptionView } from './TranscriptionView'
export { default as ReferenceView } from './ReferenceView'
export { default as DurationTimelineView } from './DurationTimelineView'
export { default as EditWordList } from './EditWordList'
export { default as TimelineEditor } from './TimelineEditor'
export { default as WordDivider } from './WordDivider'
export { default as CorrectedWordWithActions } from './CorrectedWordWithActions'
// Shared components
export { WordComponent as Word } from './shared/Word'
export { HighlightedText } from './shared/HighlightedText'
export { SourceSelector } from './shared/SourceSelector'
// Modal exports
export * from './modals'
// Synchronizer exports
export * from './synchronizer'
@@ -0,0 +1,144 @@
'use client'
import { useState, useEffect, useRef } from 'react'
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Textarea } from '@/components/ui/textarea'
import { Label } from '@/components/ui/label'
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue,
} from '@/components/ui/select'
interface AIFeedbackModalProps {
open: boolean
onClose: () => void
onSubmit: (payload: {
reviewerAction: string
finalText?: string
reasonCategory: string
reasonDetail?: string
}) => void
suggestion?: {
text: string
reasoning?: string
confidence?: number
}
}
export default function AIFeedbackModal({
open,
onClose,
onSubmit,
suggestion,
}: AIFeedbackModalProps) {
const [reviewerAction, setAction] = useState('ACCEPT')
const [finalText, setFinalText] = useState('')
const [reasonCategory, setReason] = useState('AI_CORRECT')
const [reasonDetail, setDetail] = useState('')
const contentRef = useRef<HTMLDivElement>(null)
// Focus content on open
useEffect(() => {
if (open && contentRef.current) {
contentRef.current.focus()
}
}, [open])
const handleSubmit = () => {
onSubmit({
reviewerAction,
finalText: finalText || undefined,
reasonCategory,
reasonDetail: reasonDetail || undefined,
})
}
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
<DialogContent className="max-w-md" ref={contentRef}>
<DialogHeader>
<DialogTitle>AI Suggestion</DialogTitle>
</DialogHeader>
<div className="space-y-4">
<div>
<p className="text-sm">
{suggestion?.text ?? 'No suggestion'}
{suggestion?.confidence != null
? ` (confidence ${Math.round((suggestion.confidence || 0) * 100)}%)`
: null}
</p>
{suggestion?.reasoning && (
<p className="text-xs text-muted-foreground mt-1">{suggestion.reasoning}</p>
)}
</div>
<div className="space-y-2">
<Label htmlFor="action">Action</Label>
<Select value={reviewerAction} onValueChange={setAction}>
<SelectTrigger id="action">
<SelectValue />
</SelectTrigger>
<SelectContent>
<SelectItem value="ACCEPT">Accept</SelectItem>
<SelectItem value="REJECT">Reject</SelectItem>
<SelectItem value="MODIFY">Modify</SelectItem>
</SelectContent>
</Select>
</div>
{reviewerAction === 'MODIFY' && (
<div className="space-y-2">
<Label htmlFor="finalText">Final Text</Label>
<Input
id="finalText"
value={finalText}
onChange={(e) => setFinalText(e.target.value)}
placeholder="Enter the modified text..."
/>
</div>
)}
<div className="space-y-2">
<Label htmlFor="reason">Reason</Label>
<Select value={reasonCategory} onValueChange={setReason}>
<SelectTrigger id="reason">
<SelectValue />
</SelectTrigger>
<SelectContent>
<SelectItem value="AI_CORRECT">AI_CORRECT</SelectItem>
<SelectItem value="AI_INCORRECT">AI_INCORRECT</SelectItem>
<SelectItem value="AI_SUBOPTIMAL">AI_SUBOPTIMAL</SelectItem>
<SelectItem value="CONTEXT_NEEDED">CONTEXT_NEEDED</SelectItem>
<SelectItem value="SUBJECTIVE_PREFERENCE">SUBJECTIVE_PREFERENCE</SelectItem>
</SelectContent>
</Select>
</div>
<div className="space-y-2">
<Label htmlFor="details">Details</Label>
<Textarea
id="details"
value={reasonDetail}
onChange={(e) => setDetail(e.target.value)}
placeholder="Additional details..."
rows={3}
/>
</div>
</div>
<DialogFooter>
<Button variant="outline" onClick={onClose}>
Cancel
</Button>
<Button onClick={handleSubmit}>Submit</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,106 @@
'use client'
import { useState } from 'react'
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Textarea } from '@/components/ui/textarea'
import { Label } from '@/components/ui/label'
import { Loader2 } from 'lucide-react'
interface AddLyricsModalProps {
open: boolean
onClose: () => void
onAdd: (source: string, lyrics: string) => Promise<void>
}
export default function AddLyricsModal({ open, onClose, onAdd }: AddLyricsModalProps) {
const [source, setSource] = useState('')
const [lyrics, setLyrics] = useState('')
const [isAdding, setIsAdding] = useState(false)
const [error, setError] = useState<string | null>(null)
const handleAdd = async () => {
if (!source.trim() || !lyrics.trim()) return
setIsAdding(true)
setError(null)
try {
await onAdd(source.trim(), lyrics.trim())
setSource('')
setLyrics('')
onClose()
} catch (err) {
setError(err instanceof Error ? err.message : 'Failed to add lyrics')
} finally {
setIsAdding(false)
}
}
const handleClose = () => {
if (!isAdding) {
setSource('')
setLyrics('')
setError(null)
onClose()
}
}
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && handleClose()}>
<DialogContent className="max-w-lg">
<DialogHeader>
<DialogTitle>Add Reference Lyrics</DialogTitle>
</DialogHeader>
<div className="space-y-4">
<div className="space-y-2">
<Label htmlFor="source">Source Name</Label>
<Input
id="source"
value={source}
onChange={(e) => setSource(e.target.value)}
placeholder="e.g., manual, genius, azlyrics..."
disabled={isAdding}
/>
</div>
<div className="space-y-2">
<Label htmlFor="lyrics">Lyrics</Label>
<Textarea
id="lyrics"
value={lyrics}
onChange={(e) => setLyrics(e.target.value)}
placeholder="Paste lyrics here..."
rows={10}
disabled={isAdding}
className="font-mono text-sm"
/>
</div>
{error && <p className="text-sm text-destructive">{error}</p>}
</div>
<DialogFooter>
<Button variant="outline" onClick={handleClose} disabled={isAdding}>
Cancel
</Button>
<Button
onClick={handleAdd}
disabled={isAdding || !source.trim() || !lyrics.trim()}
>
{isAdding ? (
<>
<Loader2 className="h-4 w-4 mr-2 animate-spin" />
Adding...
</>
) : (
'Add Lyrics'
)}
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,318 @@
'use client'
import { useState, useEffect } from 'react'
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Textarea } from '@/components/ui/textarea'
import { Label } from '@/components/ui/label'
import { Slider } from '@/components/ui/slider'
import { Badge } from '@/components/ui/badge'
import { Alert, AlertDescription } from '@/components/ui/alert'
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue,
} from '@/components/ui/select'
import { CorrectionAnnotation, CorrectionAnnotationType, CorrectionAction } from '@/lib/lyrics-review/types'
interface CorrectionAnnotationModalProps {
open: boolean
onClose: () => void
onSave: (annotation: Omit<CorrectionAnnotation, 'annotation_id' | 'timestamp'>) => void
onSkip: () => void
originalText: string
correctedText: string
wordIdsAffected: string[]
agenticProposal?: {
action: string
replacement_text?: string
confidence: number
reason: string
gap_category?: string
}
referenceSources: string[]
audioHash: string
artist: string
title: string
sessionId: string
gapId?: string
}
const ANNOTATION_TYPES: { value: CorrectionAnnotationType; label: string; description: string }[] = [
{
value: 'SOUND_ALIKE',
label: 'Sound-Alike Error',
description: 'Homophones or similar-sounding words (e.g., "out" vs "now")',
},
{
value: 'BACKGROUND_VOCALS',
label: 'Background Vocals',
description: 'Backing vocals that should be removed from karaoke',
},
{
value: 'EXTRA_WORDS',
label: 'Extra Filler Words',
description: 'Transcription added words like "And", "But", "Well"',
},
{
value: 'PUNCTUATION_ONLY',
label: 'Punctuation/Style Only',
description: 'Only punctuation or capitalization differences',
},
{
value: 'REPEATED_SECTION',
label: 'Repeated Section',
description: 'Chorus or verse repetition not in condensed references',
},
{
value: 'COMPLEX_MULTI_ERROR',
label: 'Complex Multi-Error',
description: 'Multiple different error types in one section',
},
{
value: 'AMBIGUOUS',
label: 'Ambiguous',
description: 'Unclear without listening to audio',
},
{
value: 'NO_ERROR',
label: 'No Error',
description: 'Transcription matches at least one reference source',
},
{
value: 'MANUAL_EDIT',
label: 'Manual Edit',
description: 'Human-initiated correction not from detected gap',
},
]
const CONFIDENCE_LABELS: Record<number, string> = {
1: '1 - Very Uncertain',
2: '2 - Somewhat Uncertain',
3: '3 - Neutral',
4: '4 - Fairly Confident',
5: '5 - Very Confident',
}
export default function CorrectionAnnotationModal({
open,
onClose,
onSave,
onSkip,
originalText,
correctedText,
wordIdsAffected,
agenticProposal,
referenceSources,
audioHash,
artist,
title,
sessionId,
gapId,
}: CorrectionAnnotationModalProps) {
const [annotationType, setAnnotationType] = useState<CorrectionAnnotationType>('MANUAL_EDIT')
const [actionTaken, setActionTaken] = useState<CorrectionAction>('REPLACE')
const [confidence, setConfidence] = useState(3)
const [reasoning, setReasoning] = useState('')
const [agenticAgreed, setAgenticAgreed] = useState(false)
const [error, setError] = useState('')
// Pre-fill if we have an agentic proposal
useEffect(() => {
if (agenticProposal && agenticProposal.gap_category) {
setAnnotationType(agenticProposal.gap_category as CorrectionAnnotationType)
const agreed = agenticProposal.replacement_text
? correctedText.toLowerCase().includes(agenticProposal.replacement_text.toLowerCase())
: false
setAgenticAgreed(agreed)
}
}, [agenticProposal, correctedText])
// Determine action type based on correction
useEffect(() => {
if (originalText === correctedText) {
setActionTaken('NO_ACTION')
} else if (correctedText === '') {
setActionTaken('DELETE')
} else if (originalText === '') {
setActionTaken('INSERT')
} else {
setActionTaken('REPLACE')
}
}, [originalText, correctedText])
const handleSave = () => {
if (reasoning.length < 10) {
setError('Reasoning must be at least 10 characters')
return
}
const annotation: Omit<CorrectionAnnotation, 'annotation_id' | 'timestamp'> = {
audio_hash: audioHash,
gap_id: gapId || null,
annotation_type: annotationType,
action_taken: actionTaken,
original_text: originalText,
corrected_text: correctedText,
confidence,
reasoning,
word_ids_affected: wordIdsAffected,
agentic_proposal: agenticProposal || null,
agentic_category: agenticProposal?.gap_category || null,
agentic_agreed: agenticAgreed,
reference_sources_consulted: referenceSources,
artist,
title,
session_id: sessionId,
}
onSave(annotation)
handleClose()
}
const handleClose = () => {
setAnnotationType('MANUAL_EDIT')
setConfidence(3)
setReasoning('')
setError('')
setAgenticAgreed(false)
onClose()
}
const handleSkipAndClose = () => {
handleClose()
onSkip()
}
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && handleClose()}>
<DialogContent className="max-w-2xl max-h-[90vh] overflow-y-auto">
<DialogHeader>
<DialogTitle>Annotate Your Correction</DialogTitle>
<p className="text-sm text-muted-foreground">
Help improve the AI by explaining your correction
</p>
</DialogHeader>
<div className="space-y-6">
{/* Show what changed */}
<div className="bg-muted p-4 rounded-lg">
<h4 className="text-sm font-medium mb-2">Your Correction:</h4>
<div className="flex items-center gap-4">
<div className="flex-1">
<span className="text-xs text-destructive">Original:</span>
<p className="font-mono text-sm line-through text-destructive">
{originalText || '(empty)'}
</p>
</div>
<span className="text-lg">→</span>
<div className="flex-1">
<span className="text-xs text-green-500">Corrected:</span>
<p className="font-mono text-sm font-bold text-green-500">
{correctedText || '(empty)'}
</p>
</div>
</div>
</div>
{/* Show AI suggestion if available */}
{agenticProposal && (
<Alert variant={agenticAgreed ? 'default' : 'default'}>
<AlertDescription>
<h4 className="font-medium mb-2">AI Suggestion:</h4>
<p className="text-sm">
Category: <strong>{agenticProposal.gap_category}</strong>
</p>
<p className="text-sm">
Action: <strong>{agenticProposal.action}</strong>
{agenticProposal.replacement_text && ` → "${agenticProposal.replacement_text}"`}
</p>
<p className="text-sm">Reason: {agenticProposal.reason}</p>
<p className="text-sm mt-2">
{agenticAgreed
? '✓ Your correction matches the AI suggestion'
: '✗ Your correction differs from the AI suggestion'}
</p>
</AlertDescription>
</Alert>
)}
{/* Reference sources */}
{referenceSources.length > 0 && (
<div>
<h4 className="text-sm font-medium mb-2">Reference Sources Consulted:</h4>
<div className="flex flex-wrap gap-2">
{referenceSources.map((source) => (
<Badge key={source} variant="secondary">
{source}
</Badge>
))}
</div>
</div>
)}
{/* Annotation type */}
<div className="space-y-2">
<Label>Correction Type *</Label>
<Select value={annotationType} onValueChange={(v) => setAnnotationType(v as CorrectionAnnotationType)}>
<SelectTrigger>
<SelectValue placeholder="Select correction type" />
</SelectTrigger>
<SelectContent>
{ANNOTATION_TYPES.map((type) => (
<SelectItem key={type.value} value={type.value}>
<div>
<p className="font-medium">{type.label}</p>
<p className="text-xs text-muted-foreground">{type.description}</p>
</div>
</SelectItem>
))}
</SelectContent>
</Select>
</div>
{/* Confidence slider */}
<div className="space-y-2">
<Label>Confidence in Your Correction *</Label>
<Slider
value={[confidence]}
min={1}
max={5}
step={1}
onValueChange={([v]) => setConfidence(v)}
/>
<p className="text-sm text-muted-foreground">{CONFIDENCE_LABELS[confidence]}</p>
</div>
{/* Reasoning text area */}
<div className="space-y-2">
<Label htmlFor="reasoning">Reasoning *</Label>
<Textarea
id="reasoning"
value={reasoning}
onChange={(e) => {
setReasoning(e.target.value)
setError('')
}}
placeholder="Explain why this correction is needed (minimum 10 characters)..."
rows={4}
className={error ? 'border-destructive' : ''}
/>
<p className={`text-sm ${error ? 'text-destructive' : 'text-muted-foreground'}`}>
{error || `${reasoning.length}/10 minimum characters`}
</p>
</div>
</div>
<DialogFooter>
<Button variant="outline" onClick={handleSkipAndClose}>
Skip
</Button>
<Button onClick={handleSave}>Save & Continue</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,464 @@
'use client'
import { useState, useEffect, useCallback, useRef } from 'react'
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Loader2, Play, Square, RotateCcw, Trash2, History } from 'lucide-react'
import { LyricsSegment, Word } from '@/lib/lyrics-review/types'
import { nanoid } from 'nanoid'
import EditWordList from '../EditWordList'
import EditTimelineSection from '../EditTimelineSection'
import useManualSync from '@/hooks/useManualSync'
import { setModalHandler } from '@/lib/lyrics-review/utils/keyboardHandlers'
interface EditModalProps {
open: boolean
onClose: () => void
segment: LyricsSegment | null
segmentIndex: number | null
originalSegment: LyricsSegment | null
onSave: (updatedSegment: LyricsSegment) => void
onPlaySegment?: (startTime: number) => void
currentTime?: number
onDelete?: (segmentIndex: number) => void
onAddSegment?: (segmentIndex: number) => void
onSplitSegment?: (segmentIndex: number, afterWordIndex: number) => void
onMergeSegment?: (segmentIndex: number, mergeWithNext: boolean) => void
setModalSpacebarHandler?: (handler: ((e: KeyboardEvent) => void) | undefined) => void
originalTranscribedSegment?: LyricsSegment | null
isGlobal?: boolean
isLoading?: boolean
}
export default function EditModal({
open,
onClose,
segment,
segmentIndex,
originalSegment,
onSave,
onPlaySegment,
currentTime = 0,
onDelete,
onAddSegment,
onSplitSegment,
onMergeSegment,
setModalSpacebarHandler,
originalTranscribedSegment,
isGlobal = false,
isLoading = false,
}: EditModalProps) {
const [editedSegment, setEditedSegment] = useState<LyricsSegment | null>(segment)
const [isPlaying, setIsPlaying] = useState(false)
const currentTimeRef = useRef(currentTime)
// Keep currentTimeRef updated
useEffect(() => {
currentTimeRef.current = currentTime
}, [currentTime])
useEffect(() => {
setEditedSegment(segment)
}, [segment])
// Track playing state from global window
useEffect(() => {
const checkPlayingState = () => {
setIsPlaying(!!window.isAudioPlaying)
}
// Check immediately and set up interval
checkPlayingState()
const intervalId = setInterval(checkPlayingState, 100)
return () => clearInterval(intervalId)
}, [])
const updateSegment = useCallback((newWords: Word[]) => {
if (!editedSegment) return
const validStartTimes = newWords.map((w) => w.start_time).filter((t): t is number => t !== null)
const validEndTimes = newWords.map((w) => w.end_time).filter((t): t is number => t !== null)
const segmentStartTime = validStartTimes.length > 0 ? Math.min(...validStartTimes) : null
const segmentEndTime = validEndTimes.length > 0 ? Math.max(...validEndTimes) : null
setEditedSegment({
...editedSegment,
words: newWords,
text: newWords.map((w) => w.text).join(' '),
start_time: segmentStartTime,
end_time: segmentEndTime,
})
}, [editedSegment])
// Manual sync hook
const {
isManualSyncing,
syncWordIndex,
startManualSync,
handleSpacebar,
isSpacebarPressed,
handleTapStart,
handleTapEnd,
cleanupManualSync,
} = useManualSync({
editedSegment,
currentTime,
onPlaySegment,
updateSegment,
})
// Wire up spacebar handler - use setModalHandler directly for proper modal state
useEffect(() => {
if (open) {
setModalHandler(handleSpacebar, true)
}
return () => {
setModalHandler(undefined, false)
}
}, [open, handleSpacebar])
// Auto-stop playback at segment end (not during manual sync or for global segments)
useEffect(() => {
if (!editedSegment || isManualSyncing || isGlobal) return
const endTime = editedSegment.end_time ?? 0
if (isPlaying && currentTime > endTime) {
window.toggleAudioPlayback?.()
}
}, [currentTime, editedSegment, isManualSyncing, isGlobal, isPlaying])
const handleWordChange = useCallback(
(index: number, updates: Partial<Word>) => {
if (!editedSegment) return
const newWords = [...editedSegment.words]
newWords[index] = { ...newWords[index], ...updates }
updateSegment(newWords)
},
[editedSegment, updateSegment]
)
const handleAddWord = useCallback(
(index?: number) => {
if (!editedSegment) return
const newWords = [...editedSegment.words]
const segStart = editedSegment.start_time ?? 0
const segEnd = editedSegment.end_time ?? segStart + 1
// Calculate timing for the new word based on insertion position
let newStartTime: number
let newEndTime: number
if (index === undefined || index === -1) {
// Inserting at beginning
const firstWord = newWords[0]
const firstWordStart = firstWord?.start_time ?? segEnd
newStartTime = segStart
newEndTime = segStart + (firstWordStart - segStart) / 2
// If gap is too small, create a small default duration
if (newEndTime - newStartTime < 0.1) {
newEndTime = newStartTime + 0.2
}
} else {
// Inserting after word at index
const prevWord = newWords[index]
const nextWord = newWords[index + 1]
const prevEnd = prevWord?.end_time ?? segStart
const nextStart = nextWord?.start_time ?? segEnd
// Fill the gap between prev end and next start
newStartTime = prevEnd
newEndTime = nextStart
// If gap is too small, create a small default duration
if (newEndTime - newStartTime < 0.1) {
newEndTime = newStartTime + 0.2
}
}
const newWord: Word = {
id: nanoid(),
text: '',
start_time: newStartTime,
end_time: newEndTime,
confidence: 1.0,
}
if (index === undefined || index === -1) {
newWords.unshift(newWord)
} else {
newWords.splice(index + 1, 0, newWord)
}
updateSegment(newWords)
},
[editedSegment, updateSegment]
)
const handleSplitWord = useCallback(
(index: number) => {
if (!editedSegment) return
const word = editedSegment.words[index]
const words = word.text.split(/\s+/).filter((w) => w.length > 0)
if (words.length <= 1) {
const half = Math.ceil(word.text.length / 2)
words[0] = word.text.slice(0, half)
words[1] = word.text.slice(half)
}
const newWords = words.map((text) => ({
id: nanoid(),
text,
start_time: null,
end_time: null,
confidence: 1.0,
}))
const allWords = [...editedSegment.words]
allWords.splice(index, 1, ...newWords)
updateSegment(allWords)
},
[editedSegment, updateSegment]
)
const handleMergeWords = useCallback(
(index: number) => {
if (!editedSegment || index >= editedSegment.words.length - 1) return
const word1 = editedSegment.words[index]
const word2 = editedSegment.words[index + 1]
const newWords = [...editedSegment.words]
newWords.splice(index, 2, {
id: nanoid(),
text: `${word1.text} ${word2.text}`.trim(),
start_time: word1.start_time,
end_time: word2.end_time,
confidence: 1.0,
})
updateSegment(newWords)
},
[editedSegment, updateSegment]
)
const handleRemoveWord = useCallback(
(index: number) => {
if (!editedSegment) return
const newWords = editedSegment.words.filter((_, i) => i !== index)
updateSegment(newWords)
},
[editedSegment, updateSegment]
)
const handleReplaceAllWords = useCallback(
(replacementText: string) => {
if (!editedSegment) return
const wordTexts = replacementText.trim().split(/\s+/).filter((w) => w.length > 0)
if (wordTexts.length === 0) return
const segStart = editedSegment.start_time ?? 0
const segEnd = editedSegment.end_time ?? segStart + 1
const totalDuration = segEnd - segStart
const wordDuration = totalDuration / wordTexts.length
const newWords: Word[] = wordTexts.map((text, index) => ({
id: nanoid(),
text,
start_time: segStart + index * wordDuration,
end_time: segStart + (index + 1) * wordDuration,
confidence: 1.0,
}))
updateSegment(newWords)
},
[editedSegment, updateSegment]
)
const handleReset = useCallback(() => {
if (!originalSegment) return
setEditedSegment(JSON.parse(JSON.stringify(originalSegment)))
}, [originalSegment])
const handleRevertToOriginal = useCallback(() => {
if (!originalTranscribedSegment) return
setEditedSegment(JSON.parse(JSON.stringify(originalTranscribedSegment)))
}, [originalTranscribedSegment])
const handleClose = useCallback(() => {
cleanupManualSync()
onClose()
}, [cleanupManualSync, onClose])
const handleSave = useCallback(() => {
if (!editedSegment) return
onSave(editedSegment)
handleClose()
}, [editedSegment, onSave, handleClose])
const handlePlayToggle = useCallback(() => {
if (!segment || !onPlaySegment) return
if (isPlaying) {
window.toggleAudioPlayback?.()
} else {
onPlaySegment(segment.start_time ?? 0)
}
}, [segment, onPlaySegment, isPlaying])
const handleDelete = useCallback(() => {
if (segmentIndex !== null) {
onDelete?.(segmentIndex)
handleClose()
}
}, [segmentIndex, onDelete, handleClose])
const handleSplitSegment = useCallback(
(wordIndex: number) => {
if (segmentIndex !== null && editedSegment) {
handleSave()
onSplitSegment?.(segmentIndex, wordIndex)
}
},
[segmentIndex, editedSegment, handleSave, onSplitSegment]
)
const handleMergeSegment = useCallback(
(mergeWithNext: boolean) => {
if (segmentIndex !== null && editedSegment) {
handleSave()
onMergeSegment?.(segmentIndex, mergeWithNext)
handleClose()
}
},
[segmentIndex, editedSegment, handleSave, onMergeSegment, handleClose]
)
const handleAddSegmentAt = useCallback(
(beforeIndex: number) => {
if (segmentIndex !== null && editedSegment) {
handleSave()
// beforeIndex 0 means before this segment, anything else means after
const insertIndex = beforeIndex === 0 ? segmentIndex : segmentIndex + 1
onAddSegment?.(insertIndex)
handleClose()
}
},
[segmentIndex, editedSegment, handleSave, onAddSegment, handleClose]
)
if (!isLoading && (!segment || !editedSegment || !originalSegment)) {
return null
}
if (!isLoading && !isGlobal && segmentIndex === null) {
return null
}
const startTime = editedSegment?.start_time ?? 0
const endTime = editedSegment?.end_time ?? startTime + 1
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && handleClose()}>
<DialogContent className="max-w-[960px] max-h-[90vh] overflow-hidden flex flex-col">
<DialogHeader>
<DialogTitle className="flex items-center gap-2">
Edit {isGlobal ? 'All Words' : `Segment ${segmentIndex}`}
{segment && segment.start_time !== null && onPlaySegment && (
<Button
variant="ghost"
size="icon"
className="h-8 w-8"
onClick={handlePlayToggle}
>
{isPlaying ? <Square className="h-4 w-4" /> : <Play className="h-4 w-4" />}
</Button>
)}
</DialogTitle>
</DialogHeader>
{isLoading ? (
<div className="flex flex-col items-center justify-center flex-1 py-12">
<Loader2 className="h-12 w-12 animate-spin text-primary" />
<p className="mt-4 text-lg font-semibold">
Loading {isGlobal ? 'all words' : 'segment'}...
</p>
</div>
) : editedSegment ? (
<div className="flex-1 overflow-auto space-y-4">
{/* Timeline editor with Tap To Sync */}
{editedSegment.words.some((w) => w.start_time !== null) && (
<EditTimelineSection
words={editedSegment.words}
startTime={startTime}
endTime={endTime}
originalStartTime={originalSegment?.start_time ?? null}
originalEndTime={originalSegment?.end_time ?? null}
currentStartTime={editedSegment.start_time}
currentEndTime={editedSegment.end_time}
currentTime={currentTime}
isManualSyncing={isManualSyncing}
syncWordIndex={syncWordIndex}
isSpacebarPressed={isSpacebarPressed}
onWordUpdate={handleWordChange}
onPlaySegment={onPlaySegment}
startManualSync={startManualSync}
isGlobal={isGlobal}
onTapStart={handleTapStart}
onTapEnd={handleTapEnd}
/>
)}
{/* Word list */}
<EditWordList
words={editedSegment.words}
onWordUpdate={handleWordChange}
onSplitWord={handleSplitWord}
onMergeWords={handleMergeWords}
onAddWord={handleAddWord}
onRemoveWord={handleRemoveWord}
onReplaceAllWords={handleReplaceAllWords}
onSplitSegment={handleSplitSegment}
onAddSegment={handleAddSegmentAt}
onMergeSegment={handleMergeSegment}
isGlobal={isGlobal}
/>
</div>
) : (
<div className="flex items-center justify-center flex-1">
<p className="text-lg">No segment data available</p>
</div>
)}
<DialogFooter className="flex flex-wrap gap-2 justify-between sm:justify-between">
<div className="flex gap-2 flex-wrap">
<Button
variant="outline"
size="sm"
onClick={handleReset}
className="text-orange-600 border-orange-600 hover:bg-orange-50 dark:text-orange-400 dark:border-orange-400 dark:hover:bg-orange-950"
>
<RotateCcw className="h-4 w-4 mr-1" />
Reset
</Button>
{originalTranscribedSegment && (
<Button variant="outline" size="sm" onClick={handleRevertToOriginal}>
<History className="h-4 w-4 mr-1" />
Un-Correct
</Button>
)}
{!isGlobal && onDelete && (
<Button variant="destructive" size="sm" onClick={handleDelete}>
<Trash2 className="h-4 w-4 mr-1" />
Delete Segment
</Button>
)}
</div>
<div className="flex gap-2 ml-auto">
<Button variant="outline" onClick={handleClose}>
Cancel
</Button>
<Button onClick={handleSave} disabled={isLoading || !editedSegment || editedSegment.words.length === 0}>
Save
</Button>
</div>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,247 @@
'use client'
import { useState, useEffect } from 'react'
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Label } from '@/components/ui/label'
import { Switch } from '@/components/ui/switch'
import { Alert, AlertDescription } from '@/components/ui/alert'
import { ScrollArea } from '@/components/ui/scroll-area'
import { Loader2, AlertCircle } from 'lucide-react'
import { CorrectionData } from '@/lib/lyrics-review/types'
interface MatchPreview {
segmentIndex: number
wordIndex?: number
segmentText: string
wordText: string
replacement: string
willBeRemoved: boolean
}
interface FindReplaceModalProps {
open: boolean
onClose: () => void
onReplace: (
findText: string,
replaceText: string,
options: { caseSensitive: boolean; useRegex: boolean; fullTextMode: boolean }
) => void
data: CorrectionData
}
export default function FindReplaceModal({
open,
onClose,
onReplace,
data,
}: FindReplaceModalProps) {
const [findText, setFindText] = useState('')
const [replaceText, setReplaceText] = useState('')
const [caseSensitive, setCaseSensitive] = useState(false)
const [useRegex, setUseRegex] = useState(false)
const [fullTextMode, setFullTextMode] = useState(false)
const [matchPreviews, setMatchPreviews] = useState<MatchPreview[]>([])
const [regexError, setRegexError] = useState<string | null>(null)
const [isSearching, setIsSearching] = useState(false)
// Reset state when modal opens
useEffect(() => {
if (open) {
setMatchPreviews([])
setRegexError(null)
}
}, [open])
// Find matches whenever search parameters change
useEffect(() => {
if (!open || !findText) {
setMatchPreviews([])
setRegexError(null)
return
}
setIsSearching(true)
const timeoutId = setTimeout(() => {
try {
const matches: MatchPreview[] = []
const segments = data.corrected_segments || []
let pattern: RegExp
if (useRegex) {
pattern = new RegExp(findText, caseSensitive ? 'g' : 'gi')
} else {
const escaped = findText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
pattern = new RegExp(escaped, caseSensitive ? 'g' : 'gi')
}
segments.forEach((segment, segmentIndex) => {
segment.words.forEach((word, wordIndex) => {
if (pattern.test(word.text)) {
pattern.lastIndex = 0
const replacedText = word.text.replace(pattern, replaceText)
matches.push({
segmentIndex,
wordIndex,
segmentText: segment.text,
wordText: word.text,
replacement: replacedText,
willBeRemoved: replacedText.trim() === '',
})
}
})
})
setMatchPreviews(matches)
setRegexError(null)
} catch (error) {
setRegexError(error instanceof Error ? error.message : 'Invalid regex pattern')
setMatchPreviews([])
} finally {
setIsSearching(false)
}
}, 300)
return () => clearTimeout(timeoutId)
}, [open, data, findText, replaceText, caseSensitive, useRegex, fullTextMode])
const handleReplace = () => {
if (!findText || regexError) return
onReplace(findText, replaceText, { caseSensitive, useRegex, fullTextMode })
onClose()
}
const handleKeyDown = (event: React.KeyboardEvent) => {
if (event.key === 'Enter' && !event.shiftKey && !regexError && findText) {
event.preventDefault()
handleReplace()
}
}
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
<DialogContent className="max-w-2xl" onKeyDown={handleKeyDown}>
<DialogHeader>
<DialogTitle>Find and Replace</DialogTitle>
</DialogHeader>
<div className="space-y-4">
<div className="space-y-2">
<Label htmlFor="find">Find</Label>
<Input
id="find"
value={findText}
onChange={(e) => setFindText(e.target.value)}
placeholder="Text to find..."
autoFocus
className={regexError ? 'border-destructive' : ''}
/>
{regexError && <p className="text-sm text-destructive">{regexError}</p>}
</div>
<div className="space-y-2">
<Label htmlFor="replace">Replace with</Label>
<Input
id="replace"
value={replaceText}
onChange={(e) => setReplaceText(e.target.value)}
placeholder="Replacement text..."
/>
</div>
<div className="flex flex-wrap gap-4">
<div className="flex items-center space-x-2">
<Switch
id="caseSensitive"
checked={caseSensitive}
onCheckedChange={setCaseSensitive}
/>
<Label htmlFor="caseSensitive">Case sensitive</Label>
</div>
<div className="flex items-center space-x-2">
<Switch id="useRegex" checked={useRegex} onCheckedChange={setUseRegex} />
<Label htmlFor="useRegex">Use regex</Label>
</div>
<div className="flex items-center space-x-2">
<Switch
id="fullTextMode"
checked={fullTextMode}
onCheckedChange={setFullTextMode}
/>
<Label htmlFor="fullTextMode">Full text mode</Label>
</div>
</div>
<div className="space-y-2">
<div className="flex items-center gap-2">
<h4 className="font-medium">Preview</h4>
{isSearching && <Loader2 className="h-4 w-4 animate-spin" />}
</div>
{matchPreviews.some((m) => m.willBeRemoved) && (
<Alert variant="destructive">
<AlertCircle className="h-4 w-4" />
<AlertDescription>
Some replacements will result in empty words, which will be removed.
</AlertDescription>
</Alert>
)}
{!isSearching && findText && matchPreviews.length === 0 && !regexError && (
<Alert>
<AlertDescription>No matches found</AlertDescription>
</Alert>
)}
{!isSearching && matchPreviews.length > 0 && (
<>
<p className="text-sm text-muted-foreground">
{matchPreviews.length} {matchPreviews.length === 1 ? 'match' : 'matches'} found
</p>
<ScrollArea className="h-48 border rounded-md p-2">
<div className="space-y-2">
{matchPreviews.slice(0, 50).map((preview, index) => (
<div key={index} className="text-sm p-2 bg-muted rounded">
<div>
<span className="text-destructive font-medium">{preview.wordText}</span>
<span className="text-muted-foreground"> → </span>
{preview.willBeRemoved ? (
<span className="text-yellow-600 font-medium">(will be removed)</span>
) : (
<span className="text-primary font-medium">{preview.replacement}</span>
)}
</div>
<div className="text-xs text-muted-foreground mt-1">
Segment {preview.segmentIndex + 1}
</div>
</div>
))}
{matchPreviews.length > 50 && (
<p className="text-sm text-muted-foreground">
{matchPreviews.length - 50} more matches not shown
</p>
)}
</div>
</ScrollArea>
</>
)}
</div>
</div>
<DialogFooter>
<Button variant="outline" onClick={onClose}>
Cancel
</Button>
<Button
onClick={handleReplace}
disabled={!findText || !!regexError || matchPreviews.length === 0}
>
Replace All ({matchPreviews.length})
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,95 @@
'use client'
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { RefreshCw, ClipboardPaste, X } from 'lucide-react'
import { cn } from '@/lib/utils'
interface ModeSelectionModalProps {
open: boolean
onClose: () => void
onSelectReplace: () => void
onSelectResync: () => void
hasExistingLyrics: boolean
}
export default function ModeSelectionModal({
open,
onClose,
onSelectReplace,
onSelectResync,
hasExistingLyrics,
}: ModeSelectionModalProps) {
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
<DialogContent className="max-w-md">
<DialogHeader>
<DialogTitle className="flex items-center justify-between">
<span>Edit All Lyrics</span>
<Button variant="ghost" size="icon" onClick={onClose} className="h-8 w-8">
<X className="h-4 w-4" />
</Button>
</DialogTitle>
</DialogHeader>
<div className="space-y-4">
<p className="text-sm text-muted-foreground">Choose how you want to edit the lyrics:</p>
<div className="flex flex-col gap-3">
{/* Re-sync Existing option - only show if there are existing lyrics */}
{hasExistingLyrics && (
<div
className={cn(
'p-4 border-2 border-primary rounded-lg cursor-pointer',
'hover:bg-primary/10 transition-colors'
)}
onClick={onSelectResync}
>
<div className="flex items-start gap-3">
<RefreshCw className="h-10 w-10 text-primary mt-0.5" />
<div className="flex-1">
<h3 className="text-lg font-semibold text-primary">Re-sync Existing Lyrics</h3>
<p className="text-sm text-muted-foreground mt-1">
Keep the current lyrics text and fix timing issues. Use this when lyrics are
correct but timing has drifted, especially in the second half of the song.
</p>
<p className="text-xs text-green-500 mt-2">Recommended for fixing timing drift</p>
</div>
</div>
</div>
)}
{/* Replace All option */}
<div
className={cn(
'p-4 border rounded-lg cursor-pointer',
'hover:bg-muted/30 hover:border-muted-foreground transition-colors'
)}
onClick={onSelectReplace}
>
<div className="flex items-start gap-3">
<ClipboardPaste className="h-10 w-10 text-muted-foreground mt-0.5" />
<div className="flex-1">
<h3 className="text-lg font-semibold">Replace All Lyrics</h3>
<p className="text-sm text-muted-foreground mt-1">
Paste completely new lyrics from clipboard and manually sync timing for all
words from scratch.
</p>
<p className="text-xs text-yellow-500 mt-2">
All existing timing data will be lost
</p>
</div>
</div>
</div>
</div>
</div>
<DialogFooter>
<Button variant="outline" onClick={onClose}>
Cancel
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,266 @@
'use client'
import { useState, useEffect, useCallback, useMemo } from 'react'
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Textarea } from '@/components/ui/textarea'
import { X, ArrowLeft, ClipboardPaste, Sparkles } from 'lucide-react'
import { nanoid } from 'nanoid'
import { LyricsSegment, Word } from '@/lib/lyrics-review/types'
import ModeSelectionModal from './ModeSelectionModal'
import LyricsSynchronizer from '../synchronizer/LyricsSynchronizer'
declare global {
interface Window {
getAudioDuration?: () => number
toggleAudioPlayback?: () => void
isAudioPlaying?: boolean
}
}
type ModalMode = 'selection' | 'replace' | 'resync'
interface ReplaceAllLyricsModalProps {
open: boolean
onClose: () => void
onSave: (newSegments: LyricsSegment[]) => void
onPlaySegment?: (startTime: number) => void
currentTime?: number
setModalSpacebarHandler: (handler: ((e: KeyboardEvent) => void) | undefined) => void
existingSegments?: LyricsSegment[]
}
export default function ReplaceAllLyricsModal({
open,
onClose,
onSave,
onPlaySegment,
currentTime = 0,
setModalSpacebarHandler,
existingSegments = [],
}: ReplaceAllLyricsModalProps) {
const [mode, setMode] = useState<ModalMode>('selection')
const [inputText, setInputText] = useState('')
const [newSegments, setNewSegments] = useState<LyricsSegment[]>([])
// Reset state when modal opens
useEffect(() => {
if (open) {
setMode('selection')
setInputText('')
setNewSegments([])
}
}, [open])
// Parse the input text to get line and word counts
const parseInfo = useMemo(() => {
if (!inputText.trim()) return { lines: 0, words: 0 }
const lines = inputText
.trim()
.split('\n')
.filter((line) => line.trim().length > 0)
const totalWords = lines.reduce((count, line) => {
return count + line.trim().split(/\s+/).length
}, 0)
return { lines: lines.length, words: totalWords }
}, [inputText])
// Process the input text into segments and words
const processLyrics = useCallback(() => {
if (!inputText.trim()) return
const lines = inputText
.trim()
.split('\n')
.filter((line) => line.trim().length > 0)
const segments: LyricsSegment[] = []
lines.forEach((line) => {
const words = line
.trim()
.split(/\s+/)
.filter((word) => word.length > 0)
const segmentWords: Word[] = words.map((wordText) => ({
id: nanoid(),
text: wordText,
start_time: null,
end_time: null,
confidence: 1.0,
created_during_correction: true,
}))
segments.push({
id: nanoid(),
text: line.trim(),
words: segmentWords,
start_time: null,
end_time: null,
})
})
setNewSegments(segments)
setMode('resync')
}, [inputText])
// Handle paste from clipboard
const handlePasteFromClipboard = useCallback(async () => {
try {
const text = await navigator.clipboard.readText()
setInputText(text)
} catch (error) {
console.error('Failed to read from clipboard:', error)
alert('Failed to read from clipboard. Please paste manually.')
}
}, [])
// Handle modal close
const handleClose = useCallback(() => {
setMode('selection')
setInputText('')
setNewSegments([])
onClose()
}, [onClose])
// Handle save from synchronizer
const handleSave = useCallback(
(segments: LyricsSegment[]) => {
onSave(segments)
handleClose()
},
[onSave, handleClose]
)
// Handle mode selection
const handleSelectReplace = useCallback(() => {
setMode('replace')
}, [])
const handleSelectResync = useCallback(() => {
setMode('resync')
}, [])
// Handle back to selection
const handleBackToSelection = useCallback(() => {
setMode('selection')
setInputText('')
setNewSegments([])
}, [])
// Determine which segments to use for synchronizer
const segmentsForSync = mode === 'resync' && newSegments.length > 0 ? newSegments : existingSegments
// Check if we have existing lyrics
const hasExistingLyrics =
existingSegments.length > 0 && existingSegments.some((s) => s.words.length > 0)
return (
<>
{/* Mode Selection Modal */}
<ModeSelectionModal
open={open && mode === 'selection'}
onClose={handleClose}
onSelectReplace={handleSelectReplace}
onSelectResync={handleSelectResync}
hasExistingLyrics={hasExistingLyrics}
/>
{/* Replace All Lyrics Modal (Paste Phase) */}
<Dialog open={open && mode === 'replace'} onOpenChange={(isOpen) => !isOpen && handleClose()}>
<DialogContent className="max-w-2xl h-[80vh] max-h-[80vh] flex flex-col">
<DialogHeader>
<DialogTitle className="flex items-center gap-2">
<Button variant="ghost" size="icon" onClick={handleBackToSelection} className="h-8 w-8">
<ArrowLeft className="h-4 w-4" />
</Button>
<span className="flex-1">Replace All Lyrics</span>
<Button variant="ghost" size="icon" onClick={handleClose} className="h-8 w-8">
<X className="h-4 w-4" />
</Button>
</DialogTitle>
</DialogHeader>
<div className="flex-1 overflow-hidden flex flex-col gap-4">
<div>
<h3 className="text-lg font-semibold">Paste your new lyrics below:</h3>
<p className="text-sm text-muted-foreground mt-1">
Each line will become a separate segment. Words will be separated by spaces.
</p>
</div>
<div className="flex items-center gap-4">
<Button variant="outline" size="sm" onClick={handlePasteFromClipboard}>
<ClipboardPaste className="h-4 w-4 mr-2" />
Paste from Clipboard
</Button>
<span className="text-sm text-muted-foreground font-medium">
{parseInfo.lines} lines, {parseInfo.words} words
</span>
</div>
<Textarea
value={inputText}
onChange={(e) => setInputText(e.target.value)}
placeholder={`Paste your lyrics here...\nEach line will become a segment\nWords will be separated by spaces`}
className="flex-1 resize-none font-mono text-sm min-h-[300px]"
/>
</div>
<DialogFooter>
<Button variant="outline" onClick={handleClose}>
Cancel
</Button>
<Button onClick={processLyrics} disabled={!inputText.trim()}>
<Sparkles className="h-4 w-4 mr-2" />
Continue to Sync
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
{/* Synchronizer Modal */}
<Dialog open={open && mode === 'resync'} onOpenChange={(isOpen) => !isOpen && handleClose()}>
<DialogContent className="max-w-[calc(100vw-4vw)] w-[calc(100vw-4vw)] h-[90vh] max-h-[90vh] flex flex-col">
<DialogHeader>
<DialogTitle className="flex items-center gap-2">
<Button variant="ghost" size="icon" onClick={handleBackToSelection} className="h-8 w-8">
<ArrowLeft className="h-4 w-4" />
</Button>
<span className="flex-1">
{newSegments.length > 0 ? 'Sync New Lyrics' : 'Re-sync Existing Lyrics'}
</span>
<Button variant="ghost" size="icon" onClick={handleClose} className="h-8 w-8">
<X className="h-4 w-4" />
</Button>
</DialogTitle>
</DialogHeader>
<div className="flex-1 overflow-hidden">
{segmentsForSync.length > 0 ? (
<LyricsSynchronizer
segments={segmentsForSync}
currentTime={currentTime}
onPlaySegment={onPlaySegment}
onSave={handleSave}
onCancel={handleClose}
setModalSpacebarHandler={setModalSpacebarHandler}
/>
) : (
<div className="flex flex-col items-center justify-center h-full gap-4">
<h3 className="text-lg font-semibold text-muted-foreground">No lyrics to sync</h3>
<p className="text-sm text-muted-foreground">
Go back and paste new lyrics, or close this modal.
</p>
<Button variant="outline" onClick={handleBackToSelection}>
<ArrowLeft className="h-4 w-4 mr-2" />
Back to Selection
</Button>
</div>
)}
</div>
</DialogContent>
</Dialog>
</>
)
}
@@ -0,0 +1,85 @@
'use client'
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { CorrectionData } from '@/lib/lyrics-review/types'
import { ArrowLeft, Upload } from 'lucide-react'
import PreviewVideoSection from '../PreviewVideoSection'
interface ApiClient {
generatePreviewVideo: (data: CorrectionData) => Promise<{
status: string
message?: string
preview_hash?: string
}>
getPreviewVideoUrl: (hash: string) => string
}
interface ReviewChangesModalProps {
open: boolean
onClose: () => void
data: CorrectionData
onSubmit: () => void
isSubmitting?: boolean
apiClient?: ApiClient | null
timingOffsetMs?: number
}
export default function ReviewChangesModal({
open,
onClose,
data,
onSubmit,
isSubmitting = false,
apiClient = null,
timingOffsetMs = 0,
}: ReviewChangesModalProps) {
const corrections = data.corrections || []
const totalSegments = data.corrected_segments?.length || 0
// Check if there are manual corrections (user-made changes)
const hasManualCorrections = corrections.some(c => c.handler === 'ManualCorrector' || c.handler === 'UserEdit')
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
<DialogContent className="max-w-4xl max-h-[90vh] overflow-y-auto">
<DialogHeader>
<DialogTitle>Preview Video (With Vocals)</DialogTitle>
</DialogHeader>
{/* Video Preview Section */}
<PreviewVideoSection
apiClient={apiClient}
isModalOpen={open}
updatedData={data}
timingOffsetMs={timingOffsetMs}
/>
{/* Info text */}
<div className="text-sm text-muted-foreground space-y-1">
{hasManualCorrections ? (
<p>Manual corrections detected. Review the preview to ensure the lyrics are synchronized correctly.</p>
) : (
<p>No manual corrections detected. If everything looks good in the preview, click submit and the server will generate the final karaoke video.</p>
)}
<p>Total segments: {totalSegments}</p>
</div>
<DialogFooter className="border-t pt-4">
<Button variant="ghost" onClick={onClose} className="text-primary">
<ArrowLeft className="h-4 w-4 mr-2" />
Cancel
</Button>
<Button
onClick={onSubmit}
disabled={isSubmitting}
className="bg-green-600 hover:bg-green-700"
>
Complete Review
<Upload className="h-4 w-4 ml-2" />
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,38 @@
'use client'
import {
Dialog,
DialogContent,
DialogHeader,
DialogTitle,
} from '@/components/ui/dialog'
import { LyricsSegment } from '@/lib/lyrics-review/types'
interface SegmentDetailsModalProps {
open: boolean
onClose: () => void
segment: LyricsSegment | null
segmentIndex: number | null
}
export default function SegmentDetailsModal({
open,
onClose,
segment,
segmentIndex,
}: SegmentDetailsModalProps) {
if (!segment || segmentIndex === null) return null
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
<DialogContent className="max-w-lg">
<DialogHeader>
<DialogTitle>Segment {segmentIndex} Details</DialogTitle>
</DialogHeader>
<pre className="m-0 font-mono text-sm whitespace-pre-wrap break-words overflow-auto max-h-[60vh] bg-muted p-4 rounded">
{JSON.stringify(segment, null, 2)}
</pre>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,95 @@
'use client'
import { useState } from 'react'
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Label } from '@/components/ui/label'
import { Slider } from '@/components/ui/slider'
interface TimingOffsetModalProps {
open: boolean
onClose: () => void
currentOffset: number
onApply: (offsetMs: number) => void
}
export default function TimingOffsetModal({
open,
onClose,
currentOffset,
onApply,
}: TimingOffsetModalProps) {
const [offset, setOffset] = useState(currentOffset)
const handleApply = () => {
onApply(offset)
onClose()
}
const handleReset = () => {
setOffset(0)
}
return (
<Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
<DialogContent className="max-w-md">
<DialogHeader>
<DialogTitle>Adjust Timing Offset</DialogTitle>
</DialogHeader>
<div className="space-y-6">
<div className="space-y-2">
<Label>Offset (milliseconds)</Label>
<div className="flex gap-4 items-center">
<Slider
value={[offset]}
min={-5000}
max={5000}
step={10}
onValueChange={([value]) => setOffset(value)}
className="flex-1"
/>
<Input
type="number"
value={offset}
onChange={(e) => setOffset(Number(e.target.value))}
className="w-24"
/>
</div>
<p className="text-sm text-muted-foreground">
Positive values shift lyrics later, negative values shift them earlier.
</p>
</div>
<div className="bg-muted p-3 rounded space-y-1">
<p className="text-sm">
<span className="text-muted-foreground">Current offset:</span>{' '}
<span className="font-mono">{currentOffset}ms</span>
</p>
<p className="text-sm">
<span className="text-muted-foreground">New offset:</span>{' '}
<span className="font-mono font-medium">{offset}ms</span>
</p>
<p className="text-sm">
<span className="text-muted-foreground">Change:</span>{' '}
<span className="font-mono">{offset - currentOffset}ms</span>
</p>
</div>
</div>
<DialogFooter className="flex gap-2 sm:justify-between">
<Button variant="outline" onClick={handleReset}>
Reset to 0
</Button>
<div className="flex gap-2">
<Button variant="outline" onClick={onClose}>
Cancel
</Button>
<Button onClick={handleApply}>Apply</Button>
</div>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
@@ -0,0 +1,10 @@
export { default as AddLyricsModal } from './AddLyricsModal'
export { default as AIFeedbackModal } from './AIFeedbackModal'
export { default as CorrectionAnnotationModal } from './CorrectionAnnotationModal'
export { default as EditModal } from './EditModal'
export { default as FindReplaceModal } from './FindReplaceModal'
export { default as ModeSelectionModal } from './ModeSelectionModal'
export { default as ReplaceAllLyricsModal } from './ReplaceAllLyricsModal'
export { default as ReviewChangesModal } from './ReviewChangesModal'
export { default as SegmentDetailsModal } from './SegmentDetailsModal'
export { default as TimingOffsetModal } from './TimingOffsetModal'
@@ -0,0 +1,425 @@
'use client'
import React from 'react'
import { Button } from '@/components/ui/button'
import { Copy } from 'lucide-react'
import { WordComponent } from './Word'
import { useWordClick } from './useWordClick'
import {
AnchorSequence,
GapSequence,
HighlightInfo,
InteractionMode,
LyricsSegment,
Word,
WordCorrection,
ModalContent,
FlashType,
LinePosition,
TranscriptionWordPosition,
WordClickInfo,
} from '@/lib/lyrics-review/types'
import { getWordsFromIds } from '@/lib/lyrics-review/utils/wordUtils'
import CorrectedWordWithActions from '../CorrectedWordWithActions'
export interface HighlightedTextProps {
text?: string
segments?: LyricsSegment[]
wordPositions: TranscriptionWordPosition[]
anchors: AnchorSequence[]
highlightInfo: HighlightInfo | null
mode: InteractionMode
onElementClick: (content: ModalContent) => void
onWordClick?: (info: WordClickInfo) => void
flashingType: FlashType
isReference?: boolean
currentSource?: string
preserveSegments?: boolean
linePositions?: LinePosition[]
currentTime?: number
referenceCorrections?: Map<string, string>
gaps?: GapSequence[]
flashingHandler?: string | null
corrections?: WordCorrection[]
// Review mode props for agentic corrections
reviewMode?: boolean
onRevertCorrection?: (wordId: string) => void
onEditCorrection?: (wordId: string) => void
onAcceptCorrection?: (wordId: string) => void
onShowCorrectionDetail?: (wordId: string) => void
}
export function HighlightedText({
text,
segments,
wordPositions = [] as TranscriptionWordPosition[],
anchors,
highlightInfo,
mode,
onElementClick,
onWordClick,
flashingType,
isReference,
currentSource = '',
preserveSegments = false,
linePositions = [],
currentTime = 0,
referenceCorrections = new Map(),
gaps = [],
flashingHandler,
corrections = [],
reviewMode = false,
onRevertCorrection,
onEditCorrection,
onAcceptCorrection,
onShowCorrectionDetail,
}: HighlightedTextProps) {
const { handleWordClick } = useWordClick({
mode,
onElementClick,
onWordClick,
isReference,
currentSource,
gaps,
anchors,
corrections,
})
const shouldWordFlash = (
wordPos: TranscriptionWordPosition | { word: string; id: string }
): boolean => {
if (!flashingType) {
return false
}
if ('type' in wordPos) {
// Add handler-specific flashing
if (flashingType === 'handler' && flashingHandler) {
const shouldFlash = corrections.some(
(correction) =>
correction.handler === flashingHandler &&
(correction.corrected_word_id === wordPos.word.id ||
correction.word_id === wordPos.word.id)
)
return shouldFlash
}
const gap = wordPos.sequence as GapSequence
const isCorrected =
corrections.some(
(correction) =>
(correction.word_id === wordPos.word.id ||
correction.corrected_word_id === wordPos.word.id) &&
gap?.transcribed_word_ids?.includes(correction.word_id)
) || wordPos.isCorrected
return Boolean(
(flashingType === 'anchor' && wordPos.type === 'anchor') ||
(flashingType === 'corrected' && isCorrected) ||
(flashingType === 'uncorrected' && wordPos.type === 'gap' && !isCorrected) ||
(flashingType === 'word' &&
((highlightInfo?.type === 'anchor' &&
wordPos.type === 'anchor' &&
(isReference && currentSource && highlightInfo.sequence
? getWordsFromIds(
segments || [],
(highlightInfo.sequence as AnchorSequence).reference_word_ids[currentSource] ||
[]
).some((w) => w.id === wordPos.word.id)
: getWordsFromIds(
segments || [],
(highlightInfo.sequence as AnchorSequence).transcribed_word_ids
).some((w) => w.id === wordPos.word.id))) ||
(highlightInfo?.type === 'gap' &&
wordPos.type === 'gap' &&
(isReference && currentSource && highlightInfo.sequence
? getWordsFromIds(
segments || [],
(highlightInfo.sequence as GapSequence).reference_word_ids[currentSource] ||
[]
).some((w) => w.id === wordPos.word.id)
: getWordsFromIds(
segments || [],
(highlightInfo.sequence as GapSequence).transcribed_word_ids
).some((w) => w.id === wordPos.word.id))) ||
(highlightInfo?.type === 'correction' &&
isReference &&
currentSource &&
highlightInfo.correction?.reference_positions?.[currentSource]?.toString() ===
wordPos.word.id)))
)
}
return false
}
const shouldHighlightWord = (
wordPos: TranscriptionWordPosition | { word: string; id: string }
): boolean => {
if (isReference) return false
if ('type' in wordPos && currentTime !== undefined && 'start_time' in wordPos.word) {
const word = wordPos.word as Word
return (
word.start_time !== null &&
word.end_time !== null &&
currentTime >= word.start_time &&
currentTime <= word.end_time
)
}
return false
}
const handleCopyLine = (lineText: string) => {
navigator.clipboard.writeText(lineText)
}
// Check if we're on mobile using window width (SSR-safe default)
const isMobile = typeof window !== 'undefined' && window.innerWidth < 640
const renderContent = () => {
if (wordPositions && !segments) {
return wordPositions.map((wordPos, index) => {
const correction = corrections?.find(
(c) => c.corrected_word_id === wordPos.word.id || c.word_id === wordPos.word.id
)
// Use CorrectedWordWithActions for agentic corrections
if (correction && correction.handler === 'AgenticCorrector') {
return (
<React.Fragment key={wordPos.word.id}>
<CorrectedWordWithActions
word={wordPos.word.text}
originalWord={correction.original_word}
correction={{
originalWord: correction.original_word,
handler: correction.handler,
confidence: correction.confidence,
source: correction.source,
reason: correction.reason,
}}
shouldFlash={shouldWordFlash(wordPos)}
showActions={reviewMode && !isMobile}
onRevert={() => onRevertCorrection?.(wordPos.word.id)}
onEdit={() => onEditCorrection?.(wordPos.word.id)}
onAccept={() => onAcceptCorrection?.(wordPos.word.id)}
onClick={() => {
if (isMobile) {
onShowCorrectionDetail?.(wordPos.word.id)
} else {
handleWordClick(
wordPos.word.text,
wordPos.word.id,
wordPos.type === 'anchor' ? (wordPos.sequence as AnchorSequence) : undefined,
wordPos.type === 'gap' ? (wordPos.sequence as GapSequence) : undefined
)
}
}}
/>
{index < wordPositions.length - 1 && ' '}
</React.Fragment>
)
}
// Default rendering with WordComponent
return (
<React.Fragment key={wordPos.word.id}>
<WordComponent
word={wordPos.word.text}
shouldFlash={shouldWordFlash(wordPos)}
isAnchor={wordPos.type === 'anchor'}
isCorrectedGap={wordPos.isCorrected}
isUncorrectedGap={wordPos.type === 'gap' && !wordPos.isCorrected}
isCurrentlyPlaying={shouldHighlightWord(wordPos)}
onClick={() =>
handleWordClick(
wordPos.word.text,
wordPos.word.id,
wordPos.type === 'anchor' ? (wordPos.sequence as AnchorSequence) : undefined,
wordPos.type === 'gap' ? (wordPos.sequence as GapSequence) : undefined
)
}
correction={
correction
? {
originalWord: correction.original_word,
handler: correction.handler,
confidence: correction.confidence,
source: correction.source,
reason: correction.reason,
}
: null
}
/>
{index < wordPositions.length - 1 && ' '}
</React.Fragment>
)
})
} else if (segments) {
return segments.map((segment) => (
<div key={segment.id} className="flex items-start mb-0">
<div className="flex-1">
{segment.words.map((word, wordIndex) => {
const wordPos = wordPositions.find(
(pos: TranscriptionWordPosition) => pos.word.id === word.id
)
const anchor =
wordPos?.type === 'anchor'
? anchors?.find((a) =>
(a.reference_word_ids[currentSource] || []).includes(word.id)
)
: undefined
const hasCorrection = referenceCorrections.has(word.id)
const isUncorrectedGap = wordPos?.type === 'gap' && !hasCorrection
const sequence =
wordPos?.type === 'gap' ? (wordPos.sequence as GapSequence) : undefined
const correction = corrections?.find(
(c) => c.corrected_word_id === word.id || c.word_id === word.id
)
// Use CorrectedWordWithActions for agentic corrections
if (correction && correction.handler === 'AgenticCorrector') {
return (
<React.Fragment key={word.id}>
<CorrectedWordWithActions
word={word.text}
originalWord={correction.original_word}
correction={{
originalWord: correction.original_word,
handler: correction.handler,
confidence: correction.confidence,
source: correction.source,
reason: correction.reason,
}}
shouldFlash={shouldWordFlash(wordPos || { word: word.text, id: word.id })}
showActions={reviewMode && !isMobile}
onRevert={() => onRevertCorrection?.(word.id)}
onEdit={() => onEditCorrection?.(word.id)}
onAccept={() => onAcceptCorrection?.(word.id)}
onClick={() => {
if (isMobile) {
onShowCorrectionDetail?.(word.id)
} else {
handleWordClick(word.text, word.id, anchor, sequence)
}
}}
/>
{wordIndex < segment.words.length - 1 && ' '}
</React.Fragment>
)
}
const correctionInfo = correction
? {
originalWord: correction.original_word,
handler: correction.handler,
confidence: correction.confidence,
source: correction.source,
reason: correction.reason,
}
: null
return (
<React.Fragment key={word.id}>
<WordComponent
word={word.text}
shouldFlash={shouldWordFlash(wordPos || { word: word.text, id: word.id })}
isAnchor={Boolean(anchor)}
isCorrectedGap={hasCorrection}
isUncorrectedGap={isUncorrectedGap}
isCurrentlyPlaying={shouldHighlightWord(
wordPos || { word: word.text, id: word.id }
)}
onClick={() => handleWordClick(word.text, word.id, anchor, sequence)}
correction={correctionInfo}
/>
{wordIndex < segment.words.length - 1 && ' '}
</React.Fragment>
)
})}
</div>
</div>
))
} else if (text) {
const lines = text.split('\n')
let wordCount = 0
return lines.map((line, lineIndex) => {
const currentLinePosition = linePositions?.find((pos) => pos.position === wordCount)
if (currentLinePosition?.isEmpty) {
wordCount++
return (
<div key={`empty-${lineIndex}`} className="flex items-start mb-0 leading-none">
<span className="text-muted-foreground w-8 min-w-[2em] text-right mr-2 select-none font-mono pt-[1px] text-[0.8rem] leading-none">
{currentLinePosition.lineNumber}
</span>
<div className="w-[18px]" />
<div className="flex-1 h-4" />
</div>
)
}
const words = line.split(' ')
const lineWords: React.ReactNode[] = []
words.forEach((word, wordIndex) => {
if (word === '') return null
if (/^\s+$/.test(word)) {
return lineWords.push(<span key={`space-${lineIndex}-${wordIndex}`}> </span>)
}
const wordId = `${currentSource}-word-${wordCount}`
wordCount++
const anchor = currentSource
? anchors?.find((a) => a.reference_word_ids[currentSource]?.includes(wordId))
: undefined
const hasCorrection = referenceCorrections.has(wordId)
lineWords.push(
<WordComponent
key={wordId}
word={word}
shouldFlash={shouldWordFlash({ word, id: wordId })}
isAnchor={Boolean(anchor)}
isCorrectedGap={hasCorrection}
isUncorrectedGap={false}
isCurrentlyPlaying={shouldHighlightWord({ word, id: wordId })}
onClick={() => handleWordClick(word, wordId, anchor, undefined)}
/>
)
})
return (
<div key={`line-${lineIndex}`} className="flex items-start mb-0 leading-none">
<span className="text-muted-foreground w-8 min-w-[2em] text-right mr-2 select-none font-mono pt-[1px] text-[0.8rem] leading-none">
{currentLinePosition?.lineNumber ?? lineIndex}
</span>
<Button
variant="ghost"
size="icon"
className="h-[18px] w-[18px] min-h-0 min-w-0 p-[1px] mr-1"
onClick={() => handleCopyLine(line)}
>
<Copy className="h-3.5 w-3.5" />
</Button>
<div className="flex-1">{lineWords}</div>
</div>
)
})
}
return null
}
return (
<div
className={`font-mono m-0 leading-tight ${preserveSegments ? 'whitespace-normal' : 'whitespace-pre-wrap'}`}
>
{renderContent()}
</div>
)
}
@@ -0,0 +1,46 @@
'use client'
import { Button } from '@/components/ui/button'
import { Plus } from 'lucide-react'
export interface SourceSelectorProps {
currentSource: string
onSourceChange: (source: string) => void
availableSources: string[]
onAddLyrics?: () => void
}
export function SourceSelector({
currentSource,
onSourceChange,
availableSources,
onAddLyrics,
}: SourceSelectorProps) {
return (
<div className="flex flex-wrap gap-1 items-center">
{availableSources.map((source) => (
<Button
key={source}
size="sm"
variant={currentSource === source ? 'default' : 'outline'}
onClick={() => onSourceChange(source)}
className="h-6 px-2 text-[0.7rem] leading-tight min-w-0"
>
{/* Capitalize first letter of source */}
{source.charAt(0).toUpperCase() + source.slice(1)}
</Button>
))}
{onAddLyrics && (
<Button
size="sm"
variant="outline"
onClick={onAddLyrics}
className="h-6 px-2 text-[0.7rem] leading-tight min-w-0"
>
<Plus className="h-3 w-3 mr-0.5" />
New
</Button>
)}
</div>
)
}
@@ -0,0 +1,85 @@
'use client'
import React from 'react'
import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
import { COLORS, HIGHLIGHT_CLASSES } from '@/lib/lyrics-review/constants'
import { WordProps } from '@/lib/lyrics-review/types'
import { cn } from '@/lib/utils'
export const WordComponent = React.memo(function Word({
word,
shouldFlash,
isAnchor,
isCorrectedGap,
isUncorrectedGap,
isCurrentlyPlaying,
padding = 'px-[3px] py-[1px]',
onClick,
correction,
}: WordProps) {
if (/^\s+$/.test(word)) {
return <>{word}</>
}
// Determine background color class
const bgColorClass = isCurrentlyPlaying
? 'bg-blue-500 text-white'
: isAnchor
? HIGHLIGHT_CLASSES.anchor
: isCorrectedGap
? HIGHLIGHT_CLASSES.corrected
: isUncorrectedGap
? HIGHLIGHT_CLASSES.uncorrectedGap
: ''
const wordElement = (
<span
className={cn(
'inline-block mr-[0.25em] transition-colors duration-200 cursor-pointer rounded-sm text-[0.85rem] leading-[1.2]',
padding,
bgColorClass,
shouldFlash && 'animate-lyrics-flash',
correction && 'underline decoration-dotted underline-offset-2 decoration-muted-foreground',
'hover:bg-foreground/[0.08]'
)}
onClick={onClick}
>
{word}
</span>
)
if (correction) {
return (
<TooltipProvider delayDuration={200}>
<Tooltip>
<TooltipTrigger asChild>{wordElement}</TooltipTrigger>
<TooltipContent side="top" className="max-w-xs">
<div className="text-xs space-y-0.5">
<div>
<strong>Original:</strong> &quot;{correction.originalWord}&quot;
</div>
<div>
<strong>Corrected by:</strong> {correction.handler}
</div>
<div>
<strong>Source:</strong> {correction.source}
</div>
{correction.reason && (
<div>
<strong>Reason:</strong> {correction.reason}
</div>
)}
{correction.confidence !== undefined && correction.confidence > 0 && (
<div>
<strong>Confidence:</strong> {(correction.confidence * 100).toFixed(0)}%
</div>
)}
</div>
</TooltipContent>
</Tooltip>
</TooltipProvider>
)
}
return wordElement
})
@@ -0,0 +1,155 @@
'use client'
import { useCallback } from 'react'
import {
AnchorSequence,
GapSequence,
InteractionMode,
WordCorrection,
ModalContent,
WordClickInfo,
} from '@/lib/lyrics-review/types'
export interface UseWordClickProps {
mode: InteractionMode
onElementClick: (content: ModalContent) => void
onWordClick?: (info: WordClickInfo) => void
isReference?: boolean
currentSource?: string
gaps?: GapSequence[]
anchors?: AnchorSequence[]
corrections?: WordCorrection[]
}
export function useWordClick({
mode,
onElementClick,
onWordClick,
isReference = false,
currentSource = '',
gaps = [],
anchors = [],
corrections = [],
}: UseWordClickProps) {
const handleWordClick = useCallback(
(word: string, wordId: string, anchor?: AnchorSequence, gap?: GapSequence) => {
// Check if word belongs to anchor
const belongsToAnchor =
anchor &&
(isReference
? anchor.reference_word_ids[currentSource]?.includes(wordId)
: anchor.transcribed_word_ids.includes(wordId))
// Find matching gap if not provided
const matchingGap =
gap ||
gaps.find(
(g) =>
g.transcribed_word_ids.includes(wordId) ||
Object.values(g.reference_word_ids).some((ids) => ids.includes(wordId))
)
// Check if word belongs to gap - include both original and corrected words
const belongsToGap =
matchingGap &&
(isReference
? matchingGap.reference_word_ids[currentSource]?.includes(wordId)
: matchingGap.transcribed_word_ids.includes(wordId) ||
corrections.some((c) => c.corrected_word_id === wordId || c.word_id === wordId))
// For reference view clicks, find the corresponding gap
if (isReference && currentSource) {
const refMatchingGap = gaps?.find((g) =>
g.reference_word_ids[currentSource]?.includes(wordId)
)
if (refMatchingGap) {
gap = refMatchingGap
}
}
if (mode === 'highlight' || mode === 'edit' || mode === 'delete_word') {
if (belongsToAnchor && anchor) {
onWordClick?.({
word_id: wordId,
type: 'anchor',
anchor,
gap: undefined,
})
} else if (belongsToGap && gap) {
onWordClick?.({
word_id: wordId,
type: 'gap',
anchor: undefined,
gap,
})
} else if (
corrections.some(
(c) =>
(c.corrected_word_id === wordId || c.word_id === wordId) &&
gap?.transcribed_word_ids.includes(c.word_id)
)
) {
// If the word is part of a correction, mark it as a gap
onWordClick?.({
word_id: wordId,
type: 'gap',
anchor: undefined,
gap,
})
} else {
onWordClick?.({
word_id: wordId,
type: 'other',
anchor: undefined,
gap: undefined,
})
}
} else {
// This is a fallback for any future modes
if (belongsToAnchor && anchor) {
onElementClick({
type: 'anchor',
data: {
...anchor,
wordId,
word,
anchor_sequences: anchors,
},
})
} else if (belongsToGap && gap) {
onElementClick({
type: 'gap',
data: {
...gap,
wordId,
word,
anchor_sequences: anchors,
},
})
} else if (!isReference) {
// Create synthetic gap for non-sequence words (transcription view only)
const syntheticGap: GapSequence = {
id: `synthetic-${wordId}`,
transcribed_word_ids: [wordId],
transcription_position: -1,
preceding_anchor_id: null,
following_anchor_id: null,
reference_word_ids: {},
}
onElementClick({
type: 'gap',
data: {
...syntheticGap,
wordId,
word,
anchor_sequences: anchors,
},
})
}
}
},
[mode, onWordClick, onElementClick, isReference, currentSource, gaps, anchors, corrections]
)
return { handleWordClick }
}
@@ -0,0 +1,955 @@
'use client'
import { useState, useCallback, useEffect, useRef, useMemo, memo } from 'react'
import { Button } from '@/components/ui/button'
import { Slider } from '@/components/ui/slider'
import { Input } from '@/components/ui/input'
import { Textarea } from '@/components/ui/textarea'
import { Alert, AlertDescription } from '@/components/ui/alert'
import {
Dialog,
DialogContent,
DialogHeader,
DialogTitle,
DialogFooter,
} from '@/components/ui/dialog'
import { ZoomIn, ZoomOut, AlertTriangle } from 'lucide-react'
import { Word, LyricsSegment } from '@/lib/lyrics-review/types'
import TimelineCanvas from './TimelineCanvas'
import UpcomingWordsBar from './UpcomingWordsBar'
import SyncControls from './SyncControls'
declare global {
interface Window {
getAudioDuration?: () => number
toggleAudioPlayback?: () => void
isAudioPlaying?: boolean
}
}
interface LyricsSynchronizerProps {
segments: LyricsSegment[]
currentTime: number
onPlaySegment?: (startTime: number) => void
onSave: (segments: LyricsSegment[]) => void
onCancel: () => void
setModalSpacebarHandler: (handler: ((e: KeyboardEvent) => void) | undefined) => void
}
// Constants for zoom
const MIN_ZOOM_SECONDS = 2
const MAX_ZOOM_SECONDS = 24
const ZOOM_STEPS = 50
// Get all words from segments
function getAllWords(segments: LyricsSegment[]): Word[] {
return segments.flatMap((s) => s.words)
}
// Deep clone segments
function cloneSegments(segments: LyricsSegment[]): LyricsSegment[] {
return JSON.parse(JSON.stringify(segments))
}
const LyricsSynchronizer = memo(function LyricsSynchronizer({
segments: initialSegments,
currentTime,
onPlaySegment,
onSave,
onCancel,
setModalSpacebarHandler,
}: LyricsSynchronizerProps) {
const isDarkMode = typeof window !== 'undefined' && window.matchMedia('(prefers-color-scheme: dark)').matches
const isMobile = typeof window !== 'undefined' && window.innerWidth < 640
// Working copy of segments
const [workingSegments, setWorkingSegments] = useState<LyricsSegment[]>(() =>
cloneSegments(initialSegments)
)
// Get all words flattened
const allWords = useMemo(() => getAllWords(workingSegments), [workingSegments])
// Audio duration
const audioDuration = useMemo(() => {
if (typeof window !== 'undefined' && typeof window.getAudioDuration === 'function') {
const duration = window.getAudioDuration()
return duration > 0 ? duration : 300
}
return 300 // 5 minute fallback
}, [])
// Zoom state
const [zoomSeconds, setZoomSeconds] = useState(12)
// Visible time range
const [visibleStartTime, setVisibleStartTime] = useState(0)
const visibleEndTime = useMemo(
() => Math.min(visibleStartTime + zoomSeconds, audioDuration),
[visibleStartTime, zoomSeconds, audioDuration]
)
// Manual sync state
const [isManualSyncing, setIsManualSyncing] = useState(false)
const [isPaused, setIsPaused] = useState(false)
const [syncWordIndex, setSyncWordIndex] = useState(-1)
const [isSpacebarPressed, setIsSpacebarPressed] = useState(false)
const wordStartTimeRef = useRef<number | null>(null)
const spacebarPressTimeRef = useRef<number | null>(null)
const currentTimeRef = useRef(currentTime)
// Selection state
const [selectedWordIds, setSelectedWordIds] = useState<Set<string>>(new Set())
// Edit lyrics modal state
const [showEditLyricsModal, setShowEditLyricsModal] = useState(false)
const [editLyricsText, setEditLyricsText] = useState('')
// Edit word modal state
const [showEditWordModal, setShowEditWordModal] = useState(false)
const [editWordText, setEditWordText] = useState('')
const [editWordId, setEditWordId] = useState<string | null>(null)
// Keep currentTimeRef up to date
useEffect(() => {
currentTimeRef.current = currentTime
}, [currentTime])
// Auto-scroll to follow playhead during sync
useEffect(() => {
if (isManualSyncing && !isPaused && currentTime > 0) {
if (currentTime > visibleEndTime - zoomSeconds * 0.1) {
const newStart = Math.max(0, currentTime - zoomSeconds * 0.1)
setVisibleStartTime(newStart)
} else if (currentTime < visibleStartTime) {
setVisibleStartTime(Math.max(0, currentTime - 1))
}
}
}, [currentTime, isManualSyncing, isPaused, visibleStartTime, visibleEndTime, zoomSeconds])
// Handle zoom slider change
const handleZoomChange = useCallback((value: number[]) => {
const zoomValue = value[0]
const newZoomSeconds =
MIN_ZOOM_SECONDS + (zoomValue / ZOOM_STEPS) * (MAX_ZOOM_SECONDS - MIN_ZOOM_SECONDS)
setZoomSeconds(newZoomSeconds)
}, [])
// Get slider value from zoom seconds
const sliderValue = useMemo(() => {
return ((zoomSeconds - MIN_ZOOM_SECONDS) / (MAX_ZOOM_SECONDS - MIN_ZOOM_SECONDS)) * ZOOM_STEPS
}, [zoomSeconds])
// Handle scroll change from timeline
const handleScrollChange = useCallback((newStartTime: number) => {
setVisibleStartTime(newStartTime)
}, [])
// Update words in segments
const updateWords = useCallback((newWords: Word[]) => {
setWorkingSegments((prevSegments) => {
const newSegments = cloneSegments(prevSegments)
const wordMap = new Map(newWords.map((w) => [w.id, w]))
for (const segment of newSegments) {
segment.words = segment.words.map((w) => wordMap.get(w.id) || w)
const timedWords = segment.words.filter(
(w) => w.start_time !== null && w.end_time !== null
)
if (timedWords.length > 0) {
segment.start_time = Math.min(...timedWords.map((w) => w.start_time!))
segment.end_time = Math.max(...timedWords.map((w) => w.end_time!))
} else {
segment.start_time = null
segment.end_time = null
}
}
return newSegments
})
}, [])
// Check if audio is playing
const [isPlaying, setIsPlaying] = useState(false)
useEffect(() => {
const checkPlaying = () => {
setIsPlaying(
typeof window !== 'undefined' && typeof window.isAudioPlaying === 'boolean'
? window.isAudioPlaying
: false
)
}
checkPlaying()
const interval = setInterval(checkPlaying, 100)
return () => clearInterval(interval)
}, [])
// Play audio from current position
const handlePlayAudio = useCallback(() => {
if (onPlaySegment) {
onPlaySegment(currentTimeRef.current)
}
}, [onPlaySegment])
// Stop audio playback
const handleStopAudio = useCallback(() => {
if (typeof window !== 'undefined' && typeof window.toggleAudioPlayback === 'function' && window.isAudioPlaying) {
window.toggleAudioPlayback()
}
if (isManualSyncing) {
setIsManualSyncing(false)
setIsPaused(false)
setIsSpacebarPressed(false)
}
}, [isManualSyncing])
// Start manual sync
const handleStartSync = useCallback(() => {
if (isManualSyncing) {
setIsManualSyncing(false)
setIsPaused(false)
setSyncWordIndex(-1)
setIsSpacebarPressed(false)
handleStopAudio()
return
}
const firstUnsyncedIndex = allWords.findIndex(
(w) => w.start_time === null || w.end_time === null
)
const startIndex = firstUnsyncedIndex !== -1 ? firstUnsyncedIndex : 0
setIsManualSyncing(true)
setIsPaused(false)
setSyncWordIndex(startIndex)
setIsSpacebarPressed(false)
if (onPlaySegment) {
onPlaySegment(Math.max(0, currentTimeRef.current - 1))
}
}, [isManualSyncing, allWords, onPlaySegment, handleStopAudio])
// Pause sync
const handlePauseSync = useCallback(() => {
setIsPaused(true)
handleStopAudio()
}, [handleStopAudio])
// Resume sync
const handleResumeSync = useCallback(() => {
setIsPaused(false)
const firstUnsyncedIndex = allWords.findIndex(
(w) => w.start_time === null || w.end_time === null
)
if (firstUnsyncedIndex !== -1 && firstUnsyncedIndex !== syncWordIndex) {
setSyncWordIndex(firstUnsyncedIndex)
}
if (onPlaySegment) {
onPlaySegment(currentTimeRef.current)
}
}, [allWords, syncWordIndex, onPlaySegment])
// Clear all sync data
const handleClearSync = useCallback(() => {
setWorkingSegments((prevSegments) => {
const newSegments = cloneSegments(prevSegments)
for (const segment of newSegments) {
for (const word of segment.words) {
word.start_time = null
word.end_time = null
}
segment.start_time = null
segment.end_time = null
}
return newSegments
})
setSyncWordIndex(-1)
}, [])
// Unsync from cursor position
const handleUnsyncFromCursor = useCallback(() => {
const cursorTime = currentTimeRef.current
setWorkingSegments((prevSegments) => {
const newSegments = cloneSegments(prevSegments)
for (const segment of newSegments) {
for (const word of segment.words) {
if (word.start_time !== null && word.start_time > cursorTime) {
word.start_time = null
word.end_time = null
}
}
const timedWords = segment.words.filter(
(w) => w.start_time !== null && w.end_time !== null
)
if (timedWords.length > 0) {
segment.start_time = Math.min(...timedWords.map((w) => w.start_time!))
segment.end_time = Math.max(...timedWords.map((w) => w.end_time!))
} else {
segment.start_time = null
segment.end_time = null
}
}
return newSegments
})
}, [])
// Check if there are words after cursor that can be unsynced
const canUnsyncFromCursor = useMemo(() => {
const cursorTime = currentTimeRef.current
return allWords.some((w) => w.start_time !== null && w.start_time > cursorTime)
}, [allWords, currentTime])
// Open edit lyrics modal
const handleEditLyrics = useCallback(() => {
const text = workingSegments.map((s) => s.text).join('\n')
setEditLyricsText(text)
setShowEditLyricsModal(true)
}, [workingSegments])
// Save edited lyrics
const handleSaveEditedLyrics = useCallback(() => {
const lines = editLyricsText.split('\n').filter((l) => l.trim())
const newSegments: LyricsSegment[] = lines.map((line, idx) => {
const words = line
.trim()
.split(/\s+/)
.map((text, wIdx) => ({
id: `word-${idx}-${wIdx}-${Date.now()}`,
text,
start_time: null,
end_time: null,
confidence: 1.0,
}))
return {
id: `segment-${idx}-${Date.now()}`,
text: line.trim(),
words,
start_time: null,
end_time: null,
}
})
setWorkingSegments(newSegments)
setShowEditLyricsModal(false)
setSyncWordIndex(-1)
}, [editLyricsText])
// Open edit word modal
const handleEditSelectedWord = useCallback(() => {
if (selectedWordIds.size !== 1) return
const wordId = Array.from(selectedWordIds)[0]
const word = allWords.find((w) => w.id === wordId)
if (word) {
setEditWordId(wordId)
setEditWordText(word.text)
setShowEditWordModal(true)
}
}, [selectedWordIds, allWords])
// Save edited word
const handleSaveEditedWord = useCallback(() => {
if (!editWordId) return
const newText = editWordText.trim()
if (!newText) return
const newWords = newText.split(/\s+/)
if (newWords.length === 1) {
const updatedWords = allWords.map((w) =>
w.id === editWordId ? { ...w, text: newWords[0] } : w
)
updateWords(updatedWords)
} else {
const originalWord = allWords.find((w) => w.id === editWordId)
if (!originalWord) return
setWorkingSegments((prevSegments) => {
const newSegments = cloneSegments(prevSegments)
for (const segment of newSegments) {
const wordIndex = segment.words.findIndex((w) => w.id === editWordId)
if (wordIndex !== -1) {
const newWordObjects = newWords.map((text, idx) => ({
id: idx === 0 ? editWordId : `${editWordId}-split-${idx}`,
text,
start_time: idx === 0 ? originalWord.start_time : null,
end_time: idx === 0 ? originalWord.end_time : null,
confidence: 1.0,
}))
segment.words.splice(wordIndex, 1, ...newWordObjects)
segment.text = segment.words.map((w) => w.text).join(' ')
break
}
}
return newSegments
})
}
setShowEditWordModal(false)
setEditWordId(null)
setEditWordText('')
setSelectedWordIds(new Set())
}, [editWordId, editWordText, allWords, updateWords])
// Delete selected words
const handleDeleteSelected = useCallback(() => {
if (selectedWordIds.size === 0) return
setWorkingSegments((prevSegments) => {
const newSegments = cloneSegments(prevSegments)
for (const segment of newSegments) {
segment.words = segment.words.filter((w) => !selectedWordIds.has(w.id))
segment.text = segment.words.map((w) => w.text).join(' ')
const timedWords = segment.words.filter(
(w) => w.start_time !== null && w.end_time !== null
)
if (timedWords.length > 0) {
segment.start_time = Math.min(...timedWords.map((w) => w.start_time!))
segment.end_time = Math.max(...timedWords.map((w) => w.end_time!))
} else {
segment.start_time = null
segment.end_time = null
}
}
return newSegments.filter((s) => s.words.length > 0)
})
setSelectedWordIds(new Set())
}, [selectedWordIds])
// Handle word click
const handleWordClick = useCallback((wordId: string, event: React.MouseEvent) => {
if (event.shiftKey || event.ctrlKey || event.metaKey) {
setSelectedWordIds((prev) => {
const newSet = new Set(prev)
if (newSet.has(wordId)) {
newSet.delete(wordId)
} else {
newSet.add(wordId)
}
return newSet
})
} else {
setSelectedWordIds(new Set([wordId]))
}
}, [])
// Handle background click
const handleBackgroundClick = useCallback(() => {
setSelectedWordIds(new Set())
}, [])
// Handle single word timing change
const handleWordTimingChange = useCallback(
(wordId: string, newStartTime: number, newEndTime: number) => {
setWorkingSegments((prevSegments) => {
const newSegments = cloneSegments(prevSegments)
for (const segment of newSegments) {
const word = segment.words.find((w) => w.id === wordId)
if (word) {
word.start_time = Math.max(0, newStartTime)
word.end_time = Math.max(word.start_time + 0.05, newEndTime)
const timedWords = segment.words.filter(
(w) => w.start_time !== null && w.end_time !== null
)
if (timedWords.length > 0) {
segment.start_time = Math.min(...timedWords.map((w) => w.start_time!))
segment.end_time = Math.max(...timedWords.map((w) => w.end_time!))
}
break
}
}
return newSegments
})
},
[]
)
// Handle moving multiple words
const handleWordsMove = useCallback(
(updates: Array<{ wordId: string; newStartTime: number; newEndTime: number }>) => {
setWorkingSegments((prevSegments) => {
const newSegments = cloneSegments(prevSegments)
const updateMap = new Map(updates.map((u) => [u.wordId, u]))
for (const segment of newSegments) {
for (const word of segment.words) {
const update = updateMap.get(word.id)
if (update) {
word.start_time = update.newStartTime
word.end_time = update.newEndTime
}
}
const timedWords = segment.words.filter(
(w) => w.start_time !== null && w.end_time !== null
)
if (timedWords.length > 0) {
segment.start_time = Math.min(...timedWords.map((w) => w.start_time!))
segment.end_time = Math.max(...timedWords.map((w) => w.end_time!))
}
}
return newSegments
})
},
[]
)
// Handle time bar click
const handleTimeBarClick = useCallback(
(time: number) => {
const newStart = Math.max(0, time - zoomSeconds / 2)
setVisibleStartTime(Math.min(newStart, Math.max(0, audioDuration - zoomSeconds)))
if (onPlaySegment) {
onPlaySegment(time)
setTimeout(() => {
if (typeof window !== 'undefined' && typeof window.toggleAudioPlayback === 'function' && window.isAudioPlaying) {
window.toggleAudioPlayback()
}
}, 50)
}
},
[zoomSeconds, audioDuration, onPlaySegment]
)
// Handle selection complete
const handleSelectionComplete = useCallback((wordIds: string[]) => {
setSelectedWordIds(new Set(wordIds))
}, [])
// Handle spacebar for manual sync
const handleKeyDown = useCallback(
(e: KeyboardEvent) => {
if (e.code !== 'Space') return
if (!isManualSyncing || isPaused) return
if (syncWordIndex < 0 || syncWordIndex >= allWords.length) return
e.preventDefault()
e.stopPropagation()
if (isSpacebarPressed) return
setIsSpacebarPressed(true)
wordStartTimeRef.current = currentTimeRef.current
spacebarPressTimeRef.current = Date.now()
const newWords = [...allWords]
const currentWord = newWords[syncWordIndex]
currentWord.start_time = currentTimeRef.current
if (syncWordIndex > 0) {
const prevWord = newWords[syncWordIndex - 1]
if (prevWord.start_time !== null && prevWord.end_time === null) {
const gap = currentTimeRef.current - prevWord.start_time
if (gap > 1.0) {
prevWord.end_time = prevWord.start_time + 0.5
} else {
prevWord.end_time = currentTimeRef.current - 0.005
}
}
}
updateWords(newWords)
},
[isManualSyncing, isPaused, syncWordIndex, allWords, isSpacebarPressed, updateWords]
)
const handleKeyUp = useCallback(
(e: KeyboardEvent) => {
if (e.code !== 'Space') return
if (!isManualSyncing || isPaused) return
if (!isSpacebarPressed) return
e.preventDefault()
e.stopPropagation()
setIsSpacebarPressed(false)
const pressDuration = spacebarPressTimeRef.current
? Date.now() - spacebarPressTimeRef.current
: 0
const isTap = pressDuration < 200
const newWords = [...allWords]
const currentWord = newWords[syncWordIndex]
if (isTap) {
currentWord.end_time = (wordStartTimeRef.current || currentTimeRef.current) + 0.5
} else {
currentWord.end_time = currentTimeRef.current
}
updateWords(newWords)
if (syncWordIndex < allWords.length - 1) {
setSyncWordIndex(syncWordIndex + 1)
} else {
setIsManualSyncing(false)
setSyncWordIndex(-1)
handleStopAudio()
}
wordStartTimeRef.current = null
spacebarPressTimeRef.current = null
},
[isManualSyncing, isPaused, isSpacebarPressed, syncWordIndex, allWords, updateWords, handleStopAudio]
)
// Combined spacebar handler
const handleSpacebar = useCallback(
(e: KeyboardEvent) => {
if (e.type === 'keydown') {
handleKeyDown(e)
} else if (e.type === 'keyup') {
handleKeyUp(e)
}
},
[handleKeyDown, handleKeyUp]
)
const spacebarHandlerRef = useRef(handleSpacebar)
spacebarHandlerRef.current = handleSpacebar
// Set up spacebar handler
useEffect(() => {
const handler = (e: KeyboardEvent) => {
if (e.code === 'Space') {
e.preventDefault()
e.stopPropagation()
spacebarHandlerRef.current(e)
}
}
setModalSpacebarHandler(handler)
return () => {
setModalSpacebarHandler(undefined)
}
}, [setModalSpacebarHandler])
// Tap handlers for mobile
const handleTapStart = useCallback(() => {
if (!isManualSyncing || isPaused) return
if (syncWordIndex < 0 || syncWordIndex >= allWords.length) return
if (isSpacebarPressed) return
setIsSpacebarPressed(true)
wordStartTimeRef.current = currentTimeRef.current
spacebarPressTimeRef.current = Date.now()
const newWords = [...allWords]
const currentWord = newWords[syncWordIndex]
currentWord.start_time = currentTimeRef.current
if (syncWordIndex > 0) {
const prevWord = newWords[syncWordIndex - 1]
if (prevWord.start_time !== null && prevWord.end_time === null) {
const gap = currentTimeRef.current - prevWord.start_time
if (gap > 1.0) {
prevWord.end_time = prevWord.start_time + 0.5
} else {
prevWord.end_time = currentTimeRef.current - 0.005
}
}
}
updateWords(newWords)
}, [isManualSyncing, isPaused, syncWordIndex, allWords, isSpacebarPressed, updateWords])
const handleTapEnd = useCallback(() => {
if (!isManualSyncing || isPaused) return
if (!isSpacebarPressed) return
setIsSpacebarPressed(false)
const pressDuration = spacebarPressTimeRef.current
? Date.now() - spacebarPressTimeRef.current
: 0
const isTap = pressDuration < 200
const newWords = [...allWords]
const currentWord = newWords[syncWordIndex]
if (isTap) {
currentWord.end_time = (wordStartTimeRef.current || currentTimeRef.current) + 0.5
} else {
currentWord.end_time = currentTimeRef.current
}
updateWords(newWords)
if (syncWordIndex < allWords.length - 1) {
setSyncWordIndex(syncWordIndex + 1)
} else {
setIsManualSyncing(false)
setSyncWordIndex(-1)
handleStopAudio()
}
wordStartTimeRef.current = null
spacebarPressTimeRef.current = null
}, [isManualSyncing, isPaused, isSpacebarPressed, syncWordIndex, allWords, updateWords, handleStopAudio])
// Handle save
const handleSave = useCallback(() => {
onSave(workingSegments)
}, [workingSegments, onSave])
// Progress stats
const stats = useMemo(() => {
const total = allWords.length
const synced = allWords.filter((w) => w.start_time !== null && w.end_time !== null).length
return { total, synced, remaining: total - synced }
}, [allWords])
// Get instruction text based on state
const getInstructionText = useCallback(() => {
if (isManualSyncing) {
if (isSpacebarPressed) {
return {
primary: '⏱️ Holding... release when word ends',
secondary: 'Release spacebar when the word finishes',
}
}
if (stats.remaining === 0) {
return {
primary: '✅ All words synced!',
secondary: 'Click "Stop Sync" then "Apply" to save',
}
}
return {
primary: '👆 Press SPACEBAR when you hear each word',
secondary: 'Tap for short words, hold for longer words',
}
}
if (stats.synced === 0) {
return {
primary: 'Click "Start Sync" to begin timing words',
secondary: "Audio will play and you'll tap spacebar for each word",
}
}
if (stats.remaining > 0) {
return {
primary: `${stats.remaining} words remaining to sync`,
secondary: 'Click "Start Sync" to continue, or "Unsync from Cursor" to re-sync from a point',
}
}
return {
primary: '✅ All words synced!',
secondary: 'Click "Apply" to save changes, or make adjustments first',
}
}, [isManualSyncing, isSpacebarPressed, stats.synced, stats.remaining])
const instruction = getInstructionText()
return (
<div className="flex flex-col h-full gap-2">
{/* Stats bar */}
<div className="flex justify-end items-center h-6">
<span className="text-sm text-muted-foreground">
{stats.synced} / {stats.total} words synced
{stats.remaining > 0 && ` (${stats.remaining} remaining)`}
</span>
</div>
{/* Instruction banner */}
<div className="h-14 flex-shrink-0">
<div
className={`p-3 h-full rounded flex flex-col justify-center ${
isManualSyncing ? 'bg-green-600 text-white' : 'bg-muted'
}`}
>
<p className="text-sm font-medium leading-tight">{instruction.primary}</p>
<p className="text-xs opacity-90 leading-tight">{instruction.secondary}</p>
</div>
</div>
{/* Controls section */}
<div className="min-h-[88px] flex-shrink-0">
<SyncControls
isManualSyncing={isManualSyncing}
isPaused={isPaused}
onStartSync={handleStartSync}
onPauseSync={handlePauseSync}
onResumeSync={handleResumeSync}
onClearSync={handleClearSync}
onEditLyrics={handleEditLyrics}
onPlay={handlePlayAudio}
onStop={handleStopAudio}
isPlaying={isPlaying}
hasSelectedWords={selectedWordIds.size > 0}
selectedWordCount={selectedWordIds.size}
onUnsyncFromCursor={handleUnsyncFromCursor}
onEditSelectedWord={handleEditSelectedWord}
onDeleteSelected={handleDeleteSelected}
canUnsyncFromCursor={canUnsyncFromCursor}
isMobile={isMobile}
onTapStart={handleTapStart}
onTapEnd={handleTapEnd}
isTapping={isSpacebarPressed}
/>
</div>
{/* Upcoming words bar */}
<div className="h-11 flex-shrink-0">
{isManualSyncing && (
<UpcomingWordsBar
words={allWords}
syncWordIndex={syncWordIndex}
isManualSyncing={isManualSyncing}
/>
)}
</div>
{/* Timeline canvas */}
<div className="flex-1 min-h-[200px]">
<TimelineCanvas
words={allWords}
segments={workingSegments}
visibleStartTime={visibleStartTime}
visibleEndTime={visibleEndTime}
currentTime={currentTime}
selectedWordIds={selectedWordIds}
onWordClick={handleWordClick}
onBackgroundClick={handleBackgroundClick}
onTimeBarClick={handleTimeBarClick}
onSelectionComplete={handleSelectionComplete}
onWordTimingChange={handleWordTimingChange}
onWordsMove={handleWordsMove}
syncWordIndex={syncWordIndex}
isManualSyncing={isManualSyncing}
onScrollChange={handleScrollChange}
audioDuration={audioDuration}
zoomSeconds={zoomSeconds}
height={200}
isDarkMode={isDarkMode}
/>
</div>
{/* Zoom slider */}
<div className="flex items-center gap-4 px-2">
<ZoomIn className="h-4 w-4 text-muted-foreground" />
<Slider
value={[sliderValue]}
onValueChange={handleZoomChange}
min={0}
max={ZOOM_STEPS}
step={1}
className="flex-1"
disabled={isManualSyncing && !isPaused}
/>
<ZoomOut className="h-4 w-4 text-muted-foreground" />
<span className="text-xs text-muted-foreground min-w-[60px]">
{zoomSeconds.toFixed(1)}s view
</span>
</div>
{/* Action buttons */}
<div className="flex justify-end gap-4 pt-4 border-t">
<Button variant="outline" onClick={onCancel}>
Cancel
</Button>
<Button onClick={handleSave} disabled={isManualSyncing && !isPaused}>
Apply
</Button>
</div>
{/* Edit Lyrics Modal */}
<Dialog open={showEditLyricsModal} onOpenChange={setShowEditLyricsModal}>
<DialogContent className="max-w-2xl">
<DialogHeader>
<DialogTitle>Edit Lyrics</DialogTitle>
</DialogHeader>
<Alert variant="destructive">
<AlertTriangle className="h-4 w-4" />
<AlertDescription>
Editing lyrics will reset all timing data. You will need to re-sync the entire song.
</AlertDescription>
</Alert>
<Textarea
value={editLyricsText}
onChange={(e) => setEditLyricsText(e.target.value)}
placeholder="Enter lyrics, one line per segment..."
rows={15}
className="font-mono"
/>
<DialogFooter>
<Button variant="outline" onClick={() => setShowEditLyricsModal(false)}>
Cancel
</Button>
<Button variant="destructive" onClick={handleSaveEditedLyrics}>
Save & Reset Timing
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
{/* Edit Word Modal */}
<Dialog open={showEditWordModal} onOpenChange={setShowEditWordModal}>
<DialogContent className="max-w-sm">
<DialogHeader>
<DialogTitle>Edit Word</DialogTitle>
</DialogHeader>
<p className="text-sm text-muted-foreground">
Edit the word text. Enter multiple words separated by spaces to split.
</p>
<Input
value={editWordText}
onChange={(e) => setEditWordText(e.target.value)}
autoFocus
onKeyDown={(e) => {
if (e.key === 'Enter') {
handleSaveEditedWord()
}
}}
/>
<DialogFooter>
<Button variant="outline" onClick={() => setShowEditWordModal(false)}>
Cancel
</Button>
<Button onClick={handleSaveEditedWord}>Save</Button>
</DialogFooter>
</DialogContent>
</Dialog>
</div>
)
})
export default LyricsSynchronizer
Loaded 100 of 798 files, more files were not shown because too many files have changed in this diff. Show more