@takimcizgisi/ajan 0.2.5

package/dist/engine/modelManager.js

@@ -0,0 +1,73 @@
+import { existsSync, statSync } from "node:fs";
+import { createModelDownloader } from "node-llama-cpp";
+import { resolveModelFilePath } from "../config/configManager.js";
+import { getModelsDir } from "../utils/paths.js";
+import { logger } from "../utils/paths.js";
+export function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return "?";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    return `${value.toFixed(unit === 0 ? 0 : 2)} ${units[unit]}`;
+}
+export function formatTime(ms) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return "?";
+    const totalSeconds = Math.floor(ms / 1000);
+    const h = Math.floor(totalSeconds / 3600);
+    const m = Math.floor((totalSeconds % 3600) / 60);
+    const s = totalSeconds % 60;
+    if (h > 0)
+        return `${h}sa ${m}dk`;
+    if (m > 0)
+        return `${m}dk ${s}sn`;
+    return `${s}sn`;
+}
+export async function downloadModel(model, options = {}) {
+    const dirPath = getModelsDir();
+    const targetPath = resolveModelFilePath(model);
+    if (existsSync(targetPath)) {
+        logger.info(`Model zaten mevcut: ${targetPath}`);
+        return targetPath;
+    }
+    logger.info(`Model indiriliyor: ${model.uri}`);
+    const downloader = await createModelDownloader({
+        modelUri: model.uri,
+        dirPath,
+        fileName: model.fileName,
+        skipExisting: true,
+        deleteTempFileOnCancel: false,
+        showCliProgress: false,
+        onProgress: (status) => {
+            options.onProgress?.(status);
+            if (options.showProgress) {
+                const pct = status.totalSize > 0 ? Math.round((status.downloadedSize / status.totalSize) * 100) : 0;
+                const speed = `${formatBytes(status.averageSpeed)}/sn`;
+                const eta = formatTime(status.estimatedTimeLeft);
+                process.stdout.write(`\r  [indirme] %${pct} · ${formatBytes(status.downloadedSize)}/${formatBytes(status.totalSize)} · ${speed} · kalan ${eta}   `);
+            }
+        }
+    });
+    const downloadedPath = await downloader.download({ signal: options.signal });
+    if (options.showProgress)
+        process.stdout.write("\n");
+    logger.info(`Model indirildi: ${downloadedPath}`);
+    return downloadedPath;
+}
+export function getModelFileSize(path) {
+    try {
+        return statSync(path).size;
+    }
+    catch {
+        return 0;
+    }
+}
+export function isDownloaded(model) {
+    return existsSync(resolveModelFilePath(model));
+}
+//# sourceMappingURL=modelManager.js.map

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { AjanAgent, type AgentOptions, type AgentEvents } from "./core/agent.js";
+export { AjanService, type ServiceEvents, type ModelWithStatus } from "./service.js";
+export { LlamaEngine, resolveChatWrapper } from "./engine/llama.js";
+export { downloadModel, formatBytes, formatTime, isDownloaded, getModelFileSize, type DownloadProgress } from "./engine/modelManager.js";
+export { DEFAULT_CONFIG, loadConfig, saveConfig, getModelsRegistry, getModelById, refreshRemoteModels, listInstalledModels, isModelInstalled, removeModelFile, resolveModelFilePath } from "./config/configManager.js";
+export { createCoreTools, buildSessionFunctions } from "./tools/registry.js";
+export { parseUnifiedDiff } from "./tools/patch.js";
+export type { AjanConfig, ModelDefinition, RemoteModelsRegistry, SessionConfig, AgentTool, ToolHandler, ToolExecutionContext, ToolExecutionResult, ChatWrapperName, GpuBackend } from "./config/types.js";
+export { getDataDir, getModelsDir, getConfigPath, getLogDir, setLogLevel, logger } from "./utils/paths.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { AjanAgent } from "./core/agent.js";
+export { AjanService } from "./service.js";
+export { LlamaEngine, resolveChatWrapper } from "./engine/llama.js";
+export { downloadModel, formatBytes, formatTime, isDownloaded, getModelFileSize } from "./engine/modelManager.js";
+export { DEFAULT_CONFIG, loadConfig, saveConfig, getModelsRegistry, getModelById, refreshRemoteModels, listInstalledModels, isModelInstalled, removeModelFile, resolveModelFilePath } from "./config/configManager.js";
+export { createCoreTools, buildSessionFunctions } from "./tools/registry.js";
+export { parseUnifiedDiff } from "./tools/patch.js";
+export { getDataDir, getModelsDir, getConfigPath, getLogDir, setLogLevel, logger } from "./utils/paths.js";
+//# sourceMappingURL=index.js.map

