@takimcizgisi/ajan 0.2.5

package/dist/tools/file.js

@@ -0,0 +1,274 @@
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname, relative } from "node:path";
+import { limitOutput, resolveUserPath, shouldSkipDir } from "./utils.js";
+function resolvePath(cwd, input) {
+    return resolveUserPath(cwd, input);
+}
+function globToRegExp(glob) {
+    const escaped = glob
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, "@@DOUBLE_STAR@@")
+        .replace(/\*/g, "[^/]*")
+        .replace(/\?/g, "[^/]")
+        .replace(/@@DOUBLE_STAR@@/g, ".*");
+    return new RegExp(`^${escaped}$`);
+}
+function normalizeLines(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+export const readFileTool = {
+    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, 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 = {
+    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, 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 = {
+    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, 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 = [];
+        let skippedCount = 0;
+        const MAX_ENTRIES = 300;
+        const walk = (current, depth) => {
+            if (depth > 5 || entries.length >= MAX_ENTRIES)
+                return;
+            let children;
+            try {
+                children = readdirSync(current, { withFileTypes: true });
+            }
+            catch (err) {
+                entries.push(`  ${"  ".repeat(depth)}[hata: ${err.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 = {
+    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, ctx) => {
+        const dirPath = resolvePath(ctx.cwd, params.path ?? ".");
+        const matches = [];
+        const pattern = params.pattern.replace(/^\/+/, "").replace(/\\/g, "/");
+        const regex = globToRegExp(pattern);
+        const walk = (current, depth) => {
+            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 = {
+    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, ctx) => {
+        const dirPath = resolvePath(ctx.cwd, params.path ?? ".");
+        let regex;
+        try {
+            regex = new RegExp(params.pattern);
+        }
+        catch (err) {
+            return { ok: false, output: `Geçersiz regex deseni: ${err.message}` };
+        }
+        let includeRe = null;
+        if (params.include) {
+            try {
+                includeRe = new RegExp(`^${params.include.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`);
+            }
+            catch {
+                includeRe = null;
+            }
+        }
+        const results = [];
+        let fileCount = 0;
+        const walk = (current, depth) => {
+            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) };
+    }
+};
+//# sourceMappingURL=file.js.map

package/dist/tools/filesys.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "../config/types.js";
+export declare const moveFileTool: AgentTool;
+export declare const deleteFileTool: AgentTool;

package/dist/tools/filesys.js

@@ -0,0 +1,74 @@
+import { existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { resolveUserPath } from "./utils.js";
+export const moveFileTool = {
+    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, 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.message}` };
+        }
+    }
+};
+export const deleteFileTool = {
+    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, 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.message}` };
+        }
+    }
+};
+//# sourceMappingURL=filesys.js.map

package/dist/tools/memory.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "../config/types.js";
+export declare const noteAddTool: AgentTool;
+export declare const noteReadTool: AgentTool;

package/dist/tools/memory.js

@@ -0,0 +1,69 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { limitOutput } from "./utils.js";
+function notesPath() {
+    const base = process.env.AJAN_HOME ?? join(process.env.USERPROFILE ?? process.env.HOME ?? ".", ".ajan");
+    return join(base, "notes.json");
+}
+function loadNotes() {
+    try {
+        if (existsSync(notesPath())) {
+            const parsed = JSON.parse(readFileSync(notesPath(), "utf8"));
+            return { notes: Array.isArray(parsed.notes) ? parsed.notes : [] };
+        }
+    }
+    catch {
+        /* bozuk dosya: sıfırla */
+    }
+    return { notes: [] };
+}
+function saveNotes(data) {
+    writeFileSync(notesPath(), JSON.stringify(data, null, 2), "utf8");
+}
+export const noteAddTool = {
+    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) => {
+        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 = {
+    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, 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) };
+    }
+};
+//# sourceMappingURL=memory.js.map

package/dist/tools/patch.d.ts

@@ -0,0 +1,15 @@
+import type { AgentTool } from "../config/types.js";
+type Hunk = {
+    oldStart: number;
+    newStart: number;
+    lines: {
+        type: " " | "+" | "-";
+        text: string;
+    }[];
+};
+declare function parseUnifiedDiff(diff: string): {
+    file: string;
+    hunks: Hunk[];
+} | null;
+export declare const applyPatchTool: AgentTool;
+export { parseUnifiedDiff };

package/dist/tools/patch.js

@@ -0,0 +1,129 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { logger } from "../utils/paths.js";
+import { resolveUserPath } from "./utils.js";
+function resolvePath(cwd, input) {
+    return resolveUserPath(cwd, input);
+}
+function parseUnifiedDiff(diff) {
+    const lines = diff.replace(/\r\n/g, "\n").split("\n");
+    let file;
+    const hunks = [];
+    let current;
+    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, hunks) {
+    const lines = original.split("\n");
+    const newLines = [];
+    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 = {
+    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, 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.message}` };
+        }
+    }
+};
+export { parseUnifiedDiff };
+//# sourceMappingURL=patch.js.map

