wormclaude 1.0.0

package/dist/commands.js

@@ -0,0 +1,540 @@
+// Slash komutları — Claude Code komut setinin WormClaude'a çalışır uyarlaması.
+// Her komut yerel model (OpenAI-uyumlu backend), git ve dosya sistemiyle gerçek iş yapar.
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { streamChat } from './api.js';
+import { tasks } from './tasks.js';
+import { connectMcpServers, getMcpServers, getMcpConfigPath } from './mcp.js';
+import * as usage from './usage.js';
+import { runCompact, contextPercent, autoCompactThreshold } from './compact.js';
+import { cmdDesc, setLang, saveLang, getLang } from './i18n.js';
+import { loadSkills, getSkills, getSkillsDir, installSkill, updateSkill, removeSkill, getRegistry } from './skills.js';
+import { isLearnEnabled, setLearnEnabled, getLearnFile, getLearnCount } from './learn.js';
+export const COMMANDS = [
+    { name: '/help', desc: 'komutları ve ipuçlarını göster' },
+    { name: '/clear', desc: 'sohbeti ve geçmişi temizle' },
+    { name: '/compact', desc: 'geçmişi modelle özetleyip bağlamı küçült' },
+    { name: '/context', desc: 'bağlam / token kullanımını göster' },
+    { name: '/cost', desc: 'oturum token tahminini göster' },
+    { name: '/config', desc: 'ayarları göster / değiştir (url, key, model)' },
+    { name: '/model', desc: 'modeli göster / değiştir' },
+    { name: '/diff', desc: 'git diff göster' },
+    { name: '/commit', desc: 'stage edilmiş değişiklikleri modelle commit et' },
+    { name: '/review', desc: 'mevcut diff’i modelle incele' },
+    { name: '/init', desc: 'projeyi tarayıp WORMCLAUDE.md üret' },
+    { name: '/memory', desc: 'WORMCLAUDE.md hafızasını oku / satır ekle' },
+    { name: '/doctor', desc: 'sistem ve backend sağlık kontrolü' },
+    { name: '/lang', desc: 'arayüz dilini değiştir (tr/en)' },
+    { name: '/skills', desc: 'skill\'leri listele / indir / yeniden yükle' },
+    { name: '/skillify', desc: 'bu oturumu yeniden kullanılabilir skill\'e çevir' },
+    { name: '/agent', desc: 'tek bir alt-agent\'a görev ver: /agent <görev>' },
+    { name: '/multi-agent', desc: 'paralel çoklu-agent koordinasyonu: /multi-agent <görev>' },
+    { name: '/mcp', desc: 'MCP sunucularını listele / yeniden bağlan' },
+    { name: '/tasks', desc: 'arka plan görevlerini (shell/agent) listele' },
+    { name: '/kill', desc: 'bir arka plan görevini durdur: /kill <id>' },
+    { name: '/dream', desc: 'arka planda hafızayı konsolide et (.wormclaude/memory.md)' },
+    { name: '/learn', desc: 'web-öğrenme datasını göster / aç-kapa (eğitim için)' },
+    { name: '/export', desc: 'sohbeti dosyaya kaydet' },
+    { name: '/resume', desc: 'en son kaydedilen oturumu yükle' },
+    { name: '/quit', desc: 'çıkış' },
+];
+// Tek seferlik tam yanıt (stream'i biriktirir, araç çağrısı yok)
+async function complete(messages, config) {
+    let out = '';
+    for await (const ev of streamChat(messages, [], config)) {
+        if (ev.type === 'text')
+            out += ev.text;
+        else if (ev.type === 'error')
+            return `[hata: ${ev.error}]`;
+    }
+    return out.trim();
+}
+function git(cmd) {
+    try {
+        const out = execSync(`git ${cmd}`, { encoding: 'utf8', timeout: 30000, windowsHide: true });
+        return { ok: true, out: out.trim() };
+    }
+    catch (e) {
+        return { ok: false, out: (e?.stdout || e?.stderr || e?.message || String(e)).toString().trim() };
+    }
+}
+function isGitRepo() {
+    return git('rev-parse --is-inside-work-tree').ok;
+}
+function approxTokens(obj) {
+    return Math.round(JSON.stringify(obj).length / 4);
+}
+const SESSION_DIR = path.join(process.cwd(), '.wormclaude', 'sessions');
+function tsStamp() {
+    const d = new Date();
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+// Komut yürütücü. true → komut işlendi, false → komut değil (normal mesaj).
+export async function runSlashCommand(input, ctx) {
+    const v = input.trim();
+    if (!v.startsWith('/'))
+        return false;
+    const [cmd, ...rest] = v.split(/\s+/);
+    const arg = rest.join(' ').trim();
+    const C = ctx.config;
+    switch (cmd) {
+        case '/quit':
+        case '/exit':
+            ctx.exit();
+            return true;
+        case '/clear':
+            ctx.clearConv();
+            return true;
+        case '/help':
+            ctx.note((getLang() === 'en' ? 'Commands:\n' : 'Komutlar:\n') +
+                COMMANDS.map((c) => `  ${c.name.padEnd(10)} ${cmdDesc(c.name)}`).join('\n') +
+                '\n\nTools: Bash · Read · Write · Edit · Glob · Grep · WebFetch · Agent');
+            return true;
+        case '/lang': {
+            const v = (arg || '').toLowerCase();
+            if (v === 'tr' || v === 'en') {
+                setLang(v);
+                saveLang(v);
+                ctx.note(v === 'en' ? 'Language set to English.' : 'Dil Türkçe olarak ayarlandı.');
+            }
+            else {
+                const next = getLang() === 'tr' ? 'en' : 'tr';
+                setLang(next);
+                saveLang(next);
+                ctx.note(next === 'en' ? 'Language set to English.' : 'Dil Türkçe olarak ayarlandı.');
+            }
+            return true;
+        }
+        case '/model':
+            if (arg) {
+                C.model = arg;
+                ctx.note(`Model: ${arg}`);
+            }
+            else
+                ctx.note(`Model: ${C.model}`);
+            return true;
+        case '/config': {
+            // /config            → göster
+            // /config url <x>    → baseUrl
+            // /config key <x>    → apiKey
+            // /config model <x>  → model
+            const [sub, ...vrest] = rest;
+            const val = vrest.join(' ').trim();
+            if (!sub) {
+                const masked = C.apiKey ? C.apiKey.slice(0, 3) + '***' : '(yok)';
+                ctx.note(`Yapılandırma:\n  baseUrl: ${C.baseUrl}\n  apiKey:  ${masked}\n  model:   ${C.model}`);
+                return true;
+            }
+            if (sub === 'url' && val) {
+                C.baseUrl = val;
+                ctx.note(`baseUrl → ${val}`);
+            }
+            else if (sub === 'key' && val) {
+                C.apiKey = val;
+                ctx.note('apiKey güncellendi');
+            }
+            else if (sub === 'model' && val) {
+                C.model = val;
+                ctx.note(`model → ${val}`);
+            }
+            else
+                ctx.note('Kullanım: /config [url|key|model] <değer>');
+            return true;
+        }
+        case '/context': {
+            const h = ctx.getHistory();
+            const byRole = {};
+            for (const m of h)
+                byRole[m.role] = (byRole[m.role] || 0) + approxTokens(m);
+            const total = approxTokens(h);
+            const pct = contextPercent(h);
+            const lines = Object.entries(byRole).map(([r, t]) => `  ${r.padEnd(10)} ~${t} tok`);
+            ctx.note(`Bağlam: ~${total.toLocaleString()} tok · %${pct}\n` +
+                `Oto-compact eşiği: ~${autoCompactThreshold().toLocaleString()} tok\n` +
+                `Mesaj sayısı: ${h.length}\n` +
+                lines.join('\n'));
+            return true;
+        }
+        case '/cost': {
+            ctx.note('── Bu oturum ──\n' + usage.formatTotals(usage.getSession()) +
+                '\n\n── Toplam (kümülatif) ──\n' + usage.formatTotals(usage.getLifetime()) +
+                '\n\n(token verisi backend usage alanından; maliyet usage.ts fiyat tablosundan)');
+            return true;
+        }
+        case '/compact': {
+            const h = ctx.getHistory();
+            if (h.filter((m) => m.role !== 'system').length === 0) {
+                ctx.note('Özetlenecek geçmiş yok.');
+                return true;
+            }
+            const { history: newHist, summary } = await runCompact(h, C, arg || undefined);
+            ctx.setHistory(newHist);
+            ctx.note(`Sohbet özetlendi: ${h.length} → ${newHist.length} mesaj`);
+            ctx.assistant(summary);
+            return true;
+        }
+        case '/diff': {
+            if (!isGitRepo()) {
+                ctx.note('Burası bir git deposu değil.');
+                return true;
+            }
+            const r = git('diff');
+            ctx.note(r.out ? r.out.slice(0, 8000) : 'Değişiklik yok (working tree temiz).');
+            return true;
+        }
+        case '/commit': {
+            if (!isGitRepo()) {
+                ctx.note('Burası bir git deposu değil.');
+                return true;
+            }
+            const staged = git('diff --cached');
+            if (!staged.out) {
+                ctx.note('Stage edilmiş değişiklik yok. Önce: git add <dosya>');
+                return true;
+            }
+            const msg = await complete([
+                { role: 'system', content: 'You write concise git commit messages. Output ONLY the message, no quotes, no prose. First line under 70 chars, imperative mood.' },
+                { role: 'user', content: 'Write a commit message for this staged diff:\n\n' + staged.out.slice(0, 12000) },
+            ], C);
+            const clean = msg.replace(/^["'`]+|["'`]+$/g, '').split('\n')[0].slice(0, 100);
+            const res = git(`commit -m "${clean.replace(/"/g, '\\"')}"`);
+            ctx.note(res.ok ? `Commit edildi: ${clean}\n${res.out}` : `Commit hatası:\n${res.out}`);
+            return true;
+        }
+        case '/review': {
+            if (!isGitRepo()) {
+                ctx.note('Burası bir git deposu değil.');
+                return true;
+            }
+            const diff = git('diff HEAD');
+            if (!diff.out) {
+                ctx.note('İncelenecek değişiklik yok.');
+                return true;
+            }
+            ctx.note('Değişiklikler inceleniyor…');
+            const out = await complete([
+                { role: 'system', content: 'You are a senior code reviewer. Review the diff for correctness bugs, security issues, and simplifications. Be specific with file:line. Answer in the user\'s language.' },
+                { role: 'user', content: 'Review this diff:\n\n' + diff.out.slice(0, 14000) },
+            ], C);
+            ctx.assistant(out);
+            return true;
+        }
+        case '/init': {
+            const files = [];
+            const walk = (d, depth = 0) => {
+                if (depth > 3 || files.length > 400)
+                    return;
+                let entries;
+                try {
+                    entries = fs.readdirSync(d, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                for (const e of entries) {
+                    if (['node_modules', '.git', 'dist', '.wormclaude', 'venv'].includes(e.name))
+                        continue;
+                    const full = path.join(d, e.name);
+                    if (e.isDirectory())
+                        walk(full, depth + 1);
+                    else
+                        files.push(path.relative(process.cwd(), full));
+                }
+            };
+            walk(process.cwd());
+            let pkg = '';
+            try {
+                pkg = fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8');
+            }
+            catch { }
+            ctx.note('Proje taranıyor, WORMCLAUDE.md üretiliyor…');
+            const md = await complete([
+                { role: 'system', content: 'You generate a concise WORMCLAUDE.md describing a codebase for an AI assistant: overview, structure, key commands (build/test/run), and conventions. Output only markdown.' },
+                { role: 'user', content: `Dosya listesi:\n${files.slice(0, 300).join('\n')}\n\npackage.json:\n${pkg.slice(0, 3000)}` },
+            ], C);
+            const dest = path.join(process.cwd(), 'WORMCLAUDE.md');
+            fs.writeFileSync(dest, md);
+            ctx.note(`WORMCLAUDE.md yazıldı (${md.length} karakter).`);
+            return true;
+        }
+        case '/memory': {
+            const dest = path.join(process.cwd(), 'WORMCLAUDE.md');
+            if (arg) {
+                const prefix = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8').replace(/\s*$/, '') + '\n' : '';
+                fs.writeFileSync(dest, prefix + `- ${arg}\n`);
+                ctx.note(`Hafızaya eklendi: ${arg}`);
+            }
+            else {
+                ctx.note(fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8').slice(0, 6000) : 'WORMCLAUDE.md yok. /init ile oluştur veya /memory <metin> ile ekle.');
+            }
+            return true;
+        }
+        case '/doctor': {
+            const checks = [];
+            checks.push(`Node:    ${process.version}`);
+            checks.push(`CWD:     ${process.cwd()}`);
+            checks.push(`Git:     ${git('--version').ok ? git('--version').out : '✗ bulunamadı'}`);
+            checks.push(`Repo:    ${isGitRepo() ? '✓ git deposu' : '— git deposu değil'}`);
+            checks.push(`Model:   ${C.model}`);
+            checks.push(`Backend: ${C.baseUrl}`);
+            try {
+                const root = C.baseUrl.replace(/\/v1\/?$/, '');
+                const res = await fetch(root + '/docs', { signal: AbortSignal.timeout(4000) });
+                checks.push(`         ${res.ok ? '✓ erişilebilir' : '✗ HTTP ' + res.status}`);
+            }
+            catch (e) {
+                checks.push(`         ✗ ulaşılamıyor (${e?.message || e})`);
+            }
+            ctx.note('Sağlık kontrolü:\n' + checks.map((c) => '  ' + c).join('\n'));
+            return true;
+        }
+        case '/skills': {
+            const en = getLang() === 'en';
+            const [sub, ...vrest] = rest;
+            const subArg = vrest.join(' ').trim();
+            // /skills install <ad | owner/repo | git url | https://.../x.md>
+            if (sub === 'install' && subArg) {
+                ctx.note(en ? `Downloading: ${subArg}…` : `İndiriliyor: ${subArg}…`);
+                const res = await installSkill(subArg);
+                if (res.error)
+                    ctx.note((en ? 'Install error: ' : 'İndirme hatası: ') + res.error);
+                else if (!res.names.length)
+                    ctx.note(en ? `No skills found in ${subArg}` : `${subArg} içinde skill bulunamadı`);
+                else
+                    ctx.note((en ? 'Installed: ' : 'Yüklendi: ') + res.names.map((n) => '/' + n).join(', '));
+                return true;
+            }
+            // /skills update <ad>
+            if (sub === 'update' && subArg) {
+                ctx.note(en ? `Updating: ${subArg}…` : `Güncelleniyor: ${subArg}…`);
+                const res = await updateSkill(subArg);
+                ctx.note(res.ok ? (en ? `Updated: /${subArg}` : `Güncellendi: /${subArg}`) : (en ? 'Update error: ' : 'Güncelleme hatası: ') + (res.error || ''));
+                return true;
+            }
+            // /skills remove <ad>
+            if (sub === 'remove' && subArg) {
+                ctx.note(removeSkill(subArg) ? (en ? `Removed: ${subArg}` : `Silindi: ${subArg}`) : (en ? `Not found: ${subArg}` : `Bulunamadı: ${subArg}`));
+                return true;
+            }
+            // /skills search <kelime>
+            if (sub === 'search') {
+                const reg = await getRegistry();
+                const q = subArg.toLowerCase();
+                const hits = Object.entries(reg).filter(([n, e]) => !q || n.toLowerCase().includes(q) || (e.description || '').toLowerCase().includes(q));
+                if (!hits.length) {
+                    ctx.note(en ? 'No skills found in registry.' : 'Registry\'de skill bulunamadı.');
+                    return true;
+                }
+                ctx.note((en ? 'Registry:\n' : 'Registry:\n') +
+                    hits.map(([n, e]) => `  ${n.padEnd(18)} ${e.description || ''}  (${e.repo})`).join('\n') +
+                    `\n\n${en ? 'install with' : 'kurmak için'}: /skills install <ad>`);
+                return true;
+            }
+            if (sub === 'reload')
+                loadSkills();
+            // Liste
+            const skills = getSkills();
+            if (!skills.length) {
+                ctx.note((en ? 'No skills loaded.\n' : 'Yüklü skill yok.\n') +
+                    `${en ? 'Folder' : 'Klasör'}: ${getSkillsDir()}\n` +
+                    (en
+                        ? 'Add: /skills install <name|owner/repo|url> · search: /skills search <q>'
+                        : 'Ekle: /skills install <ad|owner/repo|url> · ara: /skills search <kelime>'));
+                return true;
+            }
+            ctx.note((en ? 'Skills:\n' : 'Skill\'ler:\n') +
+                skills.map((s) => `  /${s.name.padEnd(16)} ${s.context}${s.autoInvoke ? ',auto' : ''}  ${s.description}`).join('\n') +
+                `\n\n/skills install <ad> · search <kelime> · update <ad> · remove <ad>`);
+            return true;
+        }
+        case '/skillify': {
+            const en = getLang() === 'en';
+            const h = ctx.getHistory().filter((m) => m.role !== 'system');
+            if (h.length < 2) {
+                ctx.note(en ? 'Not enough conversation to skillify.' : 'Skill üretmek için yeterli konuşma yok.');
+                return true;
+            }
+            ctx.note(en ? 'Capturing this session as a skill…' : 'Bu oturum skill\'e çevriliyor…');
+            const sys = ctx.getHistory().find((m) => m.role === 'system');
+            const md = await complete([
+                sys ?? { role: 'system', content: 'You create reusable skills.' },
+                ...h,
+                {
+                    role: 'user',
+                    content: 'Bu oturumdaki tekrar edilebilir süreci yeniden kullanılabilir bir SKILL olarak yakala. ' +
+                        'SADECE markdown döndür, başında frontmatter olsun:\n' +
+                        '---\nname: <kısa-kebab-ad>\ndescription: <bir cümle>\ncontext: inline\n---\n' +
+                        '<adım adım, parametrik, yeniden kullanılabilir talimat gövdesi>\n\n' +
+                        (arg ? `Kullanıcı notu: ${arg}\n` : '') +
+                        "Answer in the user's language. Frontmatter alan adları İngilizce kalsın (name/description/context).",
+                },
+            ], C);
+            // name'i frontmatter'dan çek
+            let name = (arg || '').trim().replace(/[^\w-]/g, '-');
+            const m = md.match(/name:\s*(.+)/);
+            if (!name && m)
+                name = m[1].trim().replace(/[^\w-]/g, '-');
+            if (!name)
+                name = 'skill-' + Date.now();
+            const dir = getSkillsDir();
+            fs.mkdirSync(dir, { recursive: true });
+            const file = path.join(dir, `${name}.md`);
+            fs.writeFileSync(file, md.replace(/^```\w*\n?|```$/g, '').trim() + '\n');
+            loadSkills();
+            ctx.note((en ? 'Skill created: ' : 'Skill üretildi: ') + `/${name}\n${file}`);
+            return true;
+        }
+        case '/mcp': {
+            if (arg === 'reconnect' || arg === 'reload') {
+                ctx.note('MCP yeniden bağlanıyor…');
+                await connectMcpServers();
+            }
+            const servers = getMcpServers();
+            if (!servers.length) {
+                ctx.note('Bağlı MCP sunucusu yok.\n' +
+                    `Yapılandırma: ${getMcpConfigPath()}\n` +
+                    'Örnek:\n' +
+                    '{\n  "mcpServers": {\n' +
+                    '    "filesystem": { "command": "npx", "args": ["-y","@modelcontextprotocol/server-filesystem","' +
+                    process.cwd().replace(/\\/g, '\\\\') +
+                    '"] }\n  }\n}\n' +
+                    'Sonra: /mcp reconnect');
+                return true;
+            }
+            ctx.note('MCP sunucuları:\n' +
+                servers
+                    .map((s) => {
+                    const head = `  ${s.status === 'connected' ? '●' : '✗'} ${s.name} (${s.status})${s.error ? ' — ' + s.error : ''}`;
+                    const tools = s.toolNames.length ? '\n      ' + s.toolNames.join('\n      ') : '';
+                    return head + tools;
+                })
+                    .join('\n') +
+                `\n\nYapılandırma: ${getMcpConfigPath()} · yeniden bağlan: /mcp reconnect`);
+            return true;
+        }
+        case '/tasks': {
+            const list = tasks.list();
+            if (!list.length) {
+                ctx.note('Aktif/geçmiş görev yok.');
+                return true;
+            }
+            const icon = (s) => (s === 'running' ? '●' : s === 'done' ? '✓' : s === 'error' ? '✗' : '■');
+            ctx.note('Görevler:\n' +
+                list
+                    .map((t) => {
+                    const dur = ((t.endedAt ?? Date.now()) - t.startedAt) / 1000;
+                    return `  ${icon(t.status)} ${t.id.padEnd(9)} ${t.status.padEnd(8)} ${dur.toFixed(0)}s  ${t.label}`;
+                })
+                    .join('\n') +
+                '\n\nÇıktı için modele "TaskOutput(<id>)" dedirt veya /kill <id> ile durdur.');
+            return true;
+        }
+        case '/kill': {
+            if (!arg) {
+                ctx.note('Kullanım: /kill <görev-id> (örn. shell_1, agent_2)');
+                return true;
+            }
+            ctx.note(tasks.stop(arg) ? `Durduruldu: ${arg}` : `Durdurulamadı (çalışmıyor ya da yok): ${arg}`);
+            return true;
+        }
+        case '/learn': {
+            const en = getLang() === 'en';
+            if (arg === 'on' || arg === 'off') {
+                setLearnEnabled(arg === 'on');
+            }
+            ctx.note((en ? 'Web-learning (training data collection)\n' : 'Web-öğrenme (eğitim datası toplama)\n') +
+                `  ${en ? 'status' : 'durum'}: ${isLearnEnabled() ? (en ? 'ON' : 'AÇIK') : (en ? 'OFF' : 'KAPALI')}  ·  /learn on|off\n` +
+                `  ${en ? 'collected' : 'toplanan'}: ${getLearnCount()} ${en ? 'pairs' : 'çift'}\n` +
+                `  ${en ? 'file' : 'dosya'}: ${getLearnFile()}\n` +
+                (en
+                    ? '  → feed this JSONL to modelegitim SFT/LoRA so the model permanently learns.'
+                    : '  → bu JSONL\'i modelegitim SFT/LoRA\'ya ver, model kalıcı öğrensin.'));
+            return true;
+        }
+        case '/dream': {
+            const h = ctx.getHistory();
+            const convo = h.filter((m) => m.role !== 'system');
+            if (!convo.length) {
+                ctx.note('Konsolide edilecek geçmiş yok.');
+                return true;
+            }
+            const task = tasks.create('dream', 'hafıza konsolidasyonu');
+            ctx.note(`Dream başlatıldı (${task.id}) — arka planda hafıza güncelleniyor…`);
+            const sys = h.find((m) => m.role === 'system');
+            (async () => {
+                try {
+                    const memFile = path.join(process.cwd(), '.wormclaude', 'memory.md');
+                    let prev = '';
+                    try {
+                        prev = fs.readFileSync(memFile, 'utf8');
+                    }
+                    catch { }
+                    tasks.append(task.id, 'özetleniyor…\n');
+                    const out = await complete([
+                        sys ?? { role: 'system', content: 'You consolidate long-term memory.' },
+                        ...convo,
+                        {
+                            role: 'user',
+                            content: 'Update the long-term memory below with durable facts, decisions, preferences, and project state ' +
+                                'learned in this conversation. Merge — do not duplicate. Output the FULL updated memory as markdown bullet points.\n\n' +
+                                'CURRENT MEMORY:\n' + (prev || '(empty)'),
+                        },
+                    ], C);
+                    fs.mkdirSync(path.dirname(memFile), { recursive: true });
+                    fs.writeFileSync(memFile, out);
+                    tasks.append(task.id, `\nhafıza yazıldı: ${memFile} (${out.length} karakter)`);
+                    tasks.finish(task.id, 'done');
+                }
+                catch (e) {
+                    tasks.append(task.id, `\n[hata: ${e?.message || e}]`);
+                    tasks.finish(task.id, 'error');
+                }
+            })();
+            return true;
+        }
+        case '/export': {
+            fs.mkdirSync(SESSION_DIR, { recursive: true });
+            const file = path.join(SESSION_DIR, `session-${tsStamp()}.json`);
+            fs.writeFileSync(file, JSON.stringify(ctx.getHistory(), null, 2));
+            const md = path.join(SESSION_DIR, `session-${tsStamp()}.md`);
+            const text = ctx
+                .getHistory()
+                .filter((m) => m.role !== 'system')
+                .map((m) => `### ${m.role}\n\n${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
+                .join('\n\n');
+            fs.writeFileSync(md, text);
+            ctx.note(`Oturum kaydedildi:\n  ${file}\n  ${md}`);
+            return true;
+        }
+        case '/resume': {
+            if (!fs.existsSync(SESSION_DIR)) {
+                ctx.note('Kayıtlı oturum yok. /export ile kaydet.');
+                return true;
+            }
+            const files = fs
+                .readdirSync(SESSION_DIR)
+                .filter((f) => f.endsWith('.json'))
+                .map((f) => ({ f, m: fs.statSync(path.join(SESSION_DIR, f)).mtimeMs }))
+                .sort((a, b) => b.m - a.m);
+            if (!files.length) {
+                ctx.note('Kayıtlı oturum yok.');
+                return true;
+            }
+            const latest = path.join(SESSION_DIR, files[0].f);
+            try {
+                const hist = JSON.parse(fs.readFileSync(latest, 'utf8'));
+                ctx.setHistory(hist);
+                ctx.note(`Oturum yüklendi: ${files[0].f} (${hist.length} mesaj)`);
+            }
+            catch (e) {
+                ctx.note(`Yükleme hatası: ${e?.message || e}`);
+            }
+            return true;
+        }
+        default:
+            ctx.note(`Bilinmeyen komut: ${cmd} — /help ile listeye bak.`);
+            return true;
+    }
+}

package/dist/compact.js

@@ -0,0 +1,53 @@
+// Bağlam kompaksiyonu — Claude Code compact/ mantığının uyarlaması.
+// Manuel /compact ve otomatik (eşik aşılınca) tetikleme aynı çekirdeği kullanır.
+import { completeText } from './agent.js';
+import { approxTokens } from './usage.js';
+// Bağlam penceresi (Qwen 2.5 7B = 32768). Env ile override edilebilir.
+const CONTEXT_WINDOW = Number(process.env.WORMCLAUDE_CONTEXT_WINDOW) || 32768;
+const SUMMARY_RESERVE = 4000; // özet çıktısı için rezerv (CC: ~20K büyük modellerde)
+const AUTOCOMPACT_BUFFER = 2000;
+export function autoCompactThreshold() {
+    return CONTEXT_WINDOW - SUMMARY_RESERVE - AUTOCOMPACT_BUFFER;
+}
+export function shouldAutoCompact(history) {
+    return approxTokens(history) >= autoCompactThreshold();
+}
+export function contextPercent(history) {
+    return Math.min(100, Math.round((approxTokens(history) / CONTEXT_WINDOW) * 100));
+}
+// Backend hatası bağlam/uzunluk taşması mı? → reactive compact tetikler.
+export function isContextError(msg) {
+    return /context|prompt.*(long|length)|too long|maximum.*token|413|exceed/i.test(msg || '');
+}
+// Claude Code BASE_COMPACT_PROMPT'un 9-bölümlü uyarlaması.
+export const COMPACT_PROMPT = 'KRİTİK: SADECE METİN İLE YANIT VER. HİÇBİR ARAÇ ÇAĞIRMA.\n\n' +
+    'Yukarıdaki konuşmanın detaylı bir özetini oluştur. Teknik detayları, kod desenlerini, ' +
+    'mimari kararları ve dosya adlarını koru. Bu özet konuşmanın yerine geçecek, o yüzden ' +
+    'devam etmek için gereken her şeyi içermeli.\n\n' +
+    'Aşağıdaki 9 bölümü ZORUNLU olarak doldur:\n' +
+    '1. Birincil İstek ve Amaç: Kullanıcının ne istediği (detaylı)\n' +
+    '2. Anahtar Teknik Kavramlar: Kullanılan teknoloji/framework/desenler\n' +
+    '3. Dosyalar ve Kod: Dokunulan dosyalar, önemli kod parçaları, neden önemli oldukları\n' +
+    '4. Hatalar ve Düzeltmeler: Karşılaşılan hatalar ve nasıl çözüldükleri\n' +
+    '5. Problem Çözme: Çözülen sorunlar ve yaklaşımlar\n' +
+    '6. Tüm Kullanıcı Mesajları: Kullanıcının tüm istekleri (araç sonuçları hariç)\n' +
+    '7. Bekleyen Görevler: Henüz yapılmamış işler\n' +
+    '8. Mevcut Çalışma: En son ne yapılıyordu (detaylı)\n' +
+    '9. Sonraki Adım: Varsa, en son kullanıcı isteğine uygun bir sonraki adım\n\n' +
+    "Yanıtı kullanıcının dilinde yaz.";
+// Geçmişi özetleyip [system, özet] olarak döndürür.
+export async function runCompact(history, config, focus) {
+    const sys = history.find((m) => m.role === 'system');
+    const convo = history.filter((m) => m.role !== 'system');
+    const msgs = [
+        sys ?? { role: 'system', content: 'You are WormClaude.' },
+        ...convo,
+        { role: 'user', content: (focus ? `Özellikle şuna odaklan: ${focus}\n\n` : '') + COMPACT_PROMPT },
+    ];
+    const summary = await completeText(msgs, config);
+    const newHist = [
+        sys ?? { role: 'system', content: 'You are WormClaude.' },
+        { role: 'user', content: 'Önceki konuşmanın özeti (bağlam):\n\n' + summary },
+    ];
+    return { history: newHist, summary };
+}