wormclaude 1.0.0

package/README.md

@@ -0,0 +1,147 @@
+# WormClaude CLI
+
+Qwen 2.5 tabanlı, OpenAI-uyumlu backend'e bağlanan uçbirim (ink TUI) AI kodlama/güvenlik asistanı.
+Claude Code'un araç/komut/agent mimarisinin **yerel, bulut-bağımsız** uyarlamasıdır.
+
+---
+
+## 📁 Dosya dosya: ne eklendi
+
+### Yeni dosyalar (`src/`) — bu oturumda sıfırdan eklendi
+
+| Dosya | Ne yapar |
+|-------|----------|
+| `agent.ts` | Yeniden kullanılabilir tool-calling döngüsü (`runAgentLoop`) — alt-agent çekirdeği. `completeText()` tek-seferlik yanıt yardımcısı. |
+| `commands.ts` | 18 slash komutu (`/help /clear /compact /context /cost /config /model /diff /commit /review /init /memory /doctor /mcp /tasks /kill /dream /export /resume /quit`). |
+| `tasks.ts` | Arka plan görev kayıt defteri (registry) — shell/agent/dream görevleri, durum/çıktı izleme, EventEmitter. |
+| `mcp.ts` | MCP istemcisi (resmi `@modelcontextprotocol/sdk`). `.wormclaude/mcp.json`'dan sunucu okur, araçları OpenAI şemasına çevirir. |
+| `usage.ts` | Billing/token ölçümü — model-bazlı maliyet, oturum+kümülatif sayaç, bütçe limiti, `.wormclaude/usage.json`. |
+| `compact.ts` | Oto-compact: bağlam eşiği + 9-bölümlü özet promptu + `isContextError` (reactive compact tetiği). |
+| `memory.ts` | Oto-hafıza: SessionMemory tetiği + autoDream gate + PID kilidi. `.wormclaude/memory.md`. |
+| `toolSummary.ts` | Araç-grubu özeti — 2+ araç sonrası tek satır git-commit tarzı etiket. |
+| `tips.ts` | Spinner/footer ipuçları (14 ipucu, cooldown'lı, `.wormclaude/tips.json`). |
+
+### Değiştirilen dosyalar (mevcuttu, genişletildi)
+
+| Dosya | Eklenen |
+|-------|---------|
+| `tools.ts` | Claude Code araç açıklamaları (birebir); `Agent` + `TaskOutput` araçları; `Bash run_in_background`; MCP yönlendirme; **paralel araç çalıştırma** (`executeToolCalls`); **per-tool metadata** (`TOOL_META`: readOnly/concurrencySafe/needsPermission/validate). |
+| `api.ts` | `usage` yakalama (`stream_options.include_usage`); **retry/backoff** (`fetchWithRetry`, jitter); **abort/interrupt** (AbortSignal). |
+| `cli.tsx` | Komut sistemi bağlama; footer task pill; MCP otomatik bağlanma; oto-compact + oto-hafıza tetikleri; usage kaydı; **izin dialogu**; **bütçe/maxTurns/Esc-kes**; **reactive compact**; tip + araç özeti gösterimi. |
+| `theme.ts` | _(değişmedi)_ |
+
+### Backend (`C:\Users\potur\Desktop\modelegitim\api\server.py`)
+
+| Eklenen | Açıklama |
+|---------|----------|
+| `POST /v1/chat/completions` | OpenAI-uyumlu gateway: streaming + **tools geçişi** + **usage**. Ollama'yı sarar. |
+| `GET /v1/models` | Model listesi. |
+| Model takma adı | `wormclaude` → `qwen2.5:7b` (env `WORMCLAUDE_DEFAULT_MODEL`). |
+| Opsiyonel auth | `WORMCLAUDE_API_KEYS` env'i set edilirse Bearer key zorunlu. |
+| Billing log | `api/billing.jsonl` — istek başına `{ts, key, model, prompt_tokens, completion_tokens}`. |
+
+> Not: Eski route'lar (`/chat`, `/chat/stream`) korundu; sadece `/v1/*` eklendi.
+
+---
+
+## ⚙️ Özellikler (tümü çalışır, test edildi)
+
+- **Araçlar:** Bash, Read, Write, Edit, Glob, Grep, WebFetch (Claude Code birebir açıklamalar) + Agent, TaskOutput
+- **Çoklu-agent:** alt-agent (`Agent`), arka plan görevleri (`run_in_background`), koordinatör, dream
+- **MCP:** stdio/SSE/HTTP sunucu desteği
+- **Paralel araç çalıştırma:** salt-okunur araçlar eşzamanlı (limit 10), yazanlar sıralı
+- **İzin sistemi:** Bash/Write/Edit öncesi onay (Evet / Evet-hep / Hayır)
+- **Billing:** token/maliyet ölçümü + oturum bütçe limiti
+- **Retry/backoff:** 408/409/429/5xx/529 + bağlantı hataları
+- **Oto-compact + reactive compact:** bağlam dolunca / taşınca otomatik özetle
+- **Oto-hafıza:** arka planda kalıcı bilgi çıkarımı
+- **Araç özeti + ipuçları:** UX cilası
+- **Interrupt:** çalışırken Esc ile kes
+
+---
+
+## 🚫 Dosya dosya: ne EKLENMEDİ (ve neden)
+
+Claude Code kaynağından (`Desktop\tools`, `Desktop\wormclaudegenel`) bilerek atlananlar — hepsi Anthropic bulutuna/hesabına/SDK'sına bağlı, yerelde karşılığı yok:
+
+### `services/` — atlananlar
+| Klasör/dosya | Neden eklenmedi |
+|--------------|-----------------|
+| `analytics/` (datadog, growthbook, sink...) | Anthropic telemetrisi |
+| `api/` (claude.ts, bootstrap, usage, overage, referral) | Anthropic bulut API + faturalandırma _(mantığı: retry+billing uyarlandı)_ |
+| `oauth/` | Anthropic hesabı/OAuth |
+| `mcp/` (auth, claudeai, xaa, officialRegistry...) | Bulut-bağımlı MCP _(çekirdek MCP istemcisi yeniden yazıldı)_ |
+| `plugins/` | Eklenti/marketplace sistemi |
+| `policyLimits/`, `remoteManagedSettings/`, `settingsSync/`, `teamMemorySync/` | Kurumsal/uzak senkronizasyon |
+| `voice*` (4 dosya) | Harici STT servisi |
+| `rateLimit*`, `mockRateLimits`, `claudeAiLimits*` | Anthropic abonelik limitleri |
+| `notifier`, `diagnosticTracking`, `internalLogging`, `vcr`, `preventSleep` | İç altyapı/OS |
+| `lsp/` (7 dosya) | Kod dil-sunucusu — opsiyonel, kurulmadı |
+| `MagicDocs/`, `AgentSummary/`, `PromptSuggestion/` (+speculation), `awaySummary` | İncelendi, orta/düşük değer → opsiyonel bırakıldı |
+
+### `cli/` (giriş/transport katmanı) — tamamı atlandı
+`transports/` (WebSocket/SSE/remote), `handlers/` (auth/mcp/plugins/agents), `print.ts`, `structuredIO.ts`, `remoteIO.ts`, `update.ts` → Anthropic uzak agent/SDK protokolü, yerelde gereksiz.
+
+### `tasks/` — kısmen
+| Eklenen | Atlanan |
+|---------|---------|
+| LocalShellTask (arka plan Bash), LocalAgentTask (alt-agent), DreamTask (hafıza) → `tasks.ts`'e uyarlandı | `RemoteAgentTask` (uzak bulut), `InProcessTeammateTask` (AsyncLocalStorage takım izolasyonu), `coordinator/` (analytics-bağımlı) |
+
+### Çekirdek motor (`query.ts`, `QueryEngine.ts`, `Tool.ts`, `tools.ts`) — incelendi
+| Uyarlandı | Atlandı (opsiyonel) |
+|-----------|---------------------|
+| Agent döngüsü, paralel araç, per-tool arayüz, izin, bütçe/maxTurns/interrupt, reactive compact | Streaming tool executor, stop hooks, max-output-token escalation (8K→64K) |
+
+---
+
+## 🔧 Ortam değişkenleri
+
+```bash
+WORMCLAUDE_BASE_URL=http://127.0.0.1:8788/v1   # backend
+WORMCLAUDE_API_KEY=wormclaude                  # backend key
+WORMCLAUDE_MODEL=wormclaude                    # model (backend qwen2.5:7b'ye çözer)
+WORMCLAUDE_MAX_TURNS=25                         # tur limiti
+WORMCLAUDE_BUDGET_USD=0                         # oturum maliyet tavanı (0=sınırsız)
+WORMCLAUDE_CONTEXT_WINDOW=32768                 # oto-compact için pencere
+WORMCLAUDE_MAX_RETRIES=5                        # bağlantı retry
+WORMCLAUDE_MAX_TOOL_CONCURRENCY=10             # paralel araç limiti
+# Backend tarafı:
+WORMCLAUDE_DEFAULT_MODEL=qwen2.5:7b            # takma ad hedefi
+WORMCLAUDE_API_KEYS=key1,key2                   # auth (boşsa kapalı)
+OLLAMA_NUM_CTX=8192                             # Ollama bağlam
+```
+
+---
+
+## 🚀 Kurulum & çalıştırma
+
+```bash
+# Backend (ayrı pencere)
+powershell -File C:\Users\potur\Desktop\modelegitim\api\BASLAT_API.ps1
+
+# CLI
+cd C:\Users\potur\Desktop\wormclaude-cli-ts
+npm install
+npm run build
+wormclaude        # veya: npm run dev
+```
+
+### MCP sunucu eklemek
+`.wormclaude/mcp.json`:
+```json
+{
+  "mcpServers": {
+    "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "C:\\proje\\yol"] }
+  }
+}
+```
+Sonra CLI'da `/mcp` ile gör, `/mcp reconnect` ile yeniden bağla.
+
+---
+
+## 💰 Ticari (aylık abonelik) için hazır kancalar
+
+1. **Auth aç:** `WORMCLAUDE_API_KEYS="musteri1,musteri2"` — her müşteriye anahtar
+2. **Fiyat koy:** `usage.setPricing("qwen2.5:7b", { in: 0.5, out: 1.5 })` — `/cost` USD gösterir
+3. **Bütçe tavanı:** `WORMCLAUDE_BUDGET_USD=5` — oturum maliyeti aşınca durur
+4. **Faturalandır:** `api/billing.jsonl`'i aylık topla (server-tarafı = güvenilir kaynak)

package/dist/agent.js

@@ -0,0 +1,61 @@
+// Faz 2 — Yeniden kullanılabilir tool-calling döngüsü (alt-agent çekirdeği).
+// Ana CLI döngüsünden bağımsız; alt-agent'lar (Agent aracı) ve dream görevleri
+// bunu headless olarak kullanır. Aynı OpenAI-uyumlu backend'e gider.
+import { streamChat } from './api.js';
+import { executeToolCalls } from './tools.js';
+// Tek seferlik tam metin yanıt (araç yok). compact/memory/komutlar kullanır.
+export async function completeText(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();
+}
+export async function runAgentLoop(opts) {
+    const { config, tools, executeTool } = opts;
+    const messages = opts.messages;
+    const maxIters = opts.maxIters ?? 12;
+    let finalText = '';
+    let iter = 0;
+    for (; iter < maxIters; iter++) {
+        if (opts.signal?.aborted)
+            break;
+        let assistantText = '';
+        let toolCalls = [];
+        for await (const ev of streamChat(messages, tools, config)) {
+            if (ev.type === 'text') {
+                assistantText += ev.text;
+                opts.hooks?.onText?.(ev.text);
+            }
+            else if (ev.type === 'done') {
+                toolCalls = ev.toolCalls;
+            }
+            else if (ev.type === 'error') {
+                assistantText += `\n[hata: ${ev.error}]`;
+            }
+        }
+        const asMsg = { role: 'assistant', content: assistantText || '' };
+        if (toolCalls.length) {
+            asMsg.tool_calls = toolCalls.map((t) => ({
+                id: t.id, type: 'function', function: { name: t.name, arguments: t.args || '{}' },
+            }));
+        }
+        messages.push(asMsg);
+        if (assistantText.trim())
+            finalText = assistantText.trim();
+        if (!toolCalls.length)
+            break;
+        // Paralel çalıştırma (salt-okunur araçlar eşzamanlı). Sonuçlar orijinal sırada.
+        const results = await executeToolCalls(toolCalls, {
+            onStart: (c) => opts.hooks?.onTool?.(c.name, undefined),
+            onResult: (c, _i, res) => opts.hooks?.onToolResult?.(c.name, res.args, res.ok, res.output),
+        });
+        for (let i = 0; i < toolCalls.length; i++) {
+            messages.push({ role: 'tool', tool_call_id: toolCalls[i].id, content: results[i].output.slice(0, 8000) });
+        }
+    }
+    return { finalText, messages, iters: iter };
+}

package/dist/api.js

@@ -0,0 +1,163 @@
+// Backend istemci — OpenAI-uyumlu /v1/chat/completions (streaming + tools).
+// Dayanıklılık: bağlantı kurulumunda exponential backoff + jitter retry.
+// Ölçüm: usage (token) bilgisini 'done' olayında döndürür (billing için).
+import { loadStored, DEFAULT_BASE_URL } from './auth.js';
+export function loadConfig() {
+    const stored = loadStored();
+    return {
+        baseUrl: process.env.WORMCLAUDE_BASE_URL || stored.baseUrl || DEFAULT_BASE_URL,
+        apiKey: process.env.WORMCLAUDE_API_KEY || stored.apiKey || '',
+        model: process.env.WORMCLAUDE_MODEL || stored.model || 'wormclaude',
+    };
+}
+// ── Retry/backoff (api/withRetry.ts'den uyarlandı) ────────────────────────────
+const MAX_RETRIES = Number(process.env.WORMCLAUDE_MAX_RETRIES) || 5;
+const BASE_DELAY_MS = 500;
+const MAX_DELAY_MS = 30000;
+const RETRYABLE_STATUS = new Set([408, 409, 429, 500, 502, 503, 504, 529]);
+const RETRYABLE_CODES = new Set(['ECONNRESET', 'EPIPE', 'ECONNREFUSED', 'ETIMEDOUT', 'UND_ERR_SOCKET']);
+function backoff(attempt) {
+    const base = Math.min(BASE_DELAY_MS * 2 ** attempt, MAX_DELAY_MS);
+    return base + Math.random() * 0.25 * base; // jitter %25
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// Sadece BAĞLANTI kurulurken retry edilir (stream başladıktan sonra retry edilmez
+// — aksi halde kısmi metin tekrar gelir). HTTP başlamadan önceki hatalar güvenli.
+async function fetchWithRetry(url, init) {
+    let lastErr;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            const res = await fetch(url, init);
+            if (res.ok)
+                return res;
+            if (!RETRYABLE_STATUS.has(res.status) || attempt === MAX_RETRIES)
+                return res;
+            try {
+                await res.body?.cancel();
+            }
+            catch { }
+        }
+        catch (e) {
+            if (e?.name === 'AbortError')
+                throw e; // kullanıcı kesti → retry etme
+            lastErr = e;
+            const code = e?.cause?.code || e?.code || '';
+            if (!RETRYABLE_CODES.has(code) && attempt === MAX_RETRIES)
+                throw e;
+            if (attempt === MAX_RETRIES)
+                throw e;
+        }
+        await sleep(backoff(attempt));
+    }
+    throw lastErr ?? new Error('retry exhausted');
+}
+export async function* streamChat(messages, tools, config, signal) {
+    const body = {
+        model: config.model,
+        messages,
+        stream: true,
+        temperature: 0.3,
+        stream_options: { include_usage: true }, // son chunk'ta usage döner
+    };
+    if (tools && tools.length)
+        body.tools = tools;
+    let res;
+    try {
+        res = await fetchWithRetry(`${config.baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}),
+            },
+            body: JSON.stringify(body),
+            signal,
+        });
+    }
+    catch (e) {
+        if (signal?.aborted || e?.name === 'AbortError') {
+            yield { type: 'done', toolCalls: [] };
+            return;
+        }
+        yield { type: 'error', error: `Backend'e ulaşılamadı (${config.baseUrl}): ${e?.message || e}` };
+        return;
+    }
+    if (!res.ok || !res.body) {
+        let detail = '';
+        try {
+            detail = await res.text();
+        }
+        catch { }
+        yield { type: 'error', error: `HTTP ${res.status}: ${detail.slice(0, 300)}` };
+        return;
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '';
+    const toolAcc = {};
+    let usage;
+    while (true) {
+        if (signal?.aborted) {
+            try {
+                await reader.cancel();
+            }
+            catch { }
+            break;
+        }
+        let chunk;
+        try {
+            chunk = await reader.read();
+        }
+        catch (e) {
+            if (signal?.aborted || e?.name === 'AbortError')
+                break;
+            throw e;
+        }
+        const { done, value } = chunk;
+        if (done)
+            break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split('\n');
+        buf = lines.pop() || '';
+        for (const line of lines) {
+            const t = line.trim();
+            if (!t.startsWith('data:'))
+                continue;
+            const data = t.slice(5).trim();
+            if (data === '[DONE]')
+                continue;
+            let j;
+            try {
+                j = JSON.parse(data);
+            }
+            catch {
+                continue;
+            }
+            if (j.usage) {
+                usage = {
+                    input: j.usage.prompt_tokens || 0,
+                    output: j.usage.completion_tokens || 0,
+                    cacheRead: j.usage.prompt_tokens_details?.cached_tokens || 0,
+                };
+            }
+            const delta = j.choices?.[0]?.delta;
+            if (!delta)
+                continue;
+            if (delta.content)
+                yield { type: 'text', text: delta.content };
+            if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    const idx = tc.index ?? 0;
+                    if (!toolAcc[idx])
+                        toolAcc[idx] = { id: tc.id || `call_${idx}`, name: '', args: '' };
+                    if (tc.id)
+                        toolAcc[idx].id = tc.id;
+                    if (tc.function?.name)
+                        toolAcc[idx].name += tc.function.name;
+                    if (tc.function?.arguments)
+                        toolAcc[idx].args += tc.function.arguments;
+                }
+            }
+        }
+    }
+    yield { type: 'done', toolCalls: Object.values(toolAcc), usage };
+}