package/dist/tools/registry.d.ts

@@ -0,0 +1,10 @@
+import type { ChatSessionModelFunctions } from "node-llama-cpp";
+import type { AgentTool, ToolExecutionContext, ToolExecutionSignal } from "../config/types.js";
+export type ToolEvents = {
+    onToolCall?: (name: string, params: unknown) => void;
+    onToolResult?: (name: string, ok: boolean, output: string) => void;
+};
+export declare function createCoreTools(ctx: ToolExecutionContext): AgentTool[];
+export declare function toolNames(): string[];
+export declare function buildSessionFunctions(tools: AgentTool[], ctx: ToolExecutionContext, events?: ToolEvents): ChatSessionModelFunctions;
+export type { ToolExecutionSignal };

package/dist/tools/registry.js

@@ -0,0 +1,64 @@
+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 { logger } from "../utils/paths.js";
+export function createCoreTools(ctx) {
+    return [
+        readFileTool,
+        writeFileTool,
+        listDirTool,
+        searchFilesTool,
+        grepTool,
+        editFileTool,
+        moveFileTool,
+        deleteFileTool,
+        readDataTool,
+        unzipFileTool,
+        runCommandTool,
+        applyPatchTool,
+        webSearchTool,
+        fetchUrlTool,
+        noteAddTool,
+        noteReadTool,
+        taskCompleteTool
+    ];
+}
+export function toolNames() {
+    return createCoreTools({ cwd: process.cwd(), config: { modelId: "x" } }).map((t) => t.name);
+}
+export function buildSessionFunctions(tools, ctx, events = {}) {
+    const result = {};
+    for (const tool of tools) {
+        result[tool.name] = {
+            description: tool.description,
+            params: tool.parameters,
+            handler: async (params) => {
+                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.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;
+}
+//# sourceMappingURL=registry.js.map

package/dist/tools/taskComplete.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTool } from "../config/types.js";
+export declare const taskCompleteTool: AgentTool;

package/dist/tools/taskComplete.js

@@ -0,0 +1,19 @@
+export const taskCompleteTool = {
+    name: "task_complete",
+    description: "Görevin TAMAMLANDIĞINI bildirir. Tüm istenen işler gerçekten bittiğinde ve doğrulandığında çağır. " +
+        "report parametresine yapılan işlerin özetini yaz.",
+    parameters: {
+        type: "object",
+        properties: {
+            report: { type: "string", description: "Tamamlanan işlerin kısa özeti" }
+        },
+        required: ["report"]
+    },
+    handler: async (params, ctx) => {
+        if (ctx.signals)
+            ctx.signals.taskCompleted = true;
+        const report = (params.report ?? "").trim();
+        return { ok: true, output: report || "Görev tamamlandı." };
+    }
+};
+//# sourceMappingURL=taskComplete.js.map

package/dist/tools/terminal.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTool } from "../config/types.js";
+export declare const runCommandTool: AgentTool;