@meechi-ai/core 1.0.0

package/dist/lib/audio/stt.js

@@ -0,0 +1,119 @@
+// NOTE: @xenova/transformers is imported dynamically to prevent SWC parse errors at build time.
+export class TranscriberService {
+    // Allow injecting key from outside (e.g. settings)
+    static setCloudProvider(apiKey) {
+        this.cloudKey = apiKey;
+    }
+    static async getInstance() {
+        if (!this.instance) {
+            console.log(`Loading Metadata for ${this.modelId}...`);
+            // Dynamically import @xenova/transformers
+            const { pipeline, env } = await import('@xenova/transformers');
+            env.allowLocalModels = false;
+            env.useBrowserCache = true;
+            this.instance = await pipeline('automatic-speech-recognition', this.modelId, {
+            // quantized: true, // Disable quantization to debug "empty text" issue
+            });
+            console.log("Transcriber Model Loaded");
+        }
+        return this.instance;
+    }
+    static async transcribe(audio) {
+        if (audio.length === 0)
+            return "";
+        // Pass 1: Find Peak
+        let max = 0;
+        for (let i = 0; i < audio.length; i++) {
+            const abs = Math.abs(audio[i]);
+            if (abs > max)
+                max = abs;
+        }
+        // Pass 2: Normalize to 0.95 (Boost volume)
+        const normalized = new Float32Array(audio.length);
+        const scale = max > 0 ? 0.95 / max : 1;
+        console.log(`[STT] Normalizing Audio. Peak: ${max.toFixed(4)} -> Scale: ${scale.toFixed(4)}`);
+        for (let i = 0; i < audio.length; i++) {
+            normalized[i] = audio[i] * scale;
+        }
+        // CLOUD FAST PATH (GROQ)
+        // If we have a cloud key, use Groq Whisper for 50x speedup
+        if (this.cloudKey || process.env.NEXT_PUBLIC_GROQ_API_KEY) {
+            const key = this.cloudKey || process.env.NEXT_PUBLIC_GROQ_API_KEY;
+            console.log("[STT] Using Cloud Whisper (Groq) for speed...");
+            try {
+                // Convert Float32Array to WAV Blob
+                const wavBlob = await this.encodeWAV(normalized);
+                const formData = new FormData();
+                formData.append('file', wavBlob, 'audio.wav');
+                formData.append('model', 'whisper-large-v3'); // Groq supports large-v3
+                formData.append('response_format', 'json');
+                const res = await fetch('https://api.groq.com/openai/v1/audio/transcriptions', {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${key}`
+                    },
+                    body: formData
+                });
+                if (!res.ok)
+                    throw new Error(`Groq STT Error: ${res.status}`);
+                const data = await res.json();
+                console.log("[STT-Cloud] Result:", data.text);
+                return data.text.trim();
+            }
+            catch (cloudErr) {
+                console.warn("[STT] Cloud failed, falling back to local:", cloudErr);
+            }
+        }
+        // FALLBACK: Local Xenova
+        try {
+            const transcriber = await this.getInstance();
+            // Simplified options to reduce potential conflicts
+            const output = await transcriber(normalized, {
+                language: 'english',
+                task: 'transcribe',
+            });
+            console.log("[STT-Local] Raw Output:", JSON.stringify(output, null, 2));
+            return output.text.trim();
+        }
+        catch (e) {
+            console.error("Transcription Error:", e);
+            return "";
+        }
+    }
+    // Helper: Encode Float32 to WAV for API upload
+    static encodeWAV(samples, sampleRate = 16000) {
+        const buffer = new ArrayBuffer(44 + samples.length * 2);
+        const view = new DataView(buffer);
+        const writeString = (view, offset, string) => {
+            for (let i = 0; i < string.length; i++) {
+                view.setUint8(offset + i, string.charCodeAt(i));
+            }
+        };
+        // RIFF chunk descriptor
+        writeString(view, 0, 'RIFF');
+        view.setUint32(4, 36 + samples.length * 2, true);
+        writeString(view, 8, 'WAVE');
+        writeString(view, 12, 'fmt ');
+        view.setUint32(16, 16, true);
+        view.setUint16(20, 1, true); // PCM
+        view.setUint16(22, 1, true); // Mono
+        view.setUint32(24, sampleRate, true);
+        view.setUint32(28, sampleRate * 2, true);
+        view.setUint16(32, 2, true);
+        view.setUint16(34, 16, true);
+        writeString(view, 36, 'data');
+        view.setUint32(40, samples.length * 2, true);
+        // PCM Samples
+        let offset = 44;
+        for (let i = 0; i < samples.length; i++) {
+            let s = Math.max(-1, Math.min(1, samples[i]));
+            view.setInt16(offset, s * 0x7FFF, true);
+            offset += 2;
+        }
+        return new Blob([buffer], { type: 'audio/wav' });
+    }
+}
+TranscriberService.instance = null;
+// Upgrade to base.en for better accuracy/robustness than tiny
+TranscriberService.modelId = 'Xenova/whisper-base.en';
+TranscriberService.cloudKey = null;

package/dist/lib/audio/tts.d.ts

@@ -0,0 +1,12 @@
+export declare class SynthesizerService {
+    private static tts;
+    private static modelId;
+    private static dtype;
+    private static cloudKey;
+    static setCloudProvider(apiKey: string | null): void;
+    static init(): Promise<void>;
+    static speak(text: string): Promise<{
+        audio: Float32Array;
+        sampling_rate: number;
+    } | null>;
+}

package/dist/lib/audio/tts.js

@@ -0,0 +1,128 @@
+// NOTE: KokoroTTS uses ONNX internally and @huggingface/transformers for env.
+// We dynamically import from static vendor file to prevent SWC parse errors at build time.
+export class SynthesizerService {
+    static setCloudProvider(apiKey) {
+        this.cloudKey = apiKey;
+    }
+    static async init() {
+        // If we have an OpenAI Key (or cloud key), we don't strictly NEED to load local TTS immediately.
+        // But we might want it as fallback.
+        // Let's lazy load: If speak() fails on cloud, it initializes local.
+        // So init() can be a no-op if cloud is ready, or run in background.
+        const hasCloud = !!(this.cloudKey || process.env.NEXT_PUBLIC_OPENAI_API_KEY);
+        if (!hasCloud) {
+            console.log("Initializing Local Kokoro TTS...");
+            if (!this.tts) {
+                // Dynamically import kokoro-js and configure env
+                const { KokoroTTS } = await import('kokoro-js');
+                // @ts-ignore - Load transformers from static vendor file
+                let transformers = globalThis.transformers;
+                if (!transformers) {
+                    // @ts-ignore
+                    transformers = await import(/* webpackIgnore: true */ '/vendor/transformers.js');
+                }
+                const { env } = transformers;
+                env.allowLocalModels = false;
+                env.useBrowserCache = true;
+                this.tts = await KokoroTTS.from_pretrained(this.modelId, {
+                    dtype: this.dtype,
+                });
+                console.log("Kokoro TTS Initialized");
+            }
+        }
+        else {
+            console.log("Cloud TTS Key detected. Local TTS deferred.");
+        }
+    }
+    static async speak(text) {
+        // 1. CLOUD TURBO MODE (OpenAI / Groq)
+        // Check for specific keys in order: Injected -> OpenAI Env -> Groq Env
+        const key = this.cloudKey || process.env.NEXT_PUBLIC_OPENAI_API_KEY || process.env.NEXT_PUBLIC_GROQ_API_KEY;
+        if (key) {
+            const isGroq = key.startsWith('gsk_');
+            const url = isGroq
+                ? "https://api.groq.com/openai/v1/audio/speech"
+                : "https://api.openai.com/v1/audio/speech";
+            // Groq requires specific model names.
+            // 'playai-tts' is decommissioned. New default is 'canopylabs/orpheus-v1-english'.
+            const model = isGroq ? "canopylabs/orpheus-v1-english" : "tts-1";
+            console.log(`[TTS] Using Cloud TTS (${isGroq ? 'Groq' : 'OpenAI'})... Model: ${model}`);
+            // Groq (Orpheus) supports specific voices: autumn, diana, hannah, austin, daniel, troy
+            // OpenAI supports: alloy, echo, fable, etc.
+            const voice = isGroq ? "diana" : "alloy";
+            try {
+                const res = await fetch(url, {
+                    method: "POST",
+                    headers: {
+                        "Authorization": `Bearer ${key}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        model: model,
+                        input: text,
+                        voice: voice,
+                        response_format: isGroq ? "wav" : "mp3",
+                        speed: 1.15
+                    })
+                });
+                if (!res.ok) {
+                    const errText = await res.text();
+                    throw new Error(`Cloud TTS Error (${res.status}): ${errText}`);
+                }
+                const blob = await res.blob();
+                const arrayBuffer = await blob.arrayBuffer();
+                // Decode MP3 to Float32
+                const ctx = new AudioContext();
+                const audioBuffer = await ctx.decodeAudioData(arrayBuffer);
+                const pcm = audioBuffer.getChannelData(0); // Mono
+                // Copy to new float array
+                const pcmData = new Float32Array(pcm);
+                const sampleRate = audioBuffer.sampleRate;
+                ctx.close();
+                return {
+                    audio: pcmData,
+                    sampling_rate: sampleRate
+                };
+            }
+            catch (err) {
+                console.warn("[TTS] Cloud failed, attempting local fallback:", err);
+            }
+        }
+        // 2. LOCAL FALLBACK
+        if (!this.tts) {
+            console.log("Initializing Local Kokoro TTS (Fallback)...");
+            // Dynamically import kokoro-js
+            const { KokoroTTS } = await import('kokoro-js');
+            // @ts-ignore - Load transformers from static vendor file
+            let transformers = globalThis.transformers;
+            if (!transformers) {
+                // @ts-ignore
+                transformers = await import(/* webpackIgnore: true */ '/vendor/transformers.js');
+            }
+            const { env } = transformers;
+            env.allowLocalModels = false;
+            env.useBrowserCache = true;
+            this.tts = await KokoroTTS.from_pretrained(this.modelId, {
+                dtype: this.dtype,
+            });
+        }
+        if (!this.tts)
+            return null;
+        try {
+            // Default voice: af_bella
+            const audio = await this.tts.generate(text, {
+                voice: "af_bella",
+            });
+            return audio;
+        }
+        catch (e) {
+            console.error("TTS Synthesis Error:", e);
+            return null;
+        }
+    }
+}
+SynthesizerService.tts = null; // KokoroTTS
+SynthesizerService.modelId = "onnx-community/Kokoro-82M-ONNX";
+SynthesizerService.dtype = "fp32";
+// Cloud API Key (Optional)
+SynthesizerService.cloudKey = null;

