@takimcizgisi/ajan 0.5.0

package/src/tools/edit.ts

@@ -0,0 +1,54 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import type { AgentTool } from "../config/types.js";
+import { resolveUserPath } from "./utils.js";
+
+function normalizeLines(text: string): string {
+    return text.replace(/\r\n/g, "\n");
+}
+
+export const editFileTool: AgentTool = {
+    name: "edit_file",
+    description:
+        "Bir dosyada tam eşleşen eski metni yeni metinle değiştirir (hedefli düzenleme). " +
+        "Eski metin dosyada yalnızca BİR kez geçmelidir; birden fazla geçiyorsa replaceAll=true kullanın. " +
+        "Küçük ve hedefli değişikliklerde write_file'a göre daha güvenilirdir.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Düzenlenecek dosyanın yolu" },
+            oldString: { type: "string", description: "Değiştirilecek mevcut metin (birebir eşleşme)" },
+            newString: { type: "string", description: "Eski metnin yerine geçecek yeni metin" },
+            replaceAll: { type: "boolean", description: "true ise tüm eşleşmeleri değiştirir (varsayılan: false)" },
+            cwd: { type: "string", description: "Göreli yolların çözüleceği dizin" }
+        },
+        required: ["path", "oldString", "newString"]
+    },
+    handler: async (params: { path: string; oldString: string; newString: string; replaceAll?: boolean; cwd?: string }, ctx) => {
+        const filePath = resolveUserPath(params.cwd ?? ctx.cwd, params.path);
+        if (!existsSync(filePath)) {
+            return { ok: false, output: `Dosya bulunamadı: ${params.path}` };
+        }
+        const original = normalizeLines(readFileSync(filePath, "utf8"));
+        const oldText = normalizeLines(params.oldString);
+        const newText = normalizeLines(params.newString);
+
+        if (oldText.length === 0) {
+            return { ok: false, output: "oldString boş olamaz." };
+        }
+
+        const count = original.split(oldText).length - 1;
+        if (count === 0) {
+            return { ok: false, output: `Eşleşme bulunamadı: "${params.oldString.slice(0, 120)}". Dosya içeriği değişmiş olabilir; read_file ile kontrol edin.` };
+        }
+        if (count > 1 && !params.replaceAll) {
+            return {
+                ok: false,
+                output: `"${params.oldString.slice(0, 120)}" dosyada ${count} kez geçiyor. Tek bir eşleşmeyi hedefleyin ya da replaceAll=true kullanın.`
+            };
+        }
+
+        const result = params.replaceAll ? original.split(oldText).join(newText) : original.replace(oldText, newText);
+        writeFileSync(filePath, result, "utf8");
+        return { ok: true, output: `Dosya düzenlendi: ${filePath} (${params.replaceAll ? count : 1} değişiklik)` };
+    }
+};

package/src/tools/file.ts

