@meechi-ai/core 1.0.0

package/dist/lib/sync/google-drive.js

@@ -0,0 +1,183 @@
+export class GoogleDriveClient {
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+    }
+    async request(endpoint, options = {}) {
+        var _a;
+        const url = `https://www.googleapis.com/drive/v3/${endpoint}`;
+        const headers = Object.assign({ 'Authorization': `Bearer ${this.accessToken}`, 'Content-Type': 'application/json' }, (options.headers || {}));
+        console.log(`[DriveAPI] ${options.method || 'GET'} ${url}`);
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), 30000); // 30s Timeout
+        try {
+            const res = await fetch(url, Object.assign(Object.assign({}, options), { headers, signal: controller.signal }));
+            clearTimeout(id);
+            if (res.status === 401) {
+                console.error(`[DriveAPI] 401 Unauthorized for ${url}`);
+                throw new Error("Unauthorized: Token expired or invalid");
+            }
+            if (!res.ok) {
+                const err = await res.json().catch(() => ({}));
+                console.error(`[DriveAPI] Error ${res.status} for ${url}:`, err);
+                throw new Error(`Drive API Error: ${((_a = err.error) === null || _a === void 0 ? void 0 : _a.message) || res.statusText}`);
+            }
+            return res;
+        }
+        catch (error) {
+            clearTimeout(id);
+            if (error.name === 'AbortError') {
+                console.error(`[DriveAPI] Timeout for ${url}`);
+                throw new Error("Drive API Timeout (30s)");
+            }
+            console.error(`[DriveAPI] Fetch Error for ${url}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Search for files.
+     * query: e.g. "name = 'foo.txt' and trashed = false"
+     */
+    async listFiles(query) {
+        const params = new URLSearchParams({
+            q: query,
+            fields: 'files(id, name, mimeType, parents, modifiedTime, version, trashed, capabilities, appProperties)',
+            pageSize: '1000',
+        });
+        const res = await this.request(`files?${params.toString()}`);
+        return (await res.json()).files;
+    }
+    /**
+     * Get Sync Token for tracking changes
+     */
+    async getStartPageToken() {
+        const res = await this.request('changes/startPageToken');
+        return (await res.json()).startPageToken;
+    }
+    /**
+     * List changes since token
+     */
+    async listChanges(pageToken) {
+        const params = new URLSearchParams({
+            pageToken,
+            fields: 'nextPageToken, newStartPageToken, changes(fileId, removed, file(id, name, mimeType, parents, modifiedTime, version, trashed, appProperties))',
+        });
+        const res = await this.request(`changes?${params.toString()}`);
+        return await res.json();
+    }
+    /**
+     * Download file content
+     */
+    async downloadFile(fileId) {
+        const res = await this.request(`files/${fileId}?alt=media`);
+        return await res.text();
+    }
+    /**
+     * Download file content as Binary (ArrayBuffer)
+     */
+    async downloadBinary(fileId) {
+        const res = await this.request(`files/${fileId}?alt=media`);
+        return await res.arrayBuffer();
+    }
+    /**
+     * Get file metadata
+     */
+    async getFileMetadata(fileId) {
+        const res = await this.request(`files/${fileId}?fields=id,name,parents,mimeType,modifiedTime,trashed,appProperties`);
+        return await res.json();
+    }
+    /**
+     * Update file content
+     */
+    async updateMetadata(fileId, metadata) {
+        const url = new URL(`https://www.googleapis.com/drive/v3/files/${fileId}`);
+        if (metadata.addParents)
+            url.searchParams.append('addParents', metadata.addParents.join(','));
+        if (metadata.removeParents)
+            url.searchParams.append('removeParents', metadata.removeParents.join(',')); // Important: remove old parents for move
+        const body = {};
+        if (metadata.name)
+            body.name = metadata.name;
+        if (metadata.appProperties)
+            body.appProperties = metadata.appProperties;
+        const res = await this.request(url.toString().replace('https://www.googleapis.com/drive/v3/', ''), {
+            method: 'PATCH',
+            body: JSON.stringify(body)
+        });
+        return await res.json();
+    }
+    async updateFile(fileId, content) {
+        // Simple upload (media only) is easiest for updates, but multipart is robust.
+        // For updates, we often just want to update content.
+        // Google Drive API supports PATCHing content.
+        // Ref: https://developers.google.com/drive/api/guides/manage-uploads#simple
+        const blob = content instanceof Blob ? content : new Blob([content]);
+        const res = await fetch(`https://www.googleapis.com/upload/drive/v3/files/${fileId}?uploadType=media`, {
+            method: 'PATCH',
+            headers: {
+                'Authorization': `Bearer ${this.accessToken}`,
+                'Content-Type': blob.type || 'application/octet-stream'
+            },
+            body: blob
+        });
+        if (!res.ok)
+            throw new Error("Update content failed");
+        return await res.json();
+    }
+    /**
+     * Create file
+     */
+    async createFile(name, folderId, content, appProperties) {
+        let mimeType = 'application/octet-stream';
+        if (name.endsWith('.md'))
+            mimeType = 'text/markdown';
+        else if (name.endsWith('.txt'))
+            mimeType = 'text/plain';
+        else if (name.endsWith('.pdf'))
+            mimeType = 'application/pdf';
+        const blob = content instanceof Blob ? content : new Blob([content], { type: mimeType });
+        const metadata = {
+            name,
+            parents: folderId ? [folderId] : [],
+        };
+        if (appProperties)
+            metadata.appProperties = appProperties;
+        const form = new FormData();
+        form.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
+        form.append('file', blob);
+        const res = await fetch('https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.accessToken}`,
+            },
+            body: form
+        });
+        if (!res.ok)
+            throw new Error("Create failed");
+        return await res.json();
+    }
+    /**
+     * Create Folder
+     */
+    async createFolder(name, parentId) {
+        const metadata = {
+            name,
+            mimeType: 'application/vnd.google-apps.folder',
+            parents: parentId ? [parentId] : []
+        };
+        const res = await this.request('files', {
+            method: 'POST',
+            body: JSON.stringify(metadata)
+        });
+        return await res.json();
+    }
+    /**
+     * Delete file (Trash)
+     */
+    async deleteFile(fileId) {
+        const res = await this.request(`files/${fileId}`, {
+            method: 'DELETE'
+        });
+        if (!res.ok)
+            throw new Error("Delete failed");
+    }
+}