package/dist/service.d.ts

@@ -0,0 +1,90 @@
+import type { ChatHistoryItem } from "node-llama-cpp";
+import { type AgentEvents } from "./core/agent.js";
+import type { StoredSession } from "./utils/sessions.js";
+import type { AjanConfig, ModelDefinition } from "./config/types.js";
+export type ServiceEvents = AgentEvents & {
+    onModelLoadProgress?: (pct: number) => void;
+    onModelLoadComplete?: () => void;
+};
+export type ModelWithStatus = {
+    model: ModelDefinition;
+    path: string;
+    installed: boolean;
+    active: boolean;
+};
+export declare class AjanService {
+    private agent;
+    private config;
+    private events;
+    private _active;
+    private _currentAbort;
+    constructor(events?: ServiceEvents);
+    private ensureAgent;
+    /** Event'leri güncelle (Electron IPC yeniden bağlanırken kullanılır) */
+    updateEvents(events: ServiceEvents): void;
+    sendMessage(message: string, modelId?: string): Promise<{
+        ok: boolean;
+        response?: string;
+        steps?: number;
+        completed?: boolean;
+        error?: string;
+    }>;
+    abort(): void;
+    reset(): Promise<void>;
+    getChatHistory(): ChatHistoryItem[];
+    setChatHistory(history: ChatHistoryItem[]): void;
+    getContextStats(): {
+        usedTokens: number;
+        contextSize: number;
+    } | null;
+    getConfig(): AjanConfig;
+    setConfig(patch: Record<string, unknown>): Promise<void>;
+    listProjects(): {
+        path: string;
+        active: boolean;
+    }[];
+    addProject(path: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    removeProject(path: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    setActiveProject(path: string | null): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    getModelInfo(): {
+        modelId: string;
+        name: string;
+        installed: boolean;
+    } | null;
+    listModels(): ModelWithStatus[];
+    installModel(modelId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    removeModel(modelId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    useModel(modelId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    refreshModels(): Promise<{
+        ok: boolean;
+        count?: number;
+        error?: string;
+    }>;
+    getModelsRegistry(): ModelDefinition[];
+    saveSession(session: StoredSession): Promise<void>;
+    loadSession(id: string): Promise<StoredSession | null>;
+    listSessions(): Promise<StoredSession[]>;
+    generateSessionId(): string;
+    detectGpu(): Promise<string[]>;
+    get isActive(): boolean;
+    private recreateAgent;
+    dispose(): Promise<void>;
+}

package/dist/service.js

@@ -0,0 +1,268 @@
+import { AjanAgent } from "./core/agent.js";
+import { loadConfig, saveConfig, getModelById, isModelInstalled, listInstalledModels as listInstalledFromDisk, removeModelFile, refreshRemoteModels, getModelsRegistry } from "./config/configManager.js";
+import { saveSession as saveSessionFile, loadSession as loadSessionFile, listSessions as listSessionsFromDisk, generateSessionId } from "./utils/sessions.js";
+export class AjanService {
+    agent = null;
+    config;
+    events;
+    _active = false;
+    _currentAbort = null;
+    constructor(events = {}) {
+        this.config = loadConfig();
+        this.events = events;
+    }
+    // ── Agent Lifecycle ──
+    ensureAgent() {
+        if (this.agent)
+            return;
+        this.agent = new AjanAgent({
+            config: this.config,
+            events: {
+                onTextChunk: this.events.onTextChunk,
+                onThinkingChunk: this.events.onThinkingChunk,
+                onToolCall: this.events.onToolCall,
+                onToolResult: this.events.onToolResult,
+                onComplete: this.events.onComplete,
+                onStepStart: this.events.onStepStart,
+                onStepEnd: this.events.onStepEnd,
+                onContextTrimmed: this.events.onContextTrimmed,
+                onError: this.events.onError
+            },
+            onLoadProgress: this.events.onModelLoadProgress,
+            onLoadComplete: this.events.onModelLoadComplete
+        });
+    }
+    /** Event'leri güncelle (Electron IPC yeniden bağlanırken kullanılır) */
+    updateEvents(events) {
+        this.events = events;
+        // Agent zaten varsa, yeni event'leri uygulamak için dispose + recreate gerekir
+        // Ancak çoğu durumda event'ler proxy üzerinden bağlanır, bu yüzden sadece saklıyoruz
+    }
+    // ── Prompt ──
+    async sendMessage(message, modelId) {
+        if (this._active)
+            return { ok: false, error: "Meşgul" };
+        // Model değişikliği varsa
+        if (modelId && modelId !== this.config.modelId) {
+            this.config.modelId = modelId;
+            saveConfig(this.config);
+            await this.recreateAgent();
+        }
+        this.ensureAgent();
+        if (!this.agent)
+            return { ok: false, error: "Agent başlatılamadı" };
+        this._active = true;
+        const controller = new AbortController();
+        this._currentAbort = controller;
+        try {
+            const result = await this.agent.promptTask(message, { signal: controller.signal });
+            return {
+                ok: true,
+                response: result.response,
+                steps: result.steps,
+                completed: result.completed
+            };
+        }
+        catch (err) {
+            if (controller.signal.aborted)
+                return { ok: false, error: "İptal edildi" };
+            return { ok: false, error: err.message };
+        }
+        finally {
+            if (this._currentAbort === controller)
+                this._currentAbort = null;
+            this._active = false;
+        }
+    }
+    abort() {
+        this._currentAbort?.abort();
+    }
+    async reset() {
+        this.agent?.resetConversation();
+    }
+    // ── History ──
+    getChatHistory() {
+        return this.agent?.getChatHistory() ?? [];
+    }
+    setChatHistory(history) {
+        this.agent?.setChatHistory(history);
+    }
+    getContextStats() {
+        return this.agent?.getContextStats() ?? null;
+    }
+    // ── Config ──
+    getConfig() {
+        return { ...this.config };
+    }
+    async setConfig(patch) {
+        const merged = { ...this.config, ...patch };
+        if (patch.session && typeof patch.session === "object") {
+            merged.session = { ...this.config.session, ...patch.session };
+        }
+        saveConfig(merged);
+        this.config = merged;
+        await this.recreateAgent();
+    }
+    // ── Projects ──
+    listProjects() {
+        const projects = this.config.projects ?? [];
+        return projects.map(path => ({ path, active: path === this.config.activeProject }));
+    }
+    async addProject(path) {
+        const projects = this.config.projects ?? [];
+        if (projects.includes(path))
+            return { ok: true };
+        this.config.projects = [...projects, path];
+        saveConfig(this.config);
+        return { ok: true };
+    }
+    async removeProject(path) {
+        const projects = this.config.projects ?? [];
+        this.config.projects = projects.filter(p => p !== path);
+        if (this.config.activeProject === path)
+            this.config.activeProject = undefined;
+        saveConfig(this.config);
+        return { ok: true };
+    }
+    async setActiveProject(path) {
+        if (path === null) {
+            this.config.activeProject = undefined;
+            saveConfig(this.config);
+            return { ok: true };
+        }
+        const projects = this.config.projects ?? [];
+        if (!projects.includes(path))
+            return { ok: false, error: `Proje kayıtlı değil: ${path}` };
+        this.config.activeProject = path;
+        saveConfig(this.config);
+        return { ok: true };
+    }
+    // ── Models ──
+    getModelInfo() {
+        const model = getModelById(this.config.modelId);
+        if (!model)
+            return null;
+        return {
+            modelId: model.id,
+            name: model.name,
+            installed: isModelInstalled(model)
+        };
+    }
+    listModels() {
+        const installed = listInstalledFromDisk();
+        return installed.map(item => ({
+            model: item.model,
+            path: item.path,
+            installed: item.installed,
+            active: item.model.id === this.config.modelId
+        }));
+    }
+    async installModel(modelId) {
+        const model = getModelById(modelId);
+        if (!model)
+            return { ok: false, error: `Model bulunamadı: ${modelId}` };
+        try {
+            const { downloadModel } = await import("./engine/modelManager.js");
+            await downloadModel(model, {
+                showProgress: true,
+                onProgress: (progress) => {
+                    const pct = progress.totalSize > 0
+                        ? Math.round((progress.downloadedSize / progress.totalSize) * 100)
+                        : progress.percent ?? 0;
+                    this.events.onModelLoadProgress?.(pct);
+                }
+            });
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+    async removeModel(modelId) {
+        const model = getModelById(modelId);
+        if (!model)
+            return { ok: false, error: `Model bulunamadı: ${modelId}` };
+        const removed = removeModelFile(model);
+        if (!removed)
+            return { ok: false, error: "Model dosyası bulunamadı" };
+        // Aktif model silindiyse config'i temizle/kurulu bir modele geç
+        if (this.config.modelId === modelId) {
+            const installed = listInstalledFromDisk().find(m => m.installed);
+            if (installed) {
+                this.config.modelId = installed.model.id;
+            }
+            else {
+                this.config.modelId = "";
+            }
+            saveConfig(this.config);
+            await this.recreateAgent();
+        }
+        return { ok: true };
+    }
+    async useModel(modelId) {
+        const model = getModelById(modelId);
+        if (!model)
+            return { ok: false, error: `Model bulunamadı: ${modelId}` };
+        if (!isModelInstalled(model))
+            return { ok: false, error: `Model kurulu değil: ${modelId}` };
+        this.config.modelId = modelId;
+        saveConfig(this.config);
+        await this.recreateAgent();
+        return { ok: true };
+    }
+    async refreshModels() {
+        try {
+            const models = await refreshRemoteModels();
+            return { ok: true, count: models.length };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+    getModelsRegistry() {
+        return getModelsRegistry();
+    }
+    // ── Sessions ──
+    async saveSession(session) {
+        await saveSessionFile(session);
+    }
+    async loadSession(id) {
+        const data = await loadSessionFile(id);
+        if (data && this.agent) {
+            this.agent.setChatHistory(data.history);
+        }
+        return data;
+    }
+    async listSessions() {
+        return await listSessionsFromDisk();
+    }
+    generateSessionId() {
+        return generateSessionId();
+    }
+    // ── GPU ──
+    async detectGpu() {
+        try {
+            const { LlamaEngine } = await import("./engine/llama.js");
+            return await LlamaEngine.detectSupportedGpus();
+        }
+        catch {
+            return [];
+        }
+    }
+    // ── Status ──
+    get isActive() {
+        return this._active;
+    }
+    // ── Internal ──
+    async recreateAgent() {
+        await this.agent?.dispose();
+        this.agent = null;
+        this.ensureAgent();
+    }
+    async dispose() {
+        this._currentAbort?.abort();
+        await this.agent?.dispose();
+        this.agent = null;
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/tools/data.d.ts

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

package/dist/tools/data.js

@@ -0,0 +1,111 @@
+import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import { load as loadYaml } from "js-yaml";
+import AdmZip from "adm-zip";
+import { limitOutput, resolveUserPath } from "./utils.js";
+function describeStructure(value, depth = 0) {
+    if (depth > 2)
+        return typeof value;
+    if (Array.isArray(value)) {
+        const sample = value.slice(0, 3).map((v) => describeStructure(v, depth + 1));
+        return `dizi[${value.length}]<${sample.join(", ")}${value.length > 3 ? ", …" : ""}>`;
+    }
+    if (value && typeof value === "object") {
+        const keys = Object.keys(value);
+        const shown = keys.slice(0, 12).map((k) => `${k}: ${describeStructure(value[k], depth + 1)}`);
+        return `nesne{${keys.length}}{ ${shown.join(", ")}${keys.length > 12 ? ", …" : ""} }`;
+    }
+    if (typeof value === "string")
+        return `metin(${value.length})`;
+    return String(value);
+}
+export const readDataTool = {
+    name: "read_data",
+    description: "JSON veya YAML dosyasını ayrıştırıp özetini ve yapısını döner. Yapılandırma dosyalarını incelemek için idealdir.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "JSON/YAML dosya yolu" }
+        },
+        required: ["path"]
+    },
+    handler: async (params, ctx) => {
+        const p = params.path?.trim();
+        if (!p)
+            return { ok: false, output: "path zorunludur." };
+        const filePath = resolveUserPath(ctx.cwd, p);
+        if (!existsSync(filePath))
+            return { ok: false, output: `Dosya bulunamadı: ${p}` };
+        if (!statSync(filePath).isFile())
+            return { ok: false, output: `Bu bir dosya değil: ${p}` };
+        const ext = extname(filePath).toLowerCase();
+        let data;
+        try {
+            const raw = readFileSync(filePath, "utf8");
+            if (ext === ".yaml" || ext === ".yml") {
+                data = loadYaml(raw);
+            }
+            else if (ext === ".json") {
+                data = JSON.parse(raw);
+            }
+            else {
+                try {
+                    data = JSON.parse(raw);
+                }
+                catch {
+                    data = loadYaml(raw);
+                }
+            }
+        }
+        catch (err) {
+            return { ok: false, output: `Ayrıştırma hatası: ${err.message}` };
+        }
+        const pretty = JSON.stringify(data, null, 2);
+        const summary = `Dosya: ${filePath}\nYapı: ${describeStructure(data)}\n\n${pretty}`;
+        return { ok: true, output: limitOutput(summary, Math.min(ctx.config.maxToolOutput ?? 40_000, 20_000)) };
+    }
+};
+export const unzipFileTool = {
+    name: "unzip_file",
+    description: "ZIP arşivini hedef klasöre açar. Hedef verilmezse zip'in yanına açılır.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "ZIP dosyası yolu" },
+            destination: { type: "string", description: "Hedef klasör (opsiyonel)" }
+        },
+        required: ["path"]
+    },
+    handler: async (params, ctx) => {
+        const p = params.path?.trim();
+        if (!p)
+            return { ok: false, output: "path zorunludur." };
+        const zipPath = resolveUserPath(ctx.cwd, p);
+        if (!existsSync(zipPath))
+            return { ok: false, output: `Dosya bulunamadı: ${p}` };
+        let destDir;
+        if (params.destination?.trim()) {
+            destDir = resolveUserPath(ctx.cwd, params.destination.trim());
+            if (!existsSync(destDir))
+                mkdirSync(destDir, { recursive: true });
+        }
+        else {
+            destDir = resolve(zipPath, "..");
+        }
+        try {
+            const zip = new AdmZip(zipPath);
+            const entries = zip.getEntries();
+            zip.extractAllTo(destDir, true);
+            const names = entries
+                .filter((e) => !e.isDirectory)
+                .slice(0, 30)
+                .map((e) => e.entryName);
+            const more = entries.length > 30 ? `\n… ve ${entries.length - 30} dosya daha` : "";
+            return { ok: true, output: `${entries.length} girdi açıldı → ${destDir}\n${names.join("\n")}${more}` };
+        }
+        catch (err) {
+            return { ok: false, output: `Açma başarısız: ${err.message}` };
+        }
+    }
+};
+//# sourceMappingURL=data.js.map

package/dist/tools/edit.d.ts

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

package/dist/tools/edit.js

@@ -0,0 +1,48 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolveUserPath } from "./utils.js";
+function normalizeLines(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+export const editFileTool = {
+    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, 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)` };
+    }
+};
+//# sourceMappingURL=edit.js.map

package/dist/tools/file.d.ts

@@ -0,0 +1,6 @@
+import type { AgentTool } from "../config/types.js";
+export declare const readFileTool: AgentTool;
+export declare const writeFileTool: AgentTool;
+export declare const listDirTool: AgentTool;
+export declare const searchFilesTool: AgentTool;
+export declare const grepTool: AgentTool;