@nibgat/aide 0.0.0-stage → 0.2.0

package/src/repl.mjs

@@ -0,0 +1,501 @@
+/**
+ * Etkileşimli oturum (argümansız `aide`) ve ilk kurulum sihirbazı.
+ * - Yanıt akışla gelir, bitince Markdown olarak yeniden çizilir; adımlar kalıcı soluk satırlar, son adımda canlı gösterge.
+ * - Ctrl+C: süren turu iptal eder (sunucudaki iş de durur); boş satırda iki kez → çıkış. Ctrl+D → çıkış.
+ * - Yapıştırılan çok satırlı metin tek mesajdır; satır sonu `\` ile alt satıra devam. Tur sürerken yazılanlar sıraya girer.
+ * - `/komut` (Tab ile tamamlanır), `!komut` (yerel terminal), `/aide …` (CLI'nin her komutu oturum içinden).
+ */
+import { createInterface, clearLine, cursorTo } from 'node:readline';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import os from 'node:os';
+import { normalizeServer, updateConfig, HISTORY_FILE, readConfig, streamTurn, AideError, settings, probe, login, call, ask } from './client.mjs';
+import { runGroupCommand, routesTable, parseArgs, splitLine, runApi, GROUP_TITLES } from './commands.mjs';
+import { renderMarkdown, createSpinner, visibleLength, columns, box, c } from './ui.mjs';
+
+const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+
+// ─────────────────────────────── ilk kurulum ───────────────────────────────
+
+/** İlk çalıştırma: Ai-de sunucusunun adresi sorulur, denenir, giriş yapılır ve kaydedilir. */
+const onboard = async (flags = {}) => {
+    const config = readConfig();
+
+    console.log(`\n${box([`${c.accent('✻')} ${c.bold('Ai-de')} ${c.dim(`CLI v${VERSION}`)}`, 'Şirketinizin Ai-de sistemini bu terminalden yöneteceksiniz.', c.dim('Önce hangi Ai-de sunucusuna bağlanacağımızı ayarlayalım.')])}\n`);
+
+    let server = normalizeServer(flags.server || '');
+
+    for(let attempt = 0; attempt < 5; attempt += 1) {
+        if(!server) {
+            server = normalizeServer(await ask(`${c.accent('?')} Ai-de sunucusunun adresi ${c.dim(`(ör. https://aide.sirketiniz.com) [${config.server || 'http://localhost:3000'}]`)}: `, { fallback: config.server || 'http://localhost:3000' }));
+        }
+
+        try {
+            await probe(server);
+            console.log(`${c.green('✓')} ${server} bir Ai-de sunucusu, bağlanılabiliyor.`);
+            break;
+        } catch (error) {
+            console.log(c.red(`✗ ${error.cause?.code || error.message}`));
+            server = '';
+
+            if(attempt === 4) {
+                throw new AideError('Sunucuya bağlanılamadı. Adresi kontrol edip tekrar deneyin: aide login --server <adres>');
+            }
+        }
+    }
+
+    for(let attempt = 0; attempt < 3; attempt += 1) {
+        const email = String(flags.email || await ask(`${c.accent('?')} E-posta${config.email ? c.dim(` [${config.email}]`) : ''}: `, { fallback: config.email || '' })).trim();
+        const password = String(flags.password || process.env.AIDE_PASSWORD || await ask(`${c.accent('?')} Şifre: `, { hidden: true }));
+
+        try {
+            const token = await login(server, email, password);
+
+            updateConfig({ server, email, token, sessionId: null });
+            console.log(`${c.green('✓')} Giriş yapıldı: ${email}\n`);
+
+            return { server, token };
+        } catch (error) {
+            console.log(c.red(`✗ ${error.message}`));
+
+            if(flags.password || process.env.AIDE_PASSWORD) {
+                break;
+            }
+        }
+    }
+
+    throw new AideError('Giriş yapılamadı.');
+};
+
+// ─────────────────────────────── oturum yardımcıları ───────────────────────────────
+
+const SLASH = [
+    ['/yardim', 'komutları göster'],
+    ['/yeni', 'yeni sohbet'],
+    ['/oturumlar', 'sohbetleri listele'],
+    ['/oturum', '<no|id> sohbete geç'],
+    ['/ad', '<başlık> bu sohbetin adını değiştir'],
+    ['/sil', 'bu sohbeti sil'],
+    ['/ekip', 'personel listesi'],
+    ['/durum', 'motor, model ve kuyruk durumu'],
+    ['/bildirimler', 'son bildirimler'],
+    ['/hatirlat', '<ne zaman + ne> hatırlatma kur'],
+    ['/aide', '<komut> CLI komutu çalıştır (ör. /aide data list)'],
+    ['/sunucu', 'bağlı sunucu ve kullanıcı'],
+    ['/temizle', 'ekranı temizle'],
+    ['/cikis', 'çık']
+];
+const ALIASES = { '/remind': '/hatirlat', '/hatırlat': '/hatirlat', '/help': '/yardim', '/new': '/yeni', '/sessions': '/oturumlar', '/session': '/oturum', '/rename': '/ad', '/delete': '/sil', '/team': '/ekip', '/status': '/durum', '/notifications': '/bildirimler', '/server': '/sunucu', '/clear': '/temizle', '/exit': '/cikis', '/quit': '/cikis', '/çıkış': '/cikis', '/yardım': '/yardim' };
+
+const loadHistory = () => {
+    try {
+        return readFileSync(HISTORY_FILE, 'utf8').split('\n').filter(Boolean).slice(0, 500);
+    } catch {
+        return [];
+    }
+};
+
+const saveHistory = (history) => {
+    try {
+        mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
+        writeFileSync(HISTORY_FILE, history.slice(0, 500).join('\n'), { mode: 0o600 });
+    } catch {
+        // geçmiş yazılamazsa sohbet etkilenmez
+    }
+};
+
+/** Akışla basılmış ham metni silmek için kaç ekran satırı kapladığı (satır sarmaları dahil). */
+const screenRows = (text) => String(text).split('\n').reduce((sum, line) => sum + Math.max(1, Math.ceil(visibleLength(line) / columns())), 0);
+
+const ensureSession = async (flags, fresh = false) => {
+    const config = readConfig();
+
+    if(!fresh && config.sessionId) {
+        return config.sessionId;
+    }
+
+    const json = await call(flags, 'POST', '/api/chat/sessions', { title: 'Terminal' });
+    const id = (json.data || json.session || {}).id;
+
+    updateConfig({ sessionId: id });
+
+    return id;
+};
+
+/** Gürültü adımları (yönlendirme, tamamlandı) yalnızca göstergede kalır; anlamlı adımlar kalıcı satır olur. */
+const isNoise = (message) => /^(Tamamlandı|🧭 İstek yönlendiriliyor)/.test(message);
+
+// ─────────────────────────────── etkileşimli oturum ───────────────────────────────
+
+const startRepl = async (flags = {}) => {
+    let { server, token } = settings(flags);
+
+    if(!server || !token) {
+        ({ server, token } = await onboard(flags));
+    }
+
+    const [me, profile, status] = await Promise.all([
+        call(flags, 'GET', '/api/auth/me').catch((error) => (error.status === 401 ? 'unauthorized' : null)),
+        call(flags, 'GET', '/api/me/profile').catch(() => null),
+        call(flags, 'GET', '/api/engine/status').catch(() => null)
+    ]);
+
+    if(me === 'unauthorized') {
+        console.log(c.yellow('Oturumun süresi dolmuş, yeniden giriş yapalım.'));
+        ({ server, token } = await onboard({ ...flags, server }));
+    }
+
+    let sessionId = await ensureSession(flags);
+    const user = me?.data || me?.user || me || {};
+    const organization = profile?.profile?.organization || profile?.data?.organization || {};
+    const work = status?.models?.work || status?.data?.models?.work;
+    const loaded = status?.scheduler?.loaded || status?.data?.scheduler?.loaded || [];
+
+    console.log(`\n${box([
+        `${c.accent('✻')} ${c.bold('Ai-de')} ${c.dim(`v${VERSION}`)}`,
+        `${user.name || user.email || ''}${organization.name ? c.dim(` · ${organization.name}`) : ''}`,
+        c.dim(`${server}${work ? ` · ${String(work).split('/').pop()}${loaded.length ? ` (${loaded.length} model yüklü)` : ''}` : ''}`)
+    ])}`);
+    console.log(c.dim('  /yardim komutlar · !komut yerel terminal · Ctrl+C iptal · Ctrl+D çıkış\n'));
+
+    const completer = (line) => {
+        if(!line.startsWith('/')) {
+            return [[], line];
+        }
+
+        if(line.startsWith('/aide ')) {
+            const groups = Object.keys(GROUP_TITLES).map((group) => `/aide ${group}`);
+            const hits = groups.filter((item) => item.startsWith(line));
+
+            return [hits.length ? hits : groups, line];
+        }
+
+        const all = [...SLASH.map(([name]) => name), ...Object.keys(ALIASES)];
+        const hits = all.filter((name) => name.startsWith(line));
+
+        return [hits.length ? hits : SLASH.map(([name]) => name), line];
+    };
+    const rl = createInterface({ input: process.stdin, output: process.stdout, prompt: `${c.accent('❯')} `, completer, history: loadHistory(), historySize: 500, removeHistoryDuplicates: true });
+    const state = { controller: null, lastSigint: 0, sessions: [], pending: [], queue: [], timer: null, busy: false };
+    const replFlags = { ...flags };
+
+    const replAsk = (question) => new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim())));
+
+    // ── tur ──
+    const turn = async (text) => {
+        const spinner = createSpinner('Düşünüyor');
+        const started = Date.now();
+        let streamed = '';
+
+        state.controller = new AbortController();
+        spinner.start();
+
+        try {
+            const final = await streamTurn(replFlags, {
+                signal: state.controller.signal,
+                prompt: text,
+                sessionId,
+                onStep: (message) => {
+                    const clean = message.replace(/\.\.\.$/, '…');
+
+                    if(isNoise(message)) {
+                        spinner.update(clean);
+                        return;
+                    }
+
+                    spinner.stop(`⎿ ${clean}`);
+                    spinner.update(clean);
+                    spinner.start();
+                },
+                onToken: (token) => {
+                    if(!streamed) {
+                        spinner.stop();
+                    }
+
+                    streamed += token;
+                    process.stdout.write(token);
+                }
+            });
+
+            spinner.stop();
+
+            // Akışla basılan ham metin silinir, yanıt Markdown olarak çizilir
+            if(streamed && process.stdout.isTTY) {
+                const rows = screenRows(streamed);
+
+                process.stdout.write(rows > 1 ? `\x1b[${rows - 1}F\x1b[J` : '\r\x1b[2K');
+            } else if(streamed) {
+                process.stdout.write('\n');
+            }
+
+            const parts = Array.isArray(final.messages) && final.messages.length > 1 ? final.messages : [final.finalTurkishResponse || streamed];
+            // Terminal değilse akışla basılan metin silinemez: tek parçalı yanıt yeniden basılmaz
+            const shown = streamed && !process.stdout.isTTY && parts.length === 1 ? [] : parts;
+
+            shown.forEach((part, index) => {
+                if(index > 0) {
+                    console.log(c.gray('─'.repeat(Math.min(48, columns()))));
+                }
+
+                console.log(renderMarkdown(part));
+            });
+
+            const seconds = ((final.metrics?.totalMs || Date.now() - started) / 1000).toFixed(1);
+            const analysis = final.analysis ? ` · ${final.analysis.status}${final.analysis.attempts?.length > 1 ? ` (${final.analysis.attempts.length} analiz)` : ''}` : '';
+
+            console.log(c.dim(`\n  ${seconds} sn · ${final.route || '—'}${analysis}\n`));
+        } catch (error) {
+            spinner.stop();
+
+            if(error.name === 'AbortError') {
+                console.log(c.yellow('\n⏹ İptal edildi.\n'));
+                await call(replFlags, 'POST', '/api/chat/cancel', { sessionId }).catch(() => null);
+            } else {
+                console.log(c.red(`\n✗ ${error.message}\n`));
+            }
+        } finally {
+            state.controller = null;
+        }
+    };
+
+    // ── yerel terminal ──
+    const shell = (command) => new Promise((resolve) => {
+        rl.pause();
+        process.stdin.setRawMode?.(false);
+
+        const child = spawn(command, { shell: process.platform === 'win32' ? 'powershell.exe' : (process.env.SHELL || '/bin/sh'), stdio: 'inherit' });
+
+        child.on('exit', (code) => {
+            if(code) {
+                console.log(c.red(`(çıkış kodu ${code})`));
+            }
+
+            process.stdin.setRawMode?.(true);
+            rl.resume();
+            resolve();
+        });
+    });
+
+    // ── eğik çizgi komutları ──
+    const slash = async (text) => {
+        const [rawName, ...rest] = text.split(/\s+/);
+        const name = ALIASES[rawName.toLocaleLowerCase('tr-TR')] || rawName.toLocaleLowerCase('tr-TR');
+        const argument = rest.join(' ').trim();
+
+        switch(name) {
+            case '/yardim':
+                SLASH.forEach(([command, summary]) => console.log(`  ${c.accent(command.padEnd(14))} ${c.dim(summary)}`));
+                console.log(`  ${c.accent('!komut'.padEnd(14))} ${c.dim('yerel terminalde çalıştır')}`);
+                break;
+            case '/yeni':
+                sessionId = await ensureSession(replFlags, true);
+                console.log(c.dim(`Yeni sohbet: ${sessionId}`));
+                break;
+            case '/oturumlar': {
+                const json = await call(replFlags, 'GET', '/api/chat/sessions');
+
+                state.sessions = json.data || json.sessions || [];
+                state.sessions.slice(0, 20).forEach((item, index) => console.log(`  ${c.accent(String(index + 1).padStart(2))}  ${item.id === sessionId ? c.bold(item.title) : item.title} ${c.dim(`· ${item.messageCount ?? 0} mesaj`)}`));
+                console.log(c.dim('  /oturum <no> ile geç'));
+                break;
+            }
+            case '/oturum': {
+                const byNumber = state.sessions[Number(argument) - 1];
+
+                sessionId = byNumber?.id || argument || sessionId;
+                updateConfig({ sessionId });
+                console.log(c.dim(`Sohbet: ${byNumber?.title || sessionId}`));
+                break;
+            }
+            case '/ad':
+                if(!argument) {
+                    console.log(c.dim('Kullanım: /ad <yeni başlık>'));
+                    break;
+                }
+
+                await call(replFlags, 'PATCH', `/api/chat/sessions/${encodeURIComponent(sessionId)}`, { title: argument });
+                console.log(c.green('✓ Başlık değişti.'));
+                break;
+            case '/sil':
+                if(/^(e|evet|y|yes)$/i.test(await replAsk(`Bu sohbet silinsin mi? (e/H) `))) {
+                    await call(replFlags, 'DELETE', `/api/chat/sessions/${encodeURIComponent(sessionId)}`);
+                    sessionId = await ensureSession(replFlags, true);
+                    console.log(c.green('✓ Silindi; yeni sohbet açıldı.'));
+                }
+                break;
+            case '/ekip':
+                await runGroupCommand('team', parseArgs(['list']));
+                break;
+            case '/durum': {
+                const json = await call(replFlags, 'GET', '/api/engine/status');
+                const data = json.data || json;
+
+                console.log(`  ${c.bold('modeller')}  ${Object.entries(data.models || {}).map(([role, model]) => `${role}: ${String(model).split('/').pop()}`).join(' · ')}`);
+                console.log(`  ${c.bold('yüklü')}     ${(data.scheduler?.loaded || []).map((model) => String(model).split('/').pop()).join(', ') || '—'} ${c.dim(`· kuyruk ${data.scheduler?.queued ?? 0}${data.scheduler?.busy ? ' · meşgul' : ''}`)}`);
+
+                if(data.slo) {
+                    console.log(`  ${c.bold('hız')}       p50 ${data.slo.p50Seconds ?? '—'} sn · p95 ${data.slo.p95Seconds ?? '—'} sn ${c.dim(`(${data.slo.turns ?? 0} tur)`)}`);
+                }
+                break;
+            }
+            case '/bildirimler':
+                await runGroupCommand('notify', parseArgs(['list']));
+                break;
+            case '/hatirlat':
+                if(!argument) {
+                    await runGroupCommand('reminders', parseArgs(['list']));
+                    break;
+                }
+
+                await runGroupCommand('reminders', { ...parseArgs(['add']), positional: ['add', argument] });
+                break;
+            case '/aide': {
+                const args = parseArgs(splitLine(argument));
+                const [group, ...positional] = args.positional;
+
+                if(group === 'api') {
+                    await runApi({ ...args, flags: { ...replFlags, ...args.flags }, positional });
+                } else if(group === 'routes') {
+                    routesTable(args.flags);
+                } else if(!(await runGroupCommand(group, { ...args, flags: { ...replFlags, ...args.flags }, positional }))) {
+                    console.log(c.dim(`Gruplar: ${Object.keys(GROUP_TITLES).join(', ')} · api · routes`));
+                }
+                break;
+            }
+            case '/sunucu':
+                console.log(`  ${server} ${c.dim(`· ${readConfig().email || ''} · sohbet ${sessionId}`)}`);
+                break;
+            case '/temizle':
+                console.clear();
+                break;
+            case '/cikis':
+                rl.close();
+                break;
+            default:
+                console.log(c.dim(`Bilinmeyen komut: ${rawName} (/yardim)`));
+        }
+    };
+
+    // ── girdi ──
+    const run = async (text) => {
+        state.busy = true;
+
+        try {
+            if(text.startsWith('/')) {
+                await slash(text);
+            } else if(text.startsWith('!')) {
+                await shell(text.slice(1).trim());
+            } else {
+                await turn(text);
+            }
+        } catch (error) {
+            console.log(c.red(`✗ ${error.message}`));
+        } finally {
+            state.busy = false;
+        }
+
+        if(state.queue.length > 0) {
+            const next = state.queue.shift();
+
+            console.log(`${c.accent('❯')} ${next}`);
+            await run(next);
+            return;
+        }
+
+        rl.prompt();
+    };
+
+    const submit = (text) => {
+        if(!text) {
+            rl.prompt();
+            return;
+        }
+
+        if(state.busy) {
+            state.queue.push(text);
+            console.log(c.dim(`  (sıraya alındı: ${text.slice(0, 60)})`));
+            return;
+        }
+
+        void run(text);
+    };
+
+    // Yapıştırma: art arda gelen satırlar tek mesajdır; satır sonu "\" ile devam edilir
+    rl.on('line', (line) => {
+        const continued = /\\$/.test(line);
+
+        state.pending.push(continued ? line.slice(0, -1) : line);
+        clearTimeout(state.timer);
+
+        if(continued) {
+            process.stdout.write(c.dim('… '));
+            return;
+        }
+
+        state.timer = setTimeout(() => {
+            const text = state.pending.join('\n').trim();
+
+            state.pending = [];
+            submit(text);
+        }, 30);
+    });
+
+    rl.on('SIGINT', () => {
+        if(state.controller) {
+            state.controller.abort();
+            return;
+        }
+
+        if(rl.line) {
+            rl.write(null, { ctrl: true, name: 'u' });
+            return;
+        }
+
+        if(Date.now() - state.lastSigint < 2000) {
+            rl.close();
+            return;
+        }
+
+        state.lastSigint = Date.now();
+        console.log(c.dim('\n(çıkmak için tekrar Ctrl+C ya da Ctrl+D)'));
+        rl.prompt();
+    });
+
+    // Boştayken yeni bildirimler istemin üstüne düşer
+    let since = new Date().toISOString();
+    const poll = setInterval(async () => {
+        if(state.busy) {
+            return;
+        }
+
+        const json = await call(replFlags, 'GET', `/api/engine/notifications?since=${encodeURIComponent(since)}`).catch(() => null);
+        const items = json?.data || json?.notifications || [];
+
+        if(Array.isArray(items) && items.length > 0 && !state.busy) {
+            clearLine(process.stdout, 0);
+            cursorTo(process.stdout, 0);
+            items.forEach((item) => {
+                console.log(`${c.accent('●')} ${c.bold(item.title || 'Bildirim')} ${c.dim(item.body || item.message || '')}`);
+                since = item.at || item.createdAt || since;
+            });
+            rl.prompt(true);
+        }
+    }, 30000);
+
+    rl.on('close', () => {
+        clearInterval(poll);
+        saveHistory(rl.history || []);
+        console.log(c.dim('\nGörüşmek üzere.'));
+        process.exit(0);
+    });
+
+    rl.prompt();
+};
+
+export {
+    ensureSession,
+    startRepl,
+    onboard,
+    VERSION
+};