package/dist/lib/sync/merge.d.ts

@@ -0,0 +1 @@
+export declare function mergeLogs(local: string, remote: string): string;

package/dist/lib/sync/merge.js

@@ -0,0 +1,68 @@
+export function mergeLogs(local, remote) {
+    const localEntries = parseEntries(local);
+    const remoteEntries = parseEntries(remote);
+    // Merge map: Key = "Timestamp|ContentHash" -> Entry
+    const merged = new Map();
+    // Add Remote first (Truth)
+    remoteEntries.forEach(entry => {
+        const key = generateKey(entry);
+        merged.set(key, entry.fullText);
+    });
+    // Add Local (Append/Fill gaps)
+    localEntries.forEach(entry => {
+        const key = generateKey(entry);
+        if (!merged.has(key)) {
+            merged.set(key, entry.fullText);
+        }
+    });
+    // Sort by Timestamp
+    const sortedEntries = Array.from(merged.values()).sort((a, b) => {
+        const timeA = extractDate(a);
+        const timeB = extractDate(b);
+        return timeA.getTime() - timeB.getTime();
+    });
+    return sortedEntries.join('\n\n');
+}
+// Helpers
+function parseEntries(log) {
+    if (!log)
+        return [];
+    return log.split('### ').filter(c => c.trim()).map(chunk => {
+        // Re-add delimiter for reconstruction
+        const fullText = '### ' + chunk.trim();
+        const lines = chunk.split('\n');
+        // Timestamp is the first line after ###
+        const timestampStr = lines[0].trim();
+        // We assume today's date for sorting relative to each other (since files are per day)
+        // Ideally we'd parse the full date if available, but time string works for daily logs
+        return {
+            timestampStr,
+            fullText
+        };
+    });
+}
+function generateKey(entry) {
+    // Simple key: Time + First 20 chars of content (to distinguish different messages at same second)
+    const contentSignature = entry.fullText.replace(/\s/g, '').slice(0, 50);
+    return `${entry.timestampStr}|${contentSignature}`;
+}
+function extractDate(entryText) {
+    // Extract "12:00:00 PM"
+    const match = entryText.match(/### (.*?)(\n|$)/);
+    if (!match)
+        return new Date(0);
+    const timeStr = match[1];
+    // Parse Time String (assuming today context, but really we just need relative sort)
+    // "12:00:00 PM" -> Date
+    const d = new Date();
+    const [time, period] = timeStr.split(' ');
+    if (!time)
+        return new Date(0);
+    let [hours, minutes, seconds] = time.split(':').map(Number);
+    if (period === 'PM' && hours !== 12)
+        hours += 12;
+    if (period === 'AM' && hours === 12)
+        hours = 0;
+    d.setHours(hours || 0, minutes || 0, seconds || 0);
+    return d;
+}

package/dist/lib/yjs/YjsProvider.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import * as Y from 'yjs';
+interface YjsContextType {
+    doc: Y.Doc;
+    synced: boolean;
+}
+export declare function YjsProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useYjs: () => YjsContextType;
+export {};

package/dist/lib/yjs/YjsProvider.js

@@ -0,0 +1,33 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from 'react';
+import { doc, yProvider } from './store';
+const YjsContext = createContext({
+    doc,
+    synced: false,
+});
+export function YjsProvider({ children }) {
+    const [synced, setSynced] = useState(false);
+    useEffect(() => {
+        if (!yProvider) {
+            // Server-side or non-browser environment
+            setSynced(true);
+            return;
+        }
+        const onSynced = () => setSynced(true);
+        // Check if already synced
+        if (yProvider.synced) {
+            setSynced(true);
+        }
+        else {
+            yProvider.on('synced', onSynced);
+        }
+        return () => {
+            if (yProvider) {
+                yProvider.off('synced', onSynced);
+            }
+        };
+    }, []);
+    return (_jsx(YjsContext.Provider, { value: { doc, synced }, children: children }));
+}
+export const useYjs = () => useContext(YjsContext);

package/dist/lib/yjs/graph.d.ts

@@ -0,0 +1,11 @@
+import * as Y from 'yjs';
+export interface GraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    relation: string;
+    weight?: number;
+    createdAt: number;
+    metadata?: any;
+}
+export declare const getEdgesMap: () => Y.Map<GraphEdge>;

