fow-cli 0.1.0__tar.gz → 0.2.0__tar.gz

fow_cli-0.2.0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to Fly on the Wall are documented here.
+
+## [0.2.0] - 2026-06-09
+
+### Added
+
+- Added folder-level `--delete-originals-after-import` support for watched folders.
+- Added `fow watch folders delete-originals-after-import` to toggle original cleanup for existing watch folders.
+- Added a `py.typed` marker so editors and type checkers recognize the package as typed.
+- Added pragmatic `basedpyright` type checking for source files and documented the code quality policy.
+
+### Fixed
+
+- Avoided a tight retry loop when the watch backend fails, such as `Too many open files`.
+- Resolved source-level `basedpyright` warnings.
+
+## [0.1.0] - 2026-06-09
+
+### Added
+
+- Initial public release of the `fow` CLI as the `fow-cli` PyPI package.
+- Published GitHub repository and release artifacts.

{fow_cli-0.1.0 → fow_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fow-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: Personal CLI note-taker for turning meeting audio into cleaned meeting manuscripts.
 Project-URL: Repository, https://github.com/henriksvensson/fly-on-the-wall
 License-Expression: MIT
@@ -30,6 +30,10 @@ Description-Content-Type: text/markdown
 
 # Fly on the Wall
 
+[![PyPI](https://img.shields.io/pypi/v/fow-cli.svg)](https://pypi.org/project/fow-cli/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/fow-cli.svg)](https://pypi.org/project/fow-cli/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
 Fly on the Wall is a personal CLI note-taker for meeting audio.
 
 It takes local audio recordings, transcribes them, identifies recurring speakers where possible, cleans the transcript, analyzes the meeting, exports durable Markdown artifacts, and can publish readable notes into an Obsidian vault.
@@ -419,8 +423,11 @@ Run lint and formatting checks:
 ```bash
 uv run ruff check .
 uv run ruff format --check .
+uv run basedpyright
 ```
 
+`basedpyright` is configured as a pragmatic source-code guardrail. It checks explicit type claims in `src/` without requiring every dynamic SQLite, JSON, or third-party boundary to be fully typed.
+
 Build distribution artifacts:
 
 ```bash
@@ -430,7 +437,7 @@ uv build
 Test a built wheel locally:
 
 ```bash
-uv tool install dist/fly_on_the_wall-0.1.0-py3-none-any.whl
+uv tool install dist/fow_cli-0.1.0-py3-none-any.whl
 fow setup
 ```
 

{fow_cli-0.1.0 → fow_cli-0.2.0}/README.md

@@ -1,5 +1,9 @@
 # Fly on the Wall
 
+[![PyPI](https://img.shields.io/pypi/v/fow-cli.svg)](https://pypi.org/project/fow-cli/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/fow-cli.svg)](https://pypi.org/project/fow-cli/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
 Fly on the Wall is a personal CLI note-taker for meeting audio.
 
 It takes local audio recordings, transcribes them, identifies recurring speakers where possible, cleans the transcript, analyzes the meeting, exports durable Markdown artifacts, and can publish readable notes into an Obsidian vault.
@@ -389,8 +393,11 @@ Run lint and formatting checks:
 ```bash
 uv run ruff check .
 uv run ruff format --check .
+uv run basedpyright
 ```
 
+`basedpyright` is configured as a pragmatic source-code guardrail. It checks explicit type claims in `src/` without requiring every dynamic SQLite, JSON, or third-party boundary to be fully typed.
+
 Build distribution artifacts:
 
 ```bash
@@ -400,7 +407,7 @@ uv build
 Test a built wheel locally:
 
 ```bash
-uv tool install dist/fly_on_the_wall-0.1.0-py3-none-any.whl
+uv tool install dist/fow_cli-0.1.0-py3-none-any.whl
 fow setup
 ```
 

{fow_cli-0.1.0 → fow_cli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fow-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "Personal CLI note-taker for turning meeting audio into cleaned meeting manuscripts."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -41,6 +41,7 @@ fow = "fly_on_the_wall.cli:app"
 
 [dependency-groups]
 dev = [
+    "basedpyright>=1.39.7",
     "pre-commit>=4.0.0",
     "pytest>=8.0.0",
     "ruff>=0.8.0",
@@ -58,6 +59,7 @@ ignore-vcs = true
 only-include = [
     "src/fly_on_the_wall",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "pyproject.toml",
 ]
@@ -74,3 +76,25 @@ select = ["E", "F", "I", "UP", "B"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-q"
+
+[tool.basedpyright]
+include = ["src"]
+exclude = ["tests"]
+reportAny = "none"
+reportExplicitAny = "none"
+reportUnknownVariableType = "none"
+reportUnknownMemberType = "none"
+reportUnknownArgumentType = "none"
+reportUnknownParameterType = "none"
+reportMissingParameterType = "none"
+reportMissingTypeArgument = "none"
+reportUnusedCallResult = "none"
+reportUnannotatedClassAttribute = "none"
+reportArgumentType = "error"
+reportAssignmentType = "error"
+reportReturnType = "error"
+reportOperatorIssue = "error"
+reportOptionalMemberAccess = "error"
+reportAttributeAccessIssue = "error"
+reportCallIssue = "error"
+reportImportCycles = "error"

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/__init__.py

@@ -1,3 +1,3 @@
 """Fly on the Wall CLI application."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

fow_cli-0.2.0/src/fly_on_the_wall/api_keys.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+API_KEY_ENV_VARS: dict[str, str] = {
+    "elevenlabs": "ELEVENLABS_API_KEY",
+    "openai": "OPENAI_API_KEY",
+}

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/audio_metadata.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
 from sqlite3 import Connection
+from typing import Any, cast
 
 from fly_on_the_wall.audio import AudioError, probe_metadata
 from fly_on_the_wall.storage import StoragePaths
@@ -103,9 +104,13 @@ def extract_and_store_audio_metadata(
         )
 
 
-def normalize_audio_metadata(raw_metadata: dict, audio_path: Path) -> NormalizedAudioMetadata:
+JsonObject = dict[str, Any]
+
+
+def normalize_audio_metadata(raw_metadata: JsonObject, audio_path: Path) -> NormalizedAudioMetadata:
     audio_stream = _first_audio_stream(raw_metadata)
-    format_data = raw_metadata.get("format") if isinstance(raw_metadata.get("format"), dict) else {}
+    raw_format = raw_metadata.get("format")
+    format_data: JsonObject = cast(JsonObject, raw_format) if isinstance(raw_format, dict) else {}
     format_tags = _normalized_tags(format_data.get("tags"))
     stream_tags = _normalized_tags(audio_stream.get("tags"))
     tags = {**stream_tags, **format_tags}
@@ -133,13 +138,13 @@ def normalize_audio_metadata(raw_metadata: dict, audio_path: Path) -> Normalized
     )
 
 
-def _first_audio_stream(raw_metadata: dict) -> dict:
+def _first_audio_stream(raw_metadata: JsonObject) -> JsonObject:
     streams = raw_metadata.get("streams")
     if not isinstance(streams, list):
         return {}
     for stream in streams:
         if isinstance(stream, dict) and stream.get("codec_type") == "audio":
-            return stream
+            return cast(JsonObject, stream)
     return {}
 
 
@@ -228,14 +233,22 @@ def _optional_str(value: object) -> str | None:
 
 
 def _optional_int(value: object) -> int | None:
+    if value is None:
+        return None
     try:
-        return int(value) if value is not None else None
+        if isinstance(value, int | float | str | bytes | bytearray):
+            return int(value)
+        return int(str(value))
     except (TypeError, ValueError):
         return None
 
 
 def _optional_float(value: object) -> float | None:
+    if value is None:
+        return None
     try:
-        return float(value) if value is not None else None
+        if isinstance(value, int | float | str | bytes | bytearray):
+            return float(value)
+        return float(str(value))
     except (TypeError, ValueError):
         return None

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/cli.py

@@ -93,13 +93,15 @@ def _version_callback(show_version: bool) -> None:
 
 @app.callback()
 def main(
-    version: bool = typer.Option(
-        False,
-        "--version",
-        callback=_version_callback,
-        is_eager=True,
-        help="Show the application version.",
-    ),
+    _version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            callback=_version_callback,
+            is_eager=True,
+            help="Show the application version.",
+        ),
+    ] = False,
 ) -> None:
     """Run Fly on the Wall commands."""
 

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/cli_menu.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import subprocess
 import threading
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -55,25 +56,11 @@ class InteractiveMenu:
         )
 
     def _bind_navigation_keys(self) -> None:
-        @self.key_bindings.add("up")
-        def _up(_event) -> None:
-            self._move(-1)
-
-        @self.key_bindings.add("down")
-        def _down(_event) -> None:
-            self._move(1)
-
-        @self.key_bindings.add("enter")
-        def _enter(_event) -> None:
-            if self._playback_is_running():
-                self._stop_playback()
-                return
-            self._finish(self.choices[self.selected_index])
-
-        @self.key_bindings.add("escape")
-        @self.key_bindings.add("c-c")
-        def _cancel(_event) -> None:
-            self._cancel()
+        self.key_bindings.add("up")(self._handle_up)
+        self.key_bindings.add("down")(self._handle_down)
+        self.key_bindings.add("enter")(self._handle_enter)
+        self.key_bindings.add("escape")(self._handle_cancel)
+        self.key_bindings.add("c-c")(self._handle_cancel)
 
     def _bind_shortcut_keys(self) -> None:
         bound_shortcuts: set[str] = set()
@@ -81,7 +68,28 @@ class InteractiveMenu:
             if choice.shortcut is None or choice.shortcut in bound_shortcuts:
                 continue
             bound_shortcuts.add(choice.shortcut)
-            self.key_bindings.add(choice.shortcut)(lambda _event, selected=choice: self._finish(selected))
+            self.key_bindings.add(choice.shortcut)(self._shortcut_handler(choice))
+
+    def _handle_up(self, _event: object) -> None:
+        self._move(-1)
+
+    def _handle_down(self, _event: object) -> None:
+        self._move(1)
+
+    def _handle_enter(self, _event: object) -> None:
+        if self._playback_is_running():
+            self._stop_playback()
+            return
+        self._finish(self.choices[self.selected_index])
+
+    def _handle_cancel(self, _event: object) -> None:
+        self._cancel()
+
+    def _shortcut_handler(self, choice: MenuChoice) -> Callable[[object], None]:
+        def handle_shortcut(_event: object) -> None:
+            self._finish(choice)
+
+        return handle_shortcut
 
     def _finish(self, choice: MenuChoice) -> None:
         if choice.playback_path is not None:

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/cli_watch.py

@@ -17,6 +17,7 @@ from fly_on_the_wall.watch import (
     list_watch_folders,
     remove_watch_folder,
     scan_watch_folders,
+    set_watch_folder_delete_originals_after_import,
     set_watch_folder_enabled,
 )
 
@@ -77,17 +78,26 @@ def watch_run(
 def watch_folders_add(
     path: Annotated[Path, typer.Argument(file_okay=False, dir_okay=True)],
     name: Annotated[str | None, typer.Option("--name", "-n", help="Optional folder name.")] = None,
+    delete_originals_after_import: Annotated[
+        bool,
+        typer.Option(
+            "--delete-originals-after-import",
+            help="Delete source audio files after this watch folder imports them successfully.",
+        ),
+    ] = False,
 ) -> None:
     """Add a folder to scan for audio files."""
     with database() as connection:
         try:
-            folder = add_watch_folder(connection, path, name)
+            folder = add_watch_folder(connection, path, name, delete_originals_after_import)
         except Exception as exc:
             console.print(str(exc))
             raise typer.Exit(code=1) from exc
     console.print(f"Added watch folder {folder.path}")
     if folder.name:
         console.print(f"Name: {folder.name}")
+    if folder.delete_originals_after_import:
+        console.print("Original audio files will be deleted after successful import.")
 
 
 @watch_folders_app.command("list")
@@ -102,12 +112,14 @@ def watch_folders_list() -> None:
     table.add_column("ID")
     table.add_column("Name")
     table.add_column("Enabled")
+    table.add_column("Delete Originals")
     table.add_column("Path")
     for folder in folders:
         table.add_row(
             folder.id,
             folder.name or "",
             "yes" if folder.enabled else "no",
+            "yes" if folder.delete_originals_after_import else "no",
             str(folder.path),
         )
     console.print(table)
@@ -136,6 +148,27 @@ def watch_folders_disable(identifier: str) -> None:
     _set_watch_folder_enabled_command(identifier, False)
 
 
+@watch_folders_app.command("delete-originals-after-import")
+def watch_folders_delete_originals_after_import(
+    identifier: str,
+    enabled: Annotated[
+        bool,
+        typer.Option(
+            "--enabled/--disabled",
+            help="Whether this folder deletes source audio files after successful import.",
+        ),
+    ],
+) -> None:
+    """Configure original audio deletion after import for a watched folder."""
+    with database() as connection:
+        folder = set_watch_folder_delete_originals_after_import(connection, identifier, enabled)
+    if folder is None:
+        console.print(f"Watch folder not found: {identifier}")
+        raise typer.Exit(code=1)
+    state = "enabled" if enabled else "disabled"
+    console.print(f"Delete originals after import {state} for {folder.path}")
+
+
 def _watch_run_once(config, stable_age_seconds: int, interval_seconds: int) -> None:
     existing_paths = _existing_watch_paths()
     if not existing_paths:
@@ -146,7 +179,9 @@ def _watch_run_once(config, stable_age_seconds: int, interval_seconds: int) -> N
 
     changes = _watch_for_changes(existing_paths, interval_seconds)
     if changes is None:
+        console.print("Watch backend unavailable. Running safety scan before retry delay.")
         _scan_watch_once(config, stable_age_seconds)
+        sleep(interval_seconds)
         return
 
     _print_watch_changes(changes)
@@ -192,11 +227,12 @@ def _scan_watch_once(config, stable_age_seconds: int) -> None:
             stable_age_seconds=stable_age_seconds,
             progress=lambda message: console.print(f"-> {message}"),
         )
-    console.print(
+    message = (
         f"Watch scan complete: {result.processed} processed, "
         f"{result.ignored} ignored, {result.skipped} skipped, "
         f"{result.failed} failed, {result.seen} seen."
     )
+    console.print(message)
 
 
 def _set_watch_folder_enabled_command(identifier: str, enabled: bool) -> None:

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/config.py

@@ -14,11 +14,6 @@ GLOSSARY_FILE_NAME = "glossary.yaml"
 ProviderName = Literal["elevenlabs", "openai"]
 CleanupMode = Literal["off", "deterministic", "light"]
 
-API_KEY_ENV_VARS: dict[str, str] = {
-    "elevenlabs": "ELEVENLABS_API_KEY",
-    "openai": "OPENAI_API_KEY",
-}
-
 
 class ConfigError(RuntimeError):
     """Raised when the application config cannot be loaded."""

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/db.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 
 import json
 import sqlite3
-from collections.abc import Iterator
+from collections.abc import Generator
 from contextlib import contextmanager
 from pathlib import Path
 
 from fly_on_the_wall.storage import ensure_storage_layout, storage_paths
 
-SCHEMA_VERSION = 16
+SCHEMA_VERSION = 17
 
 SCHEMA_STATEMENTS = (
     """
@@ -218,6 +218,7 @@ SCHEMA_STATEMENTS = (
         name TEXT UNIQUE,
         path TEXT NOT NULL UNIQUE,
         enabled INTEGER NOT NULL DEFAULT 1,
+        delete_originals_after_import INTEGER NOT NULL DEFAULT 0,
         created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
         updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
     )
@@ -424,6 +425,12 @@ def initialize_database(connection: sqlite3.Connection) -> None:
         _ensure_column(connection, "meetings", "title_source", "TEXT NOT NULL DEFAULT 'manual'")
         _ensure_column(connection, "meetings", "generated_title", "TEXT")
         _ensure_column(connection, "people", "is_user", "INTEGER NOT NULL DEFAULT 0")
+        _ensure_column(
+            connection,
+            "watch_folders",
+            "delete_originals_after_import",
+            "INTEGER NOT NULL DEFAULT 0",
+        )
         connection.execute(
             """
             CREATE UNIQUE INDEX IF NOT EXISTS idx_meetings_audio_sha256
@@ -499,7 +506,7 @@ def bootstrap_database(database_path: Path | None = None) -> Path:
 
 
 @contextmanager
-def database(database_path: Path | None = None) -> Iterator[sqlite3.Connection]:
+def database(database_path: Path | None = None) -> Generator[sqlite3.Connection]:
     connection = connect(database_path)
     try:
         initialize_database(connection)

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/embeddings.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import json
 import math
+from collections.abc import Iterable
 from dataclasses import dataclass
 from pathlib import Path
 from sqlite3 import Connection
-from typing import Protocol
+from typing import Protocol, runtime_checkable
 from uuid import uuid4
 
 from fly_on_the_wall.storage import StoragePaths, storage_paths
@@ -19,6 +20,11 @@ class EmbeddingBackend(Protocol):
     def embed(self, audio_path: Path) -> list[float]: ...
 
 
+@runtime_checkable
+class SupportsToList(Protocol):
+    def tolist(self) -> object: ...
+
+
 @dataclass(frozen=True)
 class CachedEmbedding:
     model_name: str
@@ -36,13 +42,28 @@ class PyannoteEmbeddingBackend:
             raise RuntimeError("pyannote.audio is required for local speaker embeddings.") from exc
 
         model = Model.from_pretrained(self.model_name)
+        if model is None:
+            raise RuntimeError(f"Could not load embedding model: {self.model_name}")
         self._inference = Inference(model, window="whole")
 
     def embed(self, audio_path: Path) -> list[float]:
-        embedding = self._inference(str(audio_path))
-        if hasattr(embedding, "tolist"):
-            return [float(value) for value in embedding.tolist()]
-        return [float(value) for value in embedding]
+        return _embedding_to_vector(self._inference(str(audio_path)))
+
+
+def _embedding_to_vector(embedding: object) -> list[float]:
+    values = embedding.tolist() if isinstance(embedding, SupportsToList) else embedding
+    if isinstance(values, str | bytes | bytearray) or not isinstance(values, Iterable):
+        raise RuntimeError("Embedding backend returned an unsupported shape.")
+    try:
+        return [_embedding_value_to_float(value) for value in values]
+    except (TypeError, ValueError) as exc:
+        raise RuntimeError("Embedding backend returned non-numeric values.") from exc
+
+
+def _embedding_value_to_float(value: object) -> float:
+    if not isinstance(value, int | float | str | bytes | bytearray):
+        raise TypeError(f"Unsupported embedding value: {type(value).__name__}")
+    return float(value)
 
 
 def cache_voice_sample_embedding(

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/processing.py

@@ -5,6 +5,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
 from sqlite3 import Connection
+from typing import Any
 
 from fly_on_the_wall.cache import read_cached_text, text_sha256, write_cached_text
 from fly_on_the_wall.cleanup import deterministic_cleanup
@@ -223,12 +224,8 @@ def _cleanup_transcript(context: RefreshContext, deterministic_transcript: str)
                 deterministic_transcript,
                 glossary_terms=glossary_terms,
                 meeting_context=context.description,
-                usage_callback=lambda response: record_openai_usage(
-                    context.connection,
-                    meeting_id=context.meeting.id,
-                    model=DEFAULT_CLEANUP_MODEL,
-                    service="cleanup",
-                    response=response,
+                usage_callback=lambda response: _record_openai_usage(
+                    context, DEFAULT_CLEANUP_MODEL, "cleanup", response
                 ),
             )
             write_cached_text(cleanup_cache_dir, cleanup_cache_key, cleaned_transcript)
@@ -278,12 +275,8 @@ def _suggest_and_apply_title(
                         analysis,
                         meeting_context=context.description,
                         options=OpenAIRequestOptions(
-                            usage_callback=lambda response: record_openai_usage(
-                                context.connection,
-                                meeting_id=context.meeting.id,
-                                model=DEFAULT_ANALYSIS_MODEL,
-                                service="title",
-                                response=response,
+                            usage_callback=lambda response: _record_openai_usage(
+                                context, DEFAULT_ANALYSIS_MODEL, "title", response
                             )
                         ),
                     ),
@@ -388,6 +381,16 @@ def _format_elapsed(seconds: float) -> str:
     return _format_duration(seconds)
 
 
+def _record_openai_usage(context: RefreshContext, model: str, service: str, response: dict[str, Any]) -> None:
+    record_openai_usage(
+        context.connection,
+        meeting_id=context.meeting.id,
+        model=model,
+        service=service,
+        response=response,
+    )
+
+
 def _analyze_transcript(
     context: RefreshContext,
     transcript: str,
@@ -409,12 +412,8 @@ def _analyze_transcript(
                     transcript,
                     meeting_context=context.description,
                     options=OpenAIRequestOptions(
-                        usage_callback=lambda response: record_openai_usage(
-                            context.connection,
-                            meeting_id=context.meeting.id,
-                            model=DEFAULT_ANALYSIS_MODEL,
-                            service="analysis",
-                            response=response,
+                        usage_callback=lambda response: _record_openai_usage(
+                            context, DEFAULT_ANALYSIS_MODEL, "analysis", response
                         )
                     ),
                 ),

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/providers/openai_analysis.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass, field
+from typing import Any
 
 import httpx
 
@@ -20,7 +21,7 @@ class OpenAIRequestOptions:
     model: str = DEFAULT_ANALYSIS_MODEL
     api_key: str | None = None
     client: httpx.Client | None = None
-    usage_callback: Callable[[dict], None] | None = None
+    usage_callback: Callable[[dict[str, Any]], None] | None = None
 
 
 @dataclass(frozen=True)
@@ -98,7 +99,7 @@ def _close_client(client: httpx.Client, close_client: bool) -> None:
         client.close()
 
 
-def _send_chat_completion(client: httpx.Client, api_key: str, request: ChatCompletionRequest) -> dict:
+def _send_chat_completion(client: httpx.Client, api_key: str, request: ChatCompletionRequest) -> dict[str, Any]:
     response = client.post(
         API_URL,
         headers={"Authorization": f"Bearer {api_key}"},
@@ -115,7 +116,7 @@ def _send_chat_completion(client: httpx.Client, api_key: str, request: ChatCompl
     return response.json()
 
 
-def _record_usage(options: OpenAIRequestOptions, response_json: dict) -> None:
+def _record_usage(options: OpenAIRequestOptions, response_json: dict[str, Any]) -> None:
     if options.usage_callback is not None:
         options.usage_callback(response_json)
 
@@ -180,7 +181,7 @@ Meeting context: {context}
 """.strip()
 
 
-def _extract_content(response: dict) -> str:
+def _extract_content(response: dict[str, Any]) -> str:
     try:
         content = response["choices"][0]["message"]["content"]
     except (KeyError, IndexError, TypeError) as exc:

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/providers/openai_cleanup.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
+from typing import Any
 
 import httpx
 
@@ -23,7 +24,7 @@ def cleanup_transcript(
     model: str = DEFAULT_MODEL,
     api_key: str | None = None,
     client: httpx.Client | None = None,
-    usage_callback: Callable[[dict], None] | None = None,
+    usage_callback: Callable[[dict[str, Any]], None] | None = None,
 ) -> str:
     resolved_api_key = api_key or get_api_key("openai")
     if not resolved_api_key:
@@ -83,7 +84,7 @@ Glossary terms: {glossary}
 """.strip()
 
 
-def _extract_content(response: dict) -> str:
+def _extract_content(response: dict[str, Any]) -> str:
     try:
         content = response["choices"][0]["message"]["content"]
     except (KeyError, IndexError, TypeError) as exc:

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/secrets.py

@@ -5,9 +5,9 @@ from dataclasses import dataclass
 from typing import Literal
 
 import keyring
-from keyring.errors import KeyringError
+from keyring.errors import KeyringError, PasswordDeleteError
 
-from fly_on_the_wall.config import API_KEY_ENV_VARS
+from fly_on_the_wall.api_keys import API_KEY_ENV_VARS
 
 KEYRING_SERVICE = "fly-on-the-wall"
 SecretSource = Literal["env", "keyring", "missing", "unknown"]
@@ -59,7 +59,7 @@ def remove_api_key(provider: str) -> None:
     normalized = _require_known_provider(provider)
     try:
         keyring.delete_password(KEYRING_SERVICE, normalized)
-    except keyring.errors.PasswordDeleteError:
+    except PasswordDeleteError:
         return
     except KeyringError as exc:
         raise SecretError(f"Could not remove {normalized} API key from OS keyring: {exc}") from exc

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/setup.py

@@ -183,7 +183,8 @@ def _print_watch_folders(console: Console, folders: list) -> None:
     console.print("Watched folders")
     for folder in folders:
         state = "enabled" if folder.enabled else "disabled"
-        console.print(f"- {folder.path} ({state})")
+        cleanup = ", deletes originals" if folder.delete_originals_after_import else ""
+        console.print(f"- {folder.path} ({state}{cleanup})")
 
 
 def _prompt_watch_folder(console: Console, connection) -> None:
@@ -191,7 +192,8 @@ def _prompt_watch_folder(console: Console, connection) -> None:
     if not path_text:
         return
     name = typer.prompt("Folder name", default="").strip() or None
-    folder = add_watch_folder(connection, Path(path_text), name)
+    delete_originals = typer.confirm("Delete original audio files after successful import?", default=False)
+    folder = add_watch_folder(connection, Path(path_text), name, delete_originals)
     console.print(f"Added watch folder: {folder.path}")
 
 

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/speaker_matching.py

@@ -4,6 +4,7 @@ import json
 from dataclasses import dataclass
 from pathlib import Path
 from sqlite3 import Connection
+from typing import TypedDict
 from uuid import uuid4
 
 from fly_on_the_wall.config import ConfidenceThresholds
@@ -19,6 +20,12 @@ class SpeakerMatch:
     margin: float | None
 
 
+class SpeakerScore(TypedDict):
+    person_id: str
+    voice_sample_id: str
+    score: float
+
+
 def match_local_speakers(
     connection: Connection,
     provider_run_id: str,
@@ -75,7 +82,7 @@ def match_local_speaker(
     return SpeakerMatch(local_speaker_id, person_id, status, best["score"], margin)
 
 
-def _score_people(connection: Connection, local_vector: list[float]) -> list[dict[str, float | str]]:
+def _score_people(connection: Connection, local_vector: list[float]) -> list[SpeakerScore]:
     rows = connection.execute(
         """
         SELECT person_id, id AS voice_sample_id, embedding_path
@@ -83,7 +90,7 @@ def _score_people(connection: Connection, local_vector: list[float]) -> list[dic
         WHERE embedding_path IS NOT NULL
         """
     ).fetchall()
-    best_by_person: dict[str, dict[str, float | str]] = {}
+    best_by_person: dict[str, SpeakerScore] = {}
     for row in rows:
         score = cosine_similarity(local_vector, read_embedding(Path(row["embedding_path"])))
         current = best_by_person.get(row["person_id"])

{fow_cli-0.1.0 → fow_cli-0.2.0}/src/fly_on_the_wall/watch.py

@@ -27,6 +27,7 @@ class WatchFolder:
     name: str | None
     path: Path
     enabled: bool
+    delete_originals_after_import: bool
 
 
 @dataclass(frozen=True)
@@ -45,6 +46,7 @@ class WatchFile:
     size_bytes: int
     mtime_ns: int
     mtime: float
+    delete_original_after_import: bool
 
 
 @dataclass(frozen=True)
@@ -66,18 +68,23 @@ class WatchScanContext:
     progress: ProgressFn | None
 
 
-def add_watch_folder(connection: Connection, path: Path, name: str | None = None) -> WatchFolder:
+def add_watch_folder(
+    connection: Connection,
+    path: Path,
+    name: str | None = None,
+    delete_originals_after_import: bool = False,
+) -> WatchFolder:
     resolved_path = _resolve_folder_path(path)
     folder_id = str(uuid4())
     with connection:
         connection.execute(
             """
-            INSERT INTO watch_folders(id, name, path, enabled)
-            VALUES (?, ?, ?, 1)
+            INSERT INTO watch_folders(id, name, path, enabled, delete_originals_after_import)
+            VALUES (?, ?, ?, 1, ?)
             """,
-            (folder_id, name, str(resolved_path)),
+            (folder_id, name, str(resolved_path), 1 if delete_originals_after_import else 0),
         )
-    return WatchFolder(folder_id, name, resolved_path, True)
+    return WatchFolder(folder_id, name, resolved_path, True, delete_originals_after_import)
 
 
 def list_watch_folders(connection: Connection) -> list[WatchFolder]:
@@ -85,7 +92,7 @@ def list_watch_folders(connection: Connection) -> list[WatchFolder]:
         _watch_folder_from_row(row)
         for row in connection.execute(
             """
-            SELECT id, name, path, enabled
+            SELECT id, name, path, enabled, delete_originals_after_import
             FROM watch_folders
             ORDER BY created_at, path
             """
@@ -98,7 +105,7 @@ def get_watch_folder(connection: Connection, identifier: str) -> WatchFolder | N
     resolved_identifier_path = str(Path(identifier).expanduser().resolve())
     row = connection.execute(
         """
-        SELECT id, name, path, enabled
+        SELECT id, name, path, enabled, delete_originals_after_import
         FROM watch_folders
         WHERE id = ? OR name = ? OR path = ? OR path = ?
         """,
@@ -129,7 +136,27 @@ def set_watch_folder_enabled(connection: Connection, identifier: str, enabled: b
             """,
             (1 if enabled else 0, folder.id),
         )
-    return WatchFolder(folder.id, folder.name, folder.path, enabled)
+    return WatchFolder(folder.id, folder.name, folder.path, enabled, folder.delete_originals_after_import)
+
+
+def set_watch_folder_delete_originals_after_import(
+    connection: Connection,
+    identifier: str,
+    delete_originals_after_import: bool,
+) -> WatchFolder | None:
+    folder = get_watch_folder(connection, identifier)
+    if folder is None:
+        return None
+    with connection:
+        connection.execute(
+            """
+            UPDATE watch_folders
+            SET delete_originals_after_import = ?, updated_at = CURRENT_TIMESTAMP
+            WHERE id = ?
+            """,
+            (1 if delete_originals_after_import else 0, folder.id),
+        )
+    return WatchFolder(folder.id, folder.name, folder.path, folder.enabled, delete_originals_after_import)
 
 
 def scan_watch_folders(
@@ -152,7 +179,7 @@ def scan_watch_folders(
 
         for audio_path in _audio_files(folder.path):
             seen += 1
-            result = _scan_audio_file(context, _watch_file(folder.id, audio_path))
+            result = _scan_audio_file(context, _watch_file(folder, audio_path))
             processed += result.processed
             ignored += result.ignored
             skipped += result.skipped
@@ -171,6 +198,7 @@ def _watch_folder_from_row(row) -> WatchFolder:
         name=row["name"],
         path=Path(row["path"]),
         enabled=bool(row["enabled"]),
+        delete_originals_after_import=bool(row["delete_originals_after_import"]),
     )
 
 
@@ -187,9 +215,11 @@ def _audio_files(folder: Path) -> Iterable[Path]:
         yield path
 
 
-def _watch_file(folder_id: str, path: Path) -> WatchFile:
+def _watch_file(folder: WatchFolder, path: Path) -> WatchFile:
     stat = path.stat()
-    return WatchFile(folder_id, path, stat.st_size, stat.st_mtime_ns, stat.st_mtime)
+    return WatchFile(
+        folder.id, path, stat.st_size, stat.st_mtime_ns, stat.st_mtime, folder.delete_originals_after_import
+    )
 
 
 def _scan_audio_file(
@@ -234,9 +264,25 @@ def _process_audio_file(
         return WatchFileResult(failed=1)
 
     _mark_item_done(context.connection, item.path, result.meeting.id)
+    if item.delete_original_after_import:
+        _delete_original_audio_file(item.path, result.meeting.imported_audio_path, context.progress)
     return WatchFileResult(processed=1)
 
 
+def _delete_original_audio_file(original_path: Path, imported_audio_path: Path, progress: ProgressFn | None) -> None:
+    if original_path.resolve() == imported_audio_path.resolve():
+        _report(progress, f"Keeping original because it is the imported audio file {original_path}")
+        return
+    try:
+        original_path.unlink()
+    except FileNotFoundError:
+        return
+    except OSError as exc:
+        _report(progress, f"Could not delete original audio file {original_path}: {exc}")
+        return
+    _report(progress, f"Deleted original audio file {original_path}")
+
+
 def _upsert_seen_item(connection: Connection, item: WatchFile) -> None:
     existing = _watch_item(connection, item.path)
     with connection: