wormclaude 1.0.14 → 1.0.16

package/dist/agent.js

@@ -20,6 +20,7 @@ export async function runAgentLoop(opts) {
     const maxIters = opts.maxIters ?? 12;
     let finalText = '';
     let iter = 0;
+    let nudged = false;
     for (; iter < maxIters; iter++) {
         if (opts.signal?.aborted)
             break;
@@ -46,8 +47,16 @@ export async function runAgentLoop(opts) {
         messages.push(asMsg);
         if (assistantText.trim())
             finalText = assistantText.trim();
-        if (!toolCalls.length)
+        if (!toolCalls.length) {
+            // Nudge: model ne metin ne araç döndürdüyse bir kez "final sonucu ver" diye dürt.
+            if (!assistantText.trim() && !nudged) {
+                nudged = true;
+                messages.push({ role: 'user', content: 'Lütfen şimdi nihai sonucu metin olarak ver ve araç çağırmayı bırak.' });
+                continue;
+            }
             break;
+        }
+        nudged = false; // ilerleme oldu → nudge sıfırla
         // 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),

package/dist/api.js

@@ -2,6 +2,8 @@
 // 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';
+import { StreamingToolCallParser } from './streamparser.js';
+import { safeJsonStringify } from './safejson.js';
 export function loadConfig() {
     const stored = loadStored();
     return {
@@ -93,7 +95,7 @@ export async function* streamChat(messages, tools, config, signal) {
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let buf = '';
-    const toolAcc = {};
+    const toolParser = new StreamingToolCallParser();
     let usage;
     while (true) {
         if (signal?.aborted) {
@@ -147,17 +149,17 @@ export async function* streamChat(messages, tools, config, signal) {
             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;
+                    toolParser.addChunk(idx, tc.function?.arguments || '', tc.id, tc.function?.name);
                 }
             }
         }
     }
-    yield { type: 'done', toolCalls: Object.values(toolAcc), usage };
+    // Tamamlanan çağrıları sağlam biçimde topla; args'ı GEÇERLİ JSON string olarak emit et
+    // (tools.ts tarafındaki JSON.parse artık asla patlamaz — onarım burada yapıldı).
+    const toolCalls = toolParser.getCompleted().map((c) => ({
+        id: c.id,
+        name: c.name,
+        args: safeJsonStringify(c.args),
+    }));
+    yield { type: 'done', toolCalls, usage };
 }

package/dist/atmention.js

@@ -0,0 +1,117 @@
+// Sohbet girişindeki @<yol> referanslarını çözer: dosya içeriğini / dizin listesini mesaja enjekte eder.
+// Gemini atCommandProcessor parser'ından uyarlandı; sadeleştirildi (data-file/workspace yok). bashCwd'ye göreli çözer.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getBashCwd } from './tools.js';
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', '.wormclaude', 'venv', '.next', 'build']);
+const MAX_FILE_BYTES = 256 * 1024;
+const MAX_INJECT_CHARS = 60000;
+/** Metindeki kaçışsız @<yol>'ları ayrıştırır (boşluk/noktalamada biter, '.' uzantı-farkında). */
+export function parseAtPaths(text) {
+    const out = [];
+    let i = 0;
+    while (i < text.length) {
+        // sonraki kaçışsız @
+        let at = -1;
+        for (let j = i; j < text.length; j++) {
+            if (text[j] === '@' && (j === 0 || text[j - 1] !== '\\')) {
+                at = j;
+                break;
+            }
+        }
+        if (at === -1)
+            break;
+        let end = at + 1;
+        let esc = false;
+        while (end < text.length) {
+            const c = text[end];
+            if (esc)
+                esc = false;
+            else if (c === '\\')
+                esc = true;
+            else if (/[\s,;!?()[\]{}]/.test(c))
+                break;
+            else if (c === '.') {
+                const n = text[end + 1] || '';
+                if (n === '' || /\s/.test(n))
+                    break;
+            }
+            end++;
+        }
+        const raw = text.slice(at + 1, end).replace(/\\(.)/g, '$1');
+        if (raw)
+            out.push(raw);
+        i = end;
+    }
+    return out;
+}
+function fuzzyFind(root, name, depth = 0, budget = { n: 0 }) {
+    if (depth > 4 || budget.n > 3000)
+        return null;
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    // önce bu dizindeki dosyalar
+    for (const e of entries) {
+        budget.n++;
+        if (e.isFile() && e.name.toLowerCase().includes(name.toLowerCase()))
+            return path.join(root, e.name);
+    }
+    for (const e of entries) {
+        if (e.isDirectory() && !SKIP_DIRS.has(e.name) && !e.name.startsWith('.')) {
+            const hit = fuzzyFind(path.join(root, e.name), name, depth + 1, budget);
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
+/**
+ * @-mention'ları çözer. Dosya bulunursa içeriği, dizinse listesi mesaj sonuna eklenir.
+ * @returns { augmented: modele gidecek (içerik eklenmiş) metin, files: çözülen yollar }
+ */
+export function resolveAtMentions(text) {
+    const paths = parseAtPaths(text);
+    if (!paths.length)
+        return { augmented: text, files: [] };
+    const cwd = getBashCwd();
+    const blocks = [];
+    const found = [];
+    for (const p of paths) {
+        let target = path.resolve(cwd, p);
+        if (!fs.existsSync(target)) {
+            const hit = fuzzyFind(cwd, path.basename(p));
+            if (!hit)
+                continue;
+            target = hit;
+        }
+        try {
+            const st = fs.statSync(target);
+            const rel = path.relative(cwd, target) || target;
+            if (st.isDirectory()) {
+                const list = fs.readdirSync(target).slice(0, 100).join('\n');
+                blocks.push(`--- Dizin: ${rel} ---\n${list}`);
+                found.push(rel);
+            }
+            else if (st.size <= MAX_FILE_BYTES) {
+                const content = fs.readFileSync(target, 'utf8').slice(0, MAX_INJECT_CHARS);
+                blocks.push(`--- Dosya: ${rel} ---\n${content}`);
+                found.push(rel);
+            }
+            else {
+                blocks.push(`--- ${rel}: çok büyük (${Math.round(st.size / 1024)}KB), atlandı ---`);
+            }
+        }
+        catch { /* erişilemedi, atla */ }
+    }
+    if (!blocks.length)
+        return { augmented: text, files: [] };
+    return {
+        augmented: `${text}\n\n[Kullanıcının @ ile referansladığı içerik:]\n${blocks.join('\n\n')}`,
+        files: found,
+    };
+}

package/dist/auth.js

@@ -37,6 +37,16 @@ function apiOrigin(baseUrl) {
 }
 function openBrowser(url) {
     try {
+        // Güvenlik: yalnız http/https aç. (Windows 'start' rastgele şema/dosya açabilir; savunma.)
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            return;
+        }
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+            return;
         let child;
         if (process.platform === 'win32') {
             child = spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' });

package/dist/cli.js

@@ -6,6 +6,10 @@ import * as path from 'node:path';
 import { theme, VERSION } from './theme.js';
 import { loadConfig, streamChat } from './api.js';
 import { allToolSchemas, executeToolCalls, executeTool, toolLabel, setToolConfig } from './tools.js';
+import { sanitizeError, sanitizeOutput } from './errorsan.js';
+import { cleanModelText } from './textclean.js';
+import { MarkdownDisplay } from './markdown.js';
+import { resolveAtMentions } from './atmention.js';
 import { summarizeTools } from './toolSummary.js';
 import { pickTipId, tipText } from './tips.js';
 import { t, cmdDesc, setLang, saveLang, loadLang, getLang } from './i18n.js';
@@ -219,8 +223,8 @@ function RenderItem({ item }) {
     if (item.kind === 'assistant') {
         return (React.createElement(Box, { marginTop: 1, flexDirection: "row" },
             React.createElement(Text, { color: theme.redBright, bold: true }, "\u23FA "),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: theme.white }, linkify(item.text)))));
+            React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
+                React.createElement(MarkdownDisplay, { text: item.text }))));
     }
     if (item.kind === 'tool') {
         const lines = item.result.split('\n').length;
@@ -535,13 +539,13 @@ function App() {
             for await (const ev of streamChat(historyRef.current, allToolSchemas(), config, ac.signal)) {
                 if (ev.type === 'text') {
                     assistantText += ev.text;
-                    setStreaming(assistantText);
+                    setStreaming(cleanModelText(assistantText));
                     setTokens(Math.round(assistantText.length / 4));
                 }
                 else if (ev.type === 'error') {
                     if (isContextError(ev.error))
                         gotCtxError = true;
-                    assistantText += `\n[hata: ${ev.error}]`;
+                    assistantText += `\n[hata: ${sanitizeError(ev.error)}]`;
                     setStreaming(assistantText);
                 }
                 else if (ev.type === 'done') {
@@ -550,6 +554,8 @@ function App() {
                 }
             }
             setStreaming('');
+            // Sızan özel-token / tool-call markup'ını bir kez temizle (hem geçmiş hem gösterim için).
+            assistantText = cleanModelText(assistantText);
             // Reactive compact: bağlam taştıysa bir kez özetle ve turu tekrar dene
             if (gotCtxError && !reactiveRetried) {
                 reactiveRetried = true;
@@ -613,7 +619,7 @@ function App() {
                 onResult: (c, _i, res) => {
                     if ((c.name === 'WebSearch' || c.name === 'WebFetch') && res.ok)
                         usedWeb = true;
-                    push({ kind: 'tool', label: toolLabel(c.name, res.args), result: res.output, ok: res.ok });
+                    push({ kind: 'tool', label: toolLabel(c.name, res.args), result: sanitizeOutput(res.output), ok: res.ok });
                 },
                 confirm: (c, args) => new Promise((resolve) => {
                     if (allowedToolsRef.current.has(c.name))
@@ -661,6 +667,29 @@ function App() {
         setCmdSel(0);
         if (!v)
             return;
+        // ! shell modu — LLM'siz doğrudan shell komutu (cmdsec ile gate'li). Sonucu modele bağlam olarak ekle.
+        if (v.startsWith('!') && v.length > 1) {
+            const cmd = v.slice(1).trim();
+            if (!cmd)
+                return;
+            push({ kind: 'user', text: v });
+            setBusy(true);
+            setThinking(false);
+            setPhase(t('phase.toolRun', 'shell'));
+            try {
+                const res = await executeTool('Bash', { command: cmd });
+                push({ kind: 'tool', label: `! ${cmd.slice(0, 60)}`, result: sanitizeOutput(res.output), ok: res.ok });
+                historyRef.current = [...historyRef.current, {
+                        role: 'user',
+                        content: `Şu shell komutunu çalıştırdım:\n\`\`\`\n${cmd}\n\`\`\`\nÇıktı:\n\`\`\`\n${(res.output || '').slice(0, 4000)}\n\`\`\``,
+                    }];
+            }
+            catch (e) {
+                push({ kind: 'note', text: t('note.cmdErr', e?.message || e) });
+            }
+            setBusy(false);
+            return;
+        }
         if (v.startsWith('/')) {
             // Seçili menü öğesini çalıştır (tam eşleşme yoksa ve argüman yoksa)
             const firstTok = v.split(' ')[0];
@@ -756,7 +785,12 @@ function App() {
             setBusy(false);
             return;
         }
-        runAgent(v);
+        // @dosya mention — referanslanan dosya/dizin içeriğini modele enjekte et, kullanıcıya orijinali göster
+        const at = resolveAtMentions(v);
+        if (at.files.length)
+            runAgent(at.augmented, v);
+        else
+            runAgent(v);
     }
     const { cols, rows } = useDimensions();
     // İlk açılış: dil seçimi

package/dist/commands.js

@@ -12,6 +12,7 @@ import { cmdDesc, setLang, saveLang, getLang } from './i18n.js';
 import { loadSkills, getSkills, getSkillsDir, installSkill, updateSkill, removeSkill, getRegistry } from './skills.js';
 import { getApprovedCommands, approveCommands, unapproveCommands, clearApproved } from './cmdsec.js';
 import { isLearnEnabled, setLearnEnabled, getLearnFile, getLearnCount } from './learn.js';
+import { saveMemoryFact, getMemoryPath, loadMemoryContext } from './memory.js';
 export const COMMANDS = [
     { name: '/help', desc: 'komutları ve ipuçlarını göster' },
     { name: '/clear', desc: 'sohbeti ve geçmişi temizle' },
@@ -24,7 +25,7 @@ export const COMMANDS = [
     { 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: '/memory', desc: 'hafızayı göster / ekle / temizle (/memory <metin> · --global · temizle)' },
     { 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' },
@@ -245,6 +246,11 @@ export async function runSlashCommand(input, ctx) {
             return true;
         }
         case '/init': {
+            const initDest = path.join(process.cwd(), 'WORMCLAUDE.md');
+            if (fs.existsSync(initDest) && fs.readFileSync(initDest, 'utf8').trim() && (arg || '').trim() !== 'force') {
+                ctx.note('WORMCLAUDE.md zaten var ve dolu. Üzerine yazmak için: /init force');
+                return true;
+            }
             const files = [];
             const walk = (d, depth = 0) => {
                 if (depth > 3 || files.length > 400)
@@ -283,15 +289,45 @@ export async function runSlashCommand(input, ctx) {
             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}`);
+            // .wormclaude/memory.md (oturumlar-arası hatıralar) — SaveMemory tool'u + oto-hafıza ile AYNI yer.
+            const a = (arg || '').trim();
+            // /memory temizle — hatıra dosyasını sıfırla
+            if (a === 'temizle' || a === 'clear') {
+                try {
+                    fs.writeFileSync(getMemoryPath(), '');
+                    ctx.note('Hatıralar temizlendi.');
+                }
+                catch (e) {
+                    ctx.note('Temizlenemedi: ' + (e?.message || e));
+                }
+                return true;
             }
-            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.');
+            // /memory ekle <metin>  veya  /memory <metin>  veya  /memory --global <metin>
+            let scope = 'project';
+            let fact = a;
+            if (fact.startsWith('ekle '))
+                fact = fact.slice(5).trim();
+            if (fact.startsWith('--global ')) {
+                scope = 'global';
+                fact = fact.slice(9).trim();
+            }
+            else if (fact.startsWith('--project ')) {
+                scope = 'project';
+                fact = fact.slice(10).trim();
+            }
+            if (fact) {
+                try {
+                    const file = saveMemoryFact(fact, scope);
+                    ctx.note(`Hafızaya eklendi (${scope}): ${fact}  →  ${file}`);
+                }
+                catch (e) {
+                    ctx.note('Eklenemedi: ' + (e?.message || e));
+                }
+                return true;
             }
+            // arg yok → mevcut hafızayı göster (memory.md + WORMCLAUDE.md birlikte)
+            const ctxStr = loadMemoryContext();
+            ctx.note(ctxStr ? ctxStr.slice(0, 6000) : 'Hafıza boş. /memory <metin> ile ekle, /init ile WORMCLAUDE.md üret.');
             return true;
         }
         case '/doctor': {

package/dist/errorsan.js

@@ -0,0 +1,94 @@
+// Hata/çıktı temizleme: (1) gizli anahtar redaksiyonu, (2) backend kimlik maskeleme (white-label),
+// (3) OpenAI-tarzı JSON hata ayrıştırma, (4) dostça timeout mesajı.
+// Gemini errorSanitizer (sadece provider-maskeleme) + errorHandler'dan uyarlandı; gerçek secret-redaction eklendi.
+const PRODUCT = 'WormClaude';
+// ── (1) Gizli anahtar redaksiyonu ─────────────────────────────────────────────
+// Yalnız NET secret desenleri — kullanıcının normal metnini bozmamak için dar tutuldu.
+const SECRET_PATTERNS = [
+    [/\bwc_live_[A-Za-z0-9]{6,}/g, 'wc_live_[REDACTED]'],
+    [/\bwc_sk_[A-Za-z0-9]{6,}/g, 'wc_sk_[REDACTED]'],
+    [/\bsk-[A-Za-z0-9_-]{16,}/g, 'sk-[REDACTED]'],
+    [/\bghp_[A-Za-z0-9]{20,}/g, 'ghp_[REDACTED]'],
+    [/\bAKIA[A-Z0-9]{16}\b/g, 'AKIA[REDACTED]'],
+    [/\b(Bearer)\s+[A-Za-z0-9._\-]{12,}/gi, '$1 [REDACTED]'],
+    // key/secret/token/password [:= veya boşluk] <değer>  (env dump, config echo)
+    [/\b(api[_-]?key|secret|token|password|passwd|vllm[_-]?key)\b(["']?\s*[:=\s]\s*["']?)([A-Za-z0-9._\-]{6,})/gi,
+        '$1$2[REDACTED]'],
+];
+// Agresif: çıplak uzun-hex anahtarlar (48+ hex). git SHA (40) ve kısa hash'leri KORUR.
+// SADECE hata mesajlarında kullanılır — tool çıktısında değil (git log SHA'larını bozmasın).
+const BARE_HEX = /\b[0-9a-f]{48,}\b/gi;
+export function redactSecrets(text, aggressive = false) {
+    if (!text)
+        return text;
+    let out = String(text);
+    for (const [re, rep] of SECRET_PATTERNS)
+        out = out.replace(re, rep);
+    if (aggressive)
+        out = out.replace(BARE_HEX, '[REDACTED]');
+    return out;
+}
+// ── (2) Backend kimlik maskeleme (white-label) ────────────────────────────────
+// SADECE backend-kaynaklı metne uygulanır (hata mesajları). Kullanıcının kendi içeriğine UYGULANMAZ
+// (ör. tool çıktısındaki "localhost" kullanıcının kendi dev sunucusu olabilir).
+const BACKEND_PATTERNS = [
+    [/\bQwen[0-9]?(?:\.[0-9]+)?-?[A-Za-z0-9.\-]*/gi, PRODUCT],
+    [/\bqwen[_-]?\w*/gi, PRODUCT],
+    [/\bvllm\b/gi, `${PRODUCT} engine`],
+    [/\bhermes\b/gi, `${PRODUCT}`],
+    [/\b127\.0\.0\.1(?::\d+)?/g, PRODUCT],
+    [/\b0\.0\.0\.0(?::\d+)?/g, PRODUCT],
+    [/\blocalhost:(?:8000|8001|8788)\b/gi, PRODUCT],
+];
+export function maskBackend(text) {
+    if (!text)
+        return text;
+    let out = String(text);
+    for (const [re, rep] of BACKEND_PATTERNS)
+        out = out.replace(re, rep);
+    return out;
+}
+// ── (3) OpenAI-tarzı JSON hata ayrıştırma ─────────────────────────────────────
+function parseApiError(text) {
+    const t = (text || '').trim();
+    // "HTTP 500: {...}" veya düz JSON gövde içinde {"error":{"message":...}}
+    const jsonStart = t.indexOf('{');
+    if (jsonStart === -1)
+        return text;
+    try {
+        const obj = JSON.parse(t.slice(jsonStart));
+        const msg = obj?.error?.message || obj?.message || obj?.detail;
+        if (typeof msg === 'string' && msg.trim()) {
+            const prefix = t.slice(0, jsonStart).trim();
+            return prefix ? `${prefix} ${msg}` : msg;
+        }
+    }
+    catch { /* JSON değil — olduğu gibi bırak */ }
+    return text;
+}
+// ── (4) Dostça timeout mesajı ─────────────────────────────────────────────────
+const TIMEOUT_HINTS = [
+    'timeout', 'timed out', 'connection timeout', 'read timeout',
+    'etimedout', 'esockettimedout', 'deadline exceeded', 'und_err_socket',
+];
+export function isTimeoutError(text) {
+    const t = (text || '').toLowerCase();
+    return TIMEOUT_HINTS.some((h) => t.includes(h));
+}
+function friendlyTimeout(text) {
+    return `${text}\n  • Girdiyi kısaltmayı veya bağlamı sadeleştirmeyi dene.\n  • Ağ bağlantını kontrol et.\n  • Sorun sürerse birkaç saniye sonra tekrar dene.`;
+}
+// ── Birleşik: kullanıcıya gösterilecek hata ───────────────────────────────────
+export function sanitizeError(input) {
+    let text = input instanceof Error ? input.message : String(input ?? '');
+    text = parseApiError(text);
+    text = maskBackend(text);
+    text = redactSecrets(text, true); // hata mesajı → agresif (çıplak hex dahil)
+    if (isTimeoutError(text))
+        text = friendlyTimeout(text);
+    return text.trim();
+}
+// Tool çıktısı için: yalnız gizli anahtar redaksiyonu (kimlik maskeleme YOK — kullanıcının kendi içeriği).
+export function sanitizeOutput(text) {
+    return redactSecrets(text);
+}