@meechi-ai/core 1.0.0

package/dist/lib/mcp/native/LocalVoiceNative.js

@@ -0,0 +1,27 @@
+/**
+ * NATIVE SERVER: LocalVoiceNative
+ *
+ * Experimental Local Voice capability.
+ * Uses client-side ONNX models (Whisper/Kokoro) for private, offline interaction.
+ *
+ * This is a "capability" native - it exposes UI features rather than AI tools.
+ */
+export class LocalVoiceNative {
+    constructor() {
+        this.id = "native-local-voice";
+        this.name = "Native Local Voice (Experimental)";
+        this.description = "Privacy-first local voice interaction using browser-based STT (Whisper) and TTS (Kokoro). Experimental.";
+        this.isPermanent = false;
+    }
+    async getTools() {
+        // Local voice exposes internal capabilities through standard audio services.
+        return [];
+    }
+    async executeTool(name, args) {
+        throw new Error(`Tool ${name} not implemented in LocalVoiceNative`);
+    }
+    // Indicates this server is capable of providing voice services
+    isVoiceCapable() {
+        return true;
+    }
+}

package/dist/lib/mcp/native/MeechiNativeCore.d.ts

@@ -0,0 +1,25 @@
+import { McpTool } from '../types';
+import { McpConnector } from '../McpRegistry';
+/**
+ * NATIVE SERVER: MeechiNativeCore
+ *
+ * The permanent, mandatory internal tool provider.
+ * Contains core file management and knowledge tools.
+ *
+ * This is a "Native" server - an in-process TypeScript class that follows
+ * the MCP interface pattern but does NOT use the actual MCP protocol
+ * (no JSON-RPC, no IPC). It's part of the same runtime as the host.
+ */
+export declare class MeechiNativeCore implements McpConnector {
+    id: string;
+    name: string;
+    description: string;
+    isPermanent: boolean;
+    private tools;
+    private storage;
+    constructor();
+    private registerTools;
+    private addTool;
+    getTools(): Promise<McpTool[]>;
+    executeTool(name: string, args: any): Promise<any>;
+}

package/dist/lib/mcp/native/MeechiNativeCore.js

@@ -0,0 +1,209 @@
+import { LocalStorageProvider } from '../../storage/local';
+import { extractTextFromPdf } from '../../pdf';
+/**
+ * NATIVE SERVER: MeechiNativeCore
+ *
+ * The permanent, mandatory internal tool provider.
+ * Contains core file management and knowledge tools.
+ *
+ * This is a "Native" server - an in-process TypeScript class that follows
+ * the MCP interface pattern but does NOT use the actual MCP protocol
+ * (no JSON-RPC, no IPC). It's part of the same runtime as the host.
+ */
+export class MeechiNativeCore {
+    constructor() {
+        this.id = "native-core";
+        this.name = "Native Core";
+        this.description = "Permanent system tools for file management, PDF reading, and settings.";
+        this.isPermanent = true;
+        this.tools = new Map();
+        this.storage = new LocalStorageProvider();
+        this.registerTools();
+    }
+    registerTools() {
+        this.addTool({
+            name: "create_file",
+            description: "Create a new file in the knowledge base. ONLY use this when the user EXPLICITLY asks to save, create, or store something. NEVER use this spontaneously.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filePath: { type: "string" },
+                    content: { type: "string" }
+                },
+                required: ["filePath", "content"]
+            },
+            handler: async (args) => {
+                await this.storage.init();
+                let cleanPath = args.filePath.replace(/^[/\\]+/, '').replace(/\\/g, '/');
+                if (!cleanPath.startsWith('misc/') && !cleanPath.startsWith('history/')) {
+                    cleanPath = `misc/${cleanPath}`;
+                }
+                if (cleanPath.endsWith('.source.md')) {
+                    throw new Error("Safety Block: Source files are immutable.");
+                }
+                await this.storage.saveFile(cleanPath, args.content);
+                return { success: true, message: `Created ${cleanPath}` };
+            }
+        });
+        this.addTool({
+            name: "update_file",
+            description: "Update or overwrite an existing file. ONLY use this when the user EXPLICITLY asks to update or modify a file. NEVER use this spontaneously.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filePath: { type: "string" },
+                    newContent: { type: "string" }
+                },
+                required: ["filePath", "newContent"]
+            },
+            handler: async (args) => {
+                await this.storage.init();
+                let cleanPath = args.filePath.replace(/^[/\\]+/, '').replace(/\\/g, '/');
+                if (!cleanPath.startsWith('misc/') && !cleanPath.startsWith('history/')) {
+                    cleanPath = `misc/${cleanPath}`;
+                }
+                if (cleanPath.endsWith('.source.md')) {
+                    throw new Error("Safety Block: Source files are immutable.");
+                }
+                await this.storage.updateFile(cleanPath, args.newContent);
+                return { success: true, message: `Updated ${cleanPath}` };
+            }
+        });
+        this.addTool({
+            name: "move_file",
+            description: "Move or rename a file. ONLY use this when the user EXPLICITLY asks to move or rename a file.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    sourcePath: { type: "string" },
+                    destinationPath: { type: "string" }
+                },
+                required: ["sourcePath", "destinationPath"]
+            },
+            handler: async (args) => {
+                await this.storage.init();
+                let source = args.sourcePath.replace(/^[/\\]+/, '').replace(/\\/g, '/');
+                let dest = args.destinationPath.replace(/^[/\\]+/, '').replace(/\\/g, '/');
+                if (!source.startsWith('misc/') && !source.startsWith('history/'))
+                    source = `misc/${source}`;
+                if (!dest.startsWith('misc/') && !dest.startsWith('history/'))
+                    dest = `misc/${dest}`;
+                const content = await this.storage.readFile(source);
+                if (!content)
+                    throw new Error(`Source ${source} not found`);
+                await this.storage.saveFile(dest, content);
+                await this.storage.deleteFile(source);
+                return { success: true, message: `Moved to ${dest}` };
+            }
+        });
+        this.addTool({
+            name: "read_pdf",
+            description: "Extract text from a PDF file. ONLY use this for files ending in .pdf.",
+            inputSchema: {
+                type: "object",
+                properties: { filePath: { type: "string" } },
+                required: ["filePath"]
+            },
+            handler: async (args) => {
+                await this.storage.init();
+                const fileData = await this.storage.readFile(args.filePath);
+                if (!fileData)
+                    throw new Error("File not found");
+                let buffer;
+                if (fileData instanceof ArrayBuffer)
+                    buffer = fileData;
+                else if (fileData instanceof Blob)
+                    buffer = await fileData.arrayBuffer();
+                else
+                    throw new Error("Format error");
+                const text = await extractTextFromPdf(buffer);
+                return { success: true, data: text.substring(0, 50000) };
+            }
+        });
+        this.addTool({
+            name: "read_file",
+            description: "Read the content of a file (markdown, text, code, etc). Use this if you need to read a file, but check if the user already provided it via citation first.",
+            inputSchema: {
+                type: "object",
+                properties: { filePath: { type: "string" } },
+                required: ["filePath"]
+            },
+            handler: async (args) => {
+                await this.storage.init();
+                const content = await this.storage.readFile(args.filePath);
+                if (content === null)
+                    throw new Error("File not found");
+                if (typeof content !== 'string')
+                    throw new Error("File is binary, use read_pdf if it is a PDF");
+                return { success: true, data: content };
+            }
+        });
+        this.addTool({
+            name: "fetch_html",
+            description: "Fetch a URL and return its text content. ONLY use this when the user explicitly provides a URL or asks to read a specific link. NEVER use this spontaneously.",
+            inputSchema: {
+                type: "object",
+                properties: { url: { type: "string" } },
+                required: ["url"]
+            },
+            handler: async (args) => {
+                // Modified: Use Proxy to avoid CORS errors
+                try {
+                    const res = await fetch('/api/proxy', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ url: args.url })
+                    });
+                    if (!res.ok) {
+                        try {
+                            const errObj = await res.json();
+                            // If the API returns a specific error (like 404), tell the LLM
+                            if (errObj.error) {
+                                // Add explicit instruction to not retry identically
+                                return { success: false, error: `Could not fetch page (${res.status}). Error: ${errObj.error}. DO NOT RETRY THIS EXACT URL.` };
+                            }
+                        }
+                        catch (e) { }
+                        return { success: false, error: `Could not fetch page. Status: ${res.status} ${res.statusText}. It may be blocked. DO NOT RETRY THIS EXACT URL.` };
+                    }
+                    const data = await res.json();
+                    return { success: true, data: data.content, title: data.title };
+                }
+                catch (e) {
+                    console.error("[NativeCore] Fetch Proxy Failed:", e);
+                    // Return error to LLM so it can try another link
+                    return { success: false, error: `Failed to read URL (${e.message}). Try a different source.` };
+                }
+            }
+        });
+        // query_rag, query_graph, and summarize_file are in the application layer
+        this.addTool({
+            name: "update_user_settings",
+            description: "Update the user's profile settings (name, tone). ONLY use this when the user EXPLICITLY asks to change their name or how the AI speaks (tone). NEVER use this to 'update' the user's mood or feelings.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    tone: { type: "string" }
+                }
+            },
+            handler: async (args) => {
+                const { settingsManager } = await import('../../settings');
+                await settingsManager.updateIdentity({ name: args.name, tone: args.tone });
+                return { success: true, message: "Settings updated" };
+            }
+        });
+    }
+    addTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    async getTools() {
+        return Array.from(this.tools.values());
+    }
+    async executeTool(name, args) {
+        const tool = this.tools.get(name);
+        if (!tool)
+            throw new Error(`Tool ${name} not found in MeechiNativeCore`);
+        return await tool.handler(args);
+    }
+}

