meeting-noter 1.2.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

meeting_noter/output/searcher.py

@@ -0,0 +1,218 @@
+"""Search functionality for meeting transcripts."""
+
+from __future__ import annotations
+
+import re
+import click
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class SearchMatch:
+    """A single match within a transcript file."""
+
+    line_number: int
+    line: str
+    timestamp: Optional[str] = None
+
+
+@dataclass
+class FileSearchResult:
+    """Search results for a single transcript file."""
+
+    filepath: Path
+    matches: list[SearchMatch]
+
+    @property
+    def match_count(self) -> int:
+        return len(self.matches)
+
+
+def _extract_timestamp(line: str) -> Optional[str]:
+    """Extract timestamp from line if present (e.g., [05:32] or [01:23:45])."""
+    match = re.match(r"^\[(\d{1,2}:\d{2}(?::\d{2})?)\]", line.strip())
+    if match:
+        return match.group(1)
+    return None
+
+
+def _truncate_line(line: str, max_length: int = 80) -> str:
+    """Truncate line to max length with ellipsis."""
+    line = line.strip()
+    if len(line) <= max_length:
+        return line
+    return line[: max_length - 3] + "..."
+
+
+def _highlight_match(line: str, query: str, case_sensitive: bool) -> str:
+    """Highlight matching text in the line."""
+    if case_sensitive:
+        pattern = re.escape(query)
+    else:
+        pattern = re.compile(re.escape(query), re.IGNORECASE)
+
+    def replace_with_highlight(match):
+        return click.style(match.group(0), bold=True, fg="yellow")
+
+    if case_sensitive:
+        return re.sub(pattern, replace_with_highlight, line)
+    else:
+        return pattern.sub(replace_with_highlight, line)
+
+
+def _search_file(
+    filepath: Path,
+    query: str,
+    case_sensitive: bool,
+    context_lines: int = 1,
+) -> Optional[FileSearchResult]:
+    """Search a single file for the query.
+
+    Returns FileSearchResult if matches found, None otherwise.
+    """
+    try:
+        content = filepath.read_text(encoding="utf-8", errors="ignore")
+    except Exception:
+        return None
+
+    lines = content.splitlines()
+    matches: list[SearchMatch] = []
+
+    search_query = query if case_sensitive else query.lower()
+
+    for i, line in enumerate(lines):
+        search_line = line if case_sensitive else line.lower()
+
+        if search_query in search_line:
+            timestamp = _extract_timestamp(line)
+            matches.append(
+                SearchMatch(
+                    line_number=i + 1,
+                    line=line,
+                    timestamp=timestamp,
+                )
+            )
+
+    if matches:
+        return FileSearchResult(filepath=filepath, matches=matches)
+    return None
+
+
+def search_transcripts(
+    transcripts_dir: Path,
+    query: str,
+    case_sensitive: bool = False,
+    limit: int = 20,
+    context_lines: int = 1,
+) -> None:
+    """Search across all meeting transcripts.
+
+    Args:
+        transcripts_dir: Directory containing transcript files
+        query: Search query string
+        case_sensitive: Whether to perform case-sensitive search
+        limit: Maximum number of matches to display
+        context_lines: Number of context lines around matches (not yet implemented)
+    """
+    if not query.strip():
+        click.echo(click.style("Error: Search query cannot be empty.", fg="red"))
+        return
+
+    if not transcripts_dir.exists():
+        click.echo(click.style(f"Directory not found: {transcripts_dir}", fg="red"))
+        return
+
+    # Find all transcript files
+    txt_files = sorted(
+        transcripts_dir.glob("*.txt"),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+
+    if not txt_files:
+        click.echo(click.style("No transcripts found.", fg="yellow"))
+        click.echo(f"\nTranscripts directory: {transcripts_dir}")
+        click.echo("Record and transcribe meetings to search them.")
+        return
+
+    # Search all files
+    results: list[FileSearchResult] = []
+    for txt_file in txt_files:
+        result = _search_file(txt_file, query, case_sensitive, context_lines)
+        if result:
+            results.append(result)
+
+    if not results:
+        click.echo(click.style(f'No results found for "{query}"', fg="yellow"))
+        click.echo(f"\nSearched {len(txt_files)} transcripts in {transcripts_dir}")
+        if not case_sensitive:
+            click.echo("Tip: Use --case-sensitive for exact matching.")
+        return
+
+    # Sort by match count (most matches first)
+    results.sort(key=lambda r: r.match_count, reverse=True)
+
+    # Count total matches
+    total_matches = sum(r.match_count for r in results)
+    total_files = len(results)
+
+    # Display header
+    click.echo()
+    matches_word = "match" if total_matches == 1 else "matches"
+    files_word = "transcript" if total_files == 1 else "transcripts"
+    click.echo(
+        click.style(
+            f"Found {total_matches} {matches_word} in {total_files} {files_word}:",
+            bold=True,
+        )
+    )
+    click.echo()
+
+    # Display results
+    matches_shown = 0
+    limit_reached = False
+    for result in results:
+        if matches_shown >= limit:
+            limit_reached = True
+            break
+
+        # File header
+        match_word = "match" if result.match_count == 1 else "matches"
+        click.echo(
+            click.style(f"{result.filepath.name}", fg="green", bold=True)
+            + f" ({result.match_count} {match_word})"
+        )
+
+        # Show matches (limited)
+        for match in result.matches:
+            if matches_shown >= limit:
+                limit_reached = True
+                break
+
+            # Format the line
+            prefix = f"  [{match.timestamp}] " if match.timestamp else "  "
+            line_text = match.line
+            if match.timestamp:
+                # Remove timestamp from line since we're showing it in prefix
+                line_text = re.sub(r"^\[\d{1,2}:\d{2}(?::\d{2})?\]\s*", "", line_text)
+
+            truncated = _truncate_line(line_text, 70)
+            highlighted = _highlight_match(truncated, query, case_sensitive)
+
+            click.echo(f"{prefix}...{highlighted}...")
+            matches_shown += 1
+
+        click.echo()
+
+    # Show remaining count if limit was reached
+    if limit_reached and matches_shown < total_matches:
+        remaining = total_matches - matches_shown
+        click.echo(
+            click.style(f"... and {remaining} more matches", fg="cyan")
+        )
+        click.echo()
+
+    # Footer
+    click.echo(f"Searched {len(txt_files)} transcripts in {transcripts_dir}")

meeting_noter/transcription/live_transcription.py

@@ -4,7 +4,7 @@ Buffers audio chunks and transcribes them in a background thread,
 writing segments to a .live.txt file that can be tailed by the CLI.
 
 Uses overlapping windows for lower latency: keeps a 5-second context window
-but transcribes every 2 seconds, only outputting new content.
+but transcribes every 1 second, only outputting new content.
 """
 
 from __future__ import annotations
@@ -24,7 +24,7 @@ class LiveTranscriber:
 
     Uses overlapping windows approach:
     - Maintains a rolling window of audio (default 5 seconds)
-    - Transcribes every `slide_seconds` (default 2 seconds)
+    - Transcribes every `slide_seconds` (default 1 second)
     - Only outputs new segments to avoid duplicates
     """
 
@@ -34,7 +34,7 @@ class LiveTranscriber:
         sample_rate: int = 48000,
         channels: int = 2,
         window_seconds: float = 5.0,
-        slide_seconds: float = 2.0,
+        slide_seconds: float = 1.0,
         model_size: str = "tiny.en",
     ):
         """Initialize the live transcriber.
@@ -115,15 +115,20 @@ class LiveTranscriber:
             except ImportError:
                 pass
 
-            if bundled_path and self.model_size == "tiny.en":
+            # Try GPU acceleration first, fall back to CPU if not supported
+            model_path = str(bundled_path) if (bundled_path and self.model_size == "tiny.en") else self.model_size
+
+            try:
+                # Try GPU with float16 first
                 self._model = WhisperModel(
-                    str(bundled_path),
-                    device="cpu",
-                    compute_type="int8",
+                    model_path,
+                    device="cuda",
+                    compute_type="float16",
                 )
-            else:
+            except Exception:
+                # Fall back to CPU with int8 (fastest CPU option)
                 self._model = WhisperModel(
-                    self.model_size,
+                    model_path,
                     device="cpu",
                     compute_type="int8",
                 )
@@ -150,11 +155,10 @@ class LiveTranscriber:
             try:
                 # Collect audio chunks
                 try:
-                    chunk = self._audio_queue.get(timeout=0.5)
+                    chunk = self._audio_queue.get(timeout=0.1)
 
-                    # Add samples to rolling buffer
-                    for sample in chunk:
-                        rolling_buffer.append(sample)
+                    # Add samples to rolling buffer (batch extend is faster than per-sample append)
+                    rolling_buffer.extend(chunk)
 
                     samples_since_last_transcribe += len(chunk)
                     self._recording_offset += len(chunk) / self.sample_rate

meeting_noter/ui/__init__.py

@@ -0,0 +1,5 @@
+"""Terminal User Interface for Meeting Noter."""
+
+from meeting_noter.ui.app import MeetingNoterApp
+
+__all__ = ["MeetingNoterApp"]

meeting_noter/ui/app.py

@@ -0,0 +1,68 @@
+"""Main Textual application for Meeting Noter."""
+
+from __future__ import annotations
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.widgets import Footer, Header
+
+from meeting_noter.ui.screens.main import MainScreen
+from meeting_noter.ui.screens.recordings import RecordingsScreen
+from meeting_noter.ui.screens.search import SearchScreen
+from meeting_noter.ui.screens.settings import SettingsScreen
+from meeting_noter.ui.screens.logs import LogsScreen
+
+
+class MeetingNoterApp(App):
+    """Meeting Noter Terminal UI Application."""
+
+    TITLE = "Meeting Noter"
+    CSS_PATH = "styles/app.tcss"
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("question_mark", "help", "Help", key_display="?"),
+        Binding("1", "switch_screen('main')", "Dashboard", show=True),
+        Binding("2", "switch_screen('recordings')", "Recordings", show=True),
+        Binding("3", "switch_screen('search')", "Search", show=True),
+        Binding("4", "switch_screen('settings')", "Settings", show=True),
+        Binding("5", "switch_screen('logs')", "Logs", show=True),
+        Binding("escape", "go_back", "Back", show=False),
+    ]
+
+    SCREENS = {
+        "main": MainScreen,
+        "recordings": RecordingsScreen,
+        "search": SearchScreen,
+        "settings": SettingsScreen,
+        "logs": LogsScreen,
+    }
+
+    def compose(self) -> ComposeResult:
+        """Compose the app layout."""
+        yield Header()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Handle app mount - show the main screen."""
+        self.push_screen("main")
+
+    def action_switch_screen(self, screen_name: str) -> None:
+        """Switch to a named screen."""
+        # Pop all screens except the base and push the new one
+        while len(self.screen_stack) > 1:
+            self.pop_screen()
+        self.push_screen(screen_name)
+
+    def action_go_back(self) -> None:
+        """Go back to the previous screen."""
+        if len(self.screen_stack) > 1:
+            self.pop_screen()
+
+    def action_help(self) -> None:
+        """Show help information."""
+        self.notify(
+            "Keys: 1-5 switch screens, q quit, ? help",
+            title="Meeting Noter Help",
+            timeout=5,
+        )

