whisper-memo 0.1.0__tar.gz

whisper_memo-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv run --group dev ruff check
+      - run: uv run --group dev ruff format --check
+
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python: ["3.11", "3.13"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python }}
+      - run: uv run --group dev pytest
+      - run: uv run whisper-memo --version

whisper_memo-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,26 @@
+name: Release
+
+# Push a tag like v0.1.0 to build and publish to PyPI.
+# One-time setup: on pypi.org, add a "trusted publisher" for this repo,
+# workflow release.yml, environment pypi. No API token is needed.
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # trusted publishing
+      contents: write # create the GitHub release
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Check tag matches package version
+        run: test "v$(uv version --short)" = "$GITHUB_REF_NAME"
+      - run: uv build
+      - run: uv publish --trusted-publishing always
+      - run: gh release create "$GITHUB_REF_NAME" dist/* --generate-notes
+        env:
+          GH_TOKEN: ${{ github.token }}

whisper_memo-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# asciinema recordings (docs/demo.gif is generated from these)
+*.cast

whisper_memo-0.1.0/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project are documented here.
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and the project uses [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-11-14
+
+### Added
+
+- `whisper-memo` command: press Enter to record, Enter to stop; the transcript is printed and copied to the clipboard.
+- Live recording display with a timer and a mic-level waveform.
+- Say "new line" while recording to turn the transcript into bullet points.
+- `--model`, `--device`, `--language` and `--no-clipboard` options.
+- Optional `cuda` extra that installs the NVIDIA libraries for GPU transcription.

whisper_memo-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 adamhp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

whisper_memo-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.5
+Name: whisper-memo
+Version: 0.1.0
+Summary: Record voice memos in your terminal and transcribe them locally with Whisper.
+Project-URL: Homepage, https://github.com/adamhp/whisper-memo
+Project-URL: Issues, https://github.com/adamhp/whisper-memo/issues
+Project-URL: Changelog, https://github.com/adamhp/whisper-memo/blob/main/CHANGELOG.md
+Author: adamhp
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,offline,speech-to-text,transcription,voice-memo,whisper
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.11
+Requires-Dist: av<16
+Requires-Dist: faster-whisper>=1.2.1
+Requires-Dist: numpy>=1.24
+Requires-Dist: pyperclip>=1.9
+Requires-Dist: rich>=13
+Requires-Dist: sounddevice>=0.5
+Provides-Extra: cuda
+Requires-Dist: nvidia-cublas-cu12<12.9; (sys_platform != 'darwin') and extra == 'cuda'
+Requires-Dist: nvidia-cudnn-cu12<10,>=9; (sys_platform != 'darwin') and extra == 'cuda'
+Description-Content-Type: text/markdown
+
+# whisper-memo
+
+Record a voice memo in your terminal, get the transcript on your clipboard.
+Transcription runs entirely on your machine with [faster-whisper](https://github.com/SYSTRAN/faster-whisper).
+No account, no API key, no audio leaves your computer.
+
+![whisper-memo recording and transcribing a memo](https://raw.githubusercontent.com/adamhp/whisper-memo/main/docs/demo.gif)
+
+## Why
+
+I built this project as a simple way to capture changes I wanted to make during quality review checks on my Claude development.
+While reviewing changes, I activate whisper-memo and just talk, then paste that into Claude.
+There are many solutions to this problem, but I had some specific needs, so I built this small tool.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/) (recommended) or [pipx](https://pipx.pypa.io/):
+
+```sh
+uv tool install whisper-memo          # CPU, works everywhere
+uv tool install 'whisper-memo[cuda]'  # NVIDIA GPU on Linux or Windows
+```
+
+Replace `uv tool install` with `pipx install` if you use pipx.
+
+The first run downloads the Whisper model from Hugging Face (about 1.6 GB for the default `large-v3-turbo`).
+After that, everything works offline.
+
+### Platform notes
+
+- **Linux:** install PortAudio for the microphone (`sudo apt install libportaudio2`)
+  and a clipboard tool (`xclip`, `xsel` or `wl-clipboard`).
+- **macOS:** the terminal asks for microphone permission the first time. Transcription runs on the CPU;
+  pick a smaller model (`-m small`) if it feels slow.
+- **Windows:** works out of the box. Add `[cuda]` for an NVIDIA GPU.
+- **WSL:** microphone access depends on WSLg audio support and may not work.
+
+## Usage
+
+```sh
+whisper-memo                  # default model, English
+whisper-memo -m small         # smaller, faster model
+whisper-memo -l auto          # detect the spoken language
+whisper-memo -d cpu           # force CPU even if a GPU is present
+whisper-memo --no-clipboard   # print only
+```
+
+Press **Enter** to start recording and **Enter** again to stop. **Ctrl+C** quits.
+
+Say **"new line"** while recording to split the transcript into bullet points:
+
+> "Rename the fetch helper to load user, new line, add a test for the empty list case, new line, drop the unused import in the CLI module"
+
+```
+- Rename the fetch helper to load user
+- Add a test for the empty list case
+- Drop the unused import in the CLI module
+```
+
+| Option | Default | |
+| --- | --- | --- |
+| `-m`, `--model` | `large-v3-turbo` | Any [faster-whisper model](https://huggingface.co/Systran) name or a local path. Also read from `WHISPER_MODEL`. |
+| `-d`, `--device` | `auto` | `auto`, `cuda` or `cpu`. `auto` uses the GPU when one is available. |
+| `-l`, `--language` | `en` | Language code (`de`, `ja`, ...) or `auto`. |
+| `--no-clipboard` | off | Don't copy transcripts to the clipboard. |
+
+## Development
+
+```sh
+git clone https://github.com/adamhp/whisper-memo
+cd whisper-memo
+uv run whisper-memo                    # run from source
+uv run --group dev pytest              # tests
+uv run --group dev ruff check          # lint
+uv run --group dev ruff format         # format
+```
+
+### Releasing
+
+1. Bump `version` in `pyproject.toml` and move the `Unreleased` notes in `CHANGELOG.md` under the new version.
+2. Commit, then tag and push: `git tag v0.2.0 && git push origin v0.2.0`.
+3. The release workflow builds the package, publishes it to PyPI and creates a GitHub release.
+
+## License
+
+[MIT](LICENSE)

whisper_memo-0.1.0/README.md

@@ -0,0 +1,86 @@
+# whisper-memo
+
+Record a voice memo in your terminal, get the transcript on your clipboard.
+Transcription runs entirely on your machine with [faster-whisper](https://github.com/SYSTRAN/faster-whisper).
+No account, no API key, no audio leaves your computer.
+
+![whisper-memo recording and transcribing a memo](https://raw.githubusercontent.com/adamhp/whisper-memo/main/docs/demo.gif)
+
+## Why
+
+I built this project as a simple way to capture changes I wanted to make during quality review checks on my Claude development.
+While reviewing changes, I activate whisper-memo and just talk, then paste that into Claude.
+There are many solutions to this problem, but I had some specific needs, so I built this small tool.
+
+## Install
+
+With [uv](https://docs.astral.sh/uv/) (recommended) or [pipx](https://pipx.pypa.io/):
+
+```sh
+uv tool install whisper-memo          # CPU, works everywhere
+uv tool install 'whisper-memo[cuda]'  # NVIDIA GPU on Linux or Windows
+```
+
+Replace `uv tool install` with `pipx install` if you use pipx.
+
+The first run downloads the Whisper model from Hugging Face (about 1.6 GB for the default `large-v3-turbo`).
+After that, everything works offline.
+
+### Platform notes
+
+- **Linux:** install PortAudio for the microphone (`sudo apt install libportaudio2`)
+  and a clipboard tool (`xclip`, `xsel` or `wl-clipboard`).
+- **macOS:** the terminal asks for microphone permission the first time. Transcription runs on the CPU;
+  pick a smaller model (`-m small`) if it feels slow.
+- **Windows:** works out of the box. Add `[cuda]` for an NVIDIA GPU.
+- **WSL:** microphone access depends on WSLg audio support and may not work.
+
+## Usage
+
+```sh
+whisper-memo                  # default model, English
+whisper-memo -m small         # smaller, faster model
+whisper-memo -l auto          # detect the spoken language
+whisper-memo -d cpu           # force CPU even if a GPU is present
+whisper-memo --no-clipboard   # print only
+```
+
+Press **Enter** to start recording and **Enter** again to stop. **Ctrl+C** quits.
+
+Say **"new line"** while recording to split the transcript into bullet points:
+
+> "Rename the fetch helper to load user, new line, add a test for the empty list case, new line, drop the unused import in the CLI module"
+
+```
+- Rename the fetch helper to load user
+- Add a test for the empty list case
+- Drop the unused import in the CLI module
+```
+
+| Option | Default | |
+| --- | --- | --- |
+| `-m`, `--model` | `large-v3-turbo` | Any [faster-whisper model](https://huggingface.co/Systran) name or a local path. Also read from `WHISPER_MODEL`. |
+| `-d`, `--device` | `auto` | `auto`, `cuda` or `cpu`. `auto` uses the GPU when one is available. |
+| `-l`, `--language` | `en` | Language code (`de`, `ja`, ...) or `auto`. |
+| `--no-clipboard` | off | Don't copy transcripts to the clipboard. |
+
+## Development
+
+```sh
+git clone https://github.com/adamhp/whisper-memo
+cd whisper-memo
+uv run whisper-memo                    # run from source
+uv run --group dev pytest              # tests
+uv run --group dev ruff check          # lint
+uv run --group dev ruff format         # format
+```
+
+### Releasing
+
+1. Bump `version` in `pyproject.toml` and move the `Unreleased` notes in `CHANGELOG.md` under the new version.
+2. Commit, then tag and push: `git tag v0.2.0 && git push origin v0.2.0`.
+3. The release workflow builds the package, publishes it to PyPI and creates a GitHub release.
+
+## License
+
+[MIT](LICENSE)

whisper_memo-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "whisper-memo"
+version = "0.1.0"
+description = "Record voice memos in your terminal and transcribe them locally with Whisper."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "adamhp" }]
+requires-python = ">=3.11"
+keywords = ["whisper", "speech-to-text", "transcription", "voice-memo", "cli", "offline"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
+]
+dependencies = [
+    "av<16",
+    "faster-whisper>=1.2.1",
+    "numpy>=1.24",
+    "pyperclip>=1.9",
+    "rich>=13",
+    "sounddevice>=0.5",
+]
+
+[project.optional-dependencies]
+# GPU acceleration on Linux/Windows with an NVIDIA card. Large download; not needed for CPU.
+cuda = [
+    "nvidia-cublas-cu12<12.9; sys_platform != 'darwin'",
+    "nvidia-cudnn-cu12>=9,<10; sys_platform != 'darwin'",
+]
+
+[project.scripts]
+whisper-memo = "whisper_memo.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/adamhp/whisper-memo"
+Issues = "https://github.com/adamhp/whisper-memo/issues"
+Changelog = "https://github.com/adamhp/whisper-memo/blob/main/CHANGELOG.md"
+
+[dependency-groups]
+dev = ["pytest>=8", "ruff>=0.8"]
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

whisper_memo-0.1.0/src/whisper_memo/__init__.py

@@ -0,0 +1,5 @@
+"""Local voice memos transcribed with Whisper."""
+
+from importlib.metadata import version
+
+__version__ = version("whisper-memo")

whisper_memo-0.1.0/src/whisper_memo/__main__.py

@@ -0,0 +1,3 @@
+from whisper_memo.cli import main
+
+main()

whisper_memo-0.1.0/src/whisper_memo/cli.py

@@ -0,0 +1,237 @@
+"""Record voice memos from the default mic and transcribe them locally with faster-whisper.
+
+Enter starts recording, Enter stops it. The transcript is printed and copied to the clipboard.
+Ctrl+C quits.
+"""
+
+import argparse
+import os
+import re
+import sys
+import threading
+import time
+from collections import deque
+from pathlib import Path
+
+import numpy as np
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+
+from whisper_memo import __version__
+
+SAMPLE_RATE = 16000  # Whisper's native rate
+DEFAULT_MODEL = os.environ.get("WHISPER_MODEL", "large-v3-turbo")
+STYLE_PROMPT = "Hello, welcome to my voice memo. Here are my thoughts, written in complete sentences."
+
+console = Console()
+
+BARS = " ▁▂▃▄▅▆▇█"
+WAVE_WIDTH = 40
+
+
+def preload_cuda_libs() -> None:
+    """Make the cuBLAS/cuDNN libraries from the optional nvidia-* wheels visible to ctranslate2."""
+    import importlib.util
+
+    spec = importlib.util.find_spec("nvidia")
+    roots = [Path(r) for r in (spec.submodule_search_locations if spec else [])]
+    pkgs = ("cuda_nvrtc", "cublas", "cudnn")
+
+    if sys.platform == "win32":
+        # On Windows the wheels ship DLLs in nvidia/<pkg>/bin.
+        for dll_dir in (root / pkg / "bin" for root in roots for pkg in pkgs):
+            if dll_dir.is_dir():
+                os.add_dll_directory(str(dll_dir))
+                os.environ["PATH"] = str(dll_dir) + os.pathsep + os.environ["PATH"]
+    elif sys.platform.startswith("linux"):
+        # On Linux the wheels put .so files in nvidia/<pkg>/lib. LD_LIBRARY_PATH is read only at
+        # process start, so preload them globally; ctranslate2's later dlopen then finds them.
+        import ctypes
+
+        libs = [so for root in roots for pkg in pkgs for so in sorted((root / pkg / "lib").glob("lib*.so*"))]
+        # Retry passes resolve inter-library dependencies regardless of load order.
+        for _ in range(3):
+            failed = []
+            for so in libs:
+                try:
+                    ctypes.CDLL(str(so), mode=ctypes.RTLD_GLOBAL)
+                except OSError:
+                    failed.append(so)
+            if not failed or len(failed) == len(libs):
+                break
+            libs = failed
+
+
+def load_model(name: str, device: str):
+    preload_cuda_libs()
+    import ctranslate2
+    from faster_whisper import WhisperModel
+
+    if device == "auto":
+        device = "cuda" if ctranslate2.get_cuda_device_count() > 0 else "cpu"
+    if device == "cuda":
+        try:
+            return WhisperModel(name, device="cuda", compute_type="float16"), "cuda"
+        except Exception as e:
+            console.print(f"[yellow]CUDA unavailable ({e}); falling back to CPU.[/]")
+    return WhisperModel(name, device="cpu", compute_type="int8"), "cpu"
+
+
+def level_bar(rms: float) -> str:
+    """Map a chunk's RMS to a bar glyph on a log scale (-60 dB silent, -10 dB full)."""
+    db = 20 * np.log10(rms + 1e-9)
+    frac = min(max((db + 60) / 50, 0.0), 1.0)
+    return BARS[round(frac * (len(BARS) - 1))]
+
+
+class AudioError(RuntimeError):
+    """The microphone or the PortAudio library is unavailable."""
+
+
+def record() -> np.ndarray:
+    try:
+        import sounddevice as sd
+    except OSError as e:  # raised when the PortAudio shared library is missing
+        raise AudioError(e) from e
+
+    chunks = []
+    levels = deque(" " * WAVE_WIDTH, maxlen=WAVE_WIDTH)
+    stop = threading.Event()
+
+    def callback(indata, *_):
+        chunks.append(indata.copy())
+        levels.append(level_bar(float(np.sqrt(np.mean(indata**2)))))
+
+    def render() -> Text:
+        secs = int(sum(len(c) for c in chunks) / SAMPLE_RATE)
+        blink = int(time.monotonic() * 2) % 2 == 0
+        return Text.assemble(
+            ("● " if blink else "  ", "bold red"),
+            ("REC ", "bold red"),
+            (f"{secs // 60:02d}:{secs % 60:02d}  ", "bold"),
+            ("".join(levels), "cyan"),
+            ("  Enter to stop", "dim"),
+        )
+
+    try:
+        stream = sd.InputStream(samplerate=SAMPLE_RATE, channels=1, dtype="float32", callback=callback)
+    except sd.PortAudioError as e:
+        raise AudioError(e) from e
+    with stream:
+        threading.Thread(target=lambda: (input(), stop.set()), daemon=True).start()
+        with Live(get_renderable=render, console=console, refresh_per_second=15, transient=True):
+            stop.wait()
+
+    return np.concatenate(chunks).flatten() if chunks else np.zeros(0, dtype=np.float32)
+
+
+# Spoken "new line" (Whisper may render it "New line.", "new-line,", "newline" etc.).
+NEW_LINE = re.compile(r"\bnew[\s-]?line\b[\s.,!?;:]*", re.IGNORECASE)
+
+
+def format_bullets(text: str) -> str:
+    """If the speaker said "new line", turn the pieces between them into bullet points."""
+    if not NEW_LINE.search(text):
+        return text
+    items = (p.strip(" ,;:") for p in NEW_LINE.split(text))
+    return "\n".join(f"- {item[0].upper()}{item[1:]}" for item in items if item)
+
+
+def copy_to_clipboard(text: str) -> bool:
+    import pyperclip
+
+    try:
+        pyperclip.copy(text)
+        return True
+    except pyperclip.PyperclipException:
+        return False
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="whisper-memo",
+        description="Record voice memos and transcribe them locally with Whisper.",
+        epilog='Say "new line" while recording to split the transcript into bullet points.',
+    )
+    parser.add_argument(
+        "-m",
+        "--model",
+        default=DEFAULT_MODEL,
+        help="Whisper model name or local path (default: %(default)s; env: WHISPER_MODEL)",
+    )
+    parser.add_argument("-d", "--device", choices=("auto", "cuda", "cpu"), default="auto", help="default: %(default)s")
+    parser.add_argument(
+        "-l", "--language", default="en", help='spoken language code, or "auto" to detect (default: %(default)s)'
+    )
+    parser.add_argument("--no-clipboard", action="store_true", help="don't copy transcripts to the clipboard")
+    parser.add_argument("-V", "--version", action="version", version=f"%(prog)s {__version__}")
+    return parser.parse_args(argv)
+
+
+def run(args: argparse.Namespace) -> None:
+    language = None if args.language == "auto" else args.language
+
+    with console.status(f"Loading [bold]{args.model}[/] (first run downloads it)...", spinner="dots"):
+        model, device = load_model(args.model, args.device)
+    console.print(f"[green]✓[/] [bold]{args.model}[/] ready on [bold]{device}[/]")
+
+    while True:
+        console.input("\n[dim]Press[/] [bold]Enter[/] [dim]to record, Ctrl+C to quit[/] ")
+        audio = record()
+        duration = audio.size / SAMPLE_RATE
+        if audio.size < SAMPLE_RATE // 2:
+            console.print("[yellow]Too short, skipped.[/]")
+            continue
+
+        start = time.monotonic()
+        with console.status(f"Transcribing {duration:.1f}s of audio...", spinner="dots"):
+            segments, _ = model.transcribe(
+                audio,
+                language=language,
+                vad_filter=True,
+                beam_size=5,
+                # Whisper mimics the prompt's style; a punctuated prompt yields punctuated output.
+                # The prompt is English, so only use it when transcribing English.
+                initial_prompt=STYLE_PROMPT if language == "en" else None,
+            )
+            # segments is lazy; joining it runs the transcription, so keep it inside the spinner.
+            text = format_bullets(" ".join(s.text.strip() for s in segments).strip())
+        if not text:
+            console.print("[yellow]No speech detected.[/]")
+            continue
+
+        status = f"transcribed in {time.monotonic() - start:.1f}s"
+        if not args.no_clipboard:
+            if copy_to_clipboard(text):
+                status += " · copied to clipboard"
+            else:
+                status += " · [yellow]clipboard unavailable[/]"
+        console.print(
+            Panel(
+                Text(text),
+                title=f"{duration:.1f}s memo",
+                subtitle=status,
+                title_align="left",
+                subtitle_align="right",
+                border_style="green",
+                padding=(1, 2),
+            )
+        )
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = parse_args(argv)
+    try:
+        run(args)
+    except KeyboardInterrupt:
+        console.print("\n[dim]Bye.[/]")
+    except AudioError as e:
+        console.print(f"[red]Audio error:[/] {e}")
+        console.print("[dim]Check that a microphone is connected and PortAudio is installed.[/]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

whisper_memo-0.1.0/tests/test_cli.py

@@ -0,0 +1,47 @@
+import pytest
+
+from whisper_memo.cli import BARS, format_bullets, level_bar, parse_args
+
+
+def test_plain_text_is_unchanged():
+    assert format_bullets("Just one thought.") == "Just one thought."
+
+
+@pytest.mark.parametrize(
+    "text",
+    [
+        "buy milk new line call mom",
+        "Buy milk. New line. Call mom.",
+        "buy milk, new-line, call mom",
+        "buy milk newline call mom",
+    ],
+)
+def test_new_line_makes_bullets(text):
+    assert format_bullets(text).replace(".", "") == "- Buy milk\n- Call mom"
+
+
+def test_trailing_new_line_adds_no_empty_bullet():
+    assert format_bullets("one thing new line") == "- One thing"
+
+
+def test_new_line_inside_a_word_is_ignored():
+    assert format_bullets("renewlines are fine") == "renewlines are fine"
+
+
+def test_level_bar_range():
+    assert level_bar(0.0) == BARS[0]
+    assert level_bar(1.0) == BARS[-1]
+    levels = [BARS.index(level_bar(r)) for r in (1e-4, 1e-3, 1e-2, 1e-1)]
+    assert levels == sorted(levels)
+
+
+def test_defaults():
+    args = parse_args([])
+    assert (args.device, args.language, args.no_clipboard) == ("auto", "en", False)
+
+
+def test_version_flag(capsys):
+    with pytest.raises(SystemExit) as exc:
+        parse_args(["--version"])
+    assert exc.value.code == 0
+    assert capsys.readouterr().out.startswith("whisper-memo ")