The 'Touch Grass' Movement in Dev Tools: Offline, Voice-First, and Real-World-Aware AI Apps vs. Cloud-Heavy Monoliths

# Pull a coding model
ollama pull qwen2.5-coder:1.5b

# Run a local inference server
ollama serve

# Query the model via REST
curl http://localhost:11434/api/generate \
  -d '{
    "model": "qwen2.5-coder:1.5b",
    "prompt": "Write a Rust function to parse TOML config files",
    "stream": true
  }'

#include "llama.h"

llama_model_params mparams = llama_model_params_default();
mparams.n_gpu_layers = 33; // Offload layers to GPU

llama_context_params cparams = llama_context_params_from_gpt2();
cparams.n_ctx = 4096;

struct llama_context *ctx = llama_init_ctx_with_model(model, cparams);

// Tokenize input
std::vector<llama_token> tokens = llama_tokenize(model, prompt, false);

// Inference
llama_eval(ctx, tokens.data(), tokens.size());

import { pipeline } from '@huggingface/transformers';

const generator = await pipeline('text-generation', 'Xenova/Qwen2.5-Coder-1.5B');

const output = await generator(
  'Write a Python function that debounces async calls:',
  { max_new_tokens: 256, temperature: 0.2 }
);

console.log(output[0].generated_text);

┌─────────────────────────────────────────────────┐
│                  User Interface                  │
│         (Terminal / Editor / Voice UI)           │
└──────────────────┬──────────────────────────────┘
                   │
┌──────────────────▼──────────────────────────────┐
│           Local Inference Engine                 │
│  ┌──────────┐  ┌──────────┐  ┌──────────────┐  │
│  │ LLM      │  │ Whisper  │  │ Embeddings   │  │
│  │ (Qwen2)  │  │ (STT)    │  │ (nomic-embed)│  │
│  └──────────┘  └──────────┘  └──────────────┘  │
│           Local Vector Store (SQLite + HNSW)     │
└──────────────────┬──────────────────────────────┘
                   │ (optional, async)
┌──────────────────▼──────────────────────────────┐
│              Cloud Escalation Layer              │
│  ┌──────────────┐  ┌─────────────────────────┐  │
│  │ Large Model  │  │ RAG over codebase index │  │
│  │ API (opt.)   │  │                         │  │
│  └──────────────┘  └─────────────────────────┘  │
└─────────────────────────────────────────────────┘

# Install whisper.cpp
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp && make

# Transcribe audio locally
./main -m models/ggml-base.en.bin -f recording.wav

# Or use the server mode for streaming
./server -m models/ggml-base.en.bin --port 8080

from faster_whisper import WhisperModel

# Load model once at startup
model = WhisperModel("base.en", device="cpu", compute_type="int8")

# Transcribe with streaming-friendly chunking
segments, info = model.transcribe(
    "meeting_audio.wav",
    beam_size=5,
    language="en",
    vad_filter=True,  # Voice Activity Detection
)

for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

import numpy as np
import sounddevice as sd
from faster_whisper import WhisperModel

SAMPLE_RATE = 16000
CHUNK_DURATION = 5  # seconds per capture chunk

class VoiceDevAssistant:
    def __init__(self):
        self.stt_model = WhisperModel("base.en", device="cpu", compute_type="int8")
        self.llm_client = None  # Would be your local LLM client

    def capture_audio(self, duration=CHUNK_DURATION):
        """Capture audio from microphone."""
        frames = sd.rec(
            int(duration * SAMPLE_RATE),
            samplerate=SAMPLE_RATE,
            channels=1,
            dtype='float32'
        )
        sd.wait()
        return frames.flatten()

    def process_command(self, audio_data):
        """Transcribe and route a voice command."""
        # Step 1: Transcribe
        segments, _ = self.stt_model.transcribe(
            audio_data,
            beam_size=1,  # Faster for real-time
            language="en",
            vad_filter=True,
        )
        transcript = " ".join(s.text.strip() for s in segments).strip()
        
        if not transcript:
            return {"status": "empty", "response": "I didn't hear anything."}
        
        # Step 2: Route by intent
        intent = self._classify_intent(transcript)
        response = self._handle_intent(intent, transcript)
        
        return {
            "status": "ok",
            "transcript": transcript,
            "intent": intent,
            "response": response,
        }

    def _classify_intent(self, text):
        """Simple keyword-based intent routing."""
        text_lower = text.lower()
        if any(kw in text_lower for kw in ["write", "create", "generate", "implement"]):
            return "code_generation"
        elif any(kw in text_lower for kw in ["explain", "what is", "how does"]):
            return "explanation"
        elif any(kw in text_lower for kw in ["search", "find", "look for"]):
            return "search"
        elif any(kw in text_lower for kw in ["fix", "debug", "error"]):
            return "debugging"
        return "general"

import platform
import time
from dataclasses import dataclass
from enum import Enum
from typing import Optional

class InferenceBackend(Enum):
    CLOUD_LARGE = "cloud_large"       # GPT-4, Claude
    CLOUD_SMALL = "cloud_small"       # GPT-4o-mini, Haiku
    LOCAL_LARGE = "local_large"       # Phi-3, Qwen2.5-7B
    LOCAL_SMALL = "local_small"       # Phi-3-mini, Qwen2.5-1.5B
    OFFLINE_CACHED = "offline_cached" # Cached responses only