package/dist/lib/yjs/graph.js

@@ -0,0 +1,7 @@
+import { doc } from './store';
+// Access the Y.Map for edges
+// Key: Edge ID (UUID)
+// Value: GraphEdge object
+export const getEdgesMap = () => {
+    return doc.getMap('graph-edges');
+};

package/dist/lib/yjs/hooks.d.ts

@@ -0,0 +1,7 @@
+import * as Y from 'yjs';
+export declare function useYDoc(): {
+    doc: Y.Doc;
+    synced: boolean;
+};
+export declare function useYMap<T>(name: string): [Y.Map<T>, T];
+export declare function useYArray<T>(name: string): [Y.Array<T>, T[]];

package/dist/lib/yjs/hooks.js

@@ -0,0 +1,37 @@
+'use client';
+import { useState, useEffect } from 'react';
+import { useYjs } from './YjsProvider';
+export function useYDoc() {
+    const { doc, synced } = useYjs();
+    return { doc, synced };
+}
+export function useYMap(name) {
+    const { doc } = useYjs();
+    const map = doc.getMap(name);
+    const [toJSON, setToJSON] = useState(map.toJSON());
+    useEffect(() => {
+        const onChange = () => {
+            setToJSON(map.toJSON());
+        };
+        map.observe(onChange);
+        return () => {
+            map.unobserve(onChange);
+        };
+    }, [map]);
+    return [map, toJSON];
+}
+export function useYArray(name) {
+    const { doc } = useYjs();
+    const array = doc.getArray(name);
+    const [toJSON, setToJSON] = useState(array.toArray());
+    useEffect(() => {
+        const onChange = () => {
+            setToJSON(array.toArray());
+        };
+        array.observe(onChange);
+        return () => {
+            array.unobserve(onChange);
+        };
+    }, [array]);
+    return [array, toJSON];
+}

