Phase 1 foundation: Tauri shell, Python sidecar, SQLite database

Tauri v2 + Svelte + TypeScript frontend:
- App shell with workspace layout (waveform, transcript, speakers, AI chat)
- Placeholder components for all major UI areas
- Typed stores (project, transcript, playback, AI)
- TypeScript interfaces matching the database schema
- Tauri bridge service with typed invoke wrappers
- svelte-check passes with 0 errors

Rust backend:
- Tauri v2 app entry point with command registration
- SQLite database layer (rusqlite with bundled SQLite)
  - Full schema: projects, media_files, speakers, segments, words,
    ai_outputs, annotations (with indexes)
  - Model structs with serde serialization
  - CRUD queries for projects, speakers, segments, words
  - Segment text editing preserves original text
  - Schema versioning for future migrations
  - 6 tests passing
- Command stubs for project, transcribe, export, AI, settings, system
- App state management

Python sidecar:
- JSON-line IPC protocol (stdin/stdout)
- Message types: IPCMessage, progress, error, ready
- Handler registry with routing and error handling
- Ping/pong handler for connectivity testing
- Service stubs: transcribe, diarize, pipeline, AI, export
- Provider stubs: local (llama-server), OpenAI, Anthropic, LiteLLM
- Hardware detection stubs
- 14 tests passing, ruff clean

Also adds:
- Testing strategy document (docs/TESTING.md)
- Validation script (scripts/validate.sh)
- Updated .gitignore for Svelte, Rust, Python artifacts

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

python/voice_to_notes/ipc/__init__.py

@@ -0,0 +1 @@
+"""IPC protocol layer for JSON-line communication with the Rust backend."""

python/voice_to_notes/ipc/handlers.py

@@ -0,0 +1,39 @@
+"""Message handler registry and routing."""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+
+from voice_to_notes.ipc.messages import IPCMessage, error_message
+
+# Handler function type: takes a message, returns a response message
+HandlerFunc = Callable[[IPCMessage], IPCMessage | None]
+
+
+class HandlerRegistry:
+    """Registry mapping message types to handler functions."""
+
+    def __init__(self) -> None:
+        self._handlers: dict[str, HandlerFunc] = {}
+
+    def register(self, message_type: str, handler: HandlerFunc) -> None:
+        """Register a handler for a message type."""
+        self._handlers[message_type] = handler
+
+    def handle(self, msg: IPCMessage) -> IPCMessage | None:
+        """Route a message to its handler. Returns a response or error."""
+        handler = self._handlers.get(msg.type)
+        if handler is None:
+            print(f"[sidecar] Unknown message type: {msg.type}", file=sys.stderr, flush=True)
+            return error_message(msg.id, "unknown_type", f"Unknown message type: {msg.type}")
+        try:
+            return handler(msg)
+        except Exception as e:
+            print(f"[sidecar] Handler error for {msg.type}: {e}", file=sys.stderr, flush=True)
+            return error_message(msg.id, "handler_error", str(e))
+
+
+def ping_handler(msg: IPCMessage) -> IPCMessage:
+    """Simple ping handler for testing connectivity."""
+    return IPCMessage(id=msg.id, type="pong", payload={"echo": msg.payload})

python/voice_to_notes/ipc/messages.py

@@ -0,0 +1,46 @@
+"""IPC message type definitions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class IPCMessage:
+    """A message exchanged between Rust and Python via JSON-line protocol."""
+
+    id: str
+    type: str
+    payload: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"id": self.id, "type": self.type, "payload": self.payload}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> IPCMessage:
+        return cls(
+            id=data.get("id", ""),
+            type=data.get("type", ""),
+            payload=data.get("payload", {}),
+        )
+
+
+def progress_message(request_id: str, percent: int, stage: str, message: str) -> IPCMessage:
+    return IPCMessage(
+        id=request_id,
+        type="progress",
+        payload={"percent": percent, "stage": stage, "message": message},
+    )
+
+
+def error_message(request_id: str, code: str, message: str) -> IPCMessage:
+    return IPCMessage(
+        id=request_id,
+        type="error",
+        payload={"code": code, "message": message},
+    )
+
+
+def ready_message() -> IPCMessage:
+    return IPCMessage(id="system", type="ready", payload={"version": "0.1.0"})

python/voice_to_notes/ipc/protocol.py

@@ -0,0 +1,47 @@
+"""JSON-line protocol reader/writer over stdin/stdout."""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+from voice_to_notes.ipc.messages import IPCMessage
+
+
+def read_message() -> IPCMessage | None:
+    """Read a single JSON-line message from stdin. Returns None on EOF."""
+    try:
+        line = sys.stdin.readline()
+        if not line:
+            return None  # EOF
+        line = line.strip()
+        if not line:
+            return None
+        data = json.loads(line)
+        return IPCMessage.from_dict(data)
+    except json.JSONDecodeError as e:
+        _log(f"Invalid JSON: {e}")
+        return None
+    except Exception as e:
+        _log(f"Read error: {e}")
+        return None
+
+
+def write_message(msg: IPCMessage) -> None:
+    """Write a JSON-line message to stdout."""
+    line = json.dumps(msg.to_dict(), separators=(",", ":"))
+    sys.stdout.write(line + "\n")
+    sys.stdout.flush()
+
+
+def write_dict(data: dict[str, Any]) -> None:
+    """Write a raw dict as a JSON-line message to stdout."""
+    line = json.dumps(data, separators=(",", ":"))
+    sys.stdout.write(line + "\n")
+    sys.stdout.flush()
+
+
+def _log(message: str) -> None:
+    """Log to stderr (stdout is reserved for IPC)."""
+    print(f"[sidecar] {message}", file=sys.stderr, flush=True)