@dataclass
class SystemContext:
    network_available: bool
    battery_level: Optional[float]  # None if not applicable
    battery_charging: bool
    time_of_day: int                # 0-23
    screen_locked: bool
    gpu_available: bool
    available_memory_gb: float
    is_meeting: bool                # Detected via calendar/OS

class ModelRouter:
    """Routes requests to the optimal inference backend."""

    def __init__(self):
        self._cache = {}  # Simple response cache for offline mode

    def select_backend(self, context: SystemContext, complexity: str) -> InferenceBackend:
        """
        Select the best inference backend based on system context
        and request complexity.
        
        Args:
            context: Current system state
            complexity: 'trivial' | 'moderate' | 'complex'
        """
        # Hard constraints first
        if context.screen_locked:
            return InferenceBackend.OFFLINE_CACHED

        if not context.network_available:
            return self._select_offline_backend(context, complexity)

        # Network available: consider quality vs. cost
        if complexity == "complex":
            return InferenceBackend.CLOUD_LARGE

        if complexity == "moderate":
            # Prefer local if capable
            if context.gpu_available and context.available_memory_gb >= 8:
                return InferenceBackend.LOCAL_LARGE
            return InferenceBackend.CLOUD_SMALL

        # Trivial requests: always local
        if context.gpu_available and context.available_memory_gb >= 4:
            return InferenceBackend.LOCAL_LARGE
        return InferenceBackend.LOCAL_SMALL

    def _select_offline_backend(self, context: SystemContext, complexity: str) -> InferenceBackend:
        """Select best local model when offline."""
        if not context.gpu_available:
            if context.available_memory_gb >= 4:
                return InferenceBackend.LOCAL_SMALL
            return InferenceBackend.OFFLINE_CACHED

        # GPU available
        if context.battery_level is not None and not context.battery_charging:
            if context.battery_level < 0.2:
                # Low battery: use smallest model
                return InferenceBackend.LOCAL_SMALL
            elif context.battery_level < 0.5:
                # Medium battery: small model, limited context
                return InferenceBackend.LOCAL_SMALL

        # Full power available
        if context.available_memory_gb >= 10:
            return InferenceBackend.LOCAL_LARGE
        return InferenceBackend.LOCAL_SMALL

    def route(self, prompt: str, context: SystemContext, complexity: str = "moderate"):
        """Route a prompt to the selected backend."""
        backend = self.select_backend(context, complexity)
        
        if backend == InferenceBackend.OFFLINE_CACHED:
            cached = self._cache.get(prompt)
            if cached:
                return {"source": "cache", "response": cached}
            return {"source": "unavailable", "response": "No network and no cached response available."}
        
        # Dispatch to appropriate backend
        response = self._dispatch(backend, prompt)
        
        # Cache successful responses for offline use
        if backend != InferenceBackend.OFFLINE_CACHED:
            self._cache[prompt] = response.get("response", "")
        
        return {"source": backend.value, **response}

    def _dispatch(self, backend: InferenceBackend, prompt: str) -> dict:
        """Dispatch to the actual inference backend."""
        # Implementation would call Ollama, cloud API, etc.
        if backend == InferenceBackend.CLOUD_LARGE:
            return self._call_cloud_large(prompt)
        elif backend == InferenceBackend.CLOUD_SMALL:
            return self._call_cloud_small(prompt)
        elif backend == InferenceBackend.LOCAL_LARGE:
            return self._call_local_large(prompt)
        elif backend == InferenceBackend.LOCAL_SMALL:
            return self._call_local_small(prompt)
        return {"response": "Backend not implemented"}

class ThermalManager:
    """Manages inference load based on thermal state."""

    THERMAL_STATES = {
        "nominal": {"max_gpu_layers": 33, "max_context": 4096, "batch_size": 4},
        "fair":    {"max_gpu_layers": 20, "max_context": 2048, "batch_size": 2},
        "serious": {"max_gpu_layers": 10, "max_context": 1024, "batch_size": 1},
        "critical":{"max_gpu_layers": 0,  "max_context": 512,  "batch_size": 1},
    }

    def __init__(self):
        self._current_state = "nominal"
        self._cooldown_until = 0

    def get_config(self, thermal_state: str) -> dict:
        """Get inference config for current thermal state."""
        return self.THERMAL_STATES.get(thermal_state, self.THERMAL_STATES["nominal"])

    def should_pause(self, thermal_state: str, time_since_last_inference: float) -> bool:
        """Determine if inference should pause to cool down."""
        if thermal_state == "critical":
            return True
        if thermal_state == "serious" and time_since_last_inference < 10:
            return True
        return False

    def adaptive_sampling(self, thermal_state: str, base_temperature: float = 0.2):
        """Adjust sampling parameters based on thermal state."""
        if thermal_state in ("serious", "critical"):
            # Use greedy decoding (temp=0) to minimize computation
            return {"temperature": 0.0, "top_p": 1.0}
        if thermal_state == "fair":
            return {"temperature": base_temperature, "top_p": 0.9}
        return {"temperature": base_temperature, "top_p": 0.95}