@@ -0,0 +1,261 @@
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync } from "node:fs";
+import { join, resolve, dirname, isAbsolute, relative } from "node:path";
+import type { AgentTool } from "../config/types.js";
+import { limitOutput, resolveUserPath, shouldSkipDir } from "./utils.js";
+
+function resolvePath(cwd: string, input: string): string {
+    return resolveUserPath(cwd, input);
+}
+
+function globToRegExp(glob: string): RegExp {
+    const escaped = glob
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, "@@DOUBLE_STAR@@")
+        .replace(/\*/g, "[^/]*")
+        .replace(/\?/g, "[^/]")
+        .replace(/@@DOUBLE_STAR@@/g, ".*");
+    return new RegExp(`^${escaped}$`);
+}
+
+function normalizeLines(text: string): string {
+    return text.replace(/\r\n/g, "\n");
+}
+
+export const readFileTool: AgentTool = {
+    name: "read_file",
+    description: "Bir dosyanın içeriğini okur. Büyük dosyalar için offset/limit ile kısmi okuma yapılabilir.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Okunacak dosyanın yolu (cwd'ye göre göreli veya mutlak)" },
+            offset: { type: "integer", description: "Başlangıç satır numarası (1 tabanlı)" },
+            limit: { type: "integer", description: "Okunacak maksimum satır sayısı" }
+        },
+        required: ["path"]
+    },
+    handler: async (params: { path: string; offset?: number; limit?: number }, ctx) => {
+        const filePath = resolvePath(ctx.cwd, params.path);
+        if (!existsSync(filePath)) {
+            return { ok: false, output: `Dosya bulunamadı: ${params.path}` };
+        }
+        const stat = statSync(filePath);
+        if (!stat.isFile()) {
+            return { ok: false, output: `Bu bir dosya değil: ${params.path}` };
+        }
+        if (stat.size > 2 * 1024 * 1024 && !params.offset && !params.limit) {
+            return {
+                ok: false,
+                output: `Dosya çok büyük (${stat.size} bayt). offset/limit parametreleriyle kısmi okuma yapın.`
+            };
+        }
+        const content = normalizeLines(readFileSync(filePath, "utf8"));
+        const lines = content.split("\n");
+        const totalLines = lines.length;
+        const start = params.offset ? Math.max(1, params.offset) : 1;
+        const end = params.limit ? Math.min(totalLines, start + params.limit - 1) : totalLines;
+        const slice = lines.slice(start - 1, end);
+        const numbered = slice.map((line, i) => `${String(start + i).padStart(6)} | ${line}`).join("\n");
+        const header = `Dosya: ${filePath}\nSatırlar: ${start}-${end} / ${totalLines}\n`;
+        return { ok: true, output: header + numbered };
+    }
+};
+
+export const writeFileTool: AgentTool = {
+    name: "write_file",
+    description:
+        "Bir dosyaya içerik yazar (oluşturur veya üzerine yazar). append=true ise sona ekler. " +
+        "Klasörler otomatik oluşturulur.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Yazılacak dosyanın yolu" },
+            content: { type: "string", description: "Dosya içeriği" },
+            append: { type: "boolean", description: "true ise içeriği dosyanın sonuna ekler (varsayılan: false)" }
+        },
+        required: ["path", "content"]
+    },
+    handler: async (params: { path: string; content: string; append?: boolean }, ctx) => {
+        const filePath = resolvePath(ctx.cwd, params.path);
+        mkdirSync(dirname(filePath), { recursive: true });
+        const content = normalizeLines(params.content);
+        writeFileSync(filePath, content, { encoding: "utf8", flag: params.append ? "a" : "w" });
+        const action = params.append ? "eklendi" : "yazıldı";
+        return { ok: true, output: `Dosya ${action}: ${filePath} (${Buffer.byteLength(content)} bayt)` };
+    }
+};
+
+export const listDirTool: AgentTool = {
+    name: "list_dir",
+    description: "Bir dizindeki dosya ve klasörleri listeler. recursive=true ile alt dizinler de dahil edilir.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Listelenecek dizin (varsayılan: cwd)" },
+            recursive: { type: "boolean", description: "Alt dizinleri de listele (varsayılan: false)" }
+        }
+    },
+    handler: async (params: { path?: string; recursive?: boolean }, ctx) => {
+        const dirPath = resolvePath(ctx.cwd, params.path ?? ".");
+        if (!existsSync(dirPath)) {
+            return { ok: false, output: `Dizin bulunamadı: ${params.path ?? "."}` };
+        }
+        if (!statSync(dirPath).isDirectory()) {
+            return { ok: false, output: `Bu bir dizin değil: ${params.path ?? "."}` };
+        }
+        const entries: string[] = [];
+        let skippedCount = 0;
+        const MAX_ENTRIES = 300;
+        const walk = (current: string, depth: number): void => {
+            if (depth > 5 || entries.length >= MAX_ENTRIES) return;
+            let children;
+            try {
+                children = readdirSync(current, { withFileTypes: true });
+            } catch (err) {
+                entries.push(`  ${"  ".repeat(depth)}[hata: ${(err as Error).message}]`);
+                return;
+            }
+            for (const child of children) {
+                if (entries.length >= MAX_ENTRIES) break;
+                const childPath = join(current, child.name);
+                const isDir = child.isDirectory();
+                if (isDir && shouldSkipDir(child.name)) {
+                    skippedCount++;
+                    continue;
+                }
+                const indent = "  ".repeat(depth);
+                const rel = relative(dirPath, childPath).replace(/\\/g, "/");
+                if (isDir) {
+                    entries.push(`${indent}${rel}/`);
+                    if (params.recursive) walk(childPath, depth + 1);
+                } else {
+                    let size = 0;
+                    try {
+                        size = statSync(childPath).size;
+                    } catch {
+                        size = 0;
+                    }
+                    entries.push(`${indent}${rel} (${size} bayt)`);
+                }
+            }
+        };
+        walk(dirPath, 0);
+        let output = `Dizin: ${dirPath}\n${entries.join("\n")}`;
+        if (skippedCount > 0) output += `\n(... ${skippedCount} ağır/gizli klasör atlandı: node_modules, .git, dist, build vb.)`;
+        if (entries.length >= MAX_ENTRIES) output += `\n(... ${entries.length} öğe sınırına ulaşıldı)`; 
+        return { ok: true, output: limitOutput(output, ctx.config.maxToolOutput) };
+    }
+};
+
+export const searchFilesTool: AgentTool = {
+    name: "search_files",
+    description: "Bir dizindeki dosyaları isim desenine (glob) göre arar.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Aranacak dizin (varsayılan: cwd)" },
+            pattern: { type: "string", description: "Glob deseni, ör. '*.ts' veya '**/*.ts'" }
+        },
+        required: ["pattern"]
+    },
+    handler: async (params: { path?: string; pattern: string }, ctx) => {
+        const dirPath = resolvePath(ctx.cwd, params.path ?? ".");
+        const matches: string[] = [];
+        const pattern = params.pattern.replace(/^\/+/, "").replace(/\\/g, "/");
+        const regex = globToRegExp(pattern);
+        const walk = (current: string, depth: number): void => {
+            if (depth > 8) return;
+            let children;
+            try {
+                children = readdirSync(current, { withFileTypes: true });
+            } catch {
+                return;
+            }
+            for (const child of children) {
+                const childPath = join(current, child.name);
+                const rel = relative(dirPath, childPath).replace(/\\/g, "/");
+                if (child.isDirectory()) {
+                    if (shouldSkipDir(child.name)) continue;
+                    if (regex.test(`${rel}/`)) matches.push(`${rel}/`);
+                    walk(childPath, depth + 1);
+                } else {
+                    if (regex.test(rel)) matches.push(rel);
+                }
+            }
+        };
+        walk(dirPath, 0);
+        const result = matches.length > 0 ? matches.join("\n") : "Eşleşen dosya bulunamadı.";
+        return { ok: true, output: `Glob: ${params.pattern}\n${result}` };
+    }
+};
+
+export const grepTool: AgentTool = {
+    name: "grep_files",
+    description: "Dosyalarda içerik araması yapar. pattern bir regex'dir.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Aranacak dizin (varsayılan: cwd)" },
+            pattern: { type: "string", description: "Regex deseni" },
+            include: { type: "string", description: "Dosya deseni filtresi, ör. '*.ts'" }
+        },
+        required: ["pattern"]
+    },
+    handler: async (params: { path?: string; pattern: string; include?: string }, ctx) => {
+        const dirPath = resolvePath(ctx.cwd, params.path ?? ".");
+        let regex: RegExp;
+        try {
+            regex = new RegExp(params.pattern);
+        } catch (err) {
+            return { ok: false, output: `Geçersiz regex deseni: ${(err as Error).message}` };
+        }
+        let includeRe: RegExp | null = null;
+        if (params.include) {
+            try {
+                includeRe = new RegExp(
+                    `^${params.include.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`
+                );
+            } catch {
+                includeRe = null;
+            }
+        }
+        const results: string[] = [];
+        let fileCount = 0;
+        const walk = (current: string, depth: number): void => {
+            if (depth > 8 || fileCount > 500) return;
+            let children;
+            try {
+                children = readdirSync(current, { withFileTypes: true });
+            } catch {
+                return;
+            }
+            for (const child of children) {
+                if (shouldSkipDir(child.name)) continue;
+                const childPath = join(current, child.name);
+                if (child.isDirectory()) {
+                    walk(childPath, depth + 1);
+                } else {
+                    if (includeRe && !includeRe.test(child.name)) continue;
+                    fileCount++;
+                    try {
+                        if (statSync(childPath).size > 2 * 1024 * 1024) continue;
+                    } catch {
+                        continue;
+                    }
+                    try {
+                        const lines = normalizeLines(readFileSync(childPath, "utf8")).split("\n");
+                        for (let i = 0; i < lines.length; i++) {
+                            const line = lines[i] ?? "";
+                            if (regex.test(line)) {
+                                results.push(`${relative(dirPath, childPath).replace(/\\/g, "/")}:${i + 1}: ${line.trim().slice(0, 200)}`);
+                            }
+                        }
+                    } catch {
+                        /* okunamayan dosyayı atla */
+                    }
+                }
+            }
+        };
+        walk(dirPath, 0);
+        return { ok: true, output: limitOutput(results.join("\n"), ctx.config.maxToolOutput) };
+    }
+};