package/dist/lib/mcp/native/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Native Servers Barrel Export
+ *
+ * All built-in "native" tool providers that run in-process.
+ * These follow the MCP interface pattern but don't use the actual protocol.
+ */
+export { MeechiNativeCore } from './MeechiNativeCore';
+export { GroqVoiceNative } from './GroqVoiceNative';
+export { LocalVoiceNative } from './LocalVoiceNative';
+export { LocalSyncNative } from './LocalSyncNative';

package/dist/lib/mcp/native/index.js

@@ -0,0 +1,10 @@
+/**
+ * Native Servers Barrel Export
+ *
+ * All built-in "native" tool providers that run in-process.
+ * These follow the MCP interface pattern but don't use the actual protocol.
+ */
+export { MeechiNativeCore } from './MeechiNativeCore';
+export { GroqVoiceNative } from './GroqVoiceNative';
+export { LocalVoiceNative } from './LocalVoiceNative';
+export { LocalSyncNative } from './LocalSyncNative';

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

@@ -0,0 +1,35 @@
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, any>;
+        required?: string[];
+    };
+    handler: (args: any) => Promise<any>;
+}
+export interface McpResource {
+    uri: string;
+    name: string;
+    mimeType?: string;
+    description?: string;
+    read: () => Promise<{
+        content: string;
+        mimeType: string;
+    }>;
+}
+export interface McpRequest {
+    method: string;
+    params?: any;
+    id?: string | number;
+}
+export interface McpResponse {
+    jsonrpc: "2.0";
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+    id?: string | number;
+}

package/dist/lib/mcp/types.js

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

package/dist/lib/pdf.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Extracts text content from a PDF ArrayBuffer with basic styling and layout preservation.
+ *
+ * Improvements:
+ * - Detects Headers based on font size relative to body text.
+ * - Detects Bold/Italic based on font name.
+ * - Preserves Paragraphs (double newline) based on vertical gaps.
+ * - Preserves Line Breaks (single newline).
+ */
+export declare function extractTextFromPdf(data: ArrayBuffer): Promise<string>;

package/dist/lib/pdf.js

