@meechi-ai/core 1.0.0

package/dist/lib/ai/providers/gemini.js

@@ -0,0 +1,88 @@
+import { GoogleGenerativeAI } from "@google/generative-ai";
+export class GeminiProvider {
+    constructor() {
+        this.id = "gemini";
+        this.name = "Google Gemini";
+    }
+    async chat(model, messages, tools, apiKey) {
+        if (!apiKey) {
+            apiKey = process.env.GEMINI_API_KEY;
+        }
+        if (!apiKey) {
+            throw new Error("Gemini API Key is missing. Please set it in Settings or .env");
+        }
+        const genAI = new GoogleGenerativeAI(apiKey);
+        const geminiModel = genAI.getGenerativeModel({
+            model: model || "gemini-flash-latest"
+        });
+        // Gemini format conversion
+        // Note: Gemini has specific rules about System prompts (must be separate)
+        let systemInstruction = "";
+        const history = [];
+        for (const msg of messages) {
+            if (msg.role === 'system') {
+                systemInstruction += msg.content + "\n";
+            }
+            else if (msg.role === 'user') {
+                history.push({ role: 'user', parts: [{ text: msg.content }] });
+            }
+            else if (msg.role === 'assistant') {
+                history.push({ role: 'model', parts: [{ text: msg.content }] });
+            }
+        }
+        // Configure generation config
+        const generationConfig = {
+            temperature: 0.7,
+            topK: 1,
+            topP: 1,
+            maxOutputTokens: 2048,
+        };
+        // Map Tools to Gemini Format
+        const geminiTools = tools === null || tools === void 0 ? void 0 : tools.map(t => ({
+            functionDeclarations: [{
+                    name: t.function.name,
+                    description: t.function.description,
+                    parameters: t.function.parameters
+                }]
+        }));
+        try {
+            const chatSession = geminiModel.startChat({
+                history: history.slice(0, -1), // All but last
+                generationConfig,
+                systemInstruction: systemInstruction ? { role: 'system', parts: [{ text: systemInstruction }] } : undefined,
+                tools: geminiTools
+            });
+            const lastMsg = history[history.length - 1];
+            const result = await chatSession.sendMessage(lastMsg.parts[0].text);
+            const response = await result.response;
+            // Check for Function Calls
+            const functionCalls = response.functionCalls();
+            if (functionCalls && functionCalls.length > 0) {
+                return {
+                    content: "",
+                    tool_calls: functionCalls.map((fc) => ({
+                        function: {
+                            name: fc.name,
+                            arguments: JSON.stringify(fc.args)
+                        }
+                    })),
+                    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+                };
+            }
+            const text = response.text();
+            return {
+                content: text,
+                usage: {
+                    // Mock usage for now as Gemini doesn't always return standard usage obj in same format
+                    prompt_tokens: 0,
+                    completion_tokens: 0,
+                    total_tokens: 0
+                }
+            };
+        }
+        catch (error) {
+            console.error("Gemini Provider Error:", error);
+            throw new Error(`Gemini Error: ${error.message}`);
+        }
+    }
+}

package/dist/lib/ai/providers/groq.d.ts

@@ -0,0 +1,6 @@
+import { AIProvider, AIChatMessage, AITool, AICompletion } from "../types";
+export declare class GroqProvider implements AIProvider {
+    id: string;
+    name: string;
+    chat(model: string, messages: AIChatMessage[], tools?: AITool[], apiKey?: string): Promise<AICompletion>;
+}

package/dist/lib/ai/providers/groq.js

