wormclaude 1.0.14 → 1.0.16

package/dist/markdown.js

@@ -0,0 +1,221 @@
+// Terminal markdown render (ink). Gemini MarkdownDisplay + InlineMarkdownRenderer + TableRenderer'dan
+// uyarlandı; WormClaude theme.ts'e bağlandı; lowlight YOK (kod blokları tek accent renk — görsel cila v1).
+import React from 'react';
+import { Text, Box } from 'ink';
+import stringWidth from 'string-width';
+import { theme } from './theme.js';
+// ── Inline markdown: **bold** *italik* ~~strike~~ `code` [text](url) <u>u</u> url ──
+const INLINE_RE = /(\*\*.*?\*\*|\*.*?\*|_.*?_|~~.*?~~|\[.*?\]\(.*?\)|`+.+?`+|<u>.*?<\/u>|https?:\/\/\S+)/g;
+export function RenderInline({ text }) {
+    if (!/[*_~`<[]|https?:/.test(text))
+        return React.createElement(Text, null, text);
+    const nodes = [];
+    let last = 0;
+    let m;
+    INLINE_RE.lastIndex = 0;
+    while ((m = INLINE_RE.exec(text)) !== null) {
+        if (m.index > last)
+            nodes.push(React.createElement(Text, { key: `t${last}` }, text.slice(last, m.index)));
+        const f = m[0];
+        const key = `m${m.index}`;
+        let node = null;
+        if (f.startsWith('**') && f.endsWith('**') && f.length > 4) {
+            node = React.createElement(Text, { key: key, bold: true }, f.slice(2, -2));
+        }
+        else if (f.length > 2 && ((f.startsWith('*') && f.endsWith('*')) || (f.startsWith('_') && f.endsWith('_'))) &&
+            // path-güvenli: kelime/yol-ayracı bitişiğinde italik sayma (dosya_adı, a/b_c bozulmasın)
+            !/\w/.test(text.substring(m.index - 1, m.index)) &&
+            !/\w/.test(text.substring(INLINE_RE.lastIndex, INLINE_RE.lastIndex + 1)) &&
+            !/\S[./\\]/.test(text.substring(m.index - 2, m.index)) &&
+            !/[./\\]\S/.test(text.substring(INLINE_RE.lastIndex, INLINE_RE.lastIndex + 2))) {
+            node = React.createElement(Text, { key: key, italic: true }, f.slice(1, -1));
+        }
+        else if (f.startsWith('~~') && f.endsWith('~~') && f.length > 4) {
+            node = React.createElement(Text, { key: key, strikethrough: true }, f.slice(2, -2));
+        }
+        else if (f.startsWith('`') && f.endsWith('`')) {
+            const cm = f.match(/^(`+)(.+?)\1$/s);
+            if (cm && cm[2])
+                node = React.createElement(Text, { key: key, color: theme.green }, cm[2]);
+        }
+        else if (f.startsWith('[') && f.includes('](') && f.endsWith(')')) {
+            const lm = f.match(/\[(.*?)\]\((.*?)\)/);
+            if (lm)
+                node = React.createElement(Text, { key: key },
+                    lm[1],
+                    React.createElement(Text, { color: theme.redBright },
+                        " (",
+                        lm[2],
+                        ")"));
+        }
+        else if (f.startsWith('<u>') && f.endsWith('</u>')) {
+            node = React.createElement(Text, { key: key, underline: true }, f.slice(3, -4));
+        }
+        else if (/^https?:\/\//.test(f)) {
+            node = React.createElement(Text, { key: key, color: theme.redBright }, f);
+        }
+        nodes.push(node ?? React.createElement(Text, { key: key }, f));
+        last = INLINE_RE.lastIndex;
+    }
+    if (last < text.length)
+        nodes.push(React.createElement(Text, { key: `t${last}` }, text.slice(last)));
+    return React.createElement(Text, null, nodes);
+}
+// markdown'ı soyup görüntü genişliği (tablo hizalama)
+export function plainLen(text) {
+    const clean = text
+        .replace(/\*\*(.*?)\*\*/g, '$1').replace(/\*(.*?)\*/g, '$1').replace(/_(.*?)_/g, '$1')
+        .replace(/~~(.*?)~~/g, '$1').replace(/`(.*?)`/g, '$1').replace(/<u>(.*?)<\/u>/g, '$1')
+        .replace(/\[(.*?)\]\(.*?\)/g, '$1');
+    return stringWidth(clean);
+}
+// ── Tablo (box-drawing) ──────────────────────────────────────────────────────
+function Table({ headers, rows, width }) {
+    const cols = headers.map((h, i) => Math.max(plainLen(h), ...rows.map((r) => plainLen(r[i] || ''))) + 2);
+    const total = cols.reduce((s, w) => s + w + 1, 1);
+    const scale = total > width ? width / total : 1;
+    const w = cols.map((c) => Math.max(3, Math.floor(c * scale)));
+    const cell = (c, width, header) => {
+        const cw = Math.max(0, width - 2);
+        let s = c;
+        if (plainLen(c) > cw) {
+            let lo = 0, hi = c.length, best = '';
+            while (lo <= hi) {
+                const mid = (lo + hi) >> 1;
+                const cand = c.slice(0, mid);
+                if (plainLen(cand) <= cw - 1) {
+                    best = cand;
+                    lo = mid + 1;
+                }
+                else
+                    hi = mid - 1;
+            }
+            s = best + '…';
+        }
+        const pad = ' '.repeat(Math.max(0, cw - plainLen(s)));
+        return header ? React.createElement(Text, { bold: true, color: theme.redBright },
+            React.createElement(RenderInline, { text: s }),
+            pad) : React.createElement(Text, null,
+            React.createElement(RenderInline, { text: s }),
+            pad);
+    };
+    const border = (l, mid, r) => (React.createElement(Text, { color: theme.greyDim }, l + w.map((x) => '─'.repeat(x)).join(mid) + r));
+    const row = (cells, header) => (React.createElement(Text, { color: theme.greyDim },
+        "\u2502 ",
+        w.map((x, i) => (React.createElement(React.Fragment, { key: i },
+            cell(cells[i] || '', x, header),
+            i < w.length - 1 ? ' │ ' : ''))),
+        " \u2502"));
+    return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
+        border('┌', '┬', '┐'),
+        row(headers, true),
+        border('├', '┼', '┤'),
+        rows.map((r, i) => React.createElement(React.Fragment, { key: i }, row(r, false))),
+        border('└', '┴', '┘')));
+}
+// ── Blok parser ──────────────────────────────────────────────────────────────
+export function MarkdownDisplay({ text, width }) {
+    if (!text)
+        return null;
+    const W = Math.max(20, (width ?? (process.stdout.columns || 80)) - 4);
+    const lines = text.split('\n');
+    const blocks = [];
+    let key = 0;
+    const push = (n) => blocks.push(React.createElement(React.Fragment, { key: key++ }, n));
+    let inCode = false, codeFence = '', codeLines = [];
+    let inTable = false, tHeaders = [], tRows = [];
+    const flushTable = () => { if (tHeaders.length)
+        push(React.createElement(Table, { headers: tHeaders, rows: tRows, width: W })); inTable = false; tHeaders = []; tRows = []; };
+    const headerRe = /^ *(#{1,4}) +(.*)/;
+    const fenceRe = /^ *(`{3,}|~{3,}) *(\w*)? *$/;
+    const ulRe = /^([ \t]*)([-*+]) +(.*)/;
+    const olRe = /^([ \t]*)(\d+)\. +(.*)/;
+    const hrRe = /^ *([-*_] *){3,} *$/;
+    const rowRe = /^\s*\|(.+)\|\s*$/;
+    const sepRe = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?\s*$/;
+    lines.forEach((line, idx) => {
+        if (inCode) {
+            const fm = line.match(fenceRe);
+            if (fm && fm[1][0] === codeFence[0] && fm[1].length >= codeFence.length) {
+                push(React.createElement(Box, { flexDirection: "column", marginY: 1 }, codeLines.map((c, i) => React.createElement(Text, { key: i, color: theme.green }, c))));
+                inCode = false;
+                codeFence = '';
+                codeLines = [];
+            }
+            else
+                codeLines.push(line);
+            return;
+        }
+        const fm = line.match(fenceRe);
+        const rm = line.match(rowRe);
+        if (fm) {
+            if (inTable)
+                flushTable();
+            inCode = true;
+            codeFence = fm[1];
+            return;
+        }
+        if (rm && !inTable) {
+            if (idx + 1 < lines.length && sepRe.test(lines[idx + 1])) {
+                inTable = true;
+                tHeaders = rm[1].split('|').map((c) => c.trim());
+                tRows = [];
+                return;
+            }
+            push(React.createElement(Text, { color: theme.white },
+                React.createElement(RenderInline, { text: line })));
+            return;
+        }
+        if (inTable && sepRe.test(line))
+            return;
+        if (inTable && rm) {
+            const cells = rm[1].split('|').map((c) => c.trim());
+            while (cells.length < tHeaders.length)
+                cells.push('');
+            cells.length = tHeaders.length;
+            tRows.push(cells);
+            return;
+        }
+        if (inTable && !rm)
+            flushTable();
+        const hm = line.match(headerRe);
+        const um = line.match(ulRe);
+        const om = line.match(olRe);
+        if (hrRe.test(line) && line.trim().length >= 3) {
+            push(React.createElement(Text, { color: theme.greyDim }, '─'.repeat(Math.min(W, 40))));
+            return;
+        }
+        if (hm) {
+            const lvl = hm[1].length;
+            const inner = React.createElement(RenderInline, { text: hm[2] });
+            if (lvl <= 2)
+                push(React.createElement(Text, { bold: true, color: theme.redBright }, inner));
+            else if (lvl === 3)
+                push(React.createElement(Text, { bold: true, color: theme.white }, inner));
+            else
+                push(React.createElement(Text, { italic: true, color: theme.grey }, inner));
+            return;
+        }
+        if (um || om) {
+            const [, ws, marker, itemText] = (um || om);
+            const prefix = om ? `${marker}. ` : '• ';
+            push(React.createElement(Box, { paddingLeft: ws.length },
+                React.createElement(Text, { color: theme.grey }, prefix),
+                React.createElement(Box, { flexGrow: 1 },
+                    React.createElement(Text, { color: theme.white },
+                        React.createElement(RenderInline, { text: itemText })))));
+            return;
+        }
+        if (line.trim().length === 0) {
+            push(React.createElement(Box, { height: 1 }));
+            return;
+        }
+        push(React.createElement(Text, { color: theme.white, wrap: "wrap" },
+            React.createElement(RenderInline, { text: line })));
+    });
+    if (inCode)
+        push(React.createElement(Box, { flexDirection: "column", marginY: 1 }, codeLines.map((c, i) => React.createElement(Text, { key: i, color: theme.green }, c))));
+    if (inTable)
+        flushTable();
+    return React.createElement(Box, { flexDirection: "column" }, blocks);
+}

package/dist/memory.js

@@ -2,6 +2,7 @@
 // Tetik eşikleri ve kilit mekanizması Claude Code'dan uyarlandı.
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import * as os from 'node:os';
 import { completeText } from './agent.js';
 import { approxTokens } from './usage.js';
 import { tasks } from './tasks.js';
@@ -133,6 +134,46 @@ export function dreamTimeGatePassed() {
     }
 }
 export function getMemoryPath() { return MEM_FILE; }
+// ── Açık kayıt: save_memory tool'u (otomatik hafızayı tamamlar) ────────────────
+const MEMORY_HEADER = '## Eklenen Hatıralar';
+/**
+ * Modelin/kullanıcının açıkça istediği tek bir kalıcı bilgiyi hafıza dosyasına ekler.
+ * Otomatik konsolidasyondan bağımsız; "## Eklenen Hatıralar" başlığı altına "- <fact>" yazar.
+ * scope: 'project' → cwd/.wormclaude/memory.md (varsayılan), 'global' → ~/.wormclaude/memory.md.
+ */
+export function saveMemoryFact(fact, scope = 'project') {
+    const clean = String(fact || '').trim().replace(/^(-+\s*)+/, '').trim();
+    if (!clean)
+        throw new Error('boş hatıra');
+    const dir = scope === 'global'
+        ? path.join(os.homedir(), '.wormclaude')
+        : MEM_DIR;
+    const file = path.join(dir, 'memory.md');
+    fs.mkdirSync(dir, { recursive: true });
+    let content = '';
+    try {
+        content = fs.readFileSync(file, 'utf8');
+    }
+    catch { }
+    const item = `- ${clean}`;
+    const idx = content.indexOf(MEMORY_HEADER);
+    if (idx === -1) {
+        const sep = content.length === 0 ? '' : content.endsWith('\n') ? '\n' : '\n\n';
+        content += `${sep}${MEMORY_HEADER}\n${item}\n`;
+    }
+    else {
+        // Başlıktan sonraki bölümün sonuna ekle (sonraki ## başlığına kadar)
+        const start = idx + MEMORY_HEADER.length;
+        let end = content.indexOf('\n## ', start);
+        if (end === -1)
+            end = content.length;
+        const before = content.slice(0, end).replace(/\s+$/, '');
+        const after = content.slice(end);
+        content = `${before}\n${item}${after.startsWith('\n') ? '' : '\n'}${after}`;
+    }
+    fs.writeFileSync(file, content);
+    return file;
+}
 // Kalıcı hafızayı başlangıçta context'e yüklemek için oku.
 // .wormclaude/memory.md (oturumlar arası hafıza) + WORMCLAUDE.md (proje notu).
 export function loadMemoryContext() {

package/dist/safejson.js

@@ -0,0 +1,166 @@
+// Qwen-14B'nin bozuk JSON tool-call argümanlarını kurtarmak için dayanıklı JSON yardımcıları.
+// Bağımlılıksız (jsonrepair YOK) — elle onarım stratejileri. Gemini safeJsonParse + fixBooleanCasing'den
+// uyarlandı; WormClaude'a özel sadeleştirildi.
+/**
+ * Python-tarzı True/False/None'ı JSON karşılıklarına çevirir (özyinelemeli, string-güvenli).
+ * Qwen bazen `{"flag": True}` üretir → geçerli JSON değil.
+ */
+export function fixBooleanCasing(text) {
+    let out = '';
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            out += ch;
+            if (escape)
+                escape = false;
+            else if (ch === '\\')
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        // String dışında: Python literal'lerini kelime-sınırında değiştir
+        const rest = text.slice(i);
+        const m = /^(True|False|None)\b/.exec(rest);
+        if (m) {
+            out += m[1] === 'True' ? 'true' : m[1] === 'False' ? 'false' : 'null';
+            i += m[1].length - 1;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+/** String dışındaki trailing virgülleri kaldırır: `{"a":1,}` → `{"a":1}` */
+function stripTrailingCommas(text) {
+    let out = '';
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            out += ch;
+            if (escape)
+                escape = false;
+            else if (ch === '\\')
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === ',') {
+            // Sonraki anlamlı karakter } veya ] ise virgülü at
+            let j = i + 1;
+            while (j < text.length && /\s/.test(text[j]))
+                j++;
+            if (text[j] === '}' || text[j] === ']')
+                continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+/** Açık kalan string/parantez/köşeli ayraçları kapatır (streaming kesintisi onarımı). */
+function closeOpenStructures(text) {
+    let inString = false;
+    let escape = false;
+    const stack = [];
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escape)
+                escape = false;
+            else if (ch === '\\')
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '{')
+            stack.push('}');
+        else if (ch === '[')
+            stack.push(']');
+        else if (ch === '}' || ch === ']')
+            stack.pop();
+    }
+    let out = text;
+    if (inString)
+        out += '"';
+    while (stack.length)
+        out += stack.pop();
+    return out;
+}
+/**
+ * Bozuk/yarım JSON'u en iyi çabayla parse eder. Sırayla: düz parse → fixBooleanCasing →
+ * trailing-comma temizliği → açık yapıları kapatma. Hepsi başarısızsa fallback döner.
+ */
+export function safeJsonParse(text, fallback) {
+    if (text == null)
+        return fallback;
+    const raw = String(text).trim();
+    if (!raw)
+        return fallback;
+    // 1) Düz
+    try {
+        return JSON.parse(raw);
+    }
+    catch { }
+    // 2) Boolean casing
+    let repaired = fixBooleanCasing(raw);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch { }
+    // 3) Trailing virgüller
+    repaired = stripTrailingCommas(repaired);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch { }
+    // 4) Açık yapıları kapat
+    repaired = closeOpenStructures(repaired);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch { }
+    // 5) Pes
+    return fallback;
+}
+/**
+ * Döngüsel referansları ve hata/undefined değerleri tolere ederek JSON üretir.
+ * Asla fırlatmaz; başarısızsa fallback string döner.
+ */
+export function safeJsonStringify(value, space, fallback = '"[unserializable]"') {
+    const seen = new WeakSet();
+    try {
+        return JSON.stringify(value, (_k, v) => {
+            if (typeof v === 'bigint')
+                return v.toString();
+            if (v instanceof Error)
+                return { name: v.name, message: v.message };
+            if (typeof v === 'object' && v !== null) {
+                if (seen.has(v))
+                    return '[Circular]';
+                seen.add(v);
+            }
+            return v;
+        }, space);
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/streamparser.js

@@ -0,0 +1,158 @@
+// Streaming tool-call delta'larını dayanıklı biçimde birleştirir.
+// Qwen-14B + vLLM(hermes) parçalı JSON arg, index çakışması, ID'siz devam chunk'ı üretebilir.
+// Gemini streamingToolCallParser'dan uyarlandı; bizim {index, id?, name?, argChunk} delta'mıza göre sade.
+import { safeJsonParse } from './safejson.js';
+export class StreamingToolCallParser {
+    buffers = new Map();
+    depths = new Map();
+    inStrings = new Map();
+    escapes = new Map();
+    meta = new Map();
+    idToIndex = new Map();
+    nextIndex = 0;
+    /**
+     * Bir delta chunk'ı ekler. index streaming yanıtından gelir (çakışabilir); id yeni çağrı başlangıcı.
+     * @returns chunk işlendikten sonra o index'te JSON tamamlandıysa parse edilmiş değer.
+     */
+    addChunk(index, chunk, id, name) {
+        let actual = index;
+        if (id) {
+            if (this.idToIndex.has(id)) {
+                actual = this.idToIndex.get(id);
+            }
+            else {
+                // Bu index'te FARKLI id'li, tamamlanmış bir çağrı varsa yeni slot bul
+                if (this.buffers.has(index)) {
+                    const buf = this.buffers.get(index);
+                    const depth = this.depths.get(index);
+                    const m = this.meta.get(index);
+                    if (buf.trim() && depth === 0 && m?.id && m.id !== id) {
+                        try {
+                            JSON.parse(buf);
+                            actual = this.findNextIndex();
+                        }
+                        catch { /* yarım → güvenle yeniden kullan */ }
+                    }
+                }
+                this.idToIndex.set(id, actual);
+            }
+        }
+        else if (this.buffers.has(index)) {
+            // ID'siz devam: bu index tamamlandıysa en son yarım çağrıya yönlendir
+            const buf = this.buffers.get(index);
+            const depth = this.depths.get(index);
+            if (depth === 0 && buf.trim()) {
+                try {
+                    JSON.parse(buf);
+                    actual = this.findMostRecentIncomplete();
+                }
+                catch {
+                    actual = index;
+                }
+            }
+        }
+        if (!this.buffers.has(actual)) {
+            this.buffers.set(actual, '');
+            this.depths.set(actual, 0);
+            this.inStrings.set(actual, false);
+            this.escapes.set(actual, false);
+            this.meta.set(actual, {});
+        }
+        const m = this.meta.get(actual);
+        if (id)
+            m.id = id;
+        if (name)
+            m.name = (m.name || '') + name;
+        const newBuffer = this.buffers.get(actual) + chunk;
+        this.buffers.set(actual, newBuffer);
+        // Derinlik takibi — sadece string DIŞINDAKİ ayraçları say
+        let depth = this.depths.get(actual);
+        let inString = this.inStrings.get(actual);
+        let escape = this.escapes.get(actual);
+        for (const ch of chunk) {
+            if (!inString) {
+                if (ch === '{' || ch === '[')
+                    depth++;
+                else if (ch === '}' || ch === ']')
+                    depth--;
+            }
+            if (ch === '"' && !escape)
+                inString = !inString;
+            escape = ch === '\\' && !escape;
+        }
+        this.depths.set(actual, depth);
+        this.inStrings.set(actual, inString);
+        this.escapes.set(actual, escape);
+        if (depth === 0 && newBuffer.trim().length > 0) {
+            try {
+                return { complete: true, value: JSON.parse(newBuffer) };
+            }
+            catch {
+                return { complete: false };
+            }
+        }
+        return { complete: false };
+    }
+    /** Stream bittiğinde (finish_reason) çağrılır. name'i olan ve buffer'ı dolu tüm çağrıları döndürür. */
+    getCompleted() {
+        const out = [];
+        for (const [index, buffer] of this.buffers.entries()) {
+            const m = this.meta.get(index);
+            if (!m?.name)
+                continue; // isimsiz parça → çağrı değil
+            // Boş buffer = argümansız tool (ör. {}). safeJsonParse onarım dener, başarısızsa {} fallback.
+            const args = buffer.trim() ? safeJsonParse(buffer, {}) : {};
+            out.push({ id: m.id || `call_${index}`, name: m.name, args, index });
+        }
+        return out;
+    }
+    reset() {
+        this.buffers.clear();
+        this.depths.clear();
+        this.inStrings.clear();
+        this.escapes.clear();
+        this.meta.clear();
+        this.idToIndex.clear();
+        this.nextIndex = 0;
+    }
+    findNextIndex() {
+        while (this.buffers.has(this.nextIndex)) {
+            const buf = this.buffers.get(this.nextIndex);
+            const depth = this.depths.get(this.nextIndex);
+            const m = this.meta.get(this.nextIndex);
+            if (!buf.trim() || depth > 0 || !m?.id)
+                return this.nextIndex;
+            try {
+                JSON.parse(buf);
+                if (depth === 0) {
+                    this.nextIndex++;
+                    continue;
+                }
+            }
+            catch {
+                return this.nextIndex;
+            }
+            this.nextIndex++;
+        }
+        return this.nextIndex++;
+    }
+    findMostRecentIncomplete() {
+        let maxIndex = -1;
+        for (const [index, buffer] of this.buffers.entries()) {
+            const depth = this.depths.get(index);
+            const m = this.meta.get(index);
+            if (m?.id && (depth > 0 || !buffer.trim())) {
+                maxIndex = Math.max(maxIndex, index);
+            }
+            else if (buffer.trim()) {
+                try {
+                    JSON.parse(buffer);
+                }
+                catch {
+                    maxIndex = Math.max(maxIndex, index);
+                }
+            }
+        }
+        return maxIndex >= 0 ? maxIndex : this.findNextIndex();
+    }
+}