package/src/tools/filesys.ts

@@ -0,0 +1,70 @@
+import { existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import type { AgentTool } from "../config/types.js";
+import { resolveUserPath } from "./utils.js";
+
+export const moveFileTool: AgentTool = {
+    name: "move_file",
+    description:
+        "Dosya veya klasörü taşır / yeniden adlandırır. Hedef dizin yoksa oluşturulur. Var olan dosyanın üzerine yazmaz.",
+    parameters: {
+        type: "object",
+        properties: {
+            source: { type: "string", description: "Kaynak yol" },
+            destination: { type: "string", description: "Hedef yol (dosya veya klasör)" }
+        },
+        required: ["source", "destination"]
+    },
+    handler: async (params: { source?: string; destination?: string }, ctx) => {
+        const src = params.source?.trim();
+        const dest = params.destination?.trim();
+        if (!src || !dest) return { ok: false, output: "source ve destination zorunludur." };
+        const srcPath = resolveUserPath(ctx.cwd, src);
+        const destPath = resolveUserPath(ctx.cwd, dest);
+        if (srcPath === destPath) return { ok: false, output: "Kaynak ve hedef aynı." };
+        if (!existsSync(srcPath)) return { ok: false, output: `Kaynak bulunamadı: ${src}` };
+        if (existsSync(destPath)) return { ok: false, output: `Hedef zaten var: ${dest} (önce silin)` };
+        try {
+            mkdirSync(dirname(destPath), { recursive: true });
+            renameSync(srcPath, destPath);
+            return { ok: true, output: `Taşındı: ${srcPath} → ${destPath}` };
+        } catch (err) {
+            return { ok: false, output: `Taşıma başarısız: ${(err as Error).message}` };
+        }
+    }
+};
+
+export const deleteFileTool: AgentTool = {
+    name: "delete_file",
+    description:
+        "Dosya veya klasör siler. Klasörler için recursive:true gerekir. Dikkatli kullan — geri alınamaz.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Silinecek yol" },
+            recursive: { type: "boolean", description: "Klasörü içeriğiyle sil (varsayılan: false)" }
+        },
+        required: ["path"]
+    },
+    handler: async (params: { path?: string; recursive?: boolean }, ctx) => {
+        const p = params.path?.trim();
+        if (!p) return { ok: false, output: "path zorunludur." };
+        const target = resolveUserPath(ctx.cwd, p);
+        if (!existsSync(target)) return { ok: false, output: `Bulunamadı: ${p}` };
+        const cwdResolved = resolve(ctx.cwd);
+        if (target === cwdResolved || cwdResolved.startsWith(target + "\\") || cwdResolved.startsWith(target + "/")) {
+            return { ok: false, output: "Çalışma dizinini veya üstünü silemezsin." };
+        }
+        const stat = statSync(target);
+        const isDir = stat.isDirectory();
+        if (isDir && !params.recursive) {
+            return { ok: false, output: `"${p}" bir klasör; silmek için recursive:true ver.` };
+        }
+        try {
+            rmSync(target, { recursive: isDir, force: true });
+            return { ok: true, output: `Silindi: ${target}${isDir ? " (klasör)" : ""}` };
+        } catch (err) {
+            return { ok: false, output: `Silme başarısız: ${(err as Error).message}` };
+        }
+    }
+};