@@ -0,0 +1,42 @@
+import Groq from "groq-sdk";
+export class GroqProvider {
+    constructor() {
+        this.id = "groq";
+        this.name = "Groq";
+    }
+    async chat(model, messages, tools, apiKey) {
+        if (!apiKey) {
+            // Fallback to Env if not provided explicitly
+            apiKey = process.env.GROQ_API_KEY || process.env.NEXT_PUBLIC_GROQ_API_KEY;
+        }
+        if (!apiKey) {
+            throw new Error("Groq API Key is missing. Please set it in Settings or .env");
+        }
+        const groq = new Groq({ apiKey });
+        console.log(`[Groq] Sending tools: ${(tools === null || tools === void 0 ? void 0 : tools.map(t => t.function.name).join(', ')) || 'None'}`);
+        try {
+            const chatCompletion = await groq.chat.completions.create({
+                messages: messages,
+                model: model || "llama-3.3-70b-versatile",
+                temperature: 0.7,
+                max_tokens: 1024,
+                top_p: 1,
+                stream: false,
+                stop: null,
+                tools: tools,
+                tool_choice: tools && tools.length > 0 ? "auto" : "none"
+            });
+            const choice = chatCompletion.choices[0];
+            const message = choice === null || choice === void 0 ? void 0 : choice.message;
+            return {
+                content: (message === null || message === void 0 ? void 0 : message.content) || "",
+                tool_calls: message === null || message === void 0 ? void 0 : message.tool_calls,
+                usage: chatCompletion.usage
+            };
+        }
+        catch (error) {
+            console.error("Groq Provider Error:", error);
+            throw new Error(`Groq Error: ${error.message}`);
+        }
+    }
+}

package/dist/lib/ai/registry.d.ts

@@ -0,0 +1,29 @@
+export interface ModelConfig {
+    id: string;
+    name: string;
+    family: 'llama' | 'gemma' | 'phi' | 'generic';
+    vram_required_mb: number;
+    low_power: boolean;
+    context_window: number;
+}
+interface LocalModelConfig extends ModelConfig {
+    id: string;
+    name: string;
+    family: 'llama' | 'gemma' | 'phi' | 'generic';
+    vram_required_mb: number;
+    low_power: boolean;
+    context_window: number;
+}
+interface CloudModelConfig {
+    id: string;
+    name: string;
+    context_window: number;
+}
+export declare const AVAILABLE_MODELS: {
+    local: LocalModelConfig[];
+    groq: CloudModelConfig[];
+    gemini: CloudModelConfig[];
+};
+export declare function getModelConfig(modelId: string): LocalModelConfig | undefined;
+export declare function getSystemPromptForModel(modelId: string): string;
+export {};

package/dist/lib/ai/registry.js

@@ -0,0 +1,52 @@
+import { SYSTEM_PROMPT } from './prompts';
+export const AVAILABLE_MODELS = {
+    local: [
+        {
+            id: 'Llama-3.2-1B-Instruct-q4f16_1-MLC',
+            name: 'Llama 3.2 1B (Fastest)',
+            family: 'llama',
+            vram_required_mb: 1500,
+            low_power: true,
+            context_window: 4096
+        },
+        {
+            id: 'Llama-3.2-3B-Instruct-q4f16_1-MLC',
+            name: 'Llama 3.2 3B (Balanced)',
+            family: 'llama',
+            vram_required_mb: 3000,
+            low_power: false,
+            context_window: 8192
+        },
+        {
+            id: 'TinyLlama-1.1B-Chat-v1.0-q4f16_1-MLC',
+            name: 'TinyLlama 1.1B',
+            family: 'llama',
+            vram_required_mb: 1000,
+            low_power: true,
+            context_window: 2048
+        }
+    ],
+    groq: [
+        { id: 'llama-3.3-70b-versatile', name: 'Llama 3.3 70B (Versatile)', context_window: 32768 },
+        { id: 'llama-3.1-8b-instant', name: 'Llama 3.1 8B (Instant)', context_window: 32768 },
+        { id: 'mixtral-8x7b-32768', name: 'Mixtral 8x7B', context_window: 32768 },
+        { id: 'gemma-2-9b-it', name: 'Gemma 2 9B', context_window: 8192 }
+    ],
+    gemini: [
+        { id: 'gemini-1.5-flash', name: 'Gemini 1.5 Flash (Fast)', context_window: 1000000 },
+        { id: 'gemini-1.5-pro', name: 'Gemini 1.5 Pro (Powerful)', context_window: 2000000 },
+        { id: 'gemini-1.0-pro', name: 'Gemini 1.0 Pro', context_window: 32000 }
+    ]
+};
+export function getModelConfig(modelId) {
+    return AVAILABLE_MODELS.local.find(m => m.id === modelId);
+}
+// Factory for getting the right System Prompt based on Model Family
+export function getSystemPromptForModel(modelId) {
+    const config = getModelConfig(modelId);
+    if (!config)
+        return SYSTEM_PROMPT; // Default
+    // We can specialize prompts here if needed in the future
+    // For now, Llama family works well with the default XML prompt
+    return SYSTEM_PROMPT;
+}

