@takimcizgisi/ajan 0.2.5

package/dist/electron/main.js

@@ -0,0 +1,364 @@
+import { app, BrowserWindow, ipcMain, shell } from "electron";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+import { AjanService } from "../service.js";
+import { getDataDir } from "../utils/paths.js";
+import { acquireLock, releaseLock } from "../utils/lock.js";
+const isDev = process.argv.includes("--dev");
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let mainWindow = null;
+let service = null;
+let isMaximized = false;
+function getVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function getGuiPath() {
+    return join(__dirname, "..", "..", "src", "gui");
+}
+function createService() {
+    if (service)
+        return;
+    service = new AjanService({
+        onTextChunk: (text) => mainWindow?.webContents.send("agent:text-chunk", text),
+        onThinkingChunk: (text) => mainWindow?.webContents.send("agent:thinking-chunk", text),
+        onToolCall: (name, params) => mainWindow?.webContents.send("agent:tool-call", name, params),
+        onToolResult: (name, ok, output) => mainWindow?.webContents.send("agent:tool-result", name, ok, output),
+        onStepStart: (step, maxSteps) => mainWindow?.webContents.send("agent:step-start", step, maxSteps),
+        onComplete: (response) => mainWindow?.webContents.send("agent:complete", response),
+        onError: (error) => mainWindow?.webContents.send("agent:error", error.message),
+        onContextTrimmed: () => { },
+        onModelLoadProgress: (pct) => mainWindow?.webContents.send("agent:load-progress", pct),
+        onModelLoadComplete: () => mainWindow?.webContents.send("agent:load-complete")
+    });
+}
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        minWidth: 800,
+        minHeight: 600,
+        frame: false,
+        titleBarStyle: "hidden",
+        backgroundColor: "#202020",
+        webPreferences: {
+            preload: join(__dirname, "preload.js"),
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: false
+        },
+        icon: join(getGuiPath(), "assets", "image", "ajan.png"),
+        title: `AJAN AI v${getVersion()}`
+    });
+    mainWindow.loadFile(join(getGuiPath(), "html", "index.html"));
+    if (isDev) {
+        mainWindow.webContents.openDevTools({ mode: "detach" });
+    }
+    mainWindow.on("closed", () => {
+        mainWindow = null;
+    });
+    mainWindow.on("maximize", () => {
+        isMaximized = true;
+        mainWindow?.webContents.send("window:maximized-changed", true);
+    });
+    mainWindow.on("unmaximize", () => {
+        isMaximized = false;
+        mainWindow?.webContents.send("window:maximized-changed", false);
+    });
+    mainWindow.webContents.on("did-finish-load", () => {
+        if (mainWindow?.isMaximized()) {
+            isMaximized = true;
+            mainWindow.webContents.send("window:maximized-changed", true);
+        }
+        restoreLastSession();
+    });
+    mainWindow.webContents.on("console-message", (_event, level, message, line, sourceId) => {
+        const line2 = `[renderer:${level}] ${sourceId}:${line} ${message}\n`;
+        console.log(line2.trimEnd());
+        try {
+            const fsmod = require("node:fs");
+            fsmod.appendFileSync(require("node:path").join(require("node:os").homedir(), ".ajan", "renderer.log"), line2);
+        }
+        catch { /* empty */ }
+    });
+    mainWindow.webContents.on("preload-error", (_event, preloadPath, error) => {
+        console.log(`[preload-error] ${preloadPath}: ${error.message}`);
+    });
+    mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+        shell.openExternal(url);
+        return { action: "deny" };
+    });
+}
+async function restoreLastSession() {
+    try {
+        if (!service)
+            return;
+        const sessions = await service.listSessions();
+        const last = sessions[0];
+        if (!last)
+            return;
+        mainWindow?.webContents.send("agent:session-restore", {
+            id: last.id,
+            title: last.title,
+            messages: last.messages,
+            createdAt: last.createdAt,
+            updatedAt: last.updatedAt
+        });
+    }
+    catch { /* empty */ }
+}
+function setupIpc() {
+    // Agent: send
+    ipcMain.handle("agent:send", async (_event, message, modelId) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        return await service.sendMessage(message, modelId || undefined);
+    });
+    // Agent: abort
+    ipcMain.handle("agent:abort", () => {
+        service?.abort();
+        return { ok: true };
+    });
+    // Agent: reset
+    ipcMain.handle("agent:reset", () => {
+        service?.reset();
+        return { ok: true };
+    });
+    // Agent: status
+    ipcMain.handle("agent:status", () => {
+        return { active: service?.isActive ?? false, contextStats: service?.getContextStats() ?? null };
+    });
+    // Config
+    ipcMain.handle("app:version", () => getVersion());
+    ipcMain.handle("config:get", () => {
+        return service?.getConfig() ?? {};
+    });
+    ipcMain.handle("config:set", async (_event, newConfig) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        await service.setConfig(newConfig);
+        return { ok: true };
+    });
+    // Model
+    ipcMain.handle("model:info", () => {
+        return service?.getModelInfo() ?? { modelId: "", name: "Bilinmeyen", installed: false };
+    });
+    ipcMain.handle("model:list", () => {
+        return service?.listModels() ?? [];
+    });
+    ipcMain.handle("model:install", async (_event, id) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        return await service.installModel(id);
+    });
+    ipcMain.handle("model:remove", async (_event, id) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        return await service.removeModel(id);
+    });
+    ipcMain.handle("model:use", async (_event, id) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        return await service.useModel(id);
+    });
+    ipcMain.handle("model:refresh", async () => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        return await service.refreshModels();
+    });
+    // Project
+    ipcMain.handle("project:list", () => {
+        return service?.listProjects() ?? [];
+    });
+    ipcMain.handle("project:add", async (_event, path) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        return await service.addProject(path);
+    });
+    ipcMain.handle("project:remove", async (_event, path) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        return await service.removeProject(path);
+    });
+    ipcMain.handle("project:set-active", async (_event, path) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        return await service.setActiveProject(path);
+    });
+    ipcMain.handle("project:pick-dir", async () => {
+        const { dialog } = await import("electron");
+        const result = await dialog.showOpenDialog(mainWindow, { properties: ["openDirectory"] });
+        return result.canceled ? null : (result.filePaths[0] ?? null);
+    });
+    ipcMain.handle("project:exists", async (_event, path) => {
+        try {
+            const { statSync } = await import("node:fs");
+            return statSync(path).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    // Session
+    ipcMain.handle("session:list", async () => {
+        return service?.listSessions() ?? [];
+    });
+    ipcMain.handle("session:load", async (_event, id) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        const data = await service.loadSession(id);
+        if (!data)
+            return { ok: false, error: "Oturum bulunamadı" };
+        return { ok: true, data };
+    });
+    ipcMain.handle("session:save", async (_event, session) => {
+        if (!service)
+            return { ok: false, error: "Servis başlatılamadı" };
+        await service.saveSession(session);
+        return { ok: true };
+    });
+    ipcMain.handle("session:new", () => {
+        service?.reset();
+        return { ok: true };
+    });
+    ipcMain.handle("session:generate-id", () => {
+        return service?.generateSessionId() ?? String(Date.now());
+    });
+    ipcMain.handle("session:get-history", () => {
+        return service?.getChatHistory() ?? [];
+    });
+    // System
+    ipcMain.handle("system:gpu", async () => {
+        try {
+            const gpus = await service?.detectGpu() ?? [];
+            return { gpus };
+        }
+        catch {
+            return { gpus: [] };
+        }
+    });
+    ipcMain.handle("system:cwd", () => {
+        return { cwd: process.cwd() };
+    });
+    ipcMain.handle("system:notes", async () => {
+        const { readFileSync: readFs } = await import("node:fs");
+        const notesPath = join(getDataDir(), "notes.json");
+        try {
+            return JSON.parse(readFs(notesPath, "utf8"));
+        }
+        catch {
+            return [];
+        }
+    });
+    ipcMain.handle("system:notes:add", async (_event, text) => {
+        const { readFileSync: readFs, writeFileSync: writeFs } = await import("node:fs");
+        const notesPath = join(getDataDir(), "notes.json");
+        let notes = [];
+        try {
+            notes = JSON.parse(readFs(notesPath, "utf8"));
+        }
+        catch { /* empty */ }
+        notes.push({ text, createdAt: new Date().toISOString() });
+        writeFs(notesPath, JSON.stringify(notes, null, 2), "utf8");
+        return { ok: true };
+    });
+    // Window controls
+    ipcMain.handle("window:minimize", () => mainWindow?.minimize());
+    ipcMain.handle("window:maximize", () => {
+        if (mainWindow?.isMaximized())
+            mainWindow.unmaximize();
+        else
+            mainWindow?.maximize();
+    });
+    ipcMain.handle("window:close", () => mainWindow?.close());
+    ipcMain.handle("window:is-maximized", () => isMaximized);
+    // GUI file reader
+    ipcMain.handle("gui:read-file", (_event, relativePath) => {
+        try {
+            const guiPath = getGuiPath();
+            const filePath = join(guiPath, relativePath);
+            if (!filePath.startsWith(guiPath)) {
+                return { ok: false, error: "Yasak yol" };
+            }
+            const content = readFileSync(filePath, "utf8");
+            return { ok: true, content };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    });
+    // Windows shortcut
+    ipcMain.handle("gui:create-shortcut", () => {
+        try {
+            const projRoot = join(__dirname, "..", "..");
+            const electronExe = join(projRoot, "node_modules", "electron", "dist", "electron.exe");
+            const targetJs = join(projRoot, "dist", "electron", "main.js");
+            if (!existsSync(electronExe)) {
+                return { ok: false, error: "electron.exe bulunamadı" };
+            }
+            const desktopPath = join(homedir(), "Desktop");
+            const startMenuPath = join(homedir(), "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs");
+            const makeShortcut = (dir, name) => {
+                const lnkPath = join(dir, `${name}.lnk`);
+                const ps = [
+                    `$ws = New-Object -ComObject WScript.Shell`,
+                    `$s = $ws.CreateShortcut('${lnkPath.replace(/'/g, "''")}')`,
+                    `$s.TargetPath = '${electronExe.replace(/'/g, "''")}'`,
+                    `$s.Arguments = '${targetJs.replace(/'/g, "''")}'`,
+                    `$s.WorkingDirectory = '${projRoot.replace(/'/g, "''")}'`,
+                    `$s.Description = 'AJAN AI Yerel Asistan'`,
+                    `$s.Save()`
+                ].join("; ");
+                execSync(`powershell -NoProfile -Command "${ps}"`, { stdio: "pipe" });
+            };
+            makeShortcut(desktopPath, "AJAN AI");
+            const ajanStartDir = join(startMenuPath, "AJAN AI");
+            if (!existsSync(ajanStartDir)) {
+                mkdirSync(ajanStartDir, { recursive: true });
+            }
+            makeShortcut(ajanStartDir, "AJAN AI");
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    });
+}
+// ── App Lifecycle ──
+app.whenReady().then(() => {
+    const lock = acquireLock("gui");
+    if (!lock.ok) {
+        console.log(lock.error);
+        app.quit();
+        return;
+    }
+    createService();
+    setupIpc();
+    createWindow();
+    app.on("activate", () => {
+        if (BrowserWindow.getAllWindows().length === 0)
+            createWindow();
+    });
+});
+app.on("window-all-closed", async () => {
+    await service?.dispose();
+    service = null;
+    releaseLock();
+    if (process.platform !== "darwin")
+        app.quit();
+});
+app.on("before-quit", async () => {
+    await service?.dispose();
+    service = null;
+    releaseLock();
+});
+//# sourceMappingURL=main.js.map

package/dist/electron/preload.d.ts

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

package/dist/electron/preload.js

@@ -0,0 +1,67 @@
+import { contextBridge, ipcRenderer } from "electron";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function onIpc(channel, cb) {
+    const handler = (_event, ...args) => cb(...args);
+    ipcRenderer.on(channel, handler);
+    return () => { ipcRenderer.removeListener(channel, handler); };
+}
+contextBridge.exposeInMainWorld("ajan", {
+    // ── Agent ──
+    sendMessage: (message, model) => ipcRenderer.invoke("agent:send", message, model),
+    abort: () => ipcRenderer.invoke("agent:abort"),
+    reset: () => ipcRenderer.invoke("agent:reset"),
+    getStatus: () => ipcRenderer.invoke("agent:status"),
+    // ── Agent Events ──
+    onTextChunk: (cb) => onIpc("agent:text-chunk", cb),
+    onThinkingChunk: (cb) => onIpc("agent:thinking-chunk", cb),
+    onToolCall: (cb) => onIpc("agent:tool-call", cb),
+    onToolResult: (cb) => onIpc("agent:tool-result", cb),
+    onStepStart: (cb) => onIpc("agent:step-start", cb),
+    onComplete: (cb) => onIpc("agent:complete", cb),
+    onError: (cb) => onIpc("agent:error", cb),
+    onLoadProgress: (cb) => onIpc("agent:load-progress", cb),
+    onLoadComplete: (cb) => onIpc("agent:load-complete", cb),
+    // ── Config ──
+    getConfig: () => ipcRenderer.invoke("config:get"),
+    setConfig: (config) => ipcRenderer.invoke("config:set", config),
+    // ── Model ──
+    getModelInfo: () => ipcRenderer.invoke("model:info"),
+    listModels: () => ipcRenderer.invoke("model:list"),
+    installModel: (id) => ipcRenderer.invoke("model:install", id),
+    removeModel: (id) => ipcRenderer.invoke("model:remove", id),
+    useModel: (id) => ipcRenderer.invoke("model:use", id),
+    refreshModels: () => ipcRenderer.invoke("model:refresh"),
+    // ── Project ──
+    listProjects: () => ipcRenderer.invoke("project:list"),
+    addProject: (path) => ipcRenderer.invoke("project:add", path),
+    removeProject: (path) => ipcRenderer.invoke("project:remove", path),
+    setActiveProject: (path) => ipcRenderer.invoke("project:set-active", path),
+    pickDir: () => ipcRenderer.invoke("project:pick-dir"),
+    projectExists: (path) => ipcRenderer.invoke("project:exists", path),
+    // ── App ──
+    getVersion: () => ipcRenderer.invoke("app:version"),
+    // ── Session ──
+    listSessions: () => ipcRenderer.invoke("session:list"),
+    loadSession: (id) => ipcRenderer.invoke("session:load", id),
+    saveSession: (session) => ipcRenderer.invoke("session:save", session),
+    newSession: () => ipcRenderer.invoke("session:new"),
+    generateSessionId: () => ipcRenderer.invoke("session:generate-id"),
+    getChatHistory: () => ipcRenderer.invoke("session:get-history"),
+    onSessionRestore: (cb) => onIpc("agent:session-restore", cb),
+    // ── System ──
+    getGpuInfo: () => ipcRenderer.invoke("system:gpu"),
+    getCwd: () => ipcRenderer.invoke("system:cwd"),
+    getNotes: () => ipcRenderer.invoke("system:notes"),
+    addNote: (text) => ipcRenderer.invoke("system:notes:add", text),
+    // ── GUI Files ──
+    readGuiFile: (relativePath) => ipcRenderer.invoke("gui:read-file", relativePath),
+    createShortcut: () => ipcRenderer.invoke("gui:create-shortcut"),
+    // ── Window Events ──
+    onMaximized: (cb) => onIpc("window:maximized-changed", cb),
+    isMaximized: () => ipcRenderer.invoke("window:is-maximized"),
+    // ── Window Controls ──
+    minimize: () => ipcRenderer.invoke("window:minimize"),
+    maximize: () => ipcRenderer.invoke("window:maximize"),
+    close: () => ipcRenderer.invoke("window:close")
+});
+//# sourceMappingURL=preload.js.map

package/dist/engine/llama.d.ts

@@ -0,0 +1,39 @@
+import { LlamaChatSession, type ChatWrapper, type ChatSessionModelFunctions } from "node-llama-cpp";
+import type { AjanConfig, ChatWrapperName } from "../config/types.js";
+export type LlamaEngineOptions = {
+    modelPath: string;
+    config: AjanConfig;
+    chatWrapperName?: ChatWrapperName;
+    gpuBackend?: AjanConfig["gpu"];
+    onProgress?: (progress: number) => void;
+    signal?: AbortSignal;
+};
+export declare class LlamaEngine {
+    private llama;
+    private model;
+    private context;
+    private sequence;
+    private session;
+    private readonly modelPath;
+    private readonly config;
+    private readonly chatWrapperName?;
+    private readonly gpuBackend?;
+    private readonly onProgress?;
+    private readonly signal?;
+    constructor(options: LlamaEngineOptions);
+    private get gpuOption();
+    static detectSupportedGpus(): Promise<string[]>;
+    init(): Promise<void>;
+    loadModel(onProgress?: (pct: number) => void): Promise<void>;
+    createContext(): Promise<void>;
+    createSession(systemPrompt: string): LlamaChatSession;
+    /** Konuşma geçmişini temizler ve yeni sistem promptu ile taze bir oturum kurar */
+    resetSession(systemPrompt: string): Promise<LlamaChatSession>;
+    getSession(): LlamaChatSession | undefined;
+    get contextSize(): number;
+    getUsedContextTokens(): number;
+    get sequenceInstalled(): boolean;
+    dispose(): Promise<void>;
+}
+export declare function resolveChatWrapper(name: ChatWrapperName): "auto" | ChatWrapper;
+export type { ChatSessionModelFunctions };

package/dist/engine/llama.js

@@ -0,0 +1,146 @@
+import { getLlama, getLlamaGpuTypes, LlamaChatSession, Gemma4ChatWrapper, GemmaChatWrapper, QwenChatWrapper, Llama3_1ChatWrapper, MistralChatWrapper, ChatMLChatWrapper, FunctionaryChatWrapper, LlamaLogLevel } from "node-llama-cpp";
+import { logger } from "../utils/paths.js";
+export class LlamaEngine {
+    llama;
+    model;
+    context;
+    sequence;
+    session;
+    modelPath;
+    config;
+    chatWrapperName;
+    gpuBackend;
+    onProgress;
+    signal;
+    constructor(options) {
+        this.modelPath = options.modelPath;
+        this.config = options.config;
+        this.chatWrapperName = options.chatWrapperName;
+        this.gpuBackend = options.gpuBackend ?? options.config.gpu;
+        this.onProgress = options.onProgress;
+        this.signal = options.signal;
+    }
+    get gpuOption() {
+        if (!this.gpuBackend)
+            return undefined;
+        if (this.gpuBackend === "auto")
+            return { type: "auto" };
+        return undefined;
+    }
+    static async detectSupportedGpus() {
+        try {
+            const supported = await getLlamaGpuTypes("supported");
+            return supported.filter((g) => typeof g === "string");
+        }
+        catch {
+            return [];
+        }
+    }
+    async init() {
+        if (this.llama)
+            return;
+        logger.info(`Motor baslatiliyor... (model: ${this.modelPath})`);
+        const supportedGpus = await LlamaEngine.detectSupportedGpus();
+        logger.debug(`Desteklenen GPU'lar: ${supportedGpus.join(", ") || "yok (CPU)"}`);
+        this.llama = await getLlama({
+            gpu: this.gpuOption,
+            logLevel: LlamaLogLevel.error,
+            progressLogs: "stderr",
+            skipDownload: true
+        });
+    }
+    async loadModel(onProgress) {
+        await this.init();
+        if (this.model)
+            return;
+        logger.info(`Model yukleniyor: ${this.modelPath}`);
+        this.model = await this.llama.loadModel({
+            modelPath: this.modelPath,
+            gpuLayers: this.config.gpuLayers ?? "auto",
+            onLoadProgress: (pct) => {
+                const percentage = Math.min(100, Math.max(0, Math.round(pct * 100)));
+                onProgress?.(percentage);
+                this.onProgress?.(percentage);
+            },
+            loadSignal: this.signal
+        });
+    }
+    async createContext() {
+        await this.loadModel();
+        if (this.context)
+            return;
+        this.context = await this.model.createContext({
+            contextSize: this.config.contextSize ?? "auto"
+        });
+        this.sequence = this.context.getSequence();
+    }
+    createSession(systemPrompt) {
+        if (!this.sequence)
+            throw new Error("Oturum olusturmadan once context olusturulmali (createContext)");
+        const wrapper = resolveChatWrapper(this.chatWrapperName ?? "auto");
+        this.session = new LlamaChatSession({
+            contextSequence: this.sequence,
+            systemPrompt,
+            chatWrapper: wrapper
+        });
+        return this.session;
+    }
+    /** Konuşma geçmişini temizler ve yeni sistem promptu ile taze bir oturum kurar */
+    async resetSession(systemPrompt) {
+        if (!this.sequence)
+            throw new Error("Oturum olusturmadan once context olusturulmali (createContext)");
+        await this.session?.dispose();
+        await this.sequence.clearHistory();
+        return this.createSession(systemPrompt);
+    }
+    getSession() {
+        return this.session;
+    }
+    get contextSize() {
+        return this.context?.contextSize ?? 0;
+    }
+    getUsedContextTokens() {
+        return this.sequence?.nextTokenIndex ?? 0;
+    }
+    get sequenceInstalled() {
+        return this.sequence != null;
+    }
+    async dispose() {
+        try {
+            this.session?.dispose();
+            this.context?.dispose();
+            this.model?.dispose();
+            this.llama?.dispose();
+        }
+        catch {
+            /* dispose hatalari yut */
+        }
+        this.session = undefined;
+        this.context = undefined;
+        this.model = undefined;
+        this.llama = undefined;
+        this.sequence = undefined;
+    }
+}
+export function resolveChatWrapper(name) {
+    switch (name) {
+        case "gemma4":
+            return new Gemma4ChatWrapper({ reasoning: true });
+        case "gemma":
+            return new GemmaChatWrapper();
+        case "qwen3":
+            return new QwenChatWrapper();
+        case "llama3":
+            return new Llama3_1ChatWrapper();
+        case "mistral":
+            return new MistralChatWrapper();
+        case "chatml":
+            return new ChatMLChatWrapper();
+        case "functionary":
+            return new FunctionaryChatWrapper();
+        case "auto":
+        default:
+            return "auto";
+    }
+}
+//# sourceMappingURL=llama.js.map

package/dist/engine/modelManager.d.ts

@@ -0,0 +1,18 @@
+import type { ModelDefinition } from "../config/types.js";
+export type DownloadProgress = {
+    totalSize: number;
+    downloadedSize: number;
+    estimatedTimeLeft: number;
+    averageSpeed: number;
+    percent?: number;
+};
+export type DownloadOptions = {
+    onProgress?: (progress: DownloadProgress) => void;
+    showProgress?: boolean;
+    signal?: AbortSignal;
+};
+export declare function formatBytes(bytes: number): string;
+export declare function formatTime(ms: number): string;
+export declare function downloadModel(model: ModelDefinition, options?: DownloadOptions): Promise<string>;
+export declare function getModelFileSize(path: string): number;
+export declare function isDownloaded(model: ModelDefinition): boolean;