wormclaude 1.0.14 → 1.0.16

package/dist/subagents.js

@@ -0,0 +1,119 @@
+// İsimli/uzman alt-ajan tanımları + kullanıcı-seviyesi loader.
+// Agent tool'u opsiyonel `subagent_type` ile çağrılınca buradan uzman prompt + tool-kısıtı çözülür.
+// Gemini builtin-agents + subagent-manager'dan uyarlandı; WormClaude güvenlik kimliğine göre.
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+// ── Gömülü uzman ajanlar ──────────────────────────────────────────────────────
+const BUILTINS = [
+    {
+        name: 'general-purpose',
+        description: 'Karmaşık soruları araştırma, kod arama ve çok adımlı görevler için genel amaçlı ajan.',
+        system: 'Sen bir WormClaude alt-ajanısın: tek bir görevi uçtan uca bitirmek için doğmuş otonom bir işçi. ' +
+            'İstenen neyse onu yap — fazlası değil, eksiği değil. Geniş arama için Grep/Glob, bilinen yol için Read kullan. ' +
+            'Gereksiz dosya YARATMA; *.md/README dosyalarını yalnız açıkça istenirse oluştur. ' +
+            'Bu görev dışında hafızan yok. Bitince yaptıklarının ve istenen sonuçların kısa, net bir raporunu döndür. ' +
+            'Yanıtta paylaştığın dosya yolları MUTLAK olmalı; göreli yol kullanma. Emoji kullanma.',
+    },
+    {
+        name: 'security-recon',
+        description: 'YETKİLİ güvenlik testlerinde keşif: port/servis/teknoloji tespiti, yüzey analizi, raporlama.',
+        system: 'Sen bir WormClaude güvenlik-keşif alt-ajanısın. SADECE yetkili/izinli hedeflerde çalış. ' +
+            'Görevin: pasif ve aktif keşif (port/servis tespiti, teknoloji parmak izi, dizin/endpoint yüzeyi, ' +
+            'sürüm tespiti) yapıp bulgularını yapılandırılmış bir rapor olarak döndürmek. ' +
+            'Yıkıcı işlem, gerçek istismar veya hizmet-dışı bırakma YAPMA — yalnız keşif ve analiz. ' +
+            'Bulguları önem derecesiyle (bilgi/düşük/orta/yüksek) sınıflandır. Komut çıktısını ham bırakma, yorumla. Emoji kullanma.',
+        tools: ['Bash', 'Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'TaskOutput'],
+    },
+    {
+        name: 'code-explorer',
+        description: 'Büyük kod tabanlarını haritalama: mimari, modül ilişkileri, giriş noktaları.',
+        system: 'Sen bir WormClaude kod-keşif alt-ajanısın. Görevin bir kod tabanını hızla haritalamak: ' +
+            'dizin yapısı, ana modüller, giriş noktaları, önemli soyutlamalar ve bağımlılıklar. ' +
+            'Grep/Glob ile geniş tara, Read ile kritik dosyaları incele. Dosya YARATMA/DEĞİŞTİRME. ' +
+            'Sonucu: kısa mimari özet + ilgili dosya yolları (MUTLAK) + kod parçaları olarak döndür. Emoji kullanma.',
+        tools: ['Grep', 'Glob', 'Read', 'TaskOutput'],
+    },
+];
+// ── Kullanıcı-seviyesi ajanlar: ~/.wormclaude/agents/*.md ─────────────────────
+function agentsDir() {
+    return path.join(os.homedir(), '.wormclaude', 'agents');
+}
+/** Minimal frontmatter ayrıştırma (yaml-parser gelene kadar; name/description/tools + body). */
+function parseAgentFile(content, fallbackName) {
+    const m = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/.exec(content);
+    if (!m)
+        return null;
+    const [, fm, body] = m;
+    const get = (key) => {
+        const r = new RegExp(`^${key}\\s*:\\s*(.+)$`, 'mi').exec(fm);
+        return r ? r[1].trim().replace(/^["']|["']$/g, '') : undefined;
+    };
+    const name = (get('name') || fallbackName).trim();
+    const description = get('description') || '';
+    const system = body.trim();
+    if (!name || !system)
+        return null;
+    // tools: [A, B] veya A,B
+    let tools;
+    const rawTools = get('tools');
+    if (rawTools) {
+        tools = rawTools.replace(/[\[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean);
+        if (!tools.length)
+            tools = undefined;
+    }
+    // İsim guard: rezerve/biçim
+    const RESERVED = new Set(['self', 'system', 'user', 'model', 'tool', 'config', 'default']);
+    if (!/^[a-zA-Z0-9_-]{2,50}$/.test(name) || RESERVED.has(name.toLowerCase()))
+        return null;
+    return { name, description, system, tools };
+}
+function loadUserAgents() {
+    try {
+        const dir = agentsDir();
+        if (!fs.existsSync(dir))
+            return [];
+        return fs.readdirSync(dir)
+            .filter((f) => f.endsWith('.md'))
+            .map((f) => {
+            try {
+                const def = parseAgentFile(fs.readFileSync(path.join(dir, f), 'utf8'), f.replace(/\.md$/, ''));
+                return def;
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((d) => d !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/** Ajanı isme göre çöz. Öncelik: kullanıcı dosyası > gömülü. Bulunamazsa null. */
+export function resolveSubagent(type) {
+    if (!type)
+        return null;
+    const t = type.trim().toLowerCase();
+    const user = loadUserAgents().find((a) => a.name.toLowerCase() === t);
+    if (user)
+        return user;
+    return BUILTINS.find((a) => a.name.toLowerCase() === t) || null;
+}
+/** Tüm kullanılabilir ajanları listele (kullanıcı dosyaları gömülüleri gölgeler). */
+export function listSubagents() {
+    const seen = new Set();
+    const out = [];
+    for (const a of [...loadUserAgents(), ...BUILTINS]) {
+        const k = a.name.toLowerCase();
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(a);
+    }
+    return out;
+}
+/** Agent tool açıklamasına eklenecek "kullanılabilir tipler" satırı. */
+export function subagentTypesHint() {
+    return listSubagents().map((a) => `- ${a.name}: ${a.description}`).join('\n');
+}

package/dist/textclean.js

@@ -0,0 +1,37 @@
+// Model metnindeki sızıntıları temizler: özel tokenlar + parçalı tool-call markup.
+// Qwen-14B + vLLM(hermes) bazen ham çıktıya kontrol token'ları veya tool-call etiketleri sızdırır.
+// ChatML / Qwen özel token'ları
+const SPECIAL_TOKENS = [
+    '<|endoftext|>', '<|im_start|>', '<|im_end|>', '<|im_sep|>',
+    '<|endofturn|>', '<|fim_prefix|>', '<|fim_middle|>', '<|fim_suffix|>',
+];
+// Hermes tool-call markup (metne sızarsa) — bloğun TAMAMINI kaldır.
+const TOOL_CALL_BLOCK = /<tool_call>[\s\S]*?<\/tool_call>/g;
+const TOOL_RESPONSE_BLOCK = /<tool_response>[\s\S]*?<\/tool_response>/g;
+// Açık kalan (kapanışı gelmemiş) tek etiketler
+const STRAY_TOOL_TAGS = /<\/?(tool_call|tool_response)>/g;
+/**
+ * Görüntülenecek/saklanacak model metnini temizler. İçeriği bozmadan yalnız
+ * sızan kontrol token'larını ve tool-call markup'ını çıkarır.
+ */
+export function cleanModelText(text) {
+    if (!text)
+        return text;
+    let out = text;
+    out = out.replace(TOOL_CALL_BLOCK, '');
+    out = out.replace(TOOL_RESPONSE_BLOCK, '');
+    out = out.replace(STRAY_TOOL_TAGS, '');
+    for (const tok of SPECIAL_TOKENS) {
+        if (out.includes(tok))
+            out = out.split(tok).join('');
+    }
+    return out;
+}
+/**
+ * Streaming sırasında güvenli temizlik: yalnız TAM özel-token'ları ve kapanmış blokları
+ * temizler — yarım gelen bir etiketi (ör. "<tool_") sonraki chunk'ı bekleyeceği için bırakır.
+ * Akan tamponun tamamına uygulanır (parçalı token'ı bölmemek için).
+ */
+export function cleanStreamingBuffer(buffer) {
+    return cleanModelText(buffer);
+}

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

@@ -8,6 +8,8 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { loadConfig } from './api.js';
 import { runAgentLoop } from './agent.js';
+import { resolveSubagent, subagentTypesHint } from './subagents.js';
+import { saveMemoryFact } from './memory.js';
 import { tasks } from './tasks.js';
 import { getMcpToolSchemas, callMcpTool } from './mcp.js';
 import { getSkills, getSkill, buildSkillPrompt } from './skills.js';
@@ -25,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();
@@ -301,12 +344,13 @@ export const toolSchemas = [
         type: 'function',
         function: {
             name: 'Agent',
-            description: AGENT_DESCRIPTION,
+            description: AGENT_DESCRIPTION + '\n\nAvailable subagent_type values (specialized prompt + restricted tools):\n' + subagentTypesHint(),
             parameters: {
                 type: 'object',
                 properties: {
                     description: { type: 'string', description: 'A short (3-5 word) description of the task' },
                     prompt: { type: 'string', description: 'The detailed, self-contained task for the sub-agent to perform' },
+                    subagent_type: { type: 'string', description: 'Optional: specialized agent to use (e.g. general-purpose, security-recon, code-explorer). Selects a tailored system prompt and a restricted tool set. Omit for a general sub-agent.' },
                     run_in_background: { type: 'boolean', description: 'Run the sub-agent in the background and return a task id (default false)' },
                 },
                 required: ['description', 'prompt'],
@@ -327,6 +371,21 @@ export const toolSchemas = [
             },
         },
     },
+    {
+        type: 'function',
+        function: {
+            name: 'SaveMemory',
+            description: 'Save a single concise fact to long-term memory so it persists across sessions. Use when the user explicitly asks you to remember something, or when you detect a durable preference, decision, project convention, or constraint worth keeping. Keep the fact short and self-contained. Do NOT use for transient or session-only details.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    fact: { type: 'string', description: 'The specific, self-contained fact to remember (e.g. "User prefers Turkish responses", "Project uses pnpm not npm").' },
+                    scope: { type: 'string', enum: ['project', 'global'], description: 'project = this project only (default), global = all projects.' },
+                },
+                required: ['fact'],
+            },
+        },
+    },
     {
         type: 'function',
         function: {
@@ -540,6 +599,7 @@ const TOOL_META = {
     Scroll: { needsPermission: true, validate: (a) => (a && a.direction ? null : 'direction gerekli') },
     WebSearch: { readOnly: true, needsPermission: true, validate: (a) => (a && a.query ? null : 'query gerekli') },
     TodoWrite: { readOnly: true, validate: (a) => (a && Array.isArray(a.todos) ? null : 'todos dizisi gerekli') },
+    SaveMemory: { validate: (a) => (a && a.fact && String(a.fact).trim() ? null : 'fact gerekli') },
     PowerShell: { needsPermission: true, validate: (a) => (a && a.command ? null : 'command gerekli') },
     NotebookEdit: { needsPermission: true, validate: (a) => (a && a.notebook_path ? null : 'notebook_path gerekli') },
     REPL: { needsPermission: true, validate: (a) => (a && a.language && a.code ? null : 'language ve code gerekli') },
@@ -664,13 +724,53 @@ export async function executeToolCalls(calls, hooks) {
     return results;
 }
 // Alt-agent'a verilecek araç seti (özyineleme/iç içe agent engellenir).
-function subAgentTools() {
-    return allToolSchemas().filter((t) => t.function.name !== 'Agent' && t.function.name !== 'Skill');
+// allow verilirse yalnız o adlardaki araçlar bırakılır (uzman ajan tool-kısıtı).
+function subAgentTools(allow) {
+    let list = allToolSchemas().filter((t) => t.function.name !== 'Agent' && t.function.name !== 'Skill');
+    if (allow && allow.length) {
+        const set = new Set(allow);
+        const filtered = list.filter((t) => set.has(t.function.name));
+        if (filtered.length)
+            list = filtered; // boş kalırsa kısıtı yok say (güvenli geri dönüş)
+    }
+    return list;
 }
 const SUBAGENT_SYSTEM = 'You are a WormClaude sub-agent: an autonomous worker spawned to complete one specific task. ' +
     'Use your tools (Bash, Read, Write, Edit, Glob, Grep, WebFetch, TaskOutput) to do the work, ' +
     'then return a concise final report of what you did and any results requested. ' +
     'You have no memory beyond this task. Be thorough and finish the task end-to-end.';
+// Levenshtein mesafesi (küçük, dep'siz) — bilinmeyen tool adına en yakın öneriler.
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    if (!m)
+        return n;
+    if (!n)
+        return m;
+    let prev = Array.from({ length: n + 1 }, (_, i) => i);
+    let cur = new Array(n + 1);
+    for (let i = 1; i <= m; i++) {
+        cur[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+        }
+        [prev, cur] = [cur, prev];
+    }
+    return prev[n];
+}
+// Bilinmeyen tool adı için " Did you mean 'X'?" önerisi (en yakın ≤3, makul mesafe).
+function suggestTools(unknown) {
+    const names = allToolSchemas().map((t) => t.function.name);
+    const ranked = names
+        .map((n) => ({ n, d: levenshtein(unknown.toLowerCase(), n.toLowerCase()) }))
+        .filter((x) => x.d <= Math.max(3, Math.floor(unknown.length / 2)))
+        .sort((a, b) => a.d - b.d)
+        .slice(0, 3)
+        .map((x) => `"${x.n}"`);
+    if (!ranked.length)
+        return '';
+    return ranked.length > 1 ? ` Did you mean one of: ${ranked.join(', ')}?` : ` Did you mean ${ranked[0]}?`;
+}
 export function toolLabel(name, args) {
     try {
         if (name === 'Bash')
@@ -688,9 +788,11 @@ export function toolLabel(name, args) {
         if (name === 'WebFetch')
             return `WebFetch(${args.url})`;
         if (name === 'Agent')
-            return `Agent(${args.description || ''}${args.run_in_background ? ', bg' : ''})`;
+            return `Agent(${args.description || ''}${args.subagent_type ? ':' + args.subagent_type : ''}${args.run_in_background ? ', bg' : ''})`;
         if (name === 'TaskOutput')
             return `TaskOutput(${args.task_id})`;
+        if (name === 'SaveMemory')
+            return `SaveMemory(${String(args.fact || '').slice(0, 50)})`;
         if (name === 'Skill')
             return `Skill(${args.name})`;
         if (name === 'WebSearch')
@@ -755,9 +857,9 @@ function walk(dir, out, depth = 0) {
 function globToRegex(pattern) {
     let re = pattern
         .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*\*/g, '')
+        .replace(/\*\*/g, '\u0000')
         .replace(/\*/g, '[^/\\\\]*')
-        .replace(//g, '.*')
+        .replace(/\u0000/g, '.*')
         .replace(/\?/g, '.');
     return new RegExp(re + '$', 'i');
 }
@@ -819,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()));
@@ -833,14 +935,16 @@ 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') {
+            // Uzman ajan seçimi: subagent_type verilirse özel prompt + tool-kısıtı uygulanır.
+            const def = resolveSubagent(args.subagent_type);
+            const sysPrompt = def ? def.system : SUBAGENT_SYSTEM;
+            const subTools = subAgentTools(def?.tools);
             const subMessages = [
-                { role: 'system', content: SUBAGENT_SYSTEM },
+                { role: 'system', content: sysPrompt },
                 { role: 'user', content: String(args.prompt || '') },
             ];
             if (args.run_in_background) {
@@ -850,7 +954,7 @@ export async function executeTool(name, args) {
                         const { finalText } = await runAgentLoop({
                             config: cfg(),
                             messages: subMessages,
-                            tools: subAgentTools(),
+                            tools: subTools,
                             executeTool,
                             hooks: {
                                 onText: (t) => tasks.append(task.id, t),
@@ -870,7 +974,7 @@ export async function executeTool(name, args) {
             const { finalText } = await runAgentLoop({
                 config: cfg(),
                 messages: subMessages,
-                tools: subAgentTools(),
+                tools: subTools,
                 executeTool,
             });
             return { ok: true, output: finalText || '(sub-agent returned no text)' };
@@ -882,6 +986,16 @@ export async function executeTool(name, args) {
             const body = t.output.slice(-9000) || '(no output yet)';
             return { ok: true, output: `[${t.id}] ${t.kind} · ${t.status} · ${t.label}\n\n${body}` };
         }
+        if (name === 'SaveMemory') {
+            try {
+                const scope = args.scope === 'global' ? 'global' : 'project';
+                const file = saveMemoryFact(String(args.fact || ''), scope);
+                return { ok: true, output: `Hatıra kaydedildi (${scope}): "${String(args.fact).trim()}" → ${file}` };
+            }
+            catch (e) {
+                return { ok: false, output: `Hatıra kaydedilemedi: ${e?.message || e}` };
+            }
+        }
         if (name === 'Read') {
             const fp = args.file_path;
             if (!fs.existsSync(fp))
@@ -1220,7 +1334,7 @@ export async function executeTool(name, args) {
         }
         if (name.startsWith('mcp__'))
             return await callMcpTool(name, args);
-        return { ok: false, output: `Unknown tool: ${name}` };
+        return { ok: false, output: `Unknown tool: ${name}.${suggestTools(name)} Use exactly the registered tool names.` };
     }
     catch (e) {
         return { ok: false, output: `Error: ${e?.message || String(e)}` };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wormclaude",
-  "version": "1.0.14",
+  "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",