package/dist/lib/ai/tools.d.ts

@@ -0,0 +1,2 @@
+import { AITool } from "./types";
+export declare const TOOLS: AITool[];

package/dist/lib/ai/tools.js

@@ -0,0 +1,106 @@
+export const TOOLS = [
+    {
+        type: "function",
+        "function": {
+            name: "update_file",
+            description: "Update the content of an existing file. ONLY use this when the user explicitly asks to edit, modify, or append to a note. DO NOT use this spontaneously.",
+            parameters: {
+                type: "object",
+                properties: {
+                    filePath: {
+                        type: "string",
+                        description: "The path of the file to update.",
+                    },
+                    newContent: {
+                        type: "string",
+                        description: "The FULL new content of the file.",
+                    },
+                },
+                required: ["filePath", "newContent"],
+            },
+        },
+    },
+    {
+        type: "function",
+        "function": {
+            name: "create_file",
+            description: "Create a new file. ONLY use this when the user explicitly provides content to save or asks to create a specific document. Never create files spontaneously for 'testing' or 'logging'.",
+            parameters: {
+                type: "object",
+                properties: {
+                    filePath: {
+                        type: "string",
+                        description: "The path for the new file.",
+                    },
+                    content: {
+                        type: "string",
+                        description: "The content of the new file.",
+                    },
+                },
+                required: ["filePath", "content"],
+            },
+        },
+    },
+    {
+        type: "function",
+        "function": {
+            name: "update_user_settings",
+            description: "Update the user's Name or Tone. ONLY use this when the user explicitly asks to change their name or how the AI sounds. NEVER use this to 'guess' or 'set' a name based on general talk.",
+            parameters: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "The user's preferred name."
+                    },
+                    tone: {
+                        type: "string",
+                        description: "The preferred tone for the AI."
+                    }
+                },
+            },
+        },
+    },
+    {
+        type: "function",
+        "function": {
+            name: "move_file",
+            description: "Move or rename a file. Use this to organize files into folders (Topics) or rename them.",
+            parameters: {
+                type: "object",
+                properties: {
+                    sourcePath: {
+                        type: "string",
+                        description: "The current path of the file (e.g. 'temp/myfile.pdf')."
+                    },
+                    destinationPath: {
+                        type: "string",
+                        description: "The new path for the file (e.g. 'misc/Work/myfile.pdf')."
+                    }
+                },
+                required: ["sourcePath", "destinationPath"]
+            }
+        }
+    },
+    {
+        type: "function",
+        "function": {
+            name: "fetch_url",
+            description: "Fetch content from a URL to save as a source. Use this when the user shares a link.",
+            parameters: {
+                type: "object",
+                properties: {
+                    url: {
+                        type: "string",
+                        description: "The URL to fetch."
+                    },
+                    destinationPath: {
+                        type: "string",
+                        description: "The path to save the source to (e.g. 'misc/Research/source.md')."
+                    }
+                },
+                required: ["url", "destinationPath"]
+            }
+        }
+    }
+];

package/dist/lib/ai/types.d.ts

@@ -0,0 +1,22 @@
+export interface AIChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface AITool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: any;
+    };
+}
+export interface AICompletion {
+    content: string;
+    tool_calls?: any[];
+    usage?: any;
+}
+export interface AIProvider {
+    id: string;
+    name: string;
+    chat(model: string, messages: AIChatMessage[], tools?: AITool[], apiKey?: string): Promise<AICompletion>;
+}

package/dist/lib/ai/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/ai/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/ai/worker.js

