@meechi-ai/core 1.0.0

package/dist/lib/storage/migrate.js

@@ -0,0 +1,122 @@
+import { openDB } from 'idb';
+import { db } from './db';
+import Dexie from 'dexie';
+const OLD_DB_NAME = 'michio-local-v1';
+const OLD_STORE_NAME = 'files';
+export async function migrateFromIdbToDexie() {
+    // 1. Check if we already have data in Dexie
+    const count = await db.files.count();
+    if (count > 0) {
+        // Already migrated
+        return;
+    }
+    try {
+        const oldDb = await openDB(OLD_DB_NAME, 1, {
+            upgrade(db) {
+                if (!db.objectStoreNames.contains(OLD_STORE_NAME)) {
+                    // No old store
+                }
+            }
+        });
+        if (!oldDb.objectStoreNames.contains(OLD_STORE_NAME)) {
+            return;
+        }
+        const allRecords = await oldDb.getAll(OLD_STORE_NAME);
+        if (allRecords.length === 0)
+            return;
+        // 4. Transform & Insert
+        const recordsToInsert = allRecords.map((rec) => ({
+            path: rec.path,
+            content: rec.content,
+            updatedAt: rec.updatedAt,
+            remoteId: rec.remoteId,
+            type: 'file'
+        }));
+        // Use bulkPut to overwrite/merge
+        await db.files.bulkPut(recordsToInsert);
+        console.log(`[Meechi] Migrated ${recordsToInsert.length} files to new storage.`);
+    }
+    catch (e) {
+        console.warn("Migration check failed (safe to ignore if new user)", e);
+    }
+}
+const OLD_MICHIO_DB = 'michio-db';
+export async function migrateFromMichioToMeechi() {
+    // Check if new DB is empty
+    const count = await db.files.count();
+    if (count > 0)
+        return; // Already initialized
+    // Check if old DB exists via Dexie
+    const oldExists = await Dexie.exists(OLD_MICHIO_DB);
+    if (!oldExists)
+        return;
+    console.log("[Meechi] Migrating from michio-db...");
+    try {
+        const oldDb = new Dexie(OLD_MICHIO_DB);
+        oldDb.version(1).stores({
+            files: 'path, remoteId, type, updatedAt'
+        });
+        // We know up to version 6 existed, let's just try to open dynamic or match the latest structure
+        // Since Dexie can open dynamically if we don't specify version, or we can use idb to just dump stores.
+        // Using idb is safer for raw dump.
+        const oldIdb = await openDB(OLD_MICHIO_DB);
+        // Migrate Files
+        if (oldIdb.objectStoreNames.contains('files')) {
+            const files = await oldIdb.getAll('files');
+            if (files.length > 0) {
+                // Ensure tags/metadata structure if moving from v6
+                // But since our current schema is v6, we can just put them in.
+                // We might need to sanitize if schema changed, but it hasn't between michio->meechi rename.
+                await db.files.bulkPut(files);
+                console.log(`[Meechi] Transferred ${files.length} files from michio-db`);
+            }
+        }
+        // Migrate Settings
+        if (oldIdb.objectStoreNames.contains('settings')) {
+            const settings = await oldIdb.getAll('settings');
+            if (settings.length > 0) {
+                await db.settings.bulkPut(settings);
+            }
+        }
+        // Migrate Journal
+        if (oldIdb.objectStoreNames.contains('journal')) {
+            const journal = await oldIdb.getAll('journal');
+            if (journal.length > 0) {
+                await db.journal.bulkPut(journal);
+            }
+        }
+        console.log("[Meechi] Migration complete.");
+    }
+    catch (e) {
+        console.error("[Meechi] Migration from michio-db failed", e);
+    }
+}
+const GUEST_DB_NAME = 'michio-guest-db';
+export async function migrateJournal() {
+    const count = await db.journal.count();
+    if (count > 0)
+        return;
+    try {
+        // We just try to open it. If it doesn't exist, openDB might create it empty or fail?
+        // Actually IDB openDB will create if not exists. We should check if it has the store.
+        const guestDb = await openDB(GUEST_DB_NAME, 1, {
+            upgrade(db) {
+                // If it doesn't exist, we don't create stores here, we just want to read.
+                // But openDB with upgrade triggers creation.
+                // If we don't provide upgrade, and version matches, it opens.
+                // If we want to check existence safely:
+            }
+        });
+        if (!guestDb.objectStoreNames.contains('journal')) {
+            return;
+        }
+        const allEntries = await guestDb.getAll('journal');
+        if (allEntries.length > 0) {
+            await db.journal.bulkAdd(allEntries);
+            console.log(`[Meechi] Migrated ${allEntries.length} journal entries.`);
+        }
+    }
+    catch (e) {
+        // Likely DB doesn't exist or other error
+    }
+}

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

@@ -0,0 +1,66 @@
+export interface FileMetadata {
+    isSource?: boolean;
+    originalContent?: string;
+    summary?: string;
+    comments?: Array<{
+        id: string;
+        text: string;
+        range?: any;
+        timestamp: number;
+    }>;
+    [key: string]: any;
+}
+export interface FileMeta {
+    id: string;
+    name: string;
+    path: string;
+    updatedAt: number;
+    type: 'file' | 'folder' | 'source';
+    remoteId?: string;
+    deleted?: number;
+    tags?: string[];
+    metadata?: FileMetadata;
+    content?: string | Blob | ArrayBuffer;
+}
+export interface StorageProvider {
+    /**
+     * Initialize the storage (e.g. open DB, auth check)
+     */
+    init(): Promise<void>;
+    /**
+     * Write content to a file. Overwrites if exists.
+     */
+    saveFile(virtualPath: string, content: string | Blob | ArrayBuffer, remoteId?: string, tags?: string[], metadata?: any): Promise<void>;
+    updateMetadata(virtualPath: string, updates: Partial<FileMeta>): Promise<void>;
+    getFilesByTag(tag: string): Promise<FileMeta[]>;
+    /**
+     * Read content of a file. Returns null if not found.
+     */
+    readFile(virtualPath: string): Promise<string | Blob | ArrayBuffer | null>;
+    /**
+     * List files in a virtual folder.
+     */
+    listFiles(virtualFolder: string): Promise<FileMeta[]>;
+    /**
+     * Append content to a file. Creates if not exists.
+     */
+    appendFile(virtualPath: string, content: string): Promise<void>;
+    renameFile(oldPath: string, newPath: string): Promise<void>;
+    deleteFile(virtualPath: string): Promise<void>;
+    createFolder(virtualPath: string): Promise<void>;
+    getFile(virtualPath: string): Promise<FileMeta | null>;
+    resetSyncState(): Promise<void>;
+    factoryReset(): Promise<void>;
+    /**
+     * Trigger a manual sync immediately.
+     */
+    forceSync?(): Promise<void>;
+    /**
+     * Collect relevant context for the AI from the local knowledge base.
+     */
+    getKnowledgeContext(query?: string): Promise<string>;
+    /**
+     * Re-index a file for semantic search.
+     */
+    indexFile(path: string, content: string): Promise<void>;
+}

package/dist/lib/storage/types.js

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

package/dist/lib/sync/client-drive.d.ts

@@ -0,0 +1,9 @@
+export declare class ClientDriveService {
+    private accessToken;
+    constructor();
+    setToken(token: string): void;
+    private request;
+    listFiles(): Promise<any>;
+    getFileContent(fileId: string): Promise<string>;
+}
+export declare const clientDrive: ClientDriveService;

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

@@ -0,0 +1,69 @@
+// Client-Side Google Drive Service for Desktop App
+// This replaces the server-side logic in /api/sync/* when running in static mode.
+const GOOGLE_DRIVE_API_BASE = 'https://www.googleapis.com/drive/v3';
+const DRIVE_SCOPE = 'https://www.googleapis.com/auth/drive.file';
+export class ClientDriveService {
+    constructor() {
+        this.accessToken = null;
+        if (typeof window !== 'undefined') {
+            this.accessToken = localStorage.getItem('google_access_token');
+        }
+    }
+    setToken(token) {
+        this.accessToken = token;
+        localStorage.setItem('google_access_token', token);
+    }
+    async request(endpoint, options = {}) {
+        if (!this.accessToken) {
+            throw new Error("No Google Access Token found. Please connect Account.");
+        }
+        const url = `${GOOGLE_DRIVE_API_BASE}/${endpoint}`;
+        const headers = Object.assign({ 'Authorization': `Bearer ${this.accessToken}`, 'Content-Type': 'application/json' }, options.headers);
+        const res = await fetch(url, Object.assign(Object.assign({}, options), { headers }));
+        if (res.status === 401) {
+            // Token expired
+            localStorage.removeItem('google_access_token');
+            this.accessToken = null;
+            throw new Error("Token Expired. Please reconnect.");
+        }
+        if (!res.ok) {
+            throw new Error(`Google Drive API Error: ${res.statusText}`);
+        }
+        return res.json();
+    }
+    async listFiles() {
+        try {
+            // Query for Docs and PDFs, not trashed
+            const q = "mimeType != 'application/vnd.google-apps.folder' and trashed = false";
+            const res = await this.request(`files?q=${encodeURIComponent(q)}&fields=files(id, name, mimeType, modifiedTime)`);
+            return res.files || [];
+        }
+        catch (e) {
+            console.error("Client Drive List Error:", e);
+            throw e;
+        }
+    }
+    async getFileContent(fileId) {
+        // For Google Docs, we must export them. For PDFs/Text, get media.
+        // Simplified: Export everything as text/plain if possible
+        try {
+            // 1. Check Metadata
+            const metadata = await this.request(`files/${fileId}?fields=mimeType`);
+            let url = `${GOOGLE_DRIVE_API_BASE}/files/${fileId}?alt=media`;
+            if (metadata.mimeType === 'application/vnd.google-apps.document') {
+                url = `${GOOGLE_DRIVE_API_BASE}/files/${fileId}/export?mimeType=text/plain`;
+            }
+            const res = await fetch(url, {
+                headers: { 'Authorization': `Bearer ${this.accessToken}` }
+            });
+            if (!res.ok)
+                throw new Error("Failed to download file content");
+            return await res.text();
+        }
+        catch (e) {
+            console.error("Download Error:", e);
+            throw e;
+        }
+    }
+}
+export const clientDrive = new ClientDriveService();

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

@@ -0,0 +1,18 @@
+import { GoogleDriveClient } from './google-drive';
+import { StorageProvider } from '../storage/types';
+export declare class SyncEngine {
+    private drive;
+    private storage;
+    private syncing;
+    constructor(drive: GoogleDriveClient, storage: StorageProvider);
+    sync(onProgress?: (msg: string) => void): Promise<void>;
+    private syncDown;
+    private performInitialPull;
+    private recursivePull;
+    private handleRemoteDelete;
+    private handleRemoteChange;
+    private syncUp;
+    private getName;
+    private getRootFolderId;
+    private resolveParentId;
+}