package/src/tools/memory.ts

@@ -0,0 +1,76 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import type { AgentTool } from "../config/types.js";
+import { limitOutput } from "./utils.js";
+
+type Note = { id: number; text: string; createdAt: string };
+
+type NotesFile = { notes: Note[] };
+
+function notesPath(): string {
+    const base = process.env.AJAN_HOME ?? join(process.env.USERPROFILE ?? process.env.HOME ?? ".", ".ajan");
+    return join(base, "notes.json");
+}
+
+function loadNotes(): NotesFile {
+    try {
+        if (existsSync(notesPath())) {
+            const parsed = JSON.parse(readFileSync(notesPath(), "utf8")) as Partial<NotesFile>;
+            return { notes: Array.isArray(parsed.notes) ? parsed.notes : [] };
+        }
+    } catch {
+        /* bozuk dosya: sıfırla */
+    }
+    return { notes: [] };
+}
+
+function saveNotes(data: NotesFile): void {
+    writeFileSync(notesPath(), JSON.stringify(data, null, 2), "utf8");
+}
+
+export const noteAddTool: AgentTool = {
+    name: "not_al",
+    description:
+        "Kalıcı hafızaya not alır. Kullanıcı tercihleri, proje kararları, önemli bilgiler için kullan. " +
+        "Notlar oturumlar arasında korunur (~/.ajan/notes.json).",
+    parameters: {
+        type: "object",
+        properties: {
+            text: { type: "string", description: "Kaydedilecek not metni" }
+        },
+        required: ["text"]
+    },
+    handler: async (params: { text?: string }) => {
+        const text = (params.text ?? "").trim();
+        if (!text) return { ok: false, output: "Not metni boş olamaz." };
+        const data = loadNotes();
+        const id = data.notes.reduce((max, n) => Math.max(max, n.id), 0) + 1;
+        data.notes.push({ id, text, createdAt: new Date().toISOString() });
+        saveNotes(data);
+        return { ok: true, output: `Not #${id} kaydedildi.` };
+    }
+};
+
+export const noteReadTool: AgentTool = {
+    name: "not_oku",
+    description:
+        "Kalıcı hafızadaki notları okur. query verilirse içinde o kelime geçen notlar döner; yoksa son 30 not.",
+    parameters: {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Notlar içinde aranacak kelime (opsiyonel)" }
+        },
+        required: []
+    },
+    handler: async (params: { query?: string }, ctx) => {
+        const data = loadNotes();
+        let notes = data.notes;
+        const q = params.query?.trim().toLowerCase();
+        if (q) notes = notes.filter((n) => n.text.toLowerCase().includes(q));
+        if (notes.length === 0) return { ok: true, output: q ? `"${params.query}" ile eşleşen not yok.` : "Hafızada not yok." };
+        const slice = notes.slice(-30);
+        const lines = slice.map((n) => `#${n.id} [${n.createdAt.slice(0, 10)}] ${n.text}`);
+        const header = `${notes.length} not${q ? ` ("${params.query}")` : ""}${notes.length > slice.length ? ` (son ${slice.length} gösteriliyor)` : ""}:\n`;
+        return { ok: true, output: limitOutput(header + lines.join("\n"), ctx.config.maxToolOutput) };
+    }
+};