@@ -0,0 +1,60 @@
+// Global storage for the pipeline
+let embedder = null;
+const EMBEDDING_MODEL = 'Xenova/all-MiniLM-L6-v2';
+// Helper to load the library from static vendor file
+async function loadLibrary() {
+    // @ts-ignore
+    if (self.transformers)
+        return self.transformers;
+    console.log("[RAG Worker] Loading Transformers.js from static vendor...");
+    // Import from public/vendor/transformers.js (served by the main app)
+    // @ts-ignore
+    const mod = await import(/* webpackIgnore: true */ '/vendor/transformers.js');
+    return mod;
+}
+// Initialize the model
+async function init() {
+    if (embedder)
+        return embedder;
+    try {
+        const { pipeline, env } = await loadLibrary();
+        // Configure environment
+        env.allowLocalModels = false; // Fetch model weights from CDN (or cache)
+        env.useBrowserCache = true; // Cache weights in browser (Offline support after first load)
+        console.log(`[RAG Worker] Loading Model: ${EMBEDDING_MODEL}...`);
+        // Load the feature extraction pipeline
+        embedder = await pipeline('feature-extraction', EMBEDDING_MODEL, {
+            quantized: true, // Use quantized model for speed/size (matches USE performance)
+        });
+        console.log("[RAG Worker] Model loaded successfully!");
+        return embedder;
+    }
+    catch (err) {
+        console.error("[RAG Worker] Initialization Failed:", err);
+        throw err;
+    }
+}
+self.onmessage = async (event) => {
+    const { id, text } = event.data;
+    if (!text) {
+        self.postMessage({ id, error: "No text provided" });
+        return;
+    }
+    try {
+        const pipe = await init();
+        // Convert text to embedding
+        // output is a Tensor { data: Float32Array, dims: [...] }
+        const output = await pipe(text, {
+            pooling: 'mean', // Mean pooling is standard for sentence embeddings
+            normalize: true, // Normalize vectors for cosine similarity
+        });
+        // Extract the vector as a plain array
+        const embedding = Array.from(output.data);
+        self.postMessage({ id, embedding });
+    }
+    catch (err) {
+        console.error("[RAG Worker] Error:", err);
+        self.postMessage({ id, error: err.message });
+    }
+};
+export {};

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

@@ -0,0 +1,13 @@
+export declare class AudioInputService {
+    private audioContext;
+    private stream;
+    private processor;
+    private source;
+    private analyser;
+    private readonly SAMPLE_RATE;
+    constructor();
+    getAnalyser(): AnalyserNode | null;
+    start(onAudioData: (data: Float32Array) => void): Promise<void>;
+    stop(): void;
+    private downsampleBuffer;
+}

package/dist/lib/audio/input.js

