wormclaude 1.0.0

package/dist/skills.js

@@ -0,0 +1,275 @@
+// Skill sistemi — klasör-tabanlı (manifest) + registry + install/update/remove.
+// Claude Code skills/ mimarisinin uyarlaması. Kod gerektirmez; markdown + skill.json.
+//
+//   .wormclaude/skills/<ad>/
+//     skill.json   { name, description, autoInvoke, context, tools, whenToUse }
+//     prompt.md    (uzmanlık talimatı = gövde)
+//     examples.md  (opsiyonel)  · templates/ assets/ (opsiyonel, model Read ile kullanır)
+//
+// Geriye uyumluluk: .wormclaude/skills/<ad>.md (frontmatter'lı düz dosya) da çalışır.
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { getLang } from './i18n.js';
+let SKILLS = [];
+const SKILLS_DIR = path.join(process.cwd(), '.wormclaude', 'skills');
+export function getSkillsDir() { return SKILLS_DIR; }
+function parseFrontmatter(raw) {
+    if (!raw.startsWith('---'))
+        return { fm: {}, body: raw };
+    const end = raw.indexOf('\n---', 3);
+    if (end === -1)
+        return { fm: {}, body: raw };
+    const fm = {};
+    for (const line of raw.slice(3, end).trim().split('\n')) {
+        const i = line.indexOf(':');
+        if (i > 0)
+            fm[line.slice(0, i).trim()] = line.slice(i + 1).trim().replace(/^["']|["']$/g, '');
+    }
+    return { fm, body: raw.slice(end + 4).replace(/^\r?\n/, '') };
+}
+function readFirst(dir, names) {
+    for (const n of names) {
+        try {
+            return fs.readFileSync(path.join(dir, n), 'utf8');
+        }
+        catch { }
+    }
+    return '';
+}
+export function loadSkills() {
+    SKILLS = [];
+    let entries = [];
+    try {
+        entries = fs.readdirSync(SKILLS_DIR, { withFileTypes: true });
+    }
+    catch {
+        return SKILLS;
+    }
+    for (const e of entries) {
+        const full = path.join(SKILLS_DIR, e.name);
+        if (e.isDirectory()) {
+            // Klasör skill'i: skill.json + prompt.md
+            let manifest = {};
+            try {
+                manifest = JSON.parse(fs.readFileSync(path.join(full, 'skill.json'), 'utf8'));
+            }
+            catch { }
+            const body = readFirst(full, ['prompt.md', 'skill.md', 'SKILL.md']);
+            if (!body && !manifest.name)
+                continue; // skill değil
+            const name = (manifest.name || e.name).trim().replace(/[^a-zA-Z0-9_-]/g, '-');
+            SKILLS.push({
+                name,
+                description: manifest.description || body.split('\n').find((l) => l.trim())?.slice(0, 80) || name,
+                whenToUse: manifest.whenToUse,
+                context: manifest.context === 'fork' ? 'fork' : 'inline',
+                autoInvoke: !!manifest.autoInvoke,
+                tools: Array.isArray(manifest.tools) ? manifest.tools : undefined,
+                body: body.trim(),
+                dir: full,
+            });
+        }
+        else if (e.name.endsWith('.md')) {
+            // Eski düz .md (frontmatter)
+            let raw = '';
+            try {
+                raw = fs.readFileSync(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const { fm, body } = parseFrontmatter(raw);
+            const name = (fm.name || e.name.replace(/\.md$/, '')).trim().replace(/[^a-zA-Z0-9_-]/g, '-');
+            if (!name)
+                continue;
+            SKILLS.push({
+                name,
+                description: fm.description || body.split('\n').find((l) => l.trim())?.slice(0, 80) || name,
+                whenToUse: fm.whenToUse,
+                context: fm.context === 'fork' ? 'fork' : 'inline',
+                autoInvoke: fm.autoInvoke === 'true',
+                tools: fm.tools ? fm.tools.split(',').map((s) => s.trim()) : undefined,
+                body: body.trim(),
+            });
+        }
+    }
+    return SKILLS;
+}
+export function getSkills() { return SKILLS; }
+export function getSkill(name) { return SKILLS.find((s) => s.name === name); }
+export function getAutoSkills() { return SKILLS.filter((s) => s.autoInvoke); }
+// Skill gövdesi + (klasör skill'iyse) dosya referansı + kullanıcı argümanı → prompt.
+export function buildSkillPrompt(skill, args) {
+    const en = getLang() === 'en';
+    let p = skill.body;
+    if (skill.dir) {
+        p = (en
+            ? `Skill base directory: ${skill.dir}\n(You may Read/Grep files here — examples.md, templates/, assets/ — as needed.)\n\n`
+            : `Skill kök dizini: ${skill.dir}\n(Gerekirse buradaki dosyaları Read/Grep ile oku — examples.md, templates/, assets/.)\n\n`) + p;
+    }
+    if (args && args.trim()) {
+        p += (en ? '\n\n## Additional context from user\n\n' : '\n\n## Kullanıcıdan ek bağlam\n\n') + args.trim();
+    }
+    return p;
+}
+// ── Registry ──────────────────────────────────────────────────────────────────
+// Kaynak: WORMCLAUDE_SKILL_REGISTRY (URL) veya yerel .wormclaude/registry.json
+// Biçim: { "skills": { "pentest": { "repo": "owner/repo", "description": "..." } } }
+const REGISTRY_URL = process.env.WORMCLAUDE_SKILL_REGISTRY || '';
+const LOCAL_REGISTRY = path.join(process.cwd(), '.wormclaude', 'registry.json');
+export async function getRegistry() {
+    try {
+        if (REGISTRY_URL) {
+            const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(15000) });
+            if (res.ok) {
+                const j = await res.json();
+                return j.skills || j || {};
+            }
+        }
+    }
+    catch { }
+    try {
+        const j = JSON.parse(fs.readFileSync(LOCAL_REGISTRY, 'utf8'));
+        return j.skills || j || {};
+    }
+    catch { }
+    return {};
+}
+function copyDir(src, dst) {
+    fs.mkdirSync(dst, { recursive: true });
+    for (const e of fs.readdirSync(src, { withFileTypes: true })) {
+        if (e.name === '.git')
+            continue;
+        const s = path.join(src, e.name), d = path.join(dst, e.name);
+        if (e.isDirectory())
+            copyDir(s, d);
+        else
+            fs.copyFileSync(s, d);
+    }
+}
+// Skill kur. source: registry adı | owner/repo | git url | https://.../x.md
+// Döner: { names, error }
+export async function installSkill(source) {
+    const en = getLang() === 'en';
+    fs.mkdirSync(SKILLS_DIR, { recursive: true });
+    // 1) Tek .md indirme
+    if (/^https?:\/\/\S+\.md$/i.test(source)) {
+        try {
+            const res = await fetch(source, { signal: AbortSignal.timeout(20000) });
+            if (!res.ok)
+                return { names: [], error: `HTTP ${res.status}` };
+            const fname = (source.split('/').pop() || 'skill.md').replace(/[^\w.-]/g, '_');
+            fs.writeFileSync(path.join(SKILLS_DIR, fname), await res.text());
+            loadSkills();
+            return { names: [fname.replace(/\.md$/, '')] };
+        }
+        catch (e) {
+            return { names: [], error: e?.message || String(e) };
+        }
+    }
+    // 2) Kaynağı çöz: registry adı / owner-repo / url
+    let repo = '';
+    let nameHint = '';
+    const reg = await getRegistry();
+    if (reg[source]) {
+        repo = reg[source].repo;
+        nameHint = source;
+    }
+    else if (/^[\w.-]+\/[\w.-]+$/.test(source))
+        repo = `https://github.com/${source}`;
+    else if (/^https?:\/\//i.test(source))
+        repo = source;
+    else
+        return { names: [], error: en ? 'Invalid source' : 'Geçersiz kaynak' };
+    if (/^[\w.-]+\/[\w.-]+$/.test(repo))
+        repo = `https://github.com/${repo}`;
+    const tmp = path.join(os.tmpdir(), `wc-skill-${Date.now()}`);
+    try {
+        execSync(`git clone --depth 1 ${repo} "${tmp}"`, { timeout: 60000, windowsHide: true, stdio: 'pipe' });
+    }
+    catch (gitErr) {
+        try {
+            fs.rmSync(tmp, { recursive: true, force: true });
+        }
+        catch { }
+        const msg = String(gitErr?.stderr || gitErr?.message || '');
+        if (/not found|could not read|repository .* not found|fatal: repository/i.test(msg))
+            return { names: [], error: en ? `Repo not found: ${repo}` : `Repo bulunamadı: ${repo}` };
+        if (/not recognized|command not found|'git'/i.test(msg))
+            return { names: [], error: en ? 'git is not installed' : 'git kurulu değil' };
+        return { names: [], error: msg.split('\n')[0].slice(0, 120) };
+    }
+    const installed = [];
+    const place = (srcDir, name) => {
+        const dst = path.join(SKILLS_DIR, name);
+        copyDir(srcDir, dst);
+        try {
+            fs.writeFileSync(path.join(dst, '.source'), repo);
+        }
+        catch { } // update için
+        installed.push(name);
+    };
+    if (fs.existsSync(path.join(tmp, 'skill.json'))) {
+        // Repo kökü tek skill
+        let nm = nameHint;
+        try {
+            nm = nm || JSON.parse(fs.readFileSync(path.join(tmp, 'skill.json'), 'utf8')).name;
+        }
+        catch { }
+        nm = (nm || repo.split('/').pop().replace(/\.git$/, '')).replace(/[^\w-]/g, '-');
+        place(tmp, nm);
+    }
+    else if (fs.existsSync(path.join(tmp, 'skills'))) {
+        // Repo içinde skills/ — her alt klasör (skill.json olan) bir skill
+        for (const e of fs.readdirSync(path.join(tmp, 'skills'), { withFileTypes: true })) {
+            if (e.isDirectory() && fs.existsSync(path.join(tmp, 'skills', e.name, 'skill.json'))) {
+                place(path.join(tmp, 'skills', e.name), e.name.replace(/[^\w-]/g, '-'));
+            }
+        }
+    }
+    else {
+        // Düz .md'ler (README hariç)
+        for (const e of fs.readdirSync(tmp, { withFileTypes: true })) {
+            if (e.isFile() && e.name.endsWith('.md') && e.name.toLowerCase() !== 'readme.md') {
+                fs.copyFileSync(path.join(tmp, e.name), path.join(SKILLS_DIR, e.name));
+                installed.push(e.name.replace(/\.md$/, ''));
+            }
+        }
+    }
+    try {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+    catch { }
+    loadSkills();
+    return { names: installed };
+}
+// Skill güncelle (kayıtlı .source repo'sundan yeniden çek)
+export async function updateSkill(name) {
+    const dir = path.join(SKILLS_DIR, name);
+    let repo = '';
+    try {
+        repo = fs.readFileSync(path.join(dir, '.source'), 'utf8').trim();
+    }
+    catch { }
+    if (!repo)
+        return { ok: false, error: getLang() === 'en' ? 'No source info (.source) for this skill' : 'Bu skill için kaynak (.source) yok' };
+    const res = await installSkill(repo);
+    return { ok: res.names.length > 0, error: res.error };
+}
+export function removeSkill(name) {
+    const dir = path.join(SKILLS_DIR, name);
+    const md = path.join(SKILLS_DIR, name.endsWith('.md') ? name : name + '.md');
+    try {
+        if (fs.existsSync(dir))
+            fs.rmSync(dir, { recursive: true, force: true });
+        else
+            fs.unlinkSync(md);
+        loadSkills();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tasks.js

@@ -0,0 +1,63 @@
+// Faz 1 — Arka plan görev kayıt defteri.
+// Hem arka plan shell komutlarını (LocalShellTask) hem de arka plan alt-agent'larını
+// (LocalAgentTask) ve hafıza konsolidasyonunu (DreamTask) izler.
+import { EventEmitter } from 'node:events';
+class TaskRegistry extends EventEmitter {
+    tasks = new Map();
+    counters = { shell: 0, agent: 0, dream: 0 };
+    create(kind, label) {
+        const id = `${kind}_${++this.counters[kind]}`;
+        const task = { id, kind, label, status: 'running', output: '', startedAt: Date.now() };
+        this.tasks.set(id, task);
+        this.emit('change');
+        return task;
+    }
+    get(id) {
+        return this.tasks.get(id);
+    }
+    list() {
+        return [...this.tasks.values()].sort((a, b) => b.startedAt - a.startedAt);
+    }
+    running() {
+        return this.list().filter((t) => t.status === 'running');
+    }
+    append(id, text) {
+        const t = this.tasks.get(id);
+        if (!t)
+            return;
+        t.output += text;
+        if (t.output.length > 200000)
+            t.output = t.output.slice(-200000);
+        this.emit('change');
+    }
+    finish(id, status) {
+        const t = this.tasks.get(id);
+        if (!t)
+            return;
+        t.status = status;
+        t.endedAt = Date.now();
+        this.emit('change');
+    }
+    stop(id) {
+        const t = this.tasks.get(id);
+        if (!t || t.status !== 'running')
+            return false;
+        try {
+            t.child?.kill();
+        }
+        catch { }
+        try {
+            t.onStop?.();
+        }
+        catch { }
+        this.finish(id, 'stopped');
+        return true;
+    }
+    clearFinished() {
+        for (const [id, t] of this.tasks)
+            if (t.status !== 'running')
+                this.tasks.delete(id);
+        this.emit('change');
+    }
+}
+export const tasks = new TaskRegistry();

package/dist/theme.js

@@ -0,0 +1,11 @@
+// WormClaude renk teması — siyah zemin + kırmızı/gri/beyaz (WormGPT tarzı)
+export const theme = {
+    red: '#ff3b3b',
+    redBright: '#ff5c5c',
+    white: '#ffffff',
+    grey: '#9a9a9a',
+    greyDim: '#666666',
+    green: '#4ade80',
+    errorRed: '#ff6b6b',
+};
+export const VERSION = '1.0.0';

package/dist/tips.js

@@ -0,0 +1,60 @@
+// Spinner/footer ipuçları (TR/EN) — Claude Code tips/ uyarlaması.
+// LLM gerektirmez. Cooldown: en uzun süredir gösterilmeyen ipucu seçilir.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getLang } from './i18n.js';
+const TIPS = [
+    { id: 'mcp', tr: '.wormclaude/mcp.json ile MCP sunucu ekle, /mcp ile gör', en: 'Add MCP servers via .wormclaude/mcp.json, view with /mcp' },
+    { id: 'agent', tr: 'Büyük işleri bir alt-agent\'a yaptır — paralel çalışır', en: 'Delegate big tasks to a sub-agent — runs in parallel' },
+    { id: 'bg', tr: 'Uzun komutları arka planda çalıştır, /tasks ile izle', en: 'Run long commands in the background, track with /tasks' },
+    { id: 'compact', tr: '/compact ile bağlamı küçült; eşik aşılınca otomatik olur', en: '/compact shrinks context; auto-runs when the threshold is hit' },
+    { id: 'dream', tr: '/dream ile hafızayı .wormclaude/memory.md\'ye konsolide et', en: '/dream consolidates memory into .wormclaude/memory.md' },
+    { id: 'cost', tr: '/cost ile token ve maliyet kullanımını gör', en: '/cost shows token and cost usage' },
+    { id: 'model', tr: '/model qwen2.5:14b ile daha güçlü modele geç', en: '/model qwen2.5:14b switches to a stronger model' },
+    { id: 'review', tr: '/review ile git diff\'ini modele incelet', en: '/review lets the model review your git diff' },
+    { id: 'commit', tr: '/commit ile stage\'li değişikliklerden otomatik commit', en: '/commit auto-writes a commit from staged changes' },
+    { id: 'config', tr: '/config ile backend url/key/model ayarla', en: '/config sets backend url/key/model' },
+    { id: 'init', tr: '/init ile projeyi tarayıp WORMCLAUDE.md üret', en: '/init scans the project and generates WORMCLAUDE.md' },
+    { id: 'context', tr: '/context ile bağlam doluluğunu ve eşiği gör', en: '/context shows context fill and the threshold' },
+    { id: 'parallel', tr: 'Salt-okunur araçlar (Read/Grep/Glob) eşzamanlı çalışır', en: 'Read-only tools (Read/Grep/Glob) run concurrently' },
+    { id: 'export', tr: '/export ile sohbeti kaydet, /resume ile geri yükle', en: '/export saves the chat, /resume restores it' },
+    { id: 'lang', tr: '/lang ile arayüz dilini değiştir (tr/en)', en: '/lang changes the interface language (tr/en)' },
+];
+const FILE = path.join(process.cwd(), '.wormclaude', 'tips.json');
+function load() {
+    try {
+        return JSON.parse(fs.readFileSync(FILE, 'utf8'));
+    }
+    catch {
+        return { seq: 0, shown: {} };
+    }
+}
+function save(h) {
+    try {
+        fs.mkdirSync(path.dirname(FILE), { recursive: true });
+        fs.writeFileSync(FILE, JSON.stringify(h));
+    }
+    catch { }
+}
+// Bir ipucu seç (en uzun süredir gösterilmeyen) ve id'sini döndür. Dilden bağımsız.
+export function pickTipId() {
+    const h = load();
+    h.seq += 1;
+    let best = TIPS[0];
+    let bestSeq = Infinity;
+    for (const tp of TIPS) {
+        const s = h.shown[tp.id] ?? -1;
+        if (s < bestSeq) {
+            bestSeq = s;
+            best = tp;
+        }
+    }
+    h.shown[best.id] = h.seq;
+    save(h);
+    return best.id;
+}
+// id'nin metnini GÜNCEL dile göre döndürür (dil değişince güncellenir).
+export function tipText(id) {
+    const tp = TIPS.find((x) => x.id === id) ?? TIPS[0];
+    return getLang() === 'en' ? tp.en : tp.tr;
+}

package/dist/toolSummary.js

@@ -0,0 +1,24 @@
+// Araç-grubu özeti — Claude Code toolUseSummary/ uyarlaması.
+// Tamamlanan bir araç batch'ini tek satır git-commit-konusu tarzı etiketle özetler.
+import { completeText } from './agent.js';
+const SYSTEM = 'Bu araç çağrılarının ne başardığını anlatan KISA bir etiket yaz. Tek satır, ' +
+    '~50 karakter, git-commit konusu gibi (cümle değil). Sadece etiketi döndür.\n\n' +
+    'Örnekler:\n- auth/ içinde arandı\n- UserService\'te NPE düzeltildi\n- 3 dosya okundu';
+export async function summarizeTools(tools, config) {
+    if (!tools.length)
+        return null;
+    const desc = tools
+        .map((t) => `Araç: ${t.name}\nGirdi: ${JSON.stringify(t.args).slice(0, 200)}`)
+        .join('\n\n');
+    try {
+        const out = await completeText([
+            { role: 'system', content: SYSTEM },
+            { role: 'user', content: `Tamamlanan araçlar:\n\n${desc}\n\nEtiket:` },
+        ], config);
+        const label = (out || '').replace(/^["'`]+|["'`]+$/g, '').split('\n')[0].trim().slice(0, 60);
+        return label || null;
+    }
+    catch {
+        return null;
+    }
+}