package/src/tools/patch.ts

@@ -0,0 +1,138 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import type { AgentTool } from "../config/types.js";
+import { logger } from "../utils/paths.js";
+import { resolveUserPath } from "./utils.js";
+
+function resolvePath(cwd: string, input: string): string {
+    return resolveUserPath(cwd, input);
+}
+
+type Hunk = {
+    oldStart: number;
+    newStart: number;
+    lines: { type: " " | "+" | "-"; text: string }[];
+};
+
+function parseUnifiedDiff(diff: string): { file: string; hunks: Hunk[] } | null {
+    const lines = diff.replace(/\r\n/g, "\n").split("\n");
+    let file: string | undefined;
+    const hunks: Hunk[] = [];
+    let current: Hunk | undefined;
+
+    for (const rawLine of lines) {
+        if (rawLine.startsWith("--- ")) {
+            file = rawLine.slice(4).replace(/^\s*[ab]\//, "").trim();
+            continue;
+        }
+        if (rawLine.startsWith("+++ ")) continue;
+        const hunkMatch = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(rawLine);
+        if (hunkMatch) {
+            current = {
+                oldStart: parseInt(hunkMatch[1] ?? "1", 10),
+                newStart: parseInt(hunkMatch[3] ?? "1", 10),
+                lines: []
+            };
+            hunks.push(current);
+            continue;
+        }
+        if (!current) continue;
+        if (rawLine.startsWith("+")) {
+            current.lines.push({ type: "+", text: rawLine.slice(1) });
+        } else if (rawLine.startsWith("-")) {
+            current.lines.push({ type: "-", text: rawLine.slice(1) });
+        } else if (rawLine.startsWith(" ")) {
+            current.lines.push({ type: " ", text: rawLine.slice(1) });
+        } else if (rawLine.startsWith("\\")) {
+            continue;
+        }
+    }
+
+    if (!file || hunks.length === 0) return null;
+    return { file, hunks };
+}
+
+function applyHunks(original: string, hunks: Hunk[]): { result: string; changedLines: number } {
+    const lines = original.split("\n");
+    const newLines: string[] = [];
+    let oldLine = 1;
+    let changedLines = 0;
+
+    for (const hunk of hunks) {
+        while (oldLine < hunk.oldStart && oldLine <= lines.length) {
+            newLines.push(lines[oldLine - 1] ?? "");
+            oldLine++;
+        }
+        let oldPos = hunk.oldStart;
+        let contextMatched = true;
+        const contextCheck = hunk.lines.filter((l) => l.type !== "+");
+        for (const cl of contextCheck) {
+            const current = lines[oldPos - 1];
+            if (current !== cl.text) {
+                contextMatched = false;
+                break;
+            }
+            oldPos++;
+        }
+        if (!contextMatched) {
+            throw new Error(
+                `Hunk satırları eşleşmiyor (${hunk.oldStart}. satır civarı). Dosya içeriği güncelliğini yitirmiş olabilir.`
+            );
+        }
+        for (const line of hunk.lines) {
+            if (line.type === "-") {
+                oldLine++;
+                changedLines++;
+            } else if (line.type === "+") {
+                newLines.push(line.text);
+                changedLines++;
+            } else {
+                newLines.push(line.text);
+                oldLine++;
+            }
+        }
+        oldPos = 0;
+    }
+    while (oldLine <= lines.length) {
+        newLines.push(lines[oldLine - 1] ?? "");
+        oldLine++;
+    }
+    return { result: newLines.join("\n"), changedLines };
+}
+
+export const applyPatchTool: AgentTool = {
+    name: "apply_patch",
+    description:
+        "Unified diff formatında bir yamayı dosyaya uygular. Eksiksiz dosya değişiklikleri için write_file'ı tercih edin. " +
+        "Yama formatı: --- a/yol + +++ b/yol + @@ -eskiSatır,sayı +yeniSatır,sayı @@ + satırlar. " +
+        "Küçük ve hedefli değişikliklerde daha güvenilirdir.",
+    parameters: {
+        type: "object",
+        properties: {
+            patch: { type: "string", description: "Uygulanacak unified diff içeriği" },
+            cwd: { type: "string", description: "Göreli yolların çözüleceği dizin" }
+        },
+        required: ["patch"]
+    },
+    handler: async (params: { patch: string; cwd?: string }, ctx) => {
+        const parsed = parseUnifiedDiff(params.patch);
+        if (!parsed) {
+            return { ok: false, output: "Geçerli bir unified diff bulunamadı. --- a/yol ve @@ hunk satırları gerekli." };
+        }
+        const filePath = resolvePath(params.cwd ?? ctx.cwd, parsed.file);
+        if (!existsSync(filePath)) {
+            return { ok: false, output: `Yamalanacak dosya bulunamadı: ${parsed.file}` };
+        }
+        const original = readFileSync(filePath, "utf8");
+        try {
+            const { result, changedLines } = applyHunks(original, parsed.hunks);
+            writeFileSync(filePath, result, "utf8");
+            logger.debug(`Patch uygulandi: ${filePath} (${changedLines} satir degisti)`);
+            return { ok: true, output: `Yama uygulandı: ${filePath} (${changedLines} satır değişti)` };
+        } catch (err) {
+            return { ok: false, output: `Yama uygulanamadı: ${(err as Error).message}` };
+        }
+    }
+};
+
+export { parseUnifiedDiff };