package/dist/lib/audio/vad.d.ts

@@ -0,0 +1,18 @@
+export declare class VADService {
+    private session;
+    private h;
+    private c;
+    private sr;
+    private readonly SAMPLE_RATE;
+    private readonly WINDOW_SIZE_SAMPLES;
+    private readonly THRESHOLD_START;
+    private readonly THRESHOLD_END;
+    private isSpeaking;
+    constructor();
+    init(modelPath?: string): Promise<void>;
+    process(audioFrame: Float32Array): Promise<{
+        isSpeech: boolean;
+        probability: number;
+    }>;
+    reset(): void;
+}

package/dist/lib/audio/vad.js

@@ -0,0 +1,117 @@
+let ort = null;
+export class VADService {
+    constructor() {
+        this.session = null; // ort.InferenceSession
+        this.h = null; // ort.Tensor
+        this.c = null; // ort.Tensor
+        this.sr = null; // ort.Tensor
+        this.SAMPLE_RATE = 16000;
+        this.WINDOW_SIZE_SAMPLES = 512; // 32ms at 16kHz
+        // Thresholds
+        this.THRESHOLD_START = 0.3; // Increased to avoid trigger on static
+        this.THRESHOLD_END = 0.15;
+        // State
+        this.isSpeaking = false;
+    }
+    async init(modelPath = '/models/silero_vad.onnx') {
+        try {
+            // Dynamically import onnxruntime-web to prevent SWC from parsing it at build time.
+            if (!ort) {
+                ort = await import('onnxruntime-web');
+                ort.env.logLevel = 'error'; // Silence benign warnings
+            }
+            // Initialize ONNX session
+            this.session = await ort.InferenceSession.create(modelPath, {
+                executionProviders: ['wasm'], // Force WASM for consistency
+                logSeverityLevel: 3, // 0:Verbose, 1:Info, 2:Warning, 3:Error, 4:Fatal
+            });
+            // Initialize states (2, 1, 64) float32
+            const dims = [2, 1, 64];
+            const size = 128;
+            this.h = new ort.Tensor('float32', new Float32Array(size).fill(0), dims);
+            this.c = new ort.Tensor('float32', new Float32Array(size).fill(0), dims);
+            // Sample rate tensor (Must be int64)
+            this.sr = new ort.Tensor('int64', BigInt64Array.from([BigInt(this.SAMPLE_RATE)]), [1]);
+            console.log("VADService initialized");
+        }
+        catch (e) {
+            console.error("Failed to initialize VAD:", e);
+            throw e;
+        }
+    }
+    async process(audioFrame) {
+        if (!this.session || !this.h || !this.c || !this.sr || !ort) {
+            return { isSpeech: false, probability: 0 };
+        }
+        try {
+            // Create Input Tensor: (1, N)
+            const input = new ort.Tensor('float32', audioFrame, [1, audioFrame.length]);
+            // Check input names to support both v4 and v5
+            const inputNames = this.session.inputNames;
+            const feeds = {
+                input: input,
+                sr: this.sr,
+            };
+            if (inputNames.includes('state')) {
+                // Silero v5: Combined state [2, 1, 128]
+                const targetShape = [2, 1, 128];
+                const targetSize = 256;
+                // 1. Validate 'h' existence and size
+                if (!this.h || this.h.data.length !== targetSize) {
+                    this.h = new ort.Tensor('float32', new Float32Array(targetSize).fill(0), targetShape);
+                }
+                // 2. Validate 'h' dimensions (Reshape if needed)
+                else if (this.h.dims.length !== 3 || this.h.dims[0] !== 2 || this.h.dims[1] !== 1 || this.h.dims[2] !== 128) {
+                    // Reshape keeping data
+                    this.h = new ort.Tensor('float32', this.h.data, targetShape);
+                }
+                feeds['state'] = this.h;
+            }
+            else {
+                // ... v4 logic ...
+                feeds['h'] = this.h;
+                feeds['c'] = this.c;
+            }
+            const results = await this.session.run(feeds);
+            const probability = results.output.data[0];
+            // Update states
+            if (inputNames.includes('state')) {
+                const rawState = results.stateN || results.state;
+                // Bug Fix: Silero V5 might Output weird shapes (e.g. {1,1,1,128,8}) in some envs
+                // We force reshape back to [2, 1, 128] for consistency in the next loop.
+                if (rawState) {
+                    const targetShape = [2, 1, 128];
+                    if (rawState.dims.length !== 3 || rawState.dims[0] !== 2) {
+                        this.h = new ort.Tensor('float32', rawState.data, targetShape);
+                    }
+                    else {
+                        this.h = rawState;
+                    }
+                }
+            }
+            else {
+                this.h = results.hn;
+                this.c = results.cn;
+            }
+            // Trigger logic
+            if (probability > this.THRESHOLD_START && !this.isSpeaking) {
+                this.isSpeaking = true;
+            }
+            else if (probability < this.THRESHOLD_END && this.isSpeaking) {
+                this.isSpeaking = false;
+            }
+            return { isSpeech: this.isSpeaking, probability };
+        }
+        catch (e) {
+            console.error("VAD Inference Error:", e);
+            return { isSpeech: false, probability: 0 };
+        }
+    }
+    reset() {
+        // Reset states
+        // We set to null so they re-init on next process() call with correct v4/v5 logic
+        this.h = null;
+        this.c = null;
+        this.isSpeaking = false;
+    }
+}