package/dist/auth.js

@@ -0,0 +1,108 @@
+// CLI kimlik: ~/.wormclaude/config.json okuma/yazma + tarayıcı device-login akışı.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { spawn } from 'node:child_process';
+export const CONFIG_DIR = path.join(os.homedir(), '.wormclaude');
+export const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+// Müşteriler bunu değiştirmesin diye varsayılan public API.
+export const DEFAULT_BASE_URL = 'https://api.wormclaude.ai/v1';
+export function loadStored() {
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveStored(cfg) {
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+    }
+    catch (e) {
+        process.stderr.write('Yapılandırma kaydedilemedi: ' + (e?.message || e) + '\n');
+    }
+}
+export function clearStored() {
+    try {
+        fs.rmSync(CONFIG_PATH);
+    }
+    catch { }
+}
+// baseUrl ".../v1" → device endpoint'leri için kök (".../v1" olmadan)
+function apiOrigin(baseUrl) {
+    return baseUrl.replace(/\/v1\/?$/, '');
+}
+function openBrowser(url) {
+    try {
+        let child;
+        if (process.platform === 'win32') {
+            child = spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' });
+        }
+        else if (process.platform === 'darwin') {
+            child = spawn('open', [url], { detached: true, stdio: 'ignore' });
+        }
+        else {
+            child = spawn('xdg-open', [url], { detached: true, stdio: 'ignore' });
+        }
+        // spawn hatası async 'error' event'i olarak gelir; yutmazsak süreç çöker.
+        child.on('error', () => { });
+        child.unref();
+    }
+    catch { /* sessiz geç */ }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function deviceLogin() {
+    const base = process.env.WORMCLAUDE_BASE_URL || loadStored().baseUrl || DEFAULT_BASE_URL;
+    const origin = apiOrigin(base);
+    let start;
+    try {
+        const r = await fetch(`${origin}/cli/device/start`, { method: 'POST' });
+        if (!r.ok)
+            throw new Error('HTTP ' + r.status);
+        start = await r.json();
+    }
+    catch (e) {
+        process.stderr.write('Giriş başlatılamadı: ' + (e?.message || e) + '\n');
+        process.exit(1);
+    }
+    const url = start.verification_uri_complete || start.verification_uri;
+    const userCode = start.user_code;
+    const deviceCode = start.device_code;
+    process.stdout.write('\n');
+    process.stdout.write('  Tarayıcıda açın ve giriş yapın:\n');
+    process.stdout.write('    \x1b[36m' + url + '\x1b[0m\n\n');
+    process.stdout.write('  Doğrulama kodu:  \x1b[1m' + userCode + '\x1b[0m\n\n');
+    openBrowser(url);
+    const pollMs = Math.max(2, Number(start.interval) || 3) * 1000;
+    const deadline = Date.now() + (Number(start.expires_in) || 600) * 1000;
+    process.stdout.write('  Onay bekleniyor');
+    while (Date.now() < deadline) {
+        await sleep(pollMs);
+        process.stdout.write('.');
+        let d;
+        try {
+            const r = await fetch(`${origin}/cli/device/poll?device_code=${encodeURIComponent(deviceCode)}`);
+            d = await r.json();
+        }
+        catch {
+            continue; // geçici ağ hatası — tekrar dene
+        }
+        if (d.status === 'approved') {
+            saveStored({
+                baseUrl: d.base_url || base,
+                apiKey: d.api_key,
+                model: d.model || 'wormclaude',
+            });
+            process.stdout.write('\n\n  \x1b[32m✓ Giriş başarılı!\x1b[0m  Artık `wormclaude` yazarak kullanabilirsiniz.\n\n');
+            return;
+        }
+        if (d.status === 'expired') {
+            process.stdout.write('\n\n  Kodun süresi doldu. Tekrar deneyin: wormclaude login\n\n');
+            process.exit(1);
+        }
+    }
+    process.stdout.write('\n\n  Süre doldu. Tekrar deneyin: wormclaude login\n\n');
+    process.exit(1);
+}