┌──────────────────────────────────────────────────────────┐
│                    Application Layer                      │
│  ┌────────┐  ┌────────────┐  ┌──────────┐  ┌─────────┐ │
│  │ Editor │  │ Voice UI   │  │ Terminal │  │ Web IDE │ │
│  └───┬────┘  └─────┬──────┘  └────┬─────┘  └────┬────┘ │
│      │              │               │              │      │
│      └──────────────┴───────┬───────┴──────────────┘      │
│                             │                             │
│                    ┌────────▼────────┐                    │
│                    │  Request Router  │                    │
│                    │  (Complexity     │                    │
│                    │   Classifier)    │                    │
│                    └──┬──────────┬───┘                    │
│                       │          │                        │
│         ┌─────────────┘          └──────────────┐         │
│         ▼                                       ▼         │
│  ┌──────────────┐                    ┌──────────────────┐ │
│  │ Local Engine │                    │  Cloud Escalation│ │
│  │ (Ollama/     │                    │  (GPT-4/Claude)  │ │
│  │  llama.cpp)  │                    │  API Gateway     │ │
│  └──────┬───────┘                    └────────┬─────────┘ │
│         │                                     │            │
│  ┌──────▼───────┐                    ┌────────▼─────────┐ │
│  │ Vector Store │                    │  Shared Vector   │ │
│  │ (local code  │◄──── sync ────────►│  Store (cloud)   │ │
│  │  embeddings) │                    │  (full codebase) │ │
│  └──────────────┘                    └──────────────────┘ │
│                                                            │
│  ┌──────────────────────────────────────────────────────┐ │
│  │              Shared State Layer                        │ │
│  │  (SQLite with CRDT sync / ElectricSQL / P2P)          │ │
│  └──────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────┘

import re
from typing import Literal

Complexity = Literal["trivial", "moderate", "complex"]

class ComplexityClassifier:
    """
    Fast heuristic-based complexity classifier.
    Runs in <1ms, no model needed.
    """

    COMPLEX_PATTERNS = [
        r"architect",
        r"design\s+(system|pattern|solution)",
        r"trade[- ]?off",
        r"compare\s+multiple",
        r"why\s+(is|does|would)",
        r"explain\s+(the\s+)?(difference|tradeoff|consequence)",
        r"multi[- ]?file",
        r"refactor\s+(the\s+)?(entire|whole|all)",
        r"concurrency|race\s+condition|deadlock",
        r"performance\s+(optimization|bottleneck)",
    ]

    TRIVIAL_PATTERNS = [
        r"what\s+(is|are)\s+\w+",
        r"how\s+to\s+(use|call|import)",
        r"what\s+does\s+\w+\s+do",
        r"explain\s+\w+\s+\w*",  # Single word explanation
        r"rename\s+\w+",
        r"add\s+(a\s+)?(doc|comment|type\s+hint)",
        r"fix\s+(typo|syntax)",
    ]

    def classify(self, prompt: str) -> Complexity:
        """Classify prompt complexity using pattern matching."""
        prompt_lower = prompt.lower()

        # Check complex patterns first (they're more specific)
        for pattern in self.COMPLEX_PATTERNS:
            if re.search(pattern, prompt_lower):
                return "complex"

        # Check trivial patterns
        for pattern in self.TRIVIAL_PATTERNS:
            if re.search(pattern, prompt_lower):
                return "trivial"

        # Heuristic: longer prompts tend to be more complex
        word_count = len(prompt_lower.split())
        if word_count > 50:
            return "complex"
        if word_count < 10:
            return "trivial"

        return "moderate"

    def should_escalate(self, local_response: str, confidence: float = 0.7) -> bool:
        """
        Check if a local response looks uncertain enough
        to warrant cloud escalation.
        """
        # Heuristic signals of low confidence
        uncertainty_markers = [
            "i'm not sure",
            "i don't know",
            "i'm not certain",
            "there could be",
            "it depends on",
        ]
        
        response_lower = local_response.lower()
        uncertainty_count = sum(1 for marker in uncertainty_markers if marker in response_lower)
        
        # If 2+ uncertainty markers, escalate
        if uncertainty_count >= 2:
            return True
        
        # If response is very short for a non-trivial prompt
        if len(local_response) < 50:
            return True
            
        return False

#!/usr/bin/env python3
"""
local_dev_assistant.py
A local-first AI development assistant with:
- Offline code assistance via Ollama
- Voice input via Whisper (faster-whisper)
- Context-aware model routing
- Thermal management
"""

import asyncio
import os
import sys
import time
import json
from pathlib import Path
from typing import Optional, Generator
from dataclasses import dataclass, field

# ─── Configuration ───────────────────────────────────────────────

@dataclass
class Config:
    ollama_url: str = "http://localhost:11434"
    local_model: str = "qwen2.5-coder:1.5b"
    cloud_api_key: Optional[str] = None
    whisper_model: str = "base.en"
    max_context_tokens: int = 2048
    data_dir: Path = Path.home() / ".local-dev-assistant"

    def __post_init__(self):
        self.data_dir.mkdir(parents=True, exist_ok=True)


# ─── Local Inference Client ──────────────────────────────────────

