wormclaude 1.0.15 → 1.0.16

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/cli.js

@@ -8,6 +8,8 @@ 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';
@@ -221,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;
@@ -665,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];
@@ -760,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/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/theme.js

@@ -8,4 +8,4 @@ export const theme = {
     green: '#4ade80',
     errorRed: '#ff6b6b',
 };
-export const VERSION = '1.0.14';
+export const VERSION = '1.0.16';

package/dist/tools.js

@@ -27,6 +27,47 @@ export function getTodos() { return todosStore; }
 const MAX_LINES_TO_READ = 2000;
 const DEFAULT_BASH_TIMEOUT_MS = 120000;
 const MAX_BASH_TIMEOUT_MS = 600000;
+// Bash çalışma dizini — oturum boyunca kalıcı. execSync her çağrıda taze shell açtığı için
+// `cd` normalde kaybolur; burada cwd'yi takip edip her komuta geçiriyoruz.
+let bashCwd;
+export function getBashCwd() { return bashCwd || process.cwd(); }
+export function setBashCwd(dir) { bashCwd = dir; }
+// Komutu çalıştırır ve sonrasında cwd değişikliğini (cd) yakalayıp bashCwd'yi günceller.
+// POSIX: pwd'yi temp dosyaya yazan, çıkış kodunu KORUYAN sarmalayıcı (hata propagasyonu bozulmaz).
+// Windows: komutu olduğu gibi çalıştır, sonra baştaki `cd <hedef>`'i regex ile yakala (best-effort).
+function runBashCapturingCwd(command, timeout) {
+    const cwd = getBashCwd();
+    const opts = { encoding: 'utf8', timeout, maxBuffer: 10 * 1024 * 1024, windowsHide: true, cwd };
+    if (process.platform === 'win32') {
+        const out = execSync(command, opts);
+        // best-effort: "cd <hedef>" / "cd /d <hedef>" (zincirsiz tek komut)
+        const m = /^\s*cd\s+(?:\/d\s+)?"?([^"&|<>]+?)"?\s*$/i.exec(command);
+        if (m) {
+            const nd = path.resolve(cwd, m[1].trim());
+            try {
+                if (fs.statSync(nd).isDirectory())
+                    bashCwd = nd;
+            }
+            catch { /* yok say */ }
+        }
+        return out;
+    }
+    // POSIX
+    const pwdFile = path.join(os.tmpdir(), `wc_pwd_${process.pid}_${Date.now()}.tmp`);
+    const wrapped = `{ ${command}\n}; __wc=$?; pwd > '${pwdFile}' 2>/dev/null; exit $__wc`;
+    try {
+        return execSync(wrapped, { ...opts, shell: '/bin/sh' });
+    }
+    finally {
+        try {
+            const p = fs.readFileSync(pwdFile, 'utf8').trim();
+            if (p)
+                bashCwd = p;
+            fs.unlinkSync(pwdFile);
+        }
+        catch { /* dosya yoksa yok say */ }
+    }
+}
 // WormClaude davranışı: bir dosyayı düzenlemeden/üzerine yazmadan önce
 // en az bir kez okumuş olman gerekir. Okunan dosyaları burada izliyoruz.
 const readFiles = new Set();
@@ -880,7 +921,7 @@ export async function executeTool(name, args) {
         if (name === 'Bash') {
             if (args.run_in_background) {
                 const task = tasks.create('shell', String(args.command).slice(0, 60));
-                const child = spawn(String(args.command), { shell: true, windowsHide: true });
+                const child = spawn(String(args.command), { shell: true, windowsHide: true, cwd: getBashCwd() });
                 task.child = child;
                 child.stdout?.on('data', (d) => tasks.append(task.id, d.toString()));
                 child.stderr?.on('data', (d) => tasks.append(task.id, d.toString()));
@@ -894,9 +935,7 @@ export async function executeTool(name, args) {
             let timeout = Number(args.timeout) || DEFAULT_BASH_TIMEOUT_MS;
             if (timeout > MAX_BASH_TIMEOUT_MS)
                 timeout = MAX_BASH_TIMEOUT_MS;
-            const out = execSync(String(args.command), {
-                encoding: 'utf8', timeout, maxBuffer: 10 * 1024 * 1024, windowsHide: true,
-            });
+            const out = runBashCapturingCwd(String(args.command), timeout);
             return { ok: true, output: (out || '(no output)').slice(0, 20000) };
         }
         if (name === 'Agent') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wormclaude",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "WormClaude CLI - uncensored security+code assistant (ink TUI, Claude-style)",
   "type": "module",
   "bin": {
@@ -19,7 +19,8 @@
     "ink": "^5.0.1",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
-    "react": "^18.3.1"
+    "react": "^18.3.1",
+    "string-width": "^7.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",