package/dist/lib/colors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Color Utilities for Meechi
+ * Implements Hex -> OKLCH conversion for the dynamic theme engine.
+ *
+ * Flow: Hex -> RGB -> Linear RGB -> OKLAB -> OKLCH
+ */
+/**
+ * Main function: Converts Hex to OKLCH string
+ * Returns an object with the components for CSS variables
+ */
+export declare function getOklch(hex: string): {
+    l: string;
+    c: string;
+    h: string;
+    cssValue: string;
+};

package/dist/lib/colors.js

@@ -0,0 +1,67 @@
+/**
+ * Color Utilities for Meechi
+ * Implements Hex -> OKLCH conversion for the dynamic theme engine.
+ *
+ * Flow: Hex -> RGB -> Linear RGB -> OKLAB -> OKLCH
+ */
+// 1. Hex to sRGB (0-1)
+function hexToRgb(hex) {
+    hex = hex.replace(/^#/, '');
+    if (hex.length === 3)
+        hex = hex.split('').map(c => c + c).join('');
+    const bigint = parseInt(hex, 16);
+    const r = ((bigint >> 16) & 255) / 255;
+    const g = ((bigint >> 8) & 255) / 255;
+    const b = (bigint & 255) / 255;
+    return { r, g, b };
+}
+// 2. sRGB to Linear RGB
+// sRGB transfer function removal
+function linearize(c) {
+    return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+// 3. Linear RGB to OKLAB
+// Approximate matrices from Okhwb/Okyz specifications
+function rgbToOklab(rLin, gLin, bLin) {
+    const l = 0.4122214708 * rLin + 0.5363325363 * gLin + 0.0514459929 * bLin;
+    const m = 0.2119034982 * rLin + 0.6806995451 * gLin + 0.1073969566 * bLin;
+    const s = 0.0883024619 * rLin + 0.2817188376 * gLin + 0.6299787005 * bLin;
+    const l_ = Math.cbrt(l);
+    const m_ = Math.cbrt(m);
+    const s_ = Math.cbrt(s);
+    const L = 0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_;
+    const a = 1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_;
+    const b = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_;
+    return { L, a, b };
+}
+// 4. OKLAB to OKLCH
+function oklabToOklch(L, a, b) {
+    const C = Math.sqrt(a * a + b * b);
+    let h = Math.atan2(b, a) * (180 / Math.PI);
+    if (h < 0)
+        h += 360;
+    return { l: L, c: C, h };
+}
+/**
+ * Main function: Converts Hex to OKLCH string
+ * Returns an object with the components for CSS variables
+ */
+export function getOklch(hex) {
+    const { r, g, b } = hexToRgb(hex);
+    const rLin = linearize(r);
+    const gLin = linearize(g);
+    const bLin = linearize(b);
+    const { L, a, b: bLab } = rgbToOklab(rLin, gLin, bLin);
+    const { l, c, h } = oklabToOklch(L, a, bLab);
+    // Format for CSS
+    // Round for clean output
+    const lStr = l.toFixed(3);
+    const cStr = c.toFixed(3);
+    const hStr = h.toFixed(2);
+    return {
+        l: lStr,
+        c: cStr,
+        h: hStr,
+        cssValue: `oklch(${lStr} ${cStr} ${hStr})`
+    };
+}

package/dist/lib/extensions.d.ts

@@ -0,0 +1,35 @@
+import { LucideIcon } from 'lucide-react';
+import React from 'react';
+/**
+ * MEECHI EXTENSION SYSTEM (Core)
+ * ----------------------------
+ * This file provides the generic slots for the application.
+ * In Core, these registries are empty.
+ * Parent applications can populate these registries at runtime/init.
+ */
+export interface SettingsTab {
+    id: string;
+    label: string;
+    icon: LucideIcon;
+    component: React.ComponentType;
+}
+export interface FileContext {
+    storage: any;
+}
+export interface FileAction {
+    id: string;
+    label: string;
+    icon?: LucideIcon;
+    handler: (file: any, context: FileContext) => Promise<void>;
+    shouldShow?: (file: any) => boolean;
+}
+declare class ExtensionRegistry {
+    private settingsTabs;
+    private fileActions;
+    registerSettingsTab(tab: SettingsTab): void;
+    getSettingsTabs(): SettingsTab[];
+    registerFileAction(action: FileAction): void;
+    getFileActions(): FileAction[];
+}
+export declare const extensions: ExtensionRegistry;
+export {};

package/dist/lib/extensions.js

@@ -0,0 +1,24 @@
+class ExtensionRegistry {
+    constructor() {
+        this.settingsTabs = [];
+        this.fileActions = [];
+    }
+    registerSettingsTab(tab) {
+        if (!this.settingsTabs.find(t => t.id === tab.id)) {
+            this.settingsTabs.push(tab);
+        }
+    }
+    getSettingsTabs() {
+        return [...this.settingsTabs];
+    }
+    // File Explorer Slots
+    registerFileAction(action) {
+        if (!this.fileActions.find(a => a.id === action.id)) {
+            this.fileActions.push(action);
+        }
+    }
+    getFileActions() {
+        return [...this.fileActions];
+    }
+}
+export const extensions = new ExtensionRegistry();

package/dist/lib/hooks/use-voice-loop.d.ts

@@ -0,0 +1,13 @@
+type VoiceState = 'idle' | 'listening' | 'processing' | 'speaking';
+export declare function useVoiceLoop(sendMessage: (text: string, onToken?: (chunk: string) => void) => Promise<string | void>): {
+    start: () => Promise<void>;
+    stop: () => void;
+    stopPlayback: () => void;
+    state: VoiceState;
+    vadProb: number;
+    transcript: string;
+    playResponse: (text: string) => Promise<void>;
+    isPlaying: boolean;
+    getAnalyser: () => AnalyserNode | null;
+};
+export {};