class OllamaClient:
    """Async client for Ollama local inference."""

    def __init__(self, config: Config):
        self.config = config
        self._base_url = config.ollama_url

    async def generate(self, prompt: str, system: str = "", 
                       max_tokens: int = 512) -> Generator[str, None, None]:
        """Stream completion from local model."""
        import aiohttp

        payload = {
            "model": self.config.local_model,
            "prompt": prompt,
            "system": system,
            "stream": True,
            "options": {
                "num_predict": max_tokens,
                "temperature": 0.2,
                "num_ctx": self.config.max_context_tokens,
            }
        }

        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self._base_url}/api/generate",
                json=payload,
                timeout=aiohttp.ClientTimeout(total=120)
            ) as resp:
                if resp.status != 200:
                    error = await resp.text()
                    yield f"[ERROR] {error}"
                    return

                async for line in resp.content:
                    chunk = json.loads(line)
                    if "response" in chunk:
                        yield chunk["response"]
                    if chunk.get("done"):
                        break

    async def is_available(self) -> bool:
        """Check if Ollama server is running."""
        import aiohttp
        try:
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    f"{self._base_url}/api/tags",
                    timeout=aiohttp.ClientTimeout(total=2)
                ) as resp:
                    return resp.status == 200
        except:
            return False


# ─── Voice Module ────────────────────────────────────────────────

class VoiceModule:
    """Handles voice input via local Whisper."""

    def __init__(self, config: Config):
        self.config = config
        self._model = None

    def _load_model(self):
        """Lazy-load Whisper model."""
        if self._model is None:
            from faster_whisper import WhisperModel
            print("Loading Whisper model... (first time may take a minute)")
            self._model = WhisperModel(
                self.config.whisper_model,
                device="cpu",
                compute_type="int8"
            )
            print("Whisper model loaded.")

    def transcribe_file(self, audio_path: str) -> str:
        """Transcribe an audio file to text."""
        self._load_model()
        segments, _ = self._model.transcribe(
            audio_path,
            beam_size=1,
            language="en",
            vad_filter=True,
        )
        return " ".join(s.text.strip() for s in segments).strip()


# ─── Main Assistant ──────────────────────────────────────────────

class LocalDevAssistant:
    """Main assistant combining local inference, voice, and routing."""

    SYSTEM_PROMPT = (
        "You are a concise, expert coding assistant. "
        "When writing code, include brief comments. "
        "When explaining, be direct and skip preamble. "
        "Format code in markdown fences with language tags."
    )

    def __init__(self, config: Config):
        self.config = config
        self.ollama = OllamaClient(config)
        self.voice = VoiceModule(config)
        self.complexity_classifier = ComplexityClassifier()
        self._history = []

    async def ask(self, question: str) -> str:
        """Process a question with local-first routing."""
        complexity = self.complexity_classifier.classify(question)
        source = "local"

        print(f"
[Router] Complexity: {complexity}")

        # Try local first
        if await self.ollama.is_available():
            try:
                response = ""
                async for chunk in self.ollama.generate(
                    prompt=question,
                    system=self.SYSTEM_PROMPT,
                    max_tokens=1024 if complexity != "trivial" else 256,
                ):
                    if chunk.startswith("[ERROR]"):
                        raise RuntimeError(chunk)
                    response += chunk
                    print(chunk, end="", flush=True)

                print()  # Newline after streaming
                return response

            except Exception as e:
                print(f"
[Local] Failed: {e}", file=sys.stderr)
                source = "cloud"

        # Escalate to cloud if local failed or unavailable
        if source == "cloud" and self.config.cloud_api_key:
            print("[Cloud] Escalating to cloud API...", file=sys.stderr)
            return await self._cloud_fallback(question)

        return "[UNAVAILABLE] No inference backend available. " \
               "Start Ollama or set a cloud API key."

    async def _cloud_fallback(self, prompt: str) -> str:
        """Fallback to cloud API (example with OpenAI)."""
        import aiohttp

        async with aiohttp.ClientSession() as session:
            async with session.post(
                "https://api.openai.com/v1/chat/completions",
                headers={"Authorization": f"Bearer {self.config.cloud_api_key}"},
                json={
                    "model": "gpt-4o-mini",
                    "messages": [
                        {"role": "system", "content": self.SYSTEM_PROMPT},
                        {"role": "user", "content": prompt},
                    ],
                    "max_tokens": 1024,
                },
                timeout=aiohttp.ClientTimeout(total=60)
            ) as resp:
                data = await resp.json()
                return data["choices"][0]["message"]["content"]

    async def run(self):
        """Interactive REPL loop."""
        print("=" * 60)
        print("  Local-First AI Dev Assistant")
        print("  Type your question, or 'voice' to use microphone")
        print("  Type 'quit' to exit")
        print("=" * 60)

        while True:
            try:
                user_input = input("
> ").strip()
            except (EOFError, KeyboardInterrupt):
                break

            if not user_input:
                continue
            if user_input.lower() == "quit":
                break

            if user_input.lower() == "voice":
                print("Speak your question (press Enter to stop)...")
                # In production, integrate with sounddevice for live capture
                audio_file = input("Audio file path: ").strip()
                if audio_file and os.path.exists(audio_file):
                    user_input = self.voice.transcribe_file(audio_file)
                    print(f"Transcribed: {user_input}")

            response = await self.ask(user_input)
            self._history.append({"question": user_input, "response": response})


# ─── Entry Point ─────────────────────────────────────────────────

async def main():
    config = Config()
    assistant = LocalDevAssistant(config)
    await assistant.run()

if __name__ == "__main__":
    asyncio.run(main())

# 1. Start Ollama with a coding model
ollama pull qwen2.5-coder:1.5b
ollama serve

# 2. Install dependencies
pip install aiohttp faster-whisper sounddevice

# 3. Run the assistant
python local_dev_assistant.py

// offline-voice-assistant.ts
import { Whisper } from '@whisper/whisper-node';
import { LocalDB } from 'localforage';
import { SpeechRecognition } from 'web-speech-api';

class OfflineVoiceAssistant {
  private whisper: Whisper;
  private db: LocalDB;
  private commandHistory: Command[] = [];
  
  constructor() {
    this.whisper = new Whisper({ model: 'base' });
    this.db = LocalDB.createInstance({ name: 'voice-assistant' });
    this.initialize();
  }
  
  async initialize() {
    // Load local model (runs on device, no cloud)
    await this.whisper.loadModel();
    
    // Restore command history from local storage
    const savedHistory = await this.db.getItem('commandHistory');
    if (savedHistory) {
      this.commandHistory = JSON.parse(savedHistory);
    }
  }
  
  async processVoiceCommand(audioBuffer: AudioBuffer): Promise<Command> {
    // 1. Transcribe locally using Whisper
    const transcript = await this.whisper.transcribe(audioBuffer);
    
    // 2. Parse command using local NLP (no API calls)
    const command = this.parseCommand(transcript);
    
    // 3. Execute locally
    const result = await this.executeCommand(command);
    
    // 4. Save to local history
    this.commandHistory.push({
      transcript,
      command,
      result,
      timestamp: Date.now()
    });
    
    await this.db.setItem('commandHistory', JSON.stringify(this.commandHistory));
    
    // 5. Sync to cloud if available (optional enhancement)
    if (navigator.onLine) {
      this.syncToCloud(command).catch(() => {/* Fail silently */});
    }
    
    return { command, result };
  }
  
  private parseCommand(transcript: string): Command {
    // Local rule-based parser (no cloud NLP)
    const patterns = [
      { regex: /open\s+(\w+)/i, type: 'open', extract: (m: RegExpMatchArray) => m[1] },
      { regex: /search\s+for\s+(.+)/i, type: 'search', extract: (m: RegExpMatchArray) => m[1] },
      { regex: /run\s+(.+)/i, type: 'run', extract: (m: RegExpMatchArray) => m[1] },
    ];
    
    for (const pattern of patterns) {
      const match = transcript.match(pattern.regex);
      if (match) {
        return {
          type: pattern.type,
          args: pattern.extract(match),
          confidence: 0.95
        };
      }
    }
    
    return { type: 'unknown', args: transcript, confidence: 0.1 };
  }
  
  private async executeCommand(command: Command): Promise<Result> {
    switch (command.type) {
      case 'open':
        return this.openFile(command.args);
      case 'search':
        return this.searchFiles(command.args);
      case 'run':
        return this.runScript(command.args);
      default:
        return { success: false, error: 'Unknown command' };
    }
  }
  
  private async syncToCloud(command: Command): Promise<void> {
    // Optional cloud sync for analytics, not required for functionality
    const response = await fetch('https://api.example.com/commands', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        ...command,
        deviceId: this.getDeviceId(),
        timestamp: Date.now()
      })
    });
    
    if (!response.ok) {
      console.warn('Cloud sync failed, but local execution succeeded');
    }
  }
}