@@ -0,0 +1,142 @@
+// Configure PDF.js worker
+const PDFJS_VERSION = '4.9.155';
+/**
+ * Extracts text content from a PDF ArrayBuffer with basic styling and layout preservation.
+ *
+ * Improvements:
+ * - Detects Headers based on font size relative to body text.
+ * - Detects Bold/Italic based on font name.
+ * - Preserves Paragraphs (double newline) based on vertical gaps.
+ * - Preserves Line Breaks (single newline).
+ */
+export async function extractTextFromPdf(data) {
+    // Dynamic import to avoid SSR crashes with DOMMatrix/Canvas
+    const pdfjsLib = await import('pdfjs-dist');
+    // Use local worker for offline support and speed
+    pdfjsLib.GlobalWorkerOptions.workerSrc = '/pdf.worker.min.mjs';
+    try {
+        const loadingTask = pdfjsLib.getDocument({ data });
+        const pdf = await loadingTask.promise;
+        let fullText = "";
+        for (let i = 1; i <= pdf.numPages; i++) {
+            const page = await pdf.getPage(i);
+            const textContent = await page.getTextContent();
+            const items = textContent.items;
+            if (items.length === 0)
+                continue;
+            // --- Pass 1: Statistics to identify Body Text ---
+            // We assume the most common font height is the body text.
+            const heightCounts = {};
+            for (const item of items) {
+                const h = Math.round(item.height); // Round to avoid precision noise
+                if (h > 0) {
+                    heightCounts[h] = (heightCounts[h] || 0) + item.str.length; // Weight by character count
+                }
+            }
+            let bodyHeight = 0;
+            let maxCount = 0;
+            for (const [h, count] of Object.entries(heightCounts)) {
+                if (count > maxCount) {
+                    maxCount = count;
+                    bodyHeight = Number(h);
+                }
+            }
+            // --- Pass 2: Reconstruction ---
+            let pageOutput = "";
+            let lastY = -1;
+            let lastX = -1;
+            // Sort items by Y (descending for top-to-bottom) then X (ascending)
+            // Note: PDF coordinates usually start from bottom-left, so higher Y is higher on page.
+            // However, pdfjs-dist usually returns items in reading order. 
+            // We rely on order but check coordinates for gaps.
+            for (let j = 0; j < items.length; j++) {
+                const item = items[j];
+                const text = item.str;
+                // Skip empty strings if they don't have significant structure implications
+                if (!text.trim())
+                    continue;
+                // PDF uses a bottom-up coordinate system (0,0 is bottom-left usually), 
+                // but sometimes it's flipped depending on the matrix. 
+                // Let's rely on transform[5] which is TranslateY.
+                const curY = item.transform[5];
+                const curX = item.transform[4];
+                const curHeight = item.height;
+                // Detect Layout Changes
+                if (lastY !== -1) {
+                    const yDiff = Math.abs(curY - lastY);
+                    // Simple heuristic: 
+                    // If yDiff is small (essentially same line), check X gap.
+                    // If yDiff is medium (next line), add \n.
+                    // If yDiff is large (paragraph gap), add \n\n.
+                    if (yDiff < curHeight * 0.5) {
+                        // Same line
+                        // Check if we need a space (simple heuristic)
+                        // If there is a gap > 5px (arbitrary, depends on scale), add space found in PDF logic usually
+                        // But item.str sometimes contains the space. 
+                        // Let's just trust implicit spaces or add one if previous didn't end with one?
+                        if (lastX !== -1 && curX > lastX + item.width && !pageOutput.endsWith(" ")) {
+                            // This checks "end of last item" vs "start of current". 
+                            // Wait, logic is: lastX + lastWidth vs curX.
+                            // Simplifying: just add space if not already there, assuming distinct items act as words
+                            if (pageOutput.length > 0 && !pageOutput.endsWith(" ") && !text.startsWith(" ")) {
+                                pageOutput += " ";
+                            }
+                        }
+                    }
+                    else if (yDiff > bodyHeight * 1.5) {
+                        // Likely a Paragraph break
+                        pageOutput += "\n\n";
+                    }
+                    else {
+                        // Standard line break
+                        pageOutput += "\n";
+                    }
+                }
+                else {
+                    // First item on page
+                }
+                // Detect Styling
+                let chunk = text;
+                const isBold = /Bold|Bol/i.test(item.fontName);
+                const isItalic = /Italic|Ita|Oblique/i.test(item.fontName);
+                // Apply Markdown Styling
+                if (isBold)
+                    chunk = `**${chunk}**`;
+                if (isItalic)
+                    chunk = `_${chunk}_`;
+                // Detect Headers
+                // If it's effectively distinct line (we just added \n or \n\n or it's start)
+                // and font is significantly larger than body.
+                // Note: This logic applies the header tag *inline*. 
+                // Ideally headers are block elements. 
+                // We'll prepend # if it looks solely like a header line.
+                // A simpler approach for robust output: Just check size and prepend #.
+                // Markdown allows headers to be single lines.
+                if (curHeight > bodyHeight * 1.1) {
+                    if (curHeight > bodyHeight * 1.5) {
+                        // H1 or H2
+                        // Only prefix if we are at start of line
+                        if (pageOutput.endsWith("\n") || pageOutput === "") {
+                            chunk = `## ${chunk}`;
+                        }
+                    }
+                    else {
+                        // H3
+                        if (pageOutput.endsWith("\n") || pageOutput === "") {
+                            chunk = `### ${chunk}`;
+                        }
+                    }
+                }
+                pageOutput += chunk;
+                lastY = curY;
+                lastX = curX; // logic for spaces would need accumulated width, skipping for now to reduce risk
+            }
+            fullText += `--- Page ${i} ---\n${pageOutput}\n\n`;
+        }
+        return fullText.trim();
+    }
+    catch (error) {
+        console.error("PDF Extraction Error:", error);
+        throw new Error("Failed to extract text from PDF");
+    }
+}