meeting_noter/ui/screens/__init__.py

@@ -0,0 +1,17 @@
+"""UI Screens for Meeting Noter."""
+
+from meeting_noter.ui.screens.main import MainScreen
+from meeting_noter.ui.screens.recordings import RecordingsScreen
+from meeting_noter.ui.screens.search import SearchScreen
+from meeting_noter.ui.screens.viewer import ViewerScreen
+from meeting_noter.ui.screens.settings import SettingsScreen
+from meeting_noter.ui.screens.logs import LogsScreen
+
+__all__ = [
+    "MainScreen",
+    "RecordingsScreen",
+    "SearchScreen",
+    "ViewerScreen",
+    "SettingsScreen",
+    "LogsScreen",
+]

meeting_noter/ui/screens/logs.py

@@ -0,0 +1,166 @@
+"""Logs viewer screen for Meeting Noter."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.screen import Screen
+from textual.widgets import Button, Label, RichLog, Static, Switch
+
+
+LOG_FILE = Path.home() / ".meeting-noter.log"
+
+
+class LogsScreen(Screen):
+    """Logs viewer screen."""
+
+    BINDINGS = [
+        ("l", "toggle_follow", "Follow"),
+        ("c", "clear_display", "Clear"),
+        ("r", "refresh", "Refresh"),
+        ("escape", "go_back", "Back"),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._follow_mode = True
+        self._last_size = 0
+
+    def compose(self) -> ComposeResult:
+        """Compose the logs screen layout."""
+        yield Container(
+            Static("[bold]Logs[/bold]", classes="title"),
+            Label(f"[dim]{LOG_FILE}[/dim]", id="log-path"),
+            Static("", classes="spacer"),
+            RichLog(id="log-content", highlight=True, markup=True),
+            Static("", classes="spacer"),
+            Horizontal(
+                Label("Follow: "),
+                Switch(value=True, id="follow-switch"),
+                Button("Refresh", id="refresh-btn"),
+                Button("Clear", id="clear-btn"),
+                Button("Back", id="back-btn"),
+                classes="button-row",
+            ),
+            id="logs-container",
+        )
+
+    def on_mount(self) -> None:
+        """Start log refresh on mount."""
+        self._load_logs()
+        self.set_interval(1.0, self._check_for_updates)
+
+    def _load_logs(self, lines: int = 100) -> None:
+        """Load the last N lines from the log file."""
+        log_content = self.query_one("#log-content", RichLog)
+
+        if not LOG_FILE.exists():
+            log_content.write("[yellow]No log file found[/yellow]")
+            return
+
+        try:
+            content = LOG_FILE.read_text()
+            all_lines = content.splitlines()
+            recent_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
+
+            log_content.clear()
+            for line in recent_lines:
+                # Color-code different log levels
+                if "Error" in line or "error" in line:
+                    log_content.write(f"[red]{line}[/red]")
+                elif "Warning" in line or "warning" in line:
+                    log_content.write(f"[yellow]{line}[/yellow]")
+                elif "Recording started" in line:
+                    log_content.write(f"[green]{line}[/green]")
+                elif "Recording saved" in line:
+                    log_content.write(f"[cyan]{line}[/cyan]")
+                else:
+                    log_content.write(line)
+
+            self._last_size = LOG_FILE.stat().st_size
+
+        except Exception as e:
+            log_content.write(f"[red]Error reading log: {e}[/red]")
+
+    def _check_for_updates(self) -> None:
+        """Check for new log content if in follow mode."""
+        if not self._follow_mode:
+            return
+
+        follow_switch = self.query_one("#follow-switch", Switch)
+        self._follow_mode = follow_switch.value
+
+        if not self._follow_mode:
+            return
+
+        if not LOG_FILE.exists():
+            return
+
+        try:
+            current_size = LOG_FILE.stat().st_size
+            if current_size > self._last_size:
+                # Read new content
+                with open(LOG_FILE, "r") as f:
+                    f.seek(self._last_size)
+                    new_content = f.read()
+
+                log_content = self.query_one("#log-content", RichLog)
+                for line in new_content.splitlines():
+                    if line.strip():
+                        if "Error" in line or "error" in line:
+                            log_content.write(f"[red]{line}[/red]")
+                        elif "Warning" in line or "warning" in line:
+                            log_content.write(f"[yellow]{line}[/yellow]")
+                        elif "Recording started" in line:
+                            log_content.write(f"[green]{line}[/green]")
+                        elif "Recording saved" in line:
+                            log_content.write(f"[cyan]{line}[/cyan]")
+                        else:
+                            log_content.write(line)
+
+                self._last_size = current_size
+
+        except Exception:
+            pass
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        button_id = event.button.id
+
+        if button_id == "refresh-btn":
+            self.action_refresh()
+        elif button_id == "clear-btn":
+            self.action_clear_display()
+        elif button_id == "back-btn":
+            self.action_go_back()
+
+    def on_switch_changed(self, event: Switch.Changed) -> None:
+        """Handle follow switch changes."""
+        if event.switch.id == "follow-switch":
+            self._follow_mode = event.value
+            if event.value:
+                self.notify("Follow mode enabled")
+            else:
+                self.notify("Follow mode disabled")
+
+    def action_toggle_follow(self) -> None:
+        """Toggle follow mode."""
+        switch = self.query_one("#follow-switch", Switch)
+        switch.value = not switch.value
+
+    def action_clear_display(self) -> None:
+        """Clear the log display."""
+        log_content = self.query_one("#log-content", RichLog)
+        log_content.clear()
+        self.notify("Display cleared")
+
+    def action_refresh(self) -> None:
+        """Refresh the log display."""
+        self._load_logs()
+        self.notify("Refreshed")
+
+    def action_go_back(self) -> None:
+        """Go back to the previous screen."""
+        self.app.pop_screen()