// context-aware-sync.ts
import { NetworkQuality } from 'network-quality-detector';
import { BatteryStatus } from 'battery-status-api';

class ContextAwareSync {
  private networkQuality: NetworkQuality;
  private batteryStatus: BatteryStatus;
  private syncQueue: SyncOperation[] = [];
  
  constructor() {
    this.networkQuality = new NetworkQuality();
    this.batteryStatus = new BatteryStatus();
    this.startMonitoring();
  }
  
  private async startMonitoring() {
    // Monitor network quality changes
    this.networkQuality.on('change', async (quality) => {
      await this.adjustSyncStrategy(quality);
    });
    
    // Monitor battery level
    this.batteryStatus.on('change', async (status) => {
      await this.adjustComputeIntensity(status);
    });
  }
  
  private async adjustSyncStrategy(quality: NetworkQualityLevel) {
    switch (quality) {
      case 'excellent':
        // Full sync with all enhancements
        await this.processQueue('full');
        break;
      case 'good':
        // Sync critical data only
        await this.processQueue('critical');
        break;
      case 'fair':
        // Minimal sync, defer non-essential
        await this.processQueue('minimal');
        break;
      case 'poor':
        // Queue operations for later
        this.queueAllOperations();
        break;
      case 'offline':
        // No sync, local-only mode
        this.enableOfflineMode();
        break;
    }
  }
  
  private async adjustComputeIntensity(battery: BatteryStatus) {
    if (battery.level < 20 && !battery.charging) {
      // Low battery: reduce computational load
      this.whisper.setModel('tiny'); // Smaller model
      this.disableRealTimeFeatures();
      this.scheduleHeavyTasks('deferred');
    } else if (battery.charging) {
      // Charging: can afford heavier operations
      this.whisper.setModel('base');
      this.enableRealTimeFeatures();
      this.processDeferredTasks();
    }
  }
  
  async queueOperation(operation: SyncOperation) {
    this.syncQueue.push(operation);
    
    // Try to process immediately if conditions allow
    const canProcess = await this.canProcessNow();
    if (canProcess) {
      await this.processQueue('critical');
    }
  }
  
  private async canProcessNow(): Promise<boolean> {
    const networkOk = this.networkQuality.getLevel() !== 'poor' && 
                      this.networkQuality.getLevel() !== 'offline';
    const batteryOk = this.batteryStatus.getLevel() > 20 || this.batteryStatus.isCharging();
    
    return networkOk && batteryOk;
  }
}