package/dist/lib/settings.d.ts

@@ -0,0 +1,48 @@
+import { StorageProvider } from './storage/types';
+export interface AIProviderConfig {
+    id: string;
+    name: string;
+    enabled: boolean;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+}
+export interface UserIdentity {
+    name: string;
+    tone: string;
+}
+export interface LocalAIConfig {
+    enabled: boolean;
+    model: string;
+}
+export interface AppearanceConfig {
+    fontFamily: string;
+    accentColor: string;
+    backgroundColor?: string;
+    surfaceColor?: string;
+    foregroundColor?: string;
+    secondaryColor?: string;
+    radius: string;
+    iconLibrary: 'lucide' | 'material' | 'custom';
+}
+export interface AppConfig {
+    identity: UserIdentity;
+    providers: AIProviderConfig[];
+    activeProviderId: string;
+    localAI: LocalAIConfig;
+    theme: 'light' | 'dark' | 'system';
+    appearance: AppearanceConfig;
+    storage: {
+        primarySync: string;
+    };
+}
+export declare class SettingsManager {
+    private storage;
+    constructor(storage: StorageProvider);
+    getConfig(): Promise<AppConfig>;
+    saveConfig(config: AppConfig): Promise<void>;
+    updateIdentity(identity: Partial<UserIdentity>): Promise<void>;
+    updateProvider(providerId: string, updates: Partial<AIProviderConfig>): Promise<void>;
+    setActiveProvider(providerId: string): Promise<void>;
+}
+export declare const settingsManager: SettingsManager;

package/dist/lib/settings.js