package/dist/lib/yjs/store.d.ts

@@ -0,0 +1,4 @@
+import * as Y from 'yjs';
+import { IndexeddbPersistence } from 'y-indexeddb';
+export declare const doc: Y.Doc;
+export declare const yProvider: IndexeddbPersistence | null;

package/dist/lib/yjs/store.js

@@ -0,0 +1,19 @@
+import * as Y from 'yjs';
+import { IndexeddbPersistence } from 'y-indexeddb';
+// Create the global Yjs document
+export const doc = new Y.Doc();
+// Initialize the persistence layer (Browser only)
+let persistence = null;
+if (typeof window !== 'undefined') {
+    // 'meechi-database' matches our app name logic, but distinct from Dexie which is 'meechi-db' usually
+    persistence = new IndexeddbPersistence('meechi-yjs-store', doc);
+    persistence.on('synced', () => {
+        console.log('[Yjs] Content loaded from IndexedDB');
+    });
+    // Initialize Graph Sync (Yjs -> Dexie)
+    // We do this here to ensure it runs as a side-effect of the app starting
+    import('./syncGraph').then(({ initGraphSync }) => {
+        initGraphSync();
+    });
+}
+export const yProvider = persistence;

package/dist/lib/yjs/syncGraph.d.ts

@@ -0,0 +1 @@
+export declare function initGraphSync(): void;

package/dist/lib/yjs/syncGraph.js

@@ -0,0 +1,38 @@
+import { db } from '../storage/db';
+import { getEdgesMap } from './graph';
+// Sync Yjs Graph Edges -> Dexie 'edges' table
+// This allows us to use Dexie for fast GraphRAG querying (e.g. "Find all neighbors of Ada")
+// while keeping Yjs as the source of truth for sync.
+export function initGraphSync() {
+    console.log('[GraphSync] Initializing...');
+    const edgesMap = getEdgesMap();
+    // 1. Initial Sync: Ensure specific indexes match if needed, or just rely on eventual consistency.
+    // For now, we trust the observe events or a full re-sync if strictly needed.
+    // Ideally, Yjs persistence loads the doc, and then we might want to dump to Dexie if Dexie is empty.
+    // But since Yjs persistence goes to IndexedDB anyway, this is "Derived Data".
+    // We observe changes.
+    edgesMap.observe((event) => {
+        // event.keysChanged is a Set of keys (Edge IDs) that changed
+        const changes = Array.from(event.keysChanged);
+        db.transaction('rw', db.edges, async () => {
+            for (const key of changes) {
+                const type = event.changes.keys.get(key);
+                // type.action is 'add', 'update', or 'delete'
+                if ((type === null || type === void 0 ? void 0 : type.action) === 'delete') {
+                    // Deleted from Yjs -> Delete from Dexie
+                    await db.edges.delete(key);
+                }
+                else {
+                    // Added or Updated -> Put to Dexie
+                    const edge = edgesMap.get(key);
+                    if (edge) {
+                        await db.edges.put(edge);
+                    }
+                }
+            }
+        }).catch(err => {
+            console.error('[GraphSync] Error syncing to Dexie:', err);
+        });
+    });
+    console.log('[GraphSync] Listening for changes.');
+}

package/dist/providers/theme-provider.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+import { ThemeProvider as NextThemesProvider } from "next-themes";
+export declare function ThemeProvider({ children, ...props }: React.ComponentProps<typeof NextThemesProvider>): import("react/jsx-runtime").JSX.Element;

package/dist/providers/theme-provider.js

@@ -0,0 +1,18 @@
+"use client";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ThemeProvider as NextThemesProvider } from "next-themes";
+export function ThemeProvider(_a) {
+    var { children } = _a, props = __rest(_a, ["children"]);
+    return _jsx(NextThemesProvider, Object.assign({}, props, { children: children }));
+}