// voice-command-router.ts
interface VoiceCommandResult {
  success: boolean;
  result?: any;
  fallbackUsed?: boolean;
  latencyMs: number;
}

class VoiceCommandRouter {
  private localModels: Map<string, VoiceModel>;
  private cloudFallback: CloudVoiceService;
  private latencyThreshold: number = 300; // ms
  
  constructor() {
    this.localModels = new Map();
    this.cloudFallback = new CloudVoiceService();
    this.loadLocalModels();
  }
  
  private async loadLocalModels() {
    // Load models for common commands
    await this.loadModel('navigation', 'whisper-tiny');
    await this.loadModel('search', 'whisper-base');
    await this.loadModel('code', 'whisper-medium');
  }
  
  async routeCommand(audio: AudioBuffer, context: CommandContext): Promise<VoiceCommandResult> {
    const startTime = Date.now();
    
    // 1. Try local processing first
    const localResult = await this.tryLocalProcessing(audio, context);
    
    if (localResult.confidence > 0.8) {
      return {
        success: true,
        result: localResult.parsedCommand,
        latencyMs: Date.now() - startTime
      };
    }
    
    // 2. If local confidence is low, try cloud fallback
    if (navigator.onLine && localResult.confidence < 0.5) {
      const cloudResult = await this.cloudFallback.transcribe(audio);
      
      if (cloudResult.confidence > 0.9) {
        // Cache cloud result for future local use
        await this.cacheCloudResult(localResult, cloudResult);
        
        return {
          success: true,
          result: cloudResult.parsedCommand,
          fallbackUsed: true,
          latencyMs: Date.now() - startTime
        };
      }
    }
    
    // 3. Return best available result
    return {
      success: localResult.confidence > 0.3,
      result: localResult.parsedCommand,
      latencyMs: Date.now() - startTime
    };
  }
  
  private async tryLocalProcessing(
    audio: AudioBuffer,
    context: CommandContext
  ): Promise<LocalProcessingResult> {
    // Select appropriate model based on context
    const modelKey = this.selectModel(context);
    const model = this.localModels.get(modelKey);
    
    if (!model) {
      return { confidence: 0, parsedCommand: null };
    }
    
    const transcript = await model.transcribe(audio);
    const parsed = model.parse(transcript, context);
    
    return {
      transcript,
      parsedCommand: parsed,
      confidence: parsed.confidence
    };
  }
  
  private selectModel(context: CommandContext): string {
    if (context.type === 'code') return 'code';
    if (context.type === 'search') return 'search';
    return 'navigation';
  }
  
  private async cacheCloudResult(
    local: LocalProcessingResult,
    cloud: CloudProcessingResult
  ) {
    // Improve local model with cloud results
    await this.localModels.get(this.selectModel(context))
      .improveWithExample(local, cloud);
  }
}

// crdt-sync.ts
import { ORMap, LWWRegister } from 'yjs';
import { WebsocketProvider } from 'y-websocket';

class OfflineFirstSync {
  private doc: Y.Doc;
  private provider: WebsocketProvider;
  private localChanges: Change[] = [];
  
  constructor() {
    this.doc = new Y.Doc();
    this.setupSync();
  }
  
  private setupSync() {
    // Use Yjs for CRDT-based synchronization
    this.provider = new WebsocketProvider(
      'wss://sync.example.com',
      'dev-tools-project',
      this.doc
    );
    
    // Listen for remote changes
    this.doc.on('update', (update, origin) => {
      if (origin !== this) {
        this.handleRemoteChange(update);
      }
    });
    
    // Listen for connection status
    this.provider.on('status', (event) => {
      this.handleConnectionStatus(event.status);
    });
  }
  
  async addCommand(command: Command) {
    // Create local change
    const commandMap = this.doc.getMap('commands');
    const commandId = crypto.randomUUID();
    
    commandMap.set(commandId, {
      ...command,
      timestamp: Date.now(),
      deviceId: this.getDeviceId()
    });
    
    // Queue for sync
    this.localChanges.push({
      type: 'add',
      commandId,
      timestamp: Date.now()
    });
    
    // Try to sync immediately if online
    if (this.provider.status === 'connected') {
      await this.syncChanges();
    }
  }
  
  private async syncChanges() {
    if (this.provider.status !== 'connected') return;
    
    try {
      // Yjs handles synchronization automatically
      // We just need to ensure updates are sent
      const update = Y.encodeStateAsUpdate(this.doc);
      this.provider.emit('sync', update);
      
      // Clear local changes queue
      this.localChanges = [];
    } catch (error) {
      // Keep changes queued for retry
      console.warn('Sync failed, changes will retry:', error);
    }
  }
  
  private handleRemoteChange(update: Uint8Array) {
    // Apply remote changes to local document
    Y.applyUpdate(this.doc, update);
    
    // Notify listeners of changes
    this.emit('remote-change', update);
  }
  
  private handleConnectionStatus(status: string) {
    switch (status) {
      case 'connected':
        // Sync all pending changes
        this.syncChanges();
        break;
      case 'disconnected':
        // Continue working offline
        this.enableOfflineMode();
        break;
      case 'synced':
        // All changes synchronized
        this.clearSyncQueue();
        break;
    }
  }
  