@@ -0,0 +1,87 @@
+import { LocalStorageProvider } from './storage/local';
+const DEFAULT_CONFIG = {
+    identity: {
+        name: "Traveler",
+        tone: "Casual, positive, and concise"
+    },
+    providers: [
+        {
+            id: 'groq',
+            name: 'Groq',
+            enabled: true,
+            model: 'llama-3.3-70b-versatile'
+        }
+    ],
+    activeProviderId: 'groq',
+    localAI: {
+        enabled: true,
+        model: 'Llama-3.2-1B-Instruct-q4f16_1-MLC' // Default to 1B (Stable)
+    },
+    theme: 'system',
+    appearance: {
+        fontFamily: 'Lora',
+        accentColor: '#6B8E6B', // Sage
+        // Colors left undefined to allow CSS variables (Light/Dark mode) to take precedence.
+        // User can still override them in settings.
+        radius: '0.5rem',
+        iconLibrary: 'lucide'
+    },
+    storage: {
+        primarySync: 'local'
+    }
+};
+const CONFIG_PATH = 'core/config.json';
+export class SettingsManager {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async getConfig() {
+        try {
+            const content = await this.storage.readFile(CONFIG_PATH);
+            if (!content || typeof content !== 'string') {
+                return DEFAULT_CONFIG;
+            }
+            const parsed = JSON.parse(content);
+            // Merge with default to ensure new fields are present
+            return Object.assign(Object.assign(Object.assign({}, DEFAULT_CONFIG), parsed), { identity: Object.assign(Object.assign({}, DEFAULT_CONFIG.identity), parsed.identity), localAI: Object.assign(Object.assign({}, DEFAULT_CONFIG.localAI), parsed.localAI) });
+        }
+        catch (e) {
+            console.warn("Failed to load config, returning default", e);
+            return DEFAULT_CONFIG;
+        }
+    }
+    async saveConfig(config) {
+        const content = JSON.stringify(config, null, 2);
+        await this.storage.saveFile(CONFIG_PATH, content);
+    }
+    async updateIdentity(identity) {
+        const config = await this.getConfig();
+        config.identity = Object.assign(Object.assign({}, config.identity), identity);
+        await this.saveConfig(config);
+    }
+    async updateProvider(providerId, updates) {
+        const config = await this.getConfig();
+        const index = config.providers.findIndex(p => p.id === providerId);
+        if (index >= 0) {
+            config.providers[index] = Object.assign(Object.assign({}, config.providers[index]), updates);
+        }
+        else {
+            // Add if not exists (allows adding generic/custom providers via this generic method if needed)
+            // But usually we want strict registration. For now, let's just update if exists.
+            console.warn(`Provider ${providerId} not found in config.`);
+        }
+        await this.saveConfig(config);
+    }
+    async setActiveProvider(providerId) {
+        const config = await this.getConfig();
+        // Verify it exists and is enabled?
+        const provider = config.providers.find(p => p.id === providerId);
+        if (provider) {
+            config.activeProviderId = providerId;
+            await this.saveConfig(config);
+        }
+    }
+}
+// Singleton helper for client-side usage if needed, 
+// though usually we instantiate this with the specific storage instance.
+export const settingsManager = new SettingsManager(new LocalStorageProvider());

package/dist/lib/storage/db.d.ts

@@ -0,0 +1,57 @@
+import Dexie, { Table } from 'dexie';
+export interface FileMetadata {
+    isSource?: boolean;
+    originalContent?: string;
+    summary?: string;
+    comments?: Array<{
+        id: string;
+        text: string;
+        range?: any;
+        timestamp: number;
+    }>;
+    [key: string]: any;
+}
+export interface FileRecord {
+    path: string;
+    content: string | Blob | ArrayBuffer;
+    updatedAt: number;
+    remoteId?: string;
+    type: 'file' | 'folder' | 'source';
+    dirty?: number;
+    deleted?: number;
+    tags?: string[];
+    metadata?: FileMetadata;
+}
+export interface SettingRecord {
+    key: string;
+    value: any;
+}
+export interface FileChunk {
+    id?: number;
+    filePath: string;
+    content: string;
+    embedding: number[];
+}
+export interface JournalEntry {
+    id?: number;
+    content: string;
+    createdAt: Date;
+}
+export interface GraphEdgeRecord {
+    id: string;
+    source: string;
+    target: string;
+    relation: string;
+    weight?: number;
+    createdAt: number;
+    metadata?: any;
+}
+export declare class MeechiDB extends Dexie {
+    files: Table<FileRecord>;
+    settings: Table<SettingRecord>;
+    chunks: Table<FileChunk>;
+    journal: Table<JournalEntry>;
+    edges: Table<GraphEdgeRecord>;
+    constructor();
+}
+export declare const db: MeechiDB;