@@ -0,0 +1,121 @@
+export class AudioInputService {
+    constructor() {
+        this.audioContext = null;
+        this.stream = null;
+        this.processor = null; // Fallback or AudioWorklet
+        this.source = null;
+        this.analyser = null;
+        // Whisper typically expects 16kHz
+        this.SAMPLE_RATE = 16000;
+    }
+    getAnalyser() {
+        return this.analyser;
+    }
+    async start(onAudioData) {
+        if (this.stream)
+            return;
+        try {
+            this.stream = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    channelCount: 1,
+                    echoCancellation: true,
+                    noiseSuppression: true,
+                    autoGainControl: true,
+                    sampleRate: this.SAMPLE_RATE
+                }
+            });
+            this.audioContext = new AudioContext({ sampleRate: this.SAMPLE_RATE });
+            console.log(`[AudioInput] AudioContext created. Requested: ${this.SAMPLE_RATE}, Actual: ${this.audioContext.sampleRate}`);
+            await this.audioContext.resume(); // Ensure running
+            this.source = this.audioContext.createMediaStreamSource(this.stream);
+            this.analyser = this.audioContext.createAnalyser();
+            this.analyser.fftSize = 256;
+            this.processor = this.audioContext.createScriptProcessor(4096, 1, 1);
+            // Mute the monitoring to prevent feedback (Microphone -> Speaker loop)
+            const muteNode = this.audioContext.createGain();
+            muteNode.gain.value = 0;
+            this.processor.connect(muteNode);
+            muteNode.connect(this.audioContext.destination);
+            let buffer = new Float32Array(0);
+            const TARGET_CHUNK_SIZE = 512;
+            this.processor.onaudioprocess = (e) => {
+                let inputData = e.inputBuffer.getChannelData(0);
+                // Software Gain (1.5x) - Reduced from 3x/5x to fix clipping/distortion
+                const GAIN_FACTOR = 1.5;
+                const amplified = new Float32Array(inputData.length);
+                for (let i = 0; i < inputData.length; i++) {
+                    amplified[i] = inputData[i] * GAIN_FACTOR;
+                }
+                inputData = amplified;
+                // DOWNSAMPLE if mismatch (e.g. 48k -> 16k)
+                if (this.audioContext && this.audioContext.sampleRate !== this.SAMPLE_RATE) {
+                    inputData = this.downsampleBuffer(inputData, this.audioContext.sampleRate, this.SAMPLE_RATE);
+                }
+                // Append
+                const newBuffer = new Float32Array(buffer.length + inputData.length);
+                newBuffer.set(buffer, 0);
+                newBuffer.set(inputData, buffer.length);
+                buffer = newBuffer;
+                while (buffer.length >= TARGET_CHUNK_SIZE) {
+                    const chunk = buffer.slice(0, TARGET_CHUNK_SIZE);
+                    buffer = buffer.slice(TARGET_CHUNK_SIZE);
+                    onAudioData(chunk);
+                }
+            };
+            // Connect graph: Source -> Analyser -> Processor -> Destination
+            this.source.connect(this.analyser);
+            this.analyser.connect(this.processor);
+            this.processor.connect(this.audioContext.destination);
+            console.log("[AudioInput] Engine started successfully");
+        }
+        catch (err) {
+            console.error("AudioInputService Error:", err);
+            throw err;
+        }
+    }
+    stop() {
+        if (this.stream) {
+            this.stream.getTracks().forEach(track => track.stop());
+            this.stream = null;
+        }
+        if (this.processor) {
+            this.processor.disconnect();
+            this.processor = null;
+        }
+        if (this.source) {
+            this.source.disconnect();
+            this.source = null;
+        }
+        if (this.audioContext) {
+            this.audioContext.close();
+            this.audioContext = null;
+        }
+    }
+    // Helper: Simple Linear Interpolation Downsampler
+    downsampleBuffer(buffer, sampleRate, outSampleRate) {
+        if (outSampleRate === sampleRate)
+            return buffer;
+        if (outSampleRate > sampleRate) {
+            console.warn("[AudioInput] Upsampling not supported, returning original");
+            return buffer;
+        }
+        const sampleRateRatio = sampleRate / outSampleRate;
+        const newLength = Math.round(buffer.length / sampleRateRatio);
+        const result = new Float32Array(newLength);
+        let offsetResult = 0;
+        let offsetBuffer = 0;
+        while (offsetResult < result.length) {
+            const nextOffsetBuffer = Math.round((offsetResult + 1) * sampleRateRatio);
+            // Average values in the range
+            let accum = 0, count = 0;
+            for (let i = offsetBuffer; i < nextOffsetBuffer && i < buffer.length; i++) {
+                accum += buffer[i];
+                count++;
+            }
+            result[offsetResult] = count > 0 ? accum / count : 0;
+            offsetResult++;
+            offsetBuffer = nextOffsetBuffer;
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,13 @@
+type TranscriberPipeline = (audio: Float32Array | Float64Array, options?: any) => Promise<{
+    text: string;
+}>;
+export declare class TranscriberService {
+    private static instance;
+    private static modelId;
+    private static cloudKey;
+    static setCloudProvider(apiKey: string | null): void;
+    static getInstance(): Promise<TranscriberPipeline>;
+    static transcribe(audio: Float32Array): Promise<string>;
+    private static encodeWAV;
+}
+export {};