  private enableOfflineMode() {
    // Switch to local-only operations
    this.doc.on('update', (update, origin) => {
      if (origin === this) {
        this.localChanges.push({
          type: 'update',
          data: update,
          timestamp: Date.now()
        });
      }
    });
  }
}

// network-simulator.ts
import { Page } from 'puppeteer';

class NetworkConditionSimulator {
  private page: Page;
  private conditions: Map<string, NetworkCondition> = new Map();
  
  constructor(page: Page) {
    this.page = page;
    this.setupConditions();
  }
  
  private setupConditions() {
    this.conditions.set('offline', {
      offline: true,
      download: 0,
      upload: 0,
      latency: 0
    });
    
    this.conditions.set('slow-3g', {
      offline: false,
      download: 40000, // 40 KB/s
      upload: 40000,
      latency: 1000 // 1s
    });
    
    this.conditions.set('fast-3g', {
      offline: false,
      download: 160000, // 160 KB/s
      upload: 160000,
      latency: 400 // 400ms
    });
    
    this.conditions.set('4g', {
      offline: false,
      download: 1000000, // 1 MB/s
      upload: 1000000,
      latency: 100 // 100ms
    });
    
    this.conditions.set('wifi', {
      offline: false,
      download: 10000000, // 10 MB/s
      upload: 10000000,
      latency: 10 // 10ms
    });
  }
  
  async applyCondition(condition: string) {
    const config = this.conditions.get(condition);
    if (!config) {
      throw new Error(`Unknown condition: ${condition}`);
    }
    
    await this.page.setOfflineMode(config.offline);
    
    if (!config.offline) {
      await this.page.emulateNetworkConditions({
        downloadThroughput: config.download,
        uploadThroughput: config.upload,
        latency: config.latency
      });
    }
  }
  
  async testOfflineResilience(tests: TestSuite) {
    const results: TestResult[] = [];
    
    for (const test of tests) {
      // Start with offline condition
      await this.applyCondition('offline');
      
      // Run test
      const result = await test.run();
      results.push(result);
      
      // Restore connectivity
      await this.applyCondition('wifi');
    }
    
    return results;
  }
  
  async testSyncRecovery() {
    // 1. Go offline
    await this.applyCondition('offline');
    
    // 2. Make local changes
    const changes = await this.makeLocalChanges();
    
    // 3. Come back online
    await this.applyCondition('4g');
    
    // 4. Wait for sync
    await this.waitForSync();
    
    // 5. Verify changes propagated
    const synced = await this.verifySync(changes);
    
    return synced;
  }
}

// performance-benchmarks.ts
import { Benchmark } from 'benchmark';

class PerformanceBenchmarks {
  private benchmarks: Benchmark[] = [];
  
  constructor() {
    this.setupBenchmarks();
  }
  
  private setupBenchmarks() {
    // Voice transcription benchmarks
    this.benchmarks.push(new Benchmark('Local Whisper Transcription', async () => {
      const audio = this.generateTestAudio();
      await this.localWhisper.transcribe(audio);
    }));
    
    this.benchmarks.push(new Benchmark('Cloud API Transcription', async () => {
      const audio = this.generateTestAudio();
      await this.cloudAPI.transcribe(audio);
    }));
    
    // Command parsing benchmarks
    this.benchmarks.push(new Benchmark('Local NLP Parsing', async () => {
      const command = 'open file utils.js';
      await this.localNLP.parse(command);
    }));
    
    this.benchmarks.push(new Benchmark('Cloud NLP Parsing', async () => {
      const command = 'open file utils.js';
      await this.cloudNLP.parse(command);
    }));
    
    // Sync operation benchmarks
    this.benchmarks.push(new Benchmark('Local CRDT Operation', async () => {
      await this.localCRDT.addCommand({ type: 'test', args: {} });
    }));
    
    this.benchmarks.push(new Benchmark('Cloud Sync Operation', async () => {
      await this.cloudSync.addCommand({ type: 'test', args: {} });
    }));
  }
  
  async runAll(): Promise<BenchmarkResult[]> {
    const results: BenchmarkResult[] = [];
    
    for (const benchmark of this.benchmarks) {
      await benchmark.run();
      
      results.push({
        name: benchmark.name,
        opsPerSecond: benchmark.hz,
        meanTime: benchmark.stats.mean,
        deviation: benchmark.stats.deviation,
        sampleSize: benchmark.stats.sampleSize
      });
    }
    
    return results;
  }
  
  generateReport(results: BenchmarkResult[]): string {
    let report = '# Performance Benchmark Report\n\n';
    report += '## Voice Transcription\n\n';
    report += '| Method | Ops/sec | Mean Time (ms) | Deviation |\n';
    report += '|--------|---------|----------------|-----------|\n';
    
    for (const result of results.filter(r => r.name.includes('Transcription'))) {
      report += `| ${result.name} | ${result.opsPerSecond.toFixed(2)} | ${result.meanTime.toFixed(2)} | ±${result.deviation.toFixed(2)} |\n`;
    }
    
    report += '\n## Key Insights\n\n';
    report += '1. **Local processing** is 10-100x faster for voice transcription\n';
    report += '2. **Cloud APIs** provide higher accuracy but with significant latency\n';
    report += '3. **CRDT operations** are essentially instant locally\n';
    report += '4. **Cloud sync** adds 200-500ms overhead per operation\n\n';
    
    report += '## Recommendations\n\n';
    report += '- Use local processing for real-time interactions\n';
    report += '- Fall back to cloud for complex analysis\n';
    report += '- Batch cloud sync operations during idle periods\n';
    report += '- Cache cloud results for offline reuse\n';
    
    return report;
  }
}

