@nibgat/aide 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,80 @@
-# Temporary Holding Version
+# aide — Ai-de komut satırı
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Şirketinizin Ai-de sistemini terminalden yönetin: sohbet, personel, yetenek setleri, veri kaynakları, otomasyonlar, bildirimler, sistem ve **cihaz/terminal yönetimi**. Panelde yapılan her iş burada da yapılır. Bağımlılığı yoktur (Node 18+; cihaz modu için Node 22+).
+
+## Kurulum
+
+```bash
+npm install -g @nibgat/aide
+aide
+```
+
+İlk çalıştırmada Ai-de sunucusunun adresi sorulur (ör. `https://aide.sirketiniz.com`). Adres denenir, Ai-de sunucusu olduğu doğrulanır, ardından e-posta ve şifre (görünmez) ile giriş yapılır. Bilgiler `~/.aide/config.json` dosyasına yalnızca sizin okuyabileceğiniz izinle yazılır.
+
+Repo içinden: `yarn aide` ya da `cd apps/cli && npm link`.
+
+## Etkileşimli oturum
+
+`aide` komutu sohbet oturumu açar:
+
+- Yanıt akışla gelir, bitince Markdown olarak (başlık, liste, tablo, kod) çizilir. Personelin veri çıktısı ve yorumu ayrı bloklardır.
+- Personelin ve araçların adımları soluk satırlar olarak düşer; son adımda canlı gösterge döner.
+- **Ctrl+C** süren yanıtı iptal eder (sunucudaki iş de durur). Boş satırda iki kez Ctrl+C ya da **Ctrl+D** çıkar.
+- Tur sürerken yazdıklarınız sıraya alınır. Yapıştırılan çok satırlı metin tek mesajdır; satır sonu `\` ile alt satıra devam edilir.
+- Geçmiş `~/.aide/history` dosyasında tutulur (↑/↓). Boştayken yeni bildirimler istemin üstüne düşer.
+
+| Komut | |
+|---|---|
+| `/yeni` · `/oturumlar` · `/oturum <no>` · `/ad <başlık>` · `/sil` | sohbetler |
+| `/ekip` · `/durum` · `/bildirimler` · `/sunucu` | ekip, model/kuyruk durumu, bildirimler |
+| `/aide <komut>` | CLI'nin her komutu oturum içinden (`/aide data list`) |
+| `!komut` | yerel terminalde çalıştır (`!git status`) |
+| `/temizle` · `/yardim` · `/cikis` | |
+
+`Tab` eğik çizgi komutlarını tamamlar.
+
+## Tek seferlik komutlar
+
+```bash
+aide chat "bu ay kaç fatura kesildi?"              # adımlar stderr'e, yanıt stdout'a
+aide chat "bunu özetle" --file rapor.pdf
+aide team list --json | jq '.data[].name'
+aide team task <id> "Ekim faturalarını kontrol et"
+aide auto schedule "Muhasebe her gün 09:00'da vadesi geçenleri raporlasın"
+aide data test netsis
+aide notify watch
+aide api GET /api/engine/panel                     # adı konmamış her uç nokta
+aide routes                                        # komut ↔ API tablosu
+aide help <grup>                                   # sessions, team, skills, data, auto, notes, me, org, culture, integrations, company, notify, system
+```
+
+Seçenekler: `--json` ham JSON · `--yes` silmede onay sorma (etkileşimsiz ortamda zorunlu) · `--server`/`--token` tek komutluk adres/anahtar · `k=v` gövde alanı (sayı, `true/false`, `[dizi]`, `{nesne}` JSON olarak okunur). Ortam: `AIDE_SERVER`, `AIDE_TOKEN`, `AIDE_PASSWORD`, `AIDE_HOME`, `NO_COLOR`.
+
+## Cihaz modu: terminal ve işletim sistemi yönetimi
+
+```bash
+aide device connect --workspace ~/projeler          # bu makineyi Ai-de'ye cihaz olarak bağla
+aide device install --workspace ~/projeler --dry    # açılışta kendiliğinden bağlanan servis: önce ne yapacağını gör
+aide device install --workspace ~/projeler          # kur (Linux: systemd kullanıcı servisi · macOS: LaunchAgent · Windows: oturum açılışı görevi)
+aide device status · aide device uninstall
+```
+
+Makine Ai-de'ye bağlanır; personel bu makinede **yalnızca çalışma klasöründe** dosya okur/yazar ve komut çalıştırır. Yazma ve komutlar her seferinde terminalde onay ister. `--read-only` yalnızca okumaya izin verir. `--approve-all` ekransız sunucular için onaysız çalışır (bilerek kullanın). Repo içinde `@aide/connectors` erişilebilirse yerel ağdaki veritabanları da bu makineden sorgulanır (Edge Runner). Personel `system_info` aracıyla makinenin durumunu (CPU, bellek, diskler, en çok bellek kullanan süreçler) salt okuma olarak görür.
+
+Servis ekransız çalıştığı için onay soramaz: varsayılan **salt okuma** kurulur; yazma/komut için `--approve-all` bilerek verilir. Kimlik `aide login` ile kaydedilen yapılandırmadan okunur.
+
+## Yayınlama
+
+```bash
+cd apps/cli
+npm pack --dry-run          # içerik denetimi (8 dosya, ~22 kB)
+npm publish                 # @nibgat kapsamı npm'de sizin olmalı; yoksa package.json "name" değiştirilir
+```
+
+## Kapsam
+
+Yeni bir API ucu eklendiğinde ya `src/commands.mjs` içindeki `ROUTES` tablosuna komut eklenir ya da gerekçesiyle `scripts/maintenance/cliCoverage.mjs` içindeki `IGNORED` listesine yazılır:
+
+```bash
+node scripts/maintenance/cliCoverage.mjs --strict
+```

package/aide.mjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * Ai-de komut satırı (aide). Argümansız: etkileşimli oturum (ilk çalıştırmada sunucu adresi ve giriş sorulur).
+ * Tek seferlik: `aide chat "…"`, `aide team list`, `aide api GET /api/...`, `aide device connect` …  Ayrıntı: aide help
+ */
+import { routesTable, runGroupCommand, parseArgs, groupHelp, runApi, GROUP_TITLES } from './src/commands.mjs';
+import { startRepl, onboard, ensureSession, VERSION } from './src/repl.mjs';
+import { updateConfig, readConfig, streamTurn, CONFIG_FILE, call, upload, AideError } from './src/client.mjs';
+import { renderMarkdown, createSpinner, print, c } from './src/ui.mjs';
+import {
+    manageService,
+    connectDevice
+} from './src/device.mjs';
+
+const help = (group) => {
+    if(group && GROUP_TITLES[group]) {
+        groupHelp(group);
+        return;
+    }
+
+    console.log(`${c.accent('✻')} ${c.bold('aide')} ${c.dim(`v${VERSION}`)} — Ai-de komut satırı
+
+${c.bold('Başlangıç')}
+  aide                                         etkileşimli oturum (ilk seferde sunucu + giriş sorulur)
+  aide login [--server <adres>] [--email <e-posta>]
+  aide chat "bu ay kaç fatura kesildi?"       tek soru (yanıt akışla)  · --file rapor.pdf · --new
+  aide remind "yarın 14:00 Ahmet Bey'i ara"   hatırlatma/alarm (aide reminders list)
+  aide whoami · aide logout · aide config [server <adres>]
+
+${c.bold('Gruplar')} ${c.dim('(aide help <grup>)')}
+${Object.entries(GROUP_TITLES).map(([key, title]) => `  ${key.padEnd(14)} ${title}`).join('\n')}
+
+${c.bold('Cihaz (terminal / işletim sistemi yönetimi)')}
+  aide device connect [--workspace <klasör>] [--read-only] [--approve-all]
+                                               bu makineyi bağla: personel burada dosya/komut işi yapar (onaylı)
+  aide device install [--workspace <klasör>] [--approve-all] [--dry]
+                                               açılışta kendiliğinden bağlanan servis (systemd / LaunchAgent / Windows görevi)
+  aide device uninstall · aide device status   servisi kaldır / durumunu göster
+
+${c.bold('Her şey')}
+  aide api <METOT> </api/yol> [k=v …] [--data '{…}']   adı konmamış her uç nokta
+  aide routes                                           komut ↔ API tablosu
+  aide notify watch                                     bildirimleri canlı izle
+
+${c.bold('Seçenekler')}
+  --json  ham JSON (betikler) · --yes  silmede onay sorma · --server/--token  geçici adres/anahtar · k=v  gövde alanı`);
+};
+
+/** Tek seferlik soru: adımlar stderr'e soluk, yanıt stdout'a (Markdown çizilmiş ya da --json). */
+const chatOnce = async ({ flags, positional }) => {
+    const sessionId = flags.session ? String(flags.session) : await ensureSession(flags, Boolean(flags.new));
+    const attachments = [];
+
+    for(const file of flags.file ? String(flags.file).split(',') : []) {
+        attachments.push(await upload(flags, file));
+    }
+
+    if(positional.length === 0) {
+        return startRepl(flags);
+    }
+
+    const spinner = flags.json || flags.quiet ? null : createSpinner('Düşünüyor');
+
+    spinner?.start();
+
+    const final = await streamTurn(flags, {
+        prompt: positional.join(' '),
+        sessionId,
+        attachments,
+        onStep: (message) => {
+            if(!spinner || /^(Tamamlandı|🧭 İstek yönlendiriliyor)/.test(message)) {
+                spinner?.update(message);
+                return;
+            }
+
+            spinner.stop(`⎿ ${message}`);
+            spinner.update(message);
+            spinner.start();
+        }
+    }).finally(() => spinner?.stop());
+
+    if(flags.json) {
+        console.log(JSON.stringify(final, null, 2));
+        return;
+    }
+
+    const parts = Array.isArray(final.messages) && final.messages.length > 1 ? final.messages : [final.finalTurkishResponse || ''];
+
+    parts.forEach((part, index) => console.log(`${index > 0 ? `${c.gray('─'.repeat(40))}\n` : ''}${renderMarkdown(part)}`));
+};
+
+const watchNotifications = async (flags) => {
+    let since = String(flags.since || new Date().toISOString());
+
+    console.log(c.dim('Bildirimler izleniyor (Ctrl+C ile çıkış)…'));
+
+    for(;;) {
+        const json = await call(flags, 'GET', `/api/engine/notifications?since=${encodeURIComponent(since)}`).catch((error) => {
+            console.error(c.red(error.message));
+            return {};
+        });
+        const items = json.data || json.notifications || [];
+
+        (Array.isArray(items) ? items : []).forEach((item) => {
+            console.log(`${c.accent('●')} ${c.bold(item.title || item.kind || 'Bildirim')} ${c.dim(item.at || item.createdAt || '')}\n  ${item.body || item.message || ''}`);
+            since = item.at || item.createdAt || since;
+        });
+
+        await new Promise((resolve) => setTimeout(resolve, 15000));
+    }
+};
+
+const main = async () => {
+    const [command, ...rest] = process.argv.slice(2);
+    const args = parseArgs(rest);
+
+    switch(command) {
+        case undefined:
+            if(!process.stdin.isTTY) {
+                help();
+                return;
+            }
+
+            return startRepl(args.flags);
+        case 'help':
+        case '--help':
+        case '-h':
+            help(args.positional[0]);
+            return;
+        case 'version':
+        case '--version':
+        case '-v':
+            console.log(VERSION);
+            return;
+        case 'login':
+            await onboard(args.flags);
+            return;
+        case 'logout':
+            await call(args.flags, 'POST', '/api/auth/logout', {}).catch(() => null);
+            updateConfig({ token: '', sessionId: null });
+            console.log(c.green('✓ Çıkış yapıldı.'));
+            return;
+        case 'whoami':
+            print(await call(args.flags, 'GET', '/api/auth/me'), args.flags);
+            return;
+        case 'config': {
+            const [action, key, value] = args.positional;
+
+            if(action === 'server' && key) {
+                updateConfig({ server: key, token: '' });
+                console.log(c.green(`✓ server = ${key} (yeniden giriş: aide login)`));
+                return;
+            }
+
+            if(action === 'set' && key) {
+                updateConfig({ [key]: value });
+                console.log(c.green(`✓ ${key} = ${value}`));
+                return;
+            }
+
+            const { token, ...visible } = readConfig();
+
+            print({ ...visible, token: token ? `${token.slice(0, 6)}…` : '(yok)', file: CONFIG_FILE }, args.flags);
+            return;
+        }
+        case 'chat':
+            return chatOnce(args);
+        case 'remind':
+            return runGroupCommand('reminders', { ...args, positional: ['add', ...args.positional] });
+        case 'api':
+            return runApi(args);
+        case 'routes':
+            routesTable(args.flags);
+            return;
+        case 'device':
+            if([
+                'uninstall',
+                'install',
+                'status'
+            ].includes(args.positional[0])) {
+                return manageService(args.positional[0], args.flags);
+            }
+
+            if(args.positional[0] !== 'connect') {
+                throw new AideError('Kullanım: aide device connect|install|uninstall|status [--workspace <klasör>] [--read-only] [--approve-all] [--dry]');
+            }
+
+            return connectDevice(args.flags);
+        default:
+            break;
+    }
+
+    if(command === 'notify' && args.positional[0] === 'watch') {
+        return watchNotifications(args.flags);
+    }
+
+    if(!(await runGroupCommand(command, args))) {
+        throw new AideError(`Bilinmeyen komut: ${command} (aide help)`);
+    }
+};
+
+main().catch((error) => {
+    console.error(c.red(`✗ ${error.message}`));
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@nibgat/aide",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Ai-de komut satırı: şirketinizin Ai-de sistemini (sohbet, personel, veri kaynakları, otomasyonlar, cihaz/terminal yönetimi) terminalden yönetin",
+  "type": "module",
+  "bin": {
+    "aide": "aide.mjs"
+  },
+  "files": [
+    "aide.mjs",
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "ai-de",
+    "aide",
+    "cli",
+    "ai",
+    "agents",
+    "erp",
+    "company"
+  ],
+  "author": "NİBGAT Teknoloji",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/client.mjs

@@ -0,0 +1,260 @@
+/**
+ * Yapılandırma (~/.aide/config.json), sunucu istekleri, akışlı sohbet turu (SSE), dosya yükleme ve terminal soruları.
+ */
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_DIR = process.env.AIDE_HOME || path.join(os.homedir(), '.aide');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const HISTORY_FILE = path.join(CONFIG_DIR, 'history');
+
+const readConfig = () => {
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
+    } catch {
+        return {};
+    }
+};
+
+const writeConfig = (config) => {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 4), { mode: 0o600 });
+};
+
+const updateConfig = (patch) => writeConfig({ ...readConfig(), ...patch });
+
+/** "aide.sirket.com" → "https://aide.sirket.com"; "localhost:3000" → "http://localhost:3000". */
+const normalizeServer = (raw) => {
+    const text = String(raw || '').trim().replace(/\/+$/, '');
+
+    if(!text) {
+        return '';
+    }
+
+    if(/^https?:\/\//i.test(text)) {
+        return text;
+    }
+
+    return /^(localhost|127\.|\d+\.\d+\.\d+\.\d+|[^.]+:\d+$)/i.test(text) ? `http://${text}` : `https://${text}`;
+};
+
+const settings = (flags = {}) => {
+    const config = readConfig();
+
+    return {
+        server: normalizeServer(flags.server || process.env.AIDE_SERVER || config.server || ''),
+        token: String(flags.token || process.env.AIDE_TOKEN || config.token || ''),
+        config
+    };
+};
+
+class AideError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+
+const call = async (flags, method, url, body) => {
+    const { server, token } = settings(flags);
+
+    if(!server) {
+        throw new AideError('Ai-de sunucusu tanımlı değil: aide login (ya da aide config server <adres>)');
+    }
+
+    let response;
+
+    try {
+        response = await fetch(`${server}${url}`, {
+            headers: { 'Content-Type': 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: flags.signal,
+            method
+        });
+    } catch (error) {
+        if(error.name === 'AbortError') {
+            throw error;
+        }
+
+        throw new AideError(`Sunucuya ulaşılamadı (${server}): ${error.cause?.code || error.message}`);
+    }
+
+    const text = await response.text();
+    let json;
+
+    try {
+        json = text ? JSON.parse(text) : {};
+    } catch {
+        json = { raw: text };
+    }
+
+    if(response.status === 401) {
+        throw new AideError('Oturum yok ya da süresi doldu: aide login', 401);
+    }
+
+    if(!response.ok || json.success === false) {
+        throw new AideError(json.error || json.message || `Sunucu hatası (${response.status})`, response.status);
+    }
+
+    return json;
+};
+
+/** Sunucu ayakta mı ve Ai-de mi (giriş gerektirmeyen uç). */
+const probe = async (server) => {
+    const response = await fetch(`${server}/api/auth/signup-enabled`, { signal: AbortSignal.timeout(8000) });
+    const json = await response.json().catch(() => null);
+
+    if(!response.ok || !json || typeof json !== 'object') {
+        throw new AideError(`Bu adres bir Ai-de sunucusu gibi görünmüyor (${response.status}).`);
+    }
+
+    return json;
+};
+
+const login = async (server, email, password) => {
+    const response = await fetch(`${server}/api/auth/login`, {
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password }),
+        method: 'POST'
+    });
+    const json = await response.json().catch(() => ({}));
+    const token = json.token || json.data?.token;
+
+    if(!response.ok || !token) {
+        throw new AideError(json.error || 'Giriş başarısız.', response.status);
+    }
+
+    return token;
+};
+
+/** Dosyayı sunucuda okutur (PDF, Word, Excel, görsel OCR); çıkarılan metin sohbete ek olarak gider. */
+const upload = async (flags, file) => {
+    const data = readFileSync(file);
+    const json = await call(flags, 'POST', '/api/chat/upload', {
+        fileData: data.toString('base64'),
+        fileName: path.basename(file),
+        mimeType: ''
+    });
+
+    if(!json.data?.extractedText) {
+        throw new AideError(`Belgeden metin çıkarılamadı: ${file}`);
+    }
+
+    return { extractedText: json.data.extractedText, fileName: json.data.fileName || path.basename(file) };
+};
+
+/**
+ * Sohbet turu (SSE: step / done / error). `onStep(message)`, `onToken(token)` çağrılır; sonuç pipelineData'dır.
+ * `signal` ile iptal edilir (Ctrl+C): istek kesilir ve sunucudaki iş durdurulur.
+ */
+const streamTurn = async (flags, { prompt, sessionId, attachments = [], onStep = () => null, onToken = () => null, signal }) => {
+    const { server, token } = settings(flags);
+    const response = await fetch(`${server}/api/chat/stream`, {
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+        body: JSON.stringify({ prompt, sessionId, attachments }),
+        method: 'POST',
+        signal
+    });
+
+    if(response.status === 401) {
+        throw new AideError('Oturum yok ya da süresi doldu: aide login', 401);
+    }
+
+    if(!response.ok || !response.body) {
+        throw new AideError(`Sunucu hatası (${response.status})`, response.status);
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let final = null;
+
+    for await (const chunk of response.body) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const blocks = buffer.split('\n\n');
+
+        buffer = blocks.pop() || '';
+
+        for(const block of blocks) {
+            const event = /^event: (.+)$/m.exec(block)?.[1];
+            const data = /^data: (.+)$/m.exec(block)?.[1];
+
+            if(!event || !data) {
+                continue;
+            }
+
+            const payload = JSON.parse(data);
+
+            if(event === 'step' && payload.stage === 'token_stream') {
+                onToken(payload.token || '');
+            } else if(event === 'step' && payload.message) {
+                onStep(payload.message, payload);
+            } else if(event === 'done') {
+                final = payload.pipelineData || {};
+            } else if(event === 'error') {
+                throw new AideError(payload.message || 'Bir hata oluştu.');
+            }
+        }
+    }
+
+    return final || {};
+};
+
+/** Terminal sorusu; `hidden` şifre içindir (yazılanlar görünmez). */
+const ask = (question, { hidden = false, fallback = '' } = {}) => new Promise((resolve) => {
+    if(!process.stdin.isTTY) {
+        resolve(fallback);
+        return;
+    }
+
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+
+    if(hidden) {
+        rl._writeToOutput = (text) => {
+            if(text.includes(question)) {
+                process.stdout.write(text);
+            }
+        };
+    }
+
+    rl.question(question, (answer) => {
+        rl.close();
+
+        if(hidden) {
+            process.stdout.write('\n');
+        }
+
+        resolve(answer.trim() || fallback);
+    });
+});
+
+const confirm = async (flags, message) => {
+    if(flags.yes || flags.y) {
+        return true;
+    }
+
+    if(!process.stdin.isTTY) {
+        throw new AideError(`${message} — onay için --yes ekleyin.`);
+    }
+
+    return /^(e|evet|y|yes)$/i.test(await ask(`${message} (e/H) `));
+};
+
+export {
+    normalizeServer,
+    updateConfig,
+    HISTORY_FILE,
+    writeConfig,
+    CONFIG_FILE,
+    readConfig,
+    streamTurn,
+    AideError,
+    settings,
+    confirm,
+    upload,
+    probe,
+    login,
+    call,
+    ask
+};