fix(tauri): UI fixes - mic button state and window persistence (#9)

* fix(tauri): remove mic button state changes and prevent empty window opening

- Remove recording button color changes (now just a link to recording window)
- Simplify CSS by removing recording state classes and animations
- Fix window opening without document on startup

* feat(macos): add debug build with dev version display

- Add BUNDLE_VERSION variable in project.yml (dev for Debug, 0.2.0 for Release)
- Update Info.plist to use $(BUNDLE_VERSION) for version strings
- Add 'make dev' and 'make build-debug' targets for Debug builds
- About panel now shows 'Version dev' in development builds

* docs: mark macOS native app as deprecated in CLAUDE.md

The Tauri version is now the primary and actively maintained version.
macOS native (apps/macos/) is no longer receiving updates.

* fix(tauri): enable window-state plugin to persist window position

The plugin was installed but not initialized. Now windows will save and restore their position/size between sessions.

* fix(tauri): await loadFile to ensure window shows when opening via CLI

* fix(tauri): use correct button classes in modal dialogs

Replace modal-btn with btn and modal-btn-primary with btn-primary
to fix styling in dark theme.

* fix(tauri): exclude recording window from window-state persistence

The recording window should always start hidden, not restore previous visibility state.

* feat(tauri): add double-click on toolbar to toggle maximize

Adds native macOS behavior - double-clicking the title bar toggles maximize/restore.

* fix(tauri): adjust toolbar padding to center macOS window buttons

* feat(build): add Makefile and local dev build script

- Add apps/tauri/Makefile with targets: dev, build, build-dev, install, clean
- Add scripts/build-dev.sh for local builds with git hash (0.0.0-{hash})
- Update CLAUDE.md with Makefile usage and build documentation
- Local builds clearly show version 0.0.0-abc1234 to differentiate from releases

* feat(ui): add active state tracking for outline headings

- Highlight current visible heading in outline sidebar
- Use IntersectionObserver to track scroll position
- Auto-scroll outline to keep active heading visible
- Add visual styling for active heading with border and color

* docs: update README with Makefile build commands

* fix(whisper): use None for automatic language detection

Changed from Some("auto") to None as per whisper.cpp API specification for automatic language detection

* fix(ui): keep last active heading highlighted in outline

Persist last active heading when scrolling between sections to prevent outline from losing active state

* fix(build): ensure ~/Applications exists before install copy

* docs: include Info.plist in set-version description

* fix(build): add dev target to .PHONY in macOS Makefile

* fix(macos): add microphone permission description to Info.plist

macOS requires NSMicrophoneUsageDescription in Info.plist for apps
that access the microphone. Without it, the system silently blocks
microphone access when the app is launched via Finder/Spotlight,
causing Whisper transcription to return [BLANK_AUDIO].

The app worked when launched from terminal because it inherited
permissions from Terminal.app.

* fix(whisper): ensure audio stream is properly closed on stop

Implements Drop trait for AudioRecorder to explicitly close the
audio stream when the recorder is destroyed. Adds a 100ms delay
after stopping the stream to give macOS time to update the
microphone indicator icon in the menu bar.

This prevents the microphone icon from staying active after
recording is stopped or cancelled.

* docs: clarify build-dev.sh must run from repo root

* fix(whisper): explicitly pause audio stream before dropping

Calls stream.pause() before dropping to ensure the audio device
is properly released. Increases delay from 100ms to 200ms to give
macOS more time to update the microphone indicator in the menu bar.

Applies to both stop() method and Drop trait implementation.

Author: wilcorrea

CLAUDE.md

@@ -4,51 +4,90 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-Arandu is a Markdown viewer application with two frontends that share the same feature set:
-- **macOS native** (`apps/macos/`) — Swift + AppKit + WebKit, uses `libcmark_gfm` for GFM rendering
-- **Tauri cross-platform** (`apps/tauri/`) — Rust backend + vanilla HTML/JS frontend, uses `comrak` for GFM rendering
+Arandu is a Markdown viewer application built with Tauri (Rust backend + vanilla HTML/JS frontend). It uses `comrak` for GFM rendering and provides:
+- GitHub Flavored Markdown support (tables, task lists, strikethrough, autolinks)
+- Theme cycling (system/light/dark)
+- File watching with live reload
+- Sidebar outline navigation
+- CLI installer for macOS
+- Offline voice-to-text via Whisper
+- Plan review comment system
 
-Both render GitHub Flavored Markdown (tables, task lists, strikethrough, autolinks), support theme cycling (system/light/dark), file watching with live reload, sidebar outline navigation, and include a CLI installer for macOS.
+**Note:** The macOS native version (`apps/macos/`) is deprecated and no longer maintained. All active development happens in the Tauri version (`apps/tauri/`).
 
 ## Build Commands
 
-### macOS Native (requires Xcode + xcodegen)
+### Tauri (requires Rust + Node.js)
+
+**Using Makefile (recommended):**
 ```bash
-brew install xcodegen          # one-time setup
-cd apps/macos
-make generate                  # generate .xcodeproj from project.yml
-make build                     # build Release config
-make install                   # build + install app to ~/Applications + CLI to /usr/local/bin
-make dist                      # build + create dist/Arandu.dmg
-make clean                     # remove build artifacts and .xcodeproj
+cd apps/tauri
+make dev         # run in development mode (hot reload)
+make build       # production build (uses version from tauri.conf.json)
+make build-dev   # local dev build with git hash (e.g. 0.0.0-abc1234)
+make install     # install app to ~/Applications + CLI to /usr/local/bin
+make clean       # remove build artifacts
+make help        # show all available targets
 ```
 
-### Tauri (requires Rust + Node.js)
+**Using npm/npx directly:**
 ```bash
 cd apps/tauri
-npm install                    # install frontend dependencies
-npx tauri dev                  # run in development mode (hot reload on localhost:1420)
-npx tauri build                # production build (outputs to src-tauri/target/release)
-npx tauri build --target <triple>  # cross-compile (e.g. aarch64-apple-darwin)
+npm install                          # install frontend dependencies
+npx tauri dev                        # run in development mode
+npx tauri build                      # production build
+npx tauri build --target <triple>    # cross-compile (e.g. aarch64-apple-darwin)
+```
+
+**Local development builds:**
+```bash
+# Build with git hash as version (e.g. Arandu_0.0.0-05ca7c4_aarch64.dmg)
+# Run from repo root:
+./scripts/build-dev.sh
+
+# This script temporarily updates version files, builds, then restores them
+# Output clearly shows it's a local dev build, not an official release
 ```
 
 ### Version Management
 ```bash
 scripts/set-version.sh 0.3.0  # updates Info.plist, Cargo.toml, tauri.conf.json, package.json
 ```
 
-## Architecture
+<details>
+<summary>Deprecated: macOS Native (no longer maintained)</summary>
 
-### Shared Assets (`shared/`)
-CSS styles (`style.css`) and highlight.js files shared between both apps. The Tauri frontend has copies in `apps/tauri/src/`; the macOS app bundles them from `apps/macos/Sources/Arandu/Resources/`.
+```bash
+brew install xcodegen          # one-time setup
+cd apps/macos
+make generate                  # generate .xcodeproj from project.yml
+make build                     # build Release config
+make install                   # build + install app to ~/Applications + CLI to /usr/local/bin
+make dist                      # build + create dist/Arandu.dmg
+make clean                     # remove build artifacts and .xcodeproj
+```
 
-### macOS Native App (`apps/macos/`)
-Single-file Swift app (`Sources/Arandu/main.swift`) containing AppDelegate, MarkdownWindowController, CLIInstaller, and all UI logic. Uses `project.yml` (XcodeGen) to generate the Xcode project. Markdown rendering via C library `libcmark_gfm`. File watching uses `DispatchSource`.
+This version is deprecated and no longer receives updates. Use the Tauri version instead.
+</details>
+
+## Architecture
 
 ### Tauri App (`apps/tauri/`)
-- **Rust backend** (`src-tauri/src/`): `lib.rs` defines all Tauri commands (`render_markdown`, `read_file`, `extract_headings`, `watch_file`, etc.) and app setup. `cli_installer.rs` handles macOS CLI installation (conditionally compiled with `#[cfg(target_os = "macos")]`). Markdown rendering via `comrak` crate. File watching via `notify` crate.
-- **JS frontend** (`src/`): `main.js` is the single entry point — communicates with Rust via `window.__TAURI__.core.invoke()`. `index.html` has the full UI including CLI installer modals. No build step or bundler; plain JS served directly.
-- **Tauri plugins**: `cli` (CLI arg parsing), `dialog` (file open), `fs` (file read), `updater` (auto-update from GitHub releases).
+- **Rust backend** (`src-tauri/src/`):
+  - `lib.rs` defines all Tauri commands (`render_markdown`, `read_file`, `extract_headings`, `watch_file`, etc.) and app setup
+  - `cli_installer.rs` handles macOS CLI installation (conditionally compiled with `#[cfg(target_os = "macos")]`)
+  - `whisper.rs` handles offline voice-to-text transcription using Whisper models
+  - `comments.rs` manages plan review comments storage
+  - Markdown rendering via `comrak` crate, file watching via `notify` crate
+- **JS frontend** (`src/`):
+  - `main.js` is the single entry point — communicates with Rust via `window.__TAURI__.core.invoke()`
+  - `index.html` has the full UI including CLI installer modals, whisper settings, comment system
+  - No build step or bundler; plain JS served directly
+  - Uses shared CSS from `shared/` directory (symlinked in `src/`)
+- **Tauri plugins**: `cli` (CLI arg parsing), `dialog` (file open), `fs` (file read), `updater` (auto-update from GitHub releases)
+
+### Shared Assets (`shared/`)
+CSS styles (`style.css`) and highlight.js files. The Tauri frontend symlinks these files in `apps/tauri/src/`.
 
 ### Website (`website/`)
 Static landing page deployed to Cloudflare Pages. No build step — plain HTML/CSS/JS.

README.md

@@ -83,23 +83,38 @@ Record audio and transcribe to text using OpenAI Whisper models (runs locally, n
 - [Rust](https://www.rust-lang.org/tools/install) (stable)
 - [Node.js](https://nodejs.org) 20+
 
-### Run locally
+### Quick Start
 
 ```bash
 cd apps/tauri
-npm install
-npx tauri dev
+npm install        # install dependencies
+make dev           # run in development mode
 ```
 
-### Production build
+### Build Commands
+
+**Using Makefile (recommended):**
+
+```bash
+cd apps/tauri
+make dev           # run in development mode (hot reload)
+make build         # production build
+make build-dev     # local dev build with git hash (e.g. Arandu_0.0.0-abc1234.dmg)
+make install       # install app to ~/Applications + CLI to /usr/local/bin
+make clean         # remove build artifacts
+make help          # show all available targets
+```
+
+**Using npm/npx directly:**
 
 ```bash
 cd apps/tauri
-npx tauri build
+npx tauri dev      # development mode
+npx tauri build    # production build
 ```
 
-### Set version across all configs
+### Version Management
 
 ```bash
-scripts/set-version.sh 0.3.0
+scripts/set-version.sh 0.3.0   # update version across all config files
 ```

apps/macos/Makefile

@@ -1,4 +1,4 @@
-.PHONY: all generate build install install-script uninstall clean dist
+.PHONY: all generate build build-debug dev install install-script uninstall clean dist
 
 SCHEME      = Arandu
 CONFIG      = Release
@@ -9,6 +9,8 @@ CLI_DEST    = /usr/local/bin/arandu
 
 all: generate build
 
+dev: generate build-debug
+
 generate:
 	xcodegen generate
 
@@ -22,6 +24,16 @@ build: generate
 	    CODE_SIGNING_ALLOWED=NO \
 	    $(if $(shell which xcpretty 2>/dev/null),| xcpretty,)
 
+build-debug: generate
+	xcodebuild \
+	    -scheme $(SCHEME) \
+	    -configuration Debug \
+	    -derivedDataPath $(BUILD_DIR) \
+	    CODE_SIGN_IDENTITY="-" \
+	    CODE_SIGNING_REQUIRED=NO \
+	    CODE_SIGNING_ALLOWED=NO \
+	    $(if $(shell which xcpretty 2>/dev/null),| xcpretty,)
+
 install: build
 	@echo "Installing $(APP_NAME) to /Applications..."
 	cp -R "$(BUILD_DIR)/Build/Products/$(CONFIG)/$(APP_NAME)" "$(APP_DEST)"

apps/macos/Sources/Arandu/Info.plist

@@ -39,9 +39,9 @@
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>0.2.0</string>
+	<string>$(BUNDLE_VERSION)</string>
 	<key>CFBundleVersion</key>
-	<string>0.2.0</string>
+	<string>$(BUNDLE_VERSION)</string>
 	<key>LSMinimumSystemVersion</key>
 	<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
 	<key>NSAppTransportSecurity</key>

apps/macos/project.yml

@@ -34,3 +34,8 @@ targets:
         MACOSX_DEPLOYMENT_TARGET: "13.0"
         ENABLE_HARDENED_RUNTIME: NO
         SWIFT_OBJC_BRIDGING_HEADER: ""
+      configs:
+        Debug:
+          BUNDLE_VERSION: dev
+        Release:
+          BUNDLE_VERSION: 0.2.0

apps/tauri/Makefile

@@ -0,0 +1,55 @@
+.PHONY: help dev build build-dev clean install
+
+# Directories
+BUILD_DIR = src-tauri/target/release
+BUNDLE_DIR = $(BUILD_DIR)/bundle/macos
+APP_NAME = Arandu.app
+APP_DEST = $(HOME)/Applications/$(APP_NAME)
+CLI_DEST = /usr/local/bin/arandu
+
+help:
+	@echo "Arandu Tauri - Build targets:"
+	@echo ""
+	@echo "  make dev        - Run in development mode (hot reload)"
+	@echo "  make build      - Production build (uses version from tauri.conf.json)"
+	@echo "  make build-dev  - Local dev build with git hash (0.0.0-{hash})"
+	@echo "  make install    - Install app to ~/Applications and CLI to /usr/local/bin"
+	@echo "  make clean      - Remove build artifacts"
+	@echo ""
+	@echo "Examples:"
+	@echo "  make build-dev  # Creates Arandu_0.0.0-abc1234_aarch64.dmg"
+	@echo "  make install    # Installs the built app locally"
+
+dev:
+	@echo "🚀 Starting Tauri in development mode..."
+	npm run tauri dev
+
+build:
+	@echo "📦 Building Tauri app (production)..."
+	npx tauri build
+
+build-dev:
+	@echo "🔨 Building local dev version with git hash..."
+	@../../scripts/build-dev.sh
+
+install:
+	@if [ ! -d "$(BUNDLE_DIR)/$(APP_NAME)" ]; then \
+		echo "❌ App not found. Run 'make build' or 'make build-dev' first."; \
+		exit 1; \
+	fi
+	@mkdir -p "$(HOME)/Applications"
+	@echo "Installing $(APP_NAME) to ~/Applications..."
+	@cp -R "$(BUNDLE_DIR)/$(APP_NAME)" "$(APP_DEST)"
+	@echo "Installing CLI to $(CLI_DEST)..."
+	@if [ -f "../../scripts/arandu" ]; then \
+		sudo cp ../../scripts/arandu "$(CLI_DEST)"; \
+		sudo chmod +x "$(CLI_DEST)"; \
+	else \
+		echo "⚠️  CLI script not found at scripts/arandu"; \
+	fi
+	@echo "✅ Done. Use 'arandu README.md' to open files."
+
+clean:
+	@echo "🧹 Cleaning build artifacts..."
+	@rm -rf src-tauri/target
+	@echo "✅ Clean complete."

apps/tauri/src-tauri/Info.plist

@@ -4,5 +4,7 @@
 <dict>
 	<key>LSUIElement</key>
 	<true/>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>Arandu uses the microphone for voice-to-text transcription with Whisper AI.</string>
 </dict>
 </plist>

apps/tauri/src-tauri/capabilities/default.json

@@ -10,6 +10,7 @@
     "core:window:allow-show",
     "core:window:allow-set-focus",
     "core:window:allow-unminimize",
+    "core:window:allow-toggle-maximize",
     "cli:default",
     "dialog:default",
     "fs:default",

apps/tauri/src-tauri/src/lib.rs

@@ -341,6 +341,11 @@ pub fn run() {
         .plugin(tauri_plugin_updater::Builder::new().build())
         .plugin(tauri_plugin_global_shortcut::Builder::new().build())
         .plugin(tauri_plugin_clipboard_manager::init())
+        .plugin(
+            tauri_plugin_window_state::Builder::default()
+                .with_denylist(&["recording"])
+                .build()
+        )
         .plugin(tauri_plugin_single_instance::init(|app, args, _cwd| {
             eprintln!("Second instance detected: {:?}", args);
 

apps/tauri/src-tauri/src/whisper/audio.rs

@@ -76,6 +76,16 @@ fn check_microphone_permission() -> Result<bool, String> {
     Ok(true)
 }
 
+impl Drop for AudioRecorder {
+    fn drop(&mut self) {
+        if let Some(stream) = self.stream.take() {
+            let _ = stream.pause();
+            drop(stream);
+            std::thread::sleep(std::time::Duration::from_millis(200));
+        }
+    }
+}
+
 impl AudioRecorder {
     pub fn new(device_name: Option<String>) -> Result<Self, String> {
         #[cfg(target_os = "macos")]
@@ -218,7 +228,11 @@ impl AudioRecorder {
     pub fn stop(&mut self) -> Result<Vec<f32>, String> {
         std::thread::sleep(std::time::Duration::from_millis(50));
 
-        self.stream.take();
+        if let Some(stream) = self.stream.take() {
+            let _ = stream.pause();
+            drop(stream);
+        }
+        std::thread::sleep(std::time::Duration::from_millis(200));
 
         let audio_received = {
             let tracker = self.last_audio_received.lock().map_err(|e| e.to_string())?;