// local-security.ts
import { encrypt, decrypt } from 'crypto';
import { SecureStorage } from 'secure-storage';

class LocalDataSecurity {
  private secureStorage: SecureStorage;
  private encryptionKey: Buffer;
  
  constructor() {
    this.secureStorage = new SecureStorage();
    this.encryptionKey = this.deriveEncryptionKey();
  }
  
  private deriveEncryptionKey(): Buffer {
    // Use platform-specific secure key storage
    // - macOS: Keychain
    // - Windows: DPAPI
    // - Linux: libsecret
    // - Mobile: Keystore/Keychain
    return this.secureStorage.getOrCreateKey('voice-assistant-key');
  }
  
  async encryptLocalData(data: any): Promise<EncryptedData> {
    const plaintext = JSON.stringify(data);
    const iv = crypto.randomBytes(16);
    
    const encrypted = encrypt('aes-256-gcm', this.encryptionKey, iv, plaintext);
    
    return {
      ciphertext: encrypted.ciphertext,
      iv: iv.toString('base64'),
      authTag: encrypted.authTag.toString('base64'),
      algorithm: 'aes-256-gcm',
      timestamp: Date.now()
    };
  }
  
  async decryptLocalData(encrypted: EncryptedData): Promise<any> {
    const iv = Buffer.from(encrypted.iv, 'base64');
    const authTag = Buffer.from(encrypted.authTag, 'base64');
    
    const decrypted = decrypt('aes-256-gcm', this.encryptionKey, iv, encrypted.ciphertext, authTag);
    
    return JSON.parse(decrypted);
  }
  
  async secureDelete(data: any) {
    // Cryptographic shredding
    const encrypted = await this.encryptLocalData(data);
    const shredded = Buffer.alloc(encrypted.ciphertext.length, 0);
    
    // Overwrite multiple times
    for (let i = 0; i < 3; i++) {
      crypto.randomFillSync(shredded);
      await this.secureStorage.write(encrypted.ciphertext, shredded);
    }
    
    // Delete metadata
    await this.secureStorage.delete(encrypted.ciphertext);
  }
}

// migration-phase-1.ts
class OfflineMigration {
  private originalAPI: CloudAPI;
  private localCache: LocalCache;
  
  constructor(originalAPI: CloudAPI) {
    this.originalAPI = originalAPI;
    this.localCache = new LocalCache();
  }
  
  async wrapAPI<T>(method: string, params: any): Promise<T> {
    // Try local cache first
    const cached = await this.localCache.get(method, params);
    if (cached) {
      return cached.data as T;
    }
    
    // Fall back to cloud API
    try {
      const result = await this.originalAPI[method](params);
      
      // Cache for offline use
      await this.localCache.set(method, params, result);
      
      return result;
    } catch (error) {
      // If cloud fails, return stale cache if available
      const staleCache = await this.localCache.getStale(method, params);
      if (staleCache) {
        console.warn('Using stale cache due to cloud failure');
        return staleCache.data as T;
      }
      
      throw error;
    }
  }
}

// migration-phase-2.ts
class LocalProcessingMigration {
  private cloudAPI: CloudAPI;
  private localProcessor: LocalProcessor;
  private modelCache: ModelCache;
  
  constructor() {
    this.cloudAPI = new CloudAPI();
    this.localProcessor = new LocalProcessor();
    this.modelCache = new ModelCache();
  }
  
  async transcribeWithFallback(audio: AudioBuffer): Promise<TranscriptionResult> {
    // Check if local model is available
    if (await this.modelCache.isAvailable('whisper-base')) {
      // Try local processing
      const localResult = await this.localProcessor.transcribe(audio);
      
      if (localResult.confidence > 0.8) {
        return localResult;
      }
    }
    
    // Fall back to cloud
    const cloudResult = await this.cloudAPI.transcribe(audio);
    
    // Cache cloud result for future local improvement
    await this.modelCache.cacheExample(audio, cloudResult);
    
    return cloudResult;
  }
}

// migration-phase-3.ts
class FullOfflineFirst {
  private localEngine: LocalEngine;
  private syncEngine: SyncEngine;
  private modelManager: ModelManager;
  
  constructor() {
    this.localEngine = new LocalEngine();
    this.syncEngine = new SyncEngine();
    this.modelManager = new ModelManager();
  }
  
  async initialize() {
    // Load local models
    await this.modelManager.loadModels(['whisper-base', 'nlp-parser']);
    
    // Restore local state
    await this.localEngine.restoreState();
    
    // Start sync engine
    this.syncEngine.start();
    
    // Subscribe to sync events
    this.syncEngine.on('sync-complete', () => {
      this.localEngine.markSynced();
    });
  }
  
  async processCommand(command: string): Promise<CommandResult> {
    // 1. Process locally
    const localResult = await this.localEngine.processCommand(command);
    
    // 2. Queue for sync
    this.syncEngine.queueOperation({
      type: 'command-executed',
      command,
      result: localResult,
      timestamp: Date.now()
    });
    
    // 3. Return immediately
    return localResult;
  }
}