@takimcizgisi/ajan 0.5.0

package/src/tools/playground.ts

@@ -0,0 +1,130 @@
+import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import type { AgentTool } from "../config/types.js";
+import { limitOutput } from "./utils.js";
+
+/** Kullanıcının açık klasöründe, projenin içindeki AJAN test klasörü: <cwd>/.ajan */
+function playgroundPath(cwd: string): string {
+    const dir = join(cwd, ".ajan");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+
+function todosPath(cwd: string): string {
+    return join(playgroundPath(cwd), "todos.json");
+}
+
+type TodoItem = { text: string; done: boolean };
+
+function loadTodos(cwd: string): TodoItem[] {
+    try {
+        if (existsSync(todosPath(cwd))) {
+            const parsed = JSON.parse(readFileSync(todosPath(cwd), "utf8"));
+            if (Array.isArray(parsed)) return parsed as TodoItem[];
+        }
+    } catch {
+        /* bozuk dosya: sıfırla */
+    }
+    return [];
+}
+
+function clearDir(dir: string): number {
+    let count = 0;
+    for (const name of readdirSync(dir)) {
+        rmSync(join(dir, name), { recursive: true, force: true });
+        count++;
+    }
+    return count;
+}
+
+export const openPlaygroundTool: AgentTool = {
+    name: "open_playground",
+    description:
+        "Açık klasörün içindeki AJAN TEST KLASÖRÜNÜ (<cwd>/.ajan) hazırlar. " +
+        "Deneme/test/prototip yapmak istediğinde önce bunu çağır. " +
+        "reset=false iken masaarkadaşları korur; reset=true ise klasörü bomboş hale getirir. " +
+        "Kullanıcının gerçek proje dosyalarına kesinlikle dokunmaz; tüm denemeler bu klasörde yapılır.",
+    parameters: {
+        type: "object",
+        properties: {
+            reset: {
+                type: "boolean",
+                description: "true ise .ajan içeriğini komple temizler (varsayılan: false)"
+            },
+            note: { type: "string", description: "Ne yapacağın hakkında kısa bir not (opsiyonel)" }
+        },
+        required: []
+    },
+    handler: async (params: { reset?: boolean; note?: string }, ctx) => {
+        const dir = playgroundPath(ctx.cwd);
+        const before = readdirSync(dir).length;
+        let cleared = 0;
+        if (params.reset) cleared = clearDir(dir);
+        const after = readdirSync(dir).length;
+        const lines = [
+            `.ajan test klasörü hazır: ${dir}`,
+            `Önceki içerik: ${before} öğe; sonraki içerik: ${after} öğe${cleared > 0 ? ` (${cleared} temizlendi)` : ""}`
+        ];
+        if (params.note) lines.push(`Not: ${params.note}`);
+        lines.push("KURAL: tüm denemeleri, geçici dosyaları ve riskli testleri BURADA yap; asıl projeye dokunma.");
+        return { ok: true, output: lines.join("\n") };
+    }
+};
+
+export const setTodosTool: AgentTool = {
+    name: "set_todos",
+    description:
+        "Görev programını (.ajan/todos.json) günceller. " +
+        "Bir göreve başlarken önce kısa bir TODO listesi planla ve bu araçla kaydet. " +
+        "done=false adım halen beklemede, done=true tamamlandı demektir.",
+    parameters: {
+        type: "object",
+        properties: {
+            todos: {
+                type: "array",
+                description: "Yapılacaklar listesi",
+                items: {
+                    type: "object",
+                    properties: {
+                        text: { type: "string", description: "Adım açıklaması" },
+                        done: { type: "boolean", description: "Tamamlandı mı (varsayılan false)" }
+                    },
+                    required: ["text"]
+                }
+            }
+        },
+        required: ["todos"]
+    },
+    handler: async (params: { todos?: TodoItem[] }, ctx) => {
+        const raw = params.todos;
+        if (!raw || raw.length === 0) return { ok: false, output: "todos listesi boş olamaz." };
+        const items: TodoItem[] = raw.map((t) => ({
+            text: String(t.text ?? "").trim(),
+            done: t.done === true
+        }));
+        if (items.some((t) => !t.text)) return { ok: false, output: "Her TODO maddesi için text gerekli." };
+        writeFileSync(todosPath(ctx.cwd), JSON.stringify(items, null, 2), "utf8");
+        const lines = items.map((t, i) => `${t.done ? "[x]" : "[ ]"} ${i + 1}. ${t.text}`);
+        return {
+            ok: true,
+            output: `TODO listesi kaydedildi (${items.length} madde): ${todosPath(ctx.cwd)}\n${lines.join("\n")}`
+        };
+    }
+};
+
+export const getTodosTool: AgentTool = {
+    name: "get_todos",
+    description: "Görev programını (.ajan/todos.json) okur. Kayıtlı TODO varsa döndürür, yoksa boş döner.",
+    parameters: {
+        type: "object",
+        properties: {}
+    },
+    handler: async (_params: unknown, ctx) => {
+        const items = loadTodos(ctx.cwd);
+        if (items.length === 0) {
+            return { ok: true, output: "Kayıtlı TODO yok. Göreve başlarken set_todos ile plan oluştur." };
+        }
+        const lines = items.map((t, i) => `${t.done ? "[x]" : "[ ]"} ${i + 1}. ${t.text}`);
+        return { ok: true, output: limitOutput(`Görev programı (${items.length} madde):\n${lines.join("\n")}`, ctx.config.maxToolOutput) };
+    }
+};

package/src/tools/registry.ts

@@ -0,0 +1,79 @@
+import type { ChatSessionModelFunction, ChatSessionModelFunctions } from "node-llama-cpp";
+import type { AgentTool, ToolExecutionContext, ToolExecutionSignal } from "../config/types.js";
+import { readFileTool, writeFileTool, listDirTool, searchFilesTool, grepTool } from "./file.js";
+import { runCommandTool } from "./terminal.js";
+import { applyPatchTool } from "./patch.js";
+import { editFileTool } from "./edit.js";
+import { webSearchTool, fetchUrlTool } from "./web.js";
+import { moveFileTool, deleteFileTool } from "./filesys.js";
+import { readDataTool, unzipFileTool } from "./data.js";
+import { noteAddTool, noteReadTool } from "./memory.js";
+import { taskCompleteTool } from "./taskComplete.js";
+import { openPlaygroundTool, setTodosTool, getTodosTool } from "./playground.js";
+import { logger } from "../utils/paths.js";
+
+export type ToolEvents = {
+    onToolCall?: (name: string, params: unknown) => void;
+    onToolResult?: (name: string, ok: boolean, output: string) => void;
+};
+
+export function createCoreTools(ctx: ToolExecutionContext): AgentTool[] {
+    return [
+        readFileTool,
+        writeFileTool,
+        listDirTool,
+        searchFilesTool,
+        grepTool,
+        editFileTool,
+        moveFileTool,
+        deleteFileTool,
+        readDataTool,
+        unzipFileTool,
+        runCommandTool,
+        applyPatchTool,
+        webSearchTool,
+        fetchUrlTool,
+        noteAddTool,
+        noteReadTool,
+        taskCompleteTool,
+        openPlaygroundTool,
+        setTodosTool,
+        getTodosTool
+    ];
+}
+
+export function buildSessionFunctions(
+    tools: AgentTool[],
+    ctx: ToolExecutionContext,
+    events: ToolEvents = {}
+): ChatSessionModelFunctions {
+    const result: Record<string, ChatSessionModelFunction<any>> = {};
+    for (const tool of tools) {
+        result[tool.name] = {
+            description: tool.description,
+            params: tool.parameters as never,
+            handler: async (params: any) => {
+                events.onToolCall?.(tool.name, params);
+                logger.debug(`Arac cagirildi: ${tool.name}`);
+                try {
+                    const res = await tool.handler(params, ctx);
+                    events.onToolResult?.(tool.name, res.ok, res.output);
+                    if (res.ok) return res.output;
+                    return (
+                        `HATA (${tool.name}): ${res.output} | ` +
+                        "NOT: Araç başarısız oldu; bu işlem GERÇEKLEŞMEDİ. Hatayı kullanıcıya bildir veya sorunu çözüp tekrar dene. Başarılı diye raporlama."
+                    );
+                } catch (err) {
+                    const msg = (err as Error).message;
+                    const out = `HATA (${tool.name}): ${msg} | NOT: Araç hata verdi; işlem gerçekleşmedi. Başarılı diye raporlama.`;
+                    logger.error(`Araç hatasi: ${tool.name}: ${msg}`);
+                    events.onToolResult?.(tool.name, false, msg);
+                    return out;
+                }
+            }
+        };
+    }
+    return result as ChatSessionModelFunctions;
+}
+
+export type { ToolExecutionSignal };

package/src/tools/taskComplete.ts

@@ -0,0 +1,34 @@
+import type { AgentTool } from "../config/types.js";
+
+export const taskCompleteTool: AgentTool = {
+    name: "task_complete",
+    description:
+        "Görev akışını KENDİ kararınla kontrol eder. " +
+        "İşin henüz bitmediyse, kalan adımlara devam etmek için continue:true ile çağır (yeni bir tur açılır). " +
+        "Görev TAMAMLANDIĞINDA ve doğrulandığında continue:false (veya continue vermeden) ile çağır; " +
+        "report parametresine yapılan işlerin özetini yaz.",
+    parameters: {
+        type: "object",
+        properties: {
+            report: { type: "string", description: "İşin durumu / tamamlanan işlerin kısa özeti" },
+            continue: {
+                type: "boolean",
+                description:
+                    "true: göreve devam et, yeni bir tur iste (tur sonunda model tekrar görüşmelere devam eder). " +
+                    "false veya verilmezse: görevi bitir."
+            }
+        },
+        required: []
+    },
+    handler: async (params: { report?: string; continue?: boolean }, ctx) => {
+        if (ctx.signals) {
+            if (params.continue === true) {
+                ctx.signals.continueRequested = true;
+                return { ok: true, output: "Devam turu istendi (continue:true). Model kalan adımına devam edecek." };
+            }
+            ctx.signals.taskCompleted = true;
+        }
+        const report = (params.report ?? "").trim();
+        return { ok: true, output: report || "Görev tamamlandı." };
+    }
+};

package/src/tools/terminal.ts

@@ -0,0 +1,138 @@
+import { spawn } from "node:child_process";
+import type { AgentTool } from "../config/types.js";
+import { limitOutput, resolveUserPath } from "./utils.js";
+
+const DEFAULT_BLOCKED_COMMANDS: string[] = [
+    "^(\\s*)(format|fdisk|diskpart|mkfs|shutdown)\\b",
+    "^\\s*(rm|del|erase|rd|rmdir|reg)\\s+.*(-rf|-r\\s+-f|/s|/q|delete)\\b",
+    "^\\s*taskkill\\s+/f\\s+/im\\s+system\\b",
+    "rm\\s+(-rf|-r\\s+-f)\\s+[/\\\\]"
+];
+
+function blockedBy(patterns: string[], command: string): string | null {
+    for (const pat of patterns) {
+        try {
+            if (new RegExp(pat, "i").test(command)) return pat;
+        } catch {
+            /* geçersiz deseni yut */
+        }
+    }
+    return null;
+}
+
+export const runCommandTool: AgentTool = {
+    name: "run_command",
+    description:
+        "Terminal komutu çalıştırır. cwd, komutun çalıştırılacağı dizindir (varsayılan: ajanın çalışma dizini). " +
+        "timeout ms cinsinden zaman aşımıdır (varsayılan: 60000). Çıktı maksimum uzunlukta kesilir.",
+    parameters: {
+        type: "object",
+        properties: {
+            command: { type: "string", description: "Çalıştırılacak terminal komutu" },
+            cwd: { type: "string", description: "Çalışma dizini (ajanın dizinine göre göreli veya mutlak yol)" },
+            timeout: { type: "integer", description: "Zaman aşımı milisaniye" }
+        },
+        required: ["command"]
+    },
+    handler: async (
+        params: { command: string; cwd?: string; timeout?: number },
+        ctx
+    ) => {
+        const timeoutMs = params.timeout ?? ctx.config.toolTimeout ?? 60_000;
+        const cwd = params.cwd ? resolveUserPath(ctx.cwd, params.cwd) : ctx.cwd;
+
+        const blocked = blockedBy(ctx.config.blockedCommands ?? DEFAULT_BLOCKED_COMMANDS, params.command);
+        if (blocked) {
+            return {
+                ok: false,
+                output:
+                    `Komut engellendi (tehlikeli komut deseni: ${blocked}).\n` +
+                    `Engellenen komut: ${params.command}\n` +
+                    'İzin vermek için config.json\'daki "blockedCommands" alanını değiştirin ([] boş liste = tümü serbest).'
+            };
+        }
+
+        const result = await new Promise<{ code: number | null; stdout: string; stderr: string; timedOut: boolean }>(
+            (resolvePromise) => {
+                const isWin = process.platform === "win32";
+                const shell = isWin ? "cmd.exe" : "/bin/sh";
+                const shellArgs = isWin ? ["/d", "/s", "/c"] : ["-c"];
+                const child = spawn(shell, [...shellArgs, params.command], {
+                    cwd,
+                    windowsHide: true,
+                    detached: !isWin,
+                    env: process.env,
+                    stdio: ["ignore", "pipe", "pipe"]
+                });
+
+                let stdout = "";
+                let stderr = "";
+                let timedOut = false;
+                let settled = false;
+                const finish = (code: number | null): void => {
+                    if (settled) return;
+                    settled = true;
+                    clearTimeout(timer);
+                    clearTimeout(safetyTimer);
+                    resolvePromise({ code, stdout, stderr, timedOut });
+                };
+
+                const timer = setTimeout(() => {
+                    timedOut = true;
+                    try {
+                        if (isWin && child.pid != null) {
+                            // Önce taskkill /T ile SÜREÇ AĞACINI (cmd + alt komutlar) öldür.
+                            // Önce ağaçta çocuk öldürülür, ardından taskkill "process not found"
+                            // ile ağacı kaçırır; bu yüzden önce taskkill, TerminateProcess'ten önce gelir.
+                            const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+                                windowsHide: true,
+                                stdio: "ignore"
+                            });
+                            killer.unref();
+                            killer.on("error", () => {
+                                /* taskkill başlatılamadıysa sessiz geç */
+                            });
+                        } else if (child.pid != null) {
+                            process.kill(-child.pid, "SIGKILL");
+                        }
+                    } catch {
+                        /* zaten ölmüş olabilir */
+                    }
+                }, timeoutMs);
+
+                // 'close' ancak süreç bitip tüm pipe'lar kapanınca tetiklenir; askıda kalmamak için
+                // güvenlik zamanlayıcısı pipe'ları serbest bırakıp sonucu zorla döndürür.
+                const safetyTimer = setTimeout(() => {
+                    if (!settled) {
+                        child.stdout?.destroy();
+                        child.stderr?.destroy();
+                        finish(child.exitCode ?? null);
+                    }
+                }, timeoutMs + 5_000);
+
+                child.stdout?.on("data", (chunk: Buffer) => {
+                    stdout += chunk.toString("utf8");
+                    if (stdout.length > 2_000_000) child.stdout?.pause();
+                });
+                child.stderr?.on("data", (chunk: Buffer) => {
+                    stderr += chunk.toString("utf8");
+                    if (stderr.length > 2_000_000) child.stderr?.pause();
+                });
+                child.on("error", (err) => {
+                    stderr += `Komut başlatılamadı: ${err.message}`;
+                    finish(null);
+                });
+                child.on("close", (code) => finish(code));
+            }
+        );
+
+        const parts: string[] = [];
+        if (result.timedOut) parts.push(`[ZAMAN AŞIMI ${timeoutMs}ms]`);
+        parts.push(`Çıkış kodu: ${result.code}`);
+        if (result.stdout.trim()) parts.push(`--- STDOUT ---\n${result.stdout.trimEnd()}`);
+        if (result.stderr.trim()) parts.push(`--- STDERR ---\n${result.stderr.trimEnd()}`);
+
+        const ok = result.code === 0 && !result.timedOut;
+        return { ok, output: limitOutput(parts.join("\n"), ctx.config.maxToolOutput) };
+    }
+};

package/src/tools/utils.ts

@@ -0,0 +1,63 @@
+import os from "node:os";
+import path from "node:path";
+import { existsSync } from "node:fs";
+
+export function limitOutput(text: string, maxChars?: number): string {
+    const limit = maxChars ?? 40_000;
+    if (text.length <= limit) return text;
+    const truncated = text.slice(0, limit);
+    return `${truncated}\n... [çıktı ${text.length - limit} karakter kesildi]`;
+}
+
+export const SKIP_DIRS = new Set<string>([
+    "node_modules", ".git", "dist", "build", ".next", ".cache",
+    "__pycache__", ".venv", "venv", ".idea", ".vscode", "coverage"
+]);
+
+/** Ağır veya gizli klasörlerde gezinmeyi atla (node_modules, dist, .git vb.) */
+export function shouldSkipDir(name: string): boolean {
+    return name.startsWith(".") || SKIP_DIRS.has(name);
+}
+
+export function toMb(bytes: number): string {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function homeFolder(key: string): string | null {
+    const candidates: string[] = [];
+    const home = os.homedir();
+    candidates.push(path.join(home, key));
+    const userProfile = process.env.USERPROFILE ?? process.env.HOME;
+    if (userProfile) candidates.push(path.join(userProfile, key));
+    const oneDrive = process.env.ONEDRIVE;
+    if (oneDrive) candidates.push(path.join(oneDrive, key));
+    for (const c of candidates) {
+        try {
+            if (existsSync(c)) return c;
+        } catch {
+            /* yut */
+        }
+    }
+    return candidates[0] ?? null;
+}
+
+const FOLDER_PATTERNS: Array<{ regex: RegExp; key: "Desktop" | "Documents" | "Downloads" }> = [
+    { regex: /masaüstü|masaustu|desktop/i, key: "Desktop" },
+    { regex: /belgeler|belgelerim|belge|documents/i, key: "Documents" },
+    { regex: /indirilenler|indirilen|indirmeler|downloads/i, key: "Downloads" }
+];
+
+/** 'masaüstü', 'belgeler', 'indirilenler' gibi adları kullanıcının gerçek klasörlerine çözer */
+export function resolveUserPath(cwd: string, input: string): string {
+    const trimmed = input.trim();
+    for (const { regex, key } of FOLDER_PATTERNS) {
+        const match = trimmed.match(new RegExp(`^(${regex.source})(?:[\\\\/](.*))?$`, "i"));
+        if (!match) continue;
+        const base = homeFolder(key);
+        if (!base) continue;
+        const rest = match[2];
+        return rest ? path.resolve(base, rest) : base;
+    }
+    return path.isAbsolute(input) ? path.resolve(input) : path.resolve(cwd, input);
+}
+

package/src/tools/web.ts

@@ -0,0 +1,204 @@
+import type { AgentTool } from "../config/types.js";
+import { limitOutput } from "./utils.js";
+
+export type WebSearchResult = {
+    title: string;
+    url: string;
+    snippet: string;
+};
+
+function decodeEntities(text: string): string {
+    return text
+        .replace(/&/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&#(\d+);/g, (_, code: string) => {
+            const cp = Number(code);
+            return cp > 0 ? String.fromCodePoint(cp) : "";
+        });
+}
+
+function stripTags(text: string): string {
+    return decodeEntities(text.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim());
+}
+
+function decodeRedirectUrl(href: string): string {
+    try {
+        if (href.startsWith("//")) href = `https:${href}`;
+        const u = new URL(href);
+        if (u.hostname.includes("duckduckgo.com")) {
+            const target = u.searchParams.get("uddg");
+            if (target) return decodeURIComponent(target);
+        }
+        return href;
+    } catch {
+        return href;
+    }
+}
+
+function parseResults(html: string, maxResults: number): WebSearchResult[] {
+    const results: WebSearchResult[] = [];
+    const resultRe =
+        /<a[^>]*class="(?:result__a|result-link)"[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi;
+    const snippetRe =
+        /<a[^>]*class="(?:result__snippet|result-snippet)"[^>]*>(.*?)<\/a>/gi;
+
+    let match: RegExpExecArray | null;
+    const titles: { href: string; title: string }[] = [];
+    while ((match = resultRe.exec(html)) !== null && titles.length < maxResults) {
+        titles.push({ href: match[1] ?? "", title: stripTags(match[2] ?? "") });
+    }
+
+    if (titles.length === 0) {
+        const genericRe = /<a[^>]*href="(https?:\/\/[^"]+)"[^>]*>(.*?)<\/a>/gi;
+        while ((match = genericRe.exec(html)) !== null && titles.length < maxResults) {
+            const title = stripTags(match[2] ?? "");
+            if (!title) continue;
+            titles.push({ href: match[1] ?? "", title });
+        }
+    }
+
+    const snippets: string[] = [];
+    while ((match = snippetRe.exec(html)) !== null && snippets.length < titles.length) {
+        snippets.push(stripTags(match[1] ?? ""));
+    }
+
+    for (let i = 0; i < titles.length; i++) {
+        const item = titles[i];
+        if (!item || !item.title) continue;
+        results.push({
+            title: item.title,
+            url: decodeRedirectUrl(item.href),
+            snippet: snippets[i] ?? ""
+        });
+    }
+    return results;
+}
+
+export const webSearchTool: AgentTool = {
+    name: "web_search",
+    description:
+        "Web'de arama yapar (DuckDuckGo, API anahtarı gerektirmez). Güncel bilgi, haber veya doküman bulmak için kullan. " +
+        "maxResults (varsayılan 5, en fazla 10) kadar sonuç döner: başlık, özet ve URL.",
+    parameters: {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Arama sorgusu (İngilizce daha iyi sonuç verir)" },
+            maxResults: { type: "integer", description: "Döndürülecek sonuç sayısı (varsayılan: 5, maks: 10)" }
+        },
+        required: ["query"]
+    },
+    handler: async (params: { query: string; maxResults?: number }, ctx) => {
+        const query = params.query.trim();
+        if (!query) return { ok: false, output: "Arama sorgusu boş olamaz." };
+        const maxResults = Math.min(Math.max(params.maxResults ?? 5, 1), 10);
+        const timeoutMs = ctx.config.toolTimeout ?? 15_000;
+
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        let html: string;
+        try {
+            const res = await fetch(
+                `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
+                {
+                    headers: {
+                        "User-Agent":
+                            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36"
+                    },
+                    signal: controller.signal,
+                    redirect: "follow"
+                }
+            );
+            if (!res.ok) {
+                return { ok: false, output: `Arama başarısız (HTTP ${res.status}): ${res.statusText}` };
+            }
+            html = await res.text();
+        } catch (err) {
+            const aborted = controller.signal.aborted;
+            return {
+                ok: false,
+                output: aborted
+                    ? `Arama zaman aşımı (${timeoutMs}ms) veya iptal edildi.`
+                    : `Arama hatası: ${(err as Error).message}`
+            };
+        } finally {
+            clearTimeout(timer);
+        }
+
+        const results = parseResults(html, maxResults);
+        if (results.length === 0) {
+            return { ok: true, output: `"${query}" için sonuç bulunamadı.` };
+        }
+
+        const lines = results.map((r, i) =>
+            `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet || "(özet yok)"}`
+        );
+        return { ok: true, output: limitOutput(lines.join("\n\n"), ctx.config.maxToolOutput) };
+    }
+};
+
+function htmlToText(html: string): string {
+    return stripTags(
+        html
+            .replace(/<script[\s\S]*?<\/script>/gi, " ")
+            .replace(/<style[\s\S]*?<\/style>/gi, " ")
+            .replace(/<(br|p|div|li|h[1-6]|tr)[^>]*>/gi, "\n")
+    );
+}
+
+export const fetchUrlTool: AgentTool = {
+    name: "fetch_url",
+    description:
+        "Bir URL'nin içeriğini indirip metin olarak döner. HTML sayfalar düz metne çevrilir. " +
+        "web_search ile bulunan bir sayfanın detayını okumak için kullan.",
+    parameters: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "İndirilecek adres (http/https)" },
+            maxLength: { type: "integer", description: "Döndürülecek maksimum karakter (varsayılan 12000, maks 40000)" }
+        },
+        required: ["url"]
+    },
+    handler: async (params: { url?: string; maxLength?: number }, ctx) => {
+        const url = params.url?.trim();
+        if (!url || !/^https?:\/\//i.test(url)) {
+            return { ok: false, output: "Geçerli bir http(s) URL gerekli." };
+        }
+        const timeoutMs = ctx.config.toolTimeout ?? 20_000;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(url, {
+                headers: {
+                    "User-Agent":
+                        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36"
+                },
+                signal: controller.signal,
+                redirect: "follow"
+            });
+            if (!res.ok) {
+                return { ok: false, output: `İndirme başarısız (HTTP ${res.status}): ${res.statusText}` };
+            }
+            const contentType = res.headers.get("content-type") ?? "";
+            const body = await res.text();
+            const isHtml = contentType.includes("text/html") || /^\s*<(!doctype|html)/i.test(body);
+            const text = isHtml ? htmlToText(body) : body;
+            const maxLen = Math.min(Math.max(params.maxLength ?? 12_000, 500), 40_000);
+            const header = `URL: ${url}\nTür: ${contentType || "bilinmiyor"}\nUzunluk: ${text.length} karakter\n\n`;
+            return { ok: true, output: limitOutput(header + text, maxLen + header.length + 100) };
+        } catch (err) {
+            const aborted = controller.signal.aborted;
+            return {
+                ok: false,
+                output: aborted
+                    ? `Zaman aşımı (${timeoutMs}ms) veya iptal edildi.`
+                    : `İndirme hatası: ${(err as Error).message}`
+            };
+        } finally {
+            clearTimeout(timer);
+        }
+    }
+};