@abelionorg/core 3.5.0

package/src/Laras.ts

@@ -0,0 +1,179 @@
+import { Hasil } from './Brankas';
+
+export type KonteksLaras = 'saku' | 'pelataran';
+
+/**
+ * Laras: Context and Path Resolver.
+ * Decoupled from Node.js top-level imports to support browser bundles.
+ */
+export class Laras {
+    private static readonly SAKU_FILE = 'saku.json';
+    private static readonly PELATARAN_DIR = '.lembaran';
+    private static readonly PELATARAN_FILE = 'pelataran.json';
+
+    /**
+     * Resolves the absolute path for the given context.
+     * Works only in Node.js environment.
+     */
+    static async temukanJalur(konteks: KonteksLaras): Promise<string> {
+        if (typeof window !== 'undefined') return '';
+
+        try {
+            // Dynamic imports for ESM/Node compatibility
+            const path = await import('path');
+            const os = await import('os');
+            const fs = await import('fs');
+
+            const SAKU_DIR = path.join(os.homedir(), '.lembaran');
+
+            let jalur: string;
+            if (konteks === 'saku') {
+                if (!fs.existsSync(SAKU_DIR)) {
+                    fs.mkdirSync(SAKU_DIR, { recursive: true });
+                }
+                jalur = path.join(SAKU_DIR, this.SAKU_FILE);
+            } else {
+                const root = (await this.temukanAkarProyek()) || process.cwd();
+                const localDir = path.join(root, this.PELATARAN_DIR);
+                if (!fs.existsSync(localDir)) {
+                    fs.mkdirSync(localDir, { recursive: true });
+                }
+                jalur = path.join(localDir, this.PELATARAN_FILE);
+            }
+
+            if (process.env.DEBUG === 'true') {
+                console.log(`[LARAS] Jalur ${konteks}: ${jalur}`);
+            }
+            return jalur;
+        } catch (err) {
+            console.error('[LARAS] Gagal menemukan jalur:', err);
+            return '';
+        }
+    }
+
+    /**
+     * Detects the project root. Node.js only.
+     */
+    private static async temukanAkarProyek(dir: string = (typeof process !== 'undefined' ? process.cwd() : '')): Promise<string | null> {
+        if (typeof window !== 'undefined') return null;
+
+        try {
+            const path = await import('path');
+            const fs = await import('fs');
+
+            const check = (curr: string): string | null => {
+                if (fs.existsSync(path.join(curr, '.git')) || fs.existsSync(path.join(curr, 'package.json'))) {
+                    return curr;
+                }
+                const parent = path.dirname(curr);
+                if (parent === curr) return null;
+                return check(parent);
+            };
+            return check(dir);
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Smart context detection. Node.js only.
+     */
+    static async deteksiKonteksOtomatis(): Promise<KonteksLaras> {
+        if (typeof window !== 'undefined') return 'saku';
+
+        try {
+            const path = await import('path');
+            const fs = await import('fs');
+
+            const root = await this.temukanAkarProyek();
+            if (root && fs.existsSync(path.join(root, this.PELATARAN_DIR, this.PELATARAN_FILE))) {
+                return 'pelataran';
+            }
+        } catch {
+            // Default to saku on error
+        }
+        return 'saku';
+    }
+
+    /**
+     * Reads local .env. Node.js only.
+     */
+    static async bacaEnv(): Promise<Record<string, string>> {
+        if (typeof window !== 'undefined') return {};
+
+        try {
+            const path = await import('path');
+            const fs = await import('fs');
+
+            const root = await this.temukanAkarProyek();
+            if (!root) return {};
+            const envPath = path.join(root, '.env');
+            if (!fs.existsSync(envPath)) return {};
+
+            const content = fs.readFileSync(envPath, 'utf8');
+            const lines = content.split('\n');
+            const env: Record<string, string> = {};
+
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#')) continue;
+                const match = trimmed.match(/^([^=]+)=(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    let val = match[2].trim();
+                    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                        val = val.substring(1, val.length - 1);
+                    }
+                    env[key] = val;
+                }
+            }
+            return env;
+        } catch {
+            return {};
+        }
+    }
+
+    /**
+     * Writes or updates a local .env variable. Node.js only.
+     */
+    static async simpanEnv(key: string, value: string): Promise<Hasil<boolean>> {
+        if (typeof window !== 'undefined') return { data: null, error: new Error('Bukan lingkungan Node.js') };
+
+        try {
+            const path = await import('path');
+            const fs = await import('fs');
+
+            const root = await this.temukanAkarProyek();
+            if (!root) return { data: null, error: new Error('Akar proyek tidak ditemukan.') };
+            const envPath = path.join(root, '.env');
+
+            let content = '';
+            if (fs.existsSync(envPath)) {
+                content = fs.readFileSync(envPath, 'utf8');
+            }
+
+            const lines = content.split('\n');
+            let found = false;
+            const newLines = lines.map(line => {
+                const trimmed = line.trim();
+                if (trimmed.startsWith(`${key}=`)) {
+                    found = true;
+                    return `${key}=${value}`;
+                }
+                return line;
+            });
+
+            if (!found) {
+                if (content.length > 0 && !content.endsWith('\n')) {
+                    newLines.push('');
+                }
+                newLines.push(`${key}=${value}`);
+            }
+
+            fs.writeFileSync(envPath, newLines.join('\n'), 'utf8');
+            return { data: true, error: null };
+        } catch (err) {
+            return { data: null, error: err instanceof Error ? err : new Error(String(err)) };
+        }
+    }
+}

package/src/Layanan.ts

@@ -0,0 +1,45 @@
+/**
+ * Layanan Layer: The gateway for future Backend/API communications.
+ * Handles synchronization, authentication, and remote backup logic.
+ * Currently stubbed for local-only operation.
+ */
+
+import { Note, UserProfile } from './Rumus';
+
+export const Layanan = {
+    /**
+     * Push a note to the remote server
+     */
+    async syncNote(note: Note): Promise<boolean> {
+        // TODO: Implement API call to backend
+        console.log('[Layanan] Syncing note to remote...', note.id);
+        return true;
+    },
+
+    /**
+     * Pull updates from the remote server
+     */
+    async fetchUpdates(): Promise<Note[]> {
+        // TODO: Implement API call to backend
+        return [];
+    },
+
+    /**
+     * Authenticate with the remote server for sync
+     */
+    async authenticate(_token: string): Promise<UserProfile | null> {
+        // TODO: Implement auth logic
+        return null;
+    },
+
+    /**
+     * Broadcast a synchronization event to other clients
+     */
+    broadcastSync(noteId: string) {
+        if (typeof window !== 'undefined') {
+            const channel = new BroadcastChannel('lembaran-sync');
+            channel.postMessage({ type: 'NOTE_SYNCED', id: noteId });
+            channel.close();
+        }
+    }
+};

package/src/Linguis.ts

@@ -0,0 +1,73 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+
+/**
+ * Linguis: AI translation engine for Lembaran.
+ * Designed to maintain the "poetic & professional" vibes.
+ */
+export class Linguis {
+    private genAI: GoogleGenerativeAI;
+    private model: ReturnType<GoogleGenerativeAI['getGenerativeModel']>;
+
+    constructor(apiKey: string) {
+        this.genAI = new GoogleGenerativeAI(apiKey);
+        this.model = this.genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
+    }
+
+    /**
+     * Translates a string (UI element) with context.
+     */
+    async terjemahkanTeks(teks: string, targetLang: 'id' | 'en'): Promise<string> {
+        const prompt = `
+            You are "Linguis", the translation spirit of Lembaran, a high-end personal archive platform.
+            Your vibe is: Poetic, professional, minimal, and elegant.
+            
+            Translate the following text into ${targetLang === 'id' ? 'Indonesian' : 'English'}.
+            Maintain the tone:
+            - If Indonesian: Use "puitis", "elegan", and "profesional".
+            - If English: Use "sophisticated", "clean", and "minimalist".
+            
+            Original Text: "${teks}"
+            
+            Return ONLY the translated string. No extra words or quotes.
+        `;
+
+        try {
+            const result = await this.model.generateContent(prompt);
+            return result.response.text().trim().replace(/^"(.*)"$/, '$1');
+        } catch (error) {
+            console.error('[Linguis] Translation error:', error);
+            return teks; // Fallback to original
+        }
+    }
+
+    /**
+     * Translates Markdown documentation.
+     */
+    async terjemahkanDokumen(markdown: string, targetLang: 'id' | 'en'): Promise<string> {
+        const prompt = `
+            You are "Linguis", the translation spirit of Lembaran.
+            Translate this documentation into ${targetLang === 'id' ? 'Indonesian' : 'English'}.
+            
+            CRITICAL RULES:
+            1. Keep ALL Markdown structure (headers, links, code blocks) intact.
+            2. Do NOT translate technical terms inside code blocks or specific command names like "lembaran", "ukir", "pantau".
+            3. Use a professional, elegant, and poetic tone.
+            4. Keep GitHub-style alerts (e.g., > [!NOTE]) exactly as they are.
+            
+            Markdown to translate:
+            ---
+            ${markdown}
+            ---
+            
+            Return ONLY the translated Markdown.
+        `;
+
+        try {
+            const result = await this.model.generateContent(prompt);
+            return result.response.text().trim();
+        } catch (error) {
+            console.error('[Linguis] Doc translation error:', error);
+            return markdown;
+        }
+    }
+}

package/src/Penjaga.ts

@@ -0,0 +1,70 @@
+'use client';
+
+import { useEffect, useRef } from 'react';
+import { usePundi } from './Pundi';
+import { Brankas } from './Brankas';
+import { audio, haptic } from './Indera';
+
+/**
+ * usePenjaga: Hook untuk memantau keamanan sesi.
+ * Menangani penguncian otomatis berdasarkan waktu idle (sessionTimeout)
+ * dan perpindahan tab (visibilitychange).
+ */
+export const usePenjaga = () => {
+    const isVaultLocked = usePundi(s => s.isVaultLocked);
+    const setVaultLocked = usePundi(s => s.setVaultLocked);
+    const settings = usePundi(s => s.settings);
+    
+    const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+    const hideTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+    const gembokBrankas = () => {
+        if (!isVaultLocked) {
+            Brankas.clearKey();
+            setVaultLocked(true);
+            audio.lock();
+            haptic.medium();
+        }
+    };
+
+    // 1. Session Timeout (Time-based lock while active)
+    useEffect(() => {
+        if (!isVaultLocked && settings.sessionTimeout) {
+            // Bersihkan timeout lama jika ada
+            if (timeoutRef.current) clearTimeout(timeoutRef.current);
+            
+            // Set timeout baru sesuai pengaturan (menit -> ms)
+            timeoutRef.current = setTimeout(() => {
+                gembokBrankas();
+            }, settings.sessionTimeout * 60 * 1000);
+        }
+
+        return () => {
+            if (timeoutRef.current) clearTimeout(timeoutRef.current);
+        };
+    }, [isVaultLocked, settings.sessionTimeout, setVaultLocked]);
+
+    // 2. Visibility Change (Auto-lock when tab hidden)
+    useEffect(() => {
+        const handleVisibilityChange = () => {
+            if (document.visibilityState === 'hidden' && !isVaultLocked) {
+                // Beri toleransi 1 menit sebelum mengunci saat tab disembunyikan
+                hideTimeoutRef.current = setTimeout(() => {
+                    gembokBrankas();
+                }, 60000); 
+            } else if (document.visibilityState === 'visible') {
+                // Batalkan penguncian jika user kembali sebelum 1 menit
+                if (hideTimeoutRef.current) {
+                    clearTimeout(hideTimeoutRef.current);
+                    hideTimeoutRef.current = null;
+                }
+            }
+        };
+
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return () => {
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+            if (hideTimeoutRef.current) clearTimeout(hideTimeoutRef.current);
+        };
+    }, [isVaultLocked, setVaultLocked]);
+};

package/src/Penyaring.ts

@@ -0,0 +1,10 @@
+export const stripHtml = (html: string): string => {
+    if (!html) return '';
+    // Use a simple regex for universal support (SSR safe)
+    return html.replace(/<[^>]*>?/gm, '');
+};
+
+export const truncate = (str: string, length: number): string => {
+    if (str.length <= length) return str;
+    return str.slice(0, length) + '...';
+};

package/src/Penyelaras.ts

@@ -0,0 +1,40 @@
+'use client';
+
+import { useEffect } from 'react';
+import { usePundi } from './Pundi';
+import { Brankas } from './Brankas';
+
+export const usePenyelaras = () => {
+    const isVaultLocked = usePundi(s => s.isVaultLocked);
+    const setVaultLocked = usePundi(s => s.setVaultLocked);
+
+    useEffect(() => {
+        const channel = new BroadcastChannel('lembaran-vault-sync');
+
+        const handleMessage = (event: MessageEvent) => {
+            if (event.data.type === 'VAULT_LOCK_STATUS') {
+                const newStatus = event.data.locked;
+                if (newStatus !== isVaultLocked) {
+                    if (newStatus) {
+                        Brankas.clearKey();
+                    }
+                    setVaultLocked(newStatus);
+                }
+            }
+        };
+
+        channel.addEventListener('message', handleMessage);
+
+        return () => {
+            channel.removeEventListener('message', handleMessage);
+            channel.close();
+        };
+    }, [isVaultLocked, setVaultLocked]);
+
+    // Kita panggil ini saat status berubah di tab ini
+    useEffect(() => {
+        const channel = new BroadcastChannel('lembaran-vault-sync');
+        channel.postMessage({ type: 'VAULT_LOCK_STATUS', locked: isVaultLocked });
+        channel.close();
+    }, [isVaultLocked]);
+};

package/src/Pujangga.ts

@@ -0,0 +1,66 @@
+import { PujanggaProvider, PujanggaPlan } from './ai/types';
+import { GeminiProvider } from './ai/GeminiProvider';
+import { LocalProvider } from './ai/LocalProvider';
+import { PenyaringRahasia } from './ai/PenyaringRahasia';
+import { AuditLog } from './AuditLog';
+
+/**
+ * Pujangga Engine: Modular & Private AI Architecture.
+ * Standardized as a class for maximum compatibility.
+ */
+export class Pujangga {
+    static _provider: PujanggaProvider = new LocalProvider();
+
+    /**
+     * Sets the active AI provider.
+     */
+    static setProvider(type: 'gemini' | 'openai' | 'claude' | 'none') {
+        switch (type) {
+            case 'gemini': this._provider = new GeminiProvider(); break;
+            case 'none': this._provider = new LocalProvider(); break;
+            default: this._provider = new LocalProvider();
+        }
+    }
+
+    /**
+     * Smart Brain with Privacy Scrubbing.
+     */
+    static async berpikir(konteks: string, instruksi: string): Promise<PujanggaPlan> {
+        // Step 1: Scrub Secrets
+        const safeKonteks = PenyaringRahasia.saring(konteks);
+        const safeInstruksi = PenyaringRahasia.saring(instruksi);
+
+        // Step 2: Laporan Transparansi (Audit)
+        await AuditLog.catat('PERMINTAAN_KECERDASAN', {
+            model: this._provider.name,
+            konteks: safeKonteks,
+            instruksi: safeInstruksi
+        });
+
+        // Step 3: Delegate to Provider
+        const plan = await this._provider.berpikir(safeKonteks, safeInstruksi);
+
+        // Step 4: Catat Keputusan
+        await AuditLog.catat('KEPUTUSAN_SENTINEL', plan);
+
+        return plan;
+    }
+
+    /**
+     * Heuristic methods.
+     */
+    static async sarankanTag(konten: string): Promise<string[]> {
+        const clean = konten.toLowerCase();
+        const tags: string[] = [];
+        if (clean.includes('koding') || clean.includes('bug')) tags.push('Developer');
+        return tags;
+    }
+
+    static async sarankanJudul(konten: string): Promise<string> {
+        return konten.substring(0, 30);
+    }
+
+    static async ringkasCerdas(konten: string): Promise<string> {
+        return konten.substring(0, 150);
+    }
+}

package/src/Pundi.ts

@@ -0,0 +1,69 @@
+'use client';
+
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import { AppSettings, UserProfile } from './Rumus';
+
+export interface LembaranState {
+    settings: AppSettings;
+    profile: UserProfile;
+    isVaultLocked: boolean;
+
+    // Actions
+    updateSettings: (settings: Partial<AppSettings>) => void;
+    updateProfile: (profile: Partial<UserProfile>) => void;
+    setVaultLocked: (isLocked: boolean) => void;
+    addCustomTheme: (name: string, color: string) => void;
+}
+
+const DEFAULT_SETTINGS: AppSettings = {
+    language: 'id',
+    theme: 'auto',
+    accentColor: '#135bec',
+    encryptionEnabled: false,
+    syncEnabled: false,
+    secretMode: "none",
+    lastSyncAt: null,
+    sessionTimeout: 1,
+    vimMode: false,
+    biometricEnabled: false,
+};
+
+const DEFAULT_PROFILE: UserProfile = {
+    name: 'Arsiparis',
+    bio: 'Menyusun fragmen memori dalam harmoni.',
+    avatarUrl: '',
+    level: 1,
+    xp: 0,
+};
+
+export const usePundi = create<LembaranState>()(
+    persist(
+        (set) => ({
+            settings: DEFAULT_SETTINGS,
+            profile: DEFAULT_PROFILE,
+            isVaultLocked: true,
+
+            updateSettings: (newSettings) =>
+                set((state) => ({ settings: { ...state.settings, ...newSettings } })),
+
+            updateProfile: (newProfile) =>
+                set((state) => ({ profile: { ...state.profile, ...newProfile } })),
+
+            setVaultLocked: (isLocked) =>
+                set({ isVaultLocked: isLocked }),
+
+            addCustomTheme: (name, color) =>
+                set((state) => ({
+                    settings: {
+                        ...state.settings,
+                        customThemes: { ...(state.settings.customThemes || {}), [name]: color }
+                    }
+                })),
+        }),
+        {
+            name: 'lembaran:pundi',
+            partialize: (state) => ({ settings: state.settings, profile: state.profile }),
+        }
+    )
+);

package/src/Rumus.ts

@@ -0,0 +1,55 @@
+export type EntityId = string;
+
+export interface Note {
+    id: EntityId;
+    title: string;
+    content: string; // Encrypted blob (iv|data)
+    preview?: string; // Plain-text snippet for list view
+    folderId: EntityId | null;
+    isPinned: boolean;
+    isFavorite: boolean;
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+    isCredentials?: boolean;
+    kredensial?: string | {
+        username?: string;
+        password?: string;
+        url?: string;
+    };
+    _hash?: string;
+    _timestamp?: string;
+    syncStatus?: "synced" | "pending" | "error";
+}
+
+export interface Folder {
+    id: EntityId;
+    name: string;
+    parentId: EntityId | null;
+    icon?: string;
+    color?: string;
+    createdAt: string;
+}
+
+export interface AppSettings {
+    language: 'id' | 'en';
+    theme: 'light' | 'dark' | 'auto';
+    accentColor: string;
+    encryptionEnabled: boolean;
+    syncEnabled: boolean;
+    lastSyncAt: string | null;
+    secretMode: "none" | "gmail";
+    panicKeyHash?: string;
+    sessionTimeout?: number;
+    customThemes?: Record<string, string>;
+    vimMode?: boolean;
+    biometricEnabled?: boolean;
+}
+
+export interface UserProfile {
+    name: string;
+    bio: string;
+    avatarUrl: string;
+    level: number;
+    xp: number;
+}