@takimcizgisi/ajan 0.5.0

package/src/engine/llama.ts

@@ -0,0 +1,329 @@
+import {
+    getLlama,
+    getLlamaGpuTypes,
+    LlamaChatSession,
+    Gemma4ChatWrapper,
+    GemmaChatWrapper,
+    QwenChatWrapper,
+    Llama3_1ChatWrapper,
+    MistralChatWrapper,
+    ChatMLChatWrapper,
+    FunctionaryChatWrapper,
+    LlamaLogLevel,
+    type Llama,
+    type LlamaModel,
+    type LlamaContext,
+    type LlamaContextSequence,
+    type ChatWrapper,
+    type ChatSessionModelFunctions
+} from "node-llama-cpp";
+import type { AjanConfig, ChatWrapperName } from "../config/types.js";
+import { logger } from "../utils/paths.js";
+
+/** Motorun gerçekten üzerinde çalıştığı arka uç */
+export type ActiveGpu = {
+    /** "cpu" | "cuda" | "vulkan" | "metal" */
+    backend: string;
+    /** Katman aktarımı açık mı */
+    offload: boolean;
+};
+
+export type LlamaEngineOptions = {
+    modelPath: string;
+    config: AjanConfig;
+    chatWrapperName?: ChatWrapperName;
+    /** Düşünme (thought) üretimi açık mı; belirtilmezse sarmalayıcının varsayılanı. */
+    reasoning?: boolean;
+    /** Modele özel bağlam penceresi; yoksa config.contextSize kullanılır. */
+    contextSize?: AjanConfig["contextSize"];
+    /** Modele özel GPU katman sayısı; yoksa config.gpuLayers kullanılır. */
+    gpuLayers?: AjanConfig["gpuLayers"];
+    gpuBackend?: AjanConfig["gpu"];
+    onProgress?: (progress: number) => void;
+    signal?: AbortSignal;
+};
+
+export class LlamaEngine {
+    private llama: Llama | undefined;
+    private model: LlamaModel | undefined;
+    private context: LlamaContext | undefined;
+    private sequence: LlamaContextSequence | undefined;
+    private session: LlamaChatSession | undefined;
+    private readonly modelPath: string;
+    private readonly config: AjanConfig;
+    private readonly chatWrapperName?: ChatWrapperName;
+    /** Katalog + kullanıcı geçersiz kılmasından çözülmüş düşünme modu */
+    private readonly reasoning?: boolean;
+    private readonly contextSizeOption: AjanConfig["contextSize"];
+    private readonly gpuLayersOption: AjanConfig["gpuLayers"];
+    private readonly gpuBackend?: AjanConfig["gpu"];
+    private readonly onProgress?: (progress: number) => void;
+    private readonly signal?: AbortSignal;
+
+    constructor(options: LlamaEngineOptions) {
+        this.modelPath = options.modelPath;
+        this.config = options.config;
+        this.chatWrapperName = options.chatWrapperName;
+        this.reasoning = options.reasoning;
+        // Katalogdaki "auto" bir sayı değil, "config'e uy" demek: aksi halde
+        // modelin eğitim bağlamı (örn. 128K) CPU'da dev KV cache'e yol açıyor.
+        const modelContext = options.contextSize;
+        this.contextSizeOption = modelContext && modelContext !== "auto" ? modelContext : options.config.contextSize;
+        const modelLayers = options.gpuLayers;
+        this.gpuLayersOption = modelLayers && modelLayers !== "auto" ? modelLayers : options.config.gpuLayers;
+        this.gpuBackend = options.gpuBackend ?? options.config.gpu;
+        this.onProgress = options.onProgress;
+        this.signal = options.signal;
+    }
+
+    /**
+     * config.gpu değerini node-llama-cpp'in kabul ettiği arka uca çevirir.
+     * Önceden otomotik dışındaki seçimler (cuda/vulkan/metal) sessizce yok sayılıyordu;
+     * config'de açıkça seçilen arka uç artık motora iletilir.
+     */
+    private get gpuOption(): "auto" | "cuda" | "vulkan" | "metal" | undefined {
+        switch (this.gpuBackend) {
+            case "cuda":
+            case "cuda-llama":
+                return "cuda";
+            case "vulkan":
+            case "vulkan-llama":
+                return "vulkan";
+            case "metal":
+                return "metal";
+            case "auto":
+            default:
+                // webgpu vb. bu node-llama-cpp sürümünde desteklenmiyor; auto'ya düş.
+                return "auto";
+        }
+    }
+
+    /**
+     * Motorun deneyeceği arka uç sırası.
+     *
+     * Yalnızca CUDA ve Vulkan desteklenir. Sıra config.gpu ile başlar:
+     * kullanıcı "vulkan" dediyse CUDA denemesi yapılmaz, "cuda" dediyse
+     * CUDA denenir ve olmazsa Vulkan'a düşülür. Sondaki "auto" node-llama-cpp'ın
+     * kendi çözümlemesidir (CUDA yoksa Vulkan, o da yoksa CPU).
+     */
+    private get gpuFallbackChain(): ("auto" | "cuda" | "vulkan")[] {
+        const wanted = this.gpuOption;
+        if (wanted === "cuda") return ["cuda", "vulkan", "auto"];
+        if (wanted === "vulkan") return ["vulkan", "auto"];
+        if (wanted === "metal") return ["auto"];
+        return ["auto"];
+    }
+
+    static async detectSupportedGpus(): Promise<string[]> {
+        try {
+            const supported = await getLlamaGpuTypes("supported");
+            return supported.filter((g): g is "metal" | "cuda" | "vulkan" => typeof g === "string");
+        } catch {
+            return [];
+        }
+    }
+
+    /**
+     * Gerçekten yüklenen arka ucu döndürür.
+     *
+     * `detectSupportedGpus()` yalnızca "makine bu arka ucu destekliyor mu"
+     * diye bakar; kurulu build'de o pakete ait ikili yoksa node-llama-cpp
+     * sessizce CPU'ya düşer ve istemci yanlışlıkla GPU kullanıldığını sanar. `Llama.gpu`
+     * ise yüklenen gerçek değerdir.
+     */
+    get activeGpu(): ActiveGpu | null {
+        const llama = this.llama;
+        if (!llama) return null;
+        return {
+            backend: llama.gpu === false ? "cpu" : llama.gpu,
+            offload: llama.supportsGpuOffloading
+        };
+    }
+
+    /** Kullanılabilen GPU belleği (MB); CPU modunda 0 döner. */
+    async gpuVramMb(): Promise<number> {
+        if (!this.llama || this.llama.gpu === false) return 0;
+        try {
+            const info = await this.llama.getLlamaMemoryUsage();
+            return Math.round(info.gpuVram / (1024 * 1024));
+        } catch {
+            return 0;
+        }
+    }
+
+    async init(): Promise<void> {
+        if (this.llama) return;
+        logger.info(`Motor baslatiliyor... (model: ${this.modelPath})`);
+        const supportedGpus = await LlamaEngine.detectSupportedGpus();
+        logger.debug(`Desteklenen GPU'lar: ${supportedGpus.join(", ") || "yok (CPU)"}`);
+
+        // Sırayla dene: ilk yüklenen kazanır. Sessizce CPU'ya düşmüyoruz —
+        // kullanıcı hangi adaya geçildiğini ve nedenini görsün.
+        const chain = this.gpuFallbackChain;
+        const failures: string[] = [];
+        for (const candidate of chain) {
+            try {
+                this.llama = await getLlama({
+                    gpu: candidate,
+                    logLevel: LlamaLogLevel.error,
+                    progressLogs: "stderr",
+                    skipDownload: true
+                });
+                this.reportGpuChoice(candidate, chain.length > 1, supportedGpus);
+                return;
+            } catch (err) {
+                const reason = firstLine((err as Error).message);
+                failures.push(`${candidate}: ${reason}`);
+                logger.warn(`${candidate} kullanilamadi (${reason})`);
+            }
+        }
+
+        // Zincirin tamamı tuttu. Sessiz yavaşlamak yerine açıkça hata ver.
+        throw new Error(
+            `GPU motoru baslatilamadi. Denenenler -> ${failures.join(" | ")}`
+        );
+    }
+
+    /**
+     * İstenen arka uç ile gerçekte yüklenen arka uç farklıysa gürültü atma,
+     * logla. Kullanıcı "CUDA seçtim ama CPU'da çalışıyor" krizini önceden görsün.
+     */
+    private reportGpuChoice(loaded: string, hadFallbacks: boolean, supportedGpus: string[]): void {
+        const active = this.activeGpu?.backend;
+        if (!active) return;
+        if (active === "cpu") {
+            logger.warn(
+                `GPU kullanilamiyor, CPU uzerinde calisiliyor. ` +
+                    `istenen: ${this.gpuOption} · makinede: ${supportedGpus.join(", ") || "yok"}`
+            );
+            return;
+        }
+        if (!hadFallbacks) return;
+        if (loaded === "auto" && active !== this.gpuOption) {
+            logger.warn(`istenen arka uc ${this.gpuOption}, yuklenen ${active}`);
+        } else {
+            logger.info(`GPU arka ucu: ${active}`);
+        }
+    }
+
+    /** Modelin kaç katmanını GPU'ya yükledi (0 = tamamen CPU'da). */
+    get gpuLayersUsed(): number {
+        return this.model?.gpuLayers ?? 0;
+    }
+
+    async loadModel(onProgress?: (pct: number) => void): Promise<void> {
+        await this.init();
+        if (this.model) return;
+        logger.info(`Model yukleniyor: ${this.modelPath}`);
+
+        this.model = await this.llama!.loadModel({
+            modelPath: this.modelPath,
+            gpuLayers: this.gpuLayersOption ?? "auto",
+            onLoadProgress: (pct) => {
+                const percentage = Math.min(100, Math.max(0, Math.round(pct * 100)));
+                onProgress?.(percentage);
+                this.onProgress?.(percentage);
+            },
+            loadSignal: this.signal
+        });
+    }
+
+    async createContext(): Promise<void> {
+        await this.loadModel();
+        if (this.context) return;
+        this.context = await this.model!.createContext({
+            contextSize: this.contextSizeOption ?? "auto"
+        });
+        this.sequence = this.context.getSequence();
+    }
+
+    createSession(systemPrompt: string): LlamaChatSession {
+        if (!this.sequence) throw new Error("Oturum olusturmadan once context olusturulmali (createContext)");
+        const wrapper = resolveChatWrapper(this.chatWrapperName ?? "auto", this.reasoning);
+        this.session = new LlamaChatSession({
+            contextSequence: this.sequence,
+            systemPrompt,
+            chatWrapper: wrapper
+        });
+        return this.session;
+    }
+
+    /** Konuşma geçmişini temizler ve yeni sistem promptu ile taze bir oturum kurar */
+    async resetSession(systemPrompt: string): Promise<LlamaChatSession> {
+        if (!this.sequence) throw new Error("Oturum olusturmadan once context olusturulmali (createContext)");
+        await this.session?.dispose();
+        await this.sequence.clearHistory();
+        return this.createSession(systemPrompt);
+    }
+
+    getSession(): LlamaChatSession | undefined {
+        return this.session;
+    }
+
+    get contextSize(): number {
+        return this.context?.contextSize ?? 0;
+    }
+
+    getUsedContextTokens(): number {
+        return this.sequence?.nextTokenIndex ?? 0;
+    }
+
+    get sequenceInstalled(): boolean {
+        return this.sequence != null;
+    }
+
+    async dispose(): Promise<void> {
+        try {
+            this.session?.dispose();
+            this.context?.dispose();
+            this.model?.dispose();
+            this.llama?.dispose();
+        } catch {
+            /* dispose hatalari yut */
+        }
+        this.session = undefined;
+        this.context = undefined;
+        this.model = undefined;
+        this.llama = undefined;
+        this.sequence = undefined;
+    }
+}
+
+/**
+ * Chat sarmalayıcısını kurar.
+ *
+ * Düşünme seçeneği her sarmalayıcıda farklı ad taşır: Gemma4'te `reasoning`,
+ * Qwen3'te `thoughts`. Seçeneği olmayan sarmalayıcılara dokunulmaz, böylece
+ * kapatılmış bir düşünme onların şablonunu bozmaz.
+ */
+function resolveChatWrapper(name: ChatWrapperName, reasoning?: boolean): "auto" | ChatWrapper {
+    switch (name) {
+        case "gemma4":
+            return new Gemma4ChatWrapper({ reasoning: reasoning ?? true });
+        case "gemma":
+            return new GemmaChatWrapper();
+        case "qwen3":
+            // QwenChatWrapper boolean kabul etmez: "discourage" modeli düşünmekten
+            // vazgeçirir, "auto" normal davranışı verir.
+            return new QwenChatWrapper({ thoughts: reasoning === false ? "discourage" : "auto" });
+        case "llama3":
+            return new Llama3_1ChatWrapper();
+        case "mistral":
+            return new MistralChatWrapper();
+        case "chatml":
+            return new ChatMLChatWrapper();
+        case "functionary":
+            return new FunctionaryChatWrapper();
+        case "auto":
+        default:
+            return "auto";
+    }
+}
+
+export type { ChatSessionModelFunctions };
+
+/** Hata mesajının ilk satırı; node-llama-cpp çok satırlı hata veriyor. */
+function firstLine(message: string): string {
+    const line = message.split("\n").find((l) => l.trim().length > 0) ?? message;
+    return line.trim().slice(0, 160);
+}

package/src/engine/modelManager.ts

@@ -0,0 +1,84 @@
+import { existsSync, statSync } from "node:fs";
+import { createModelDownloader } from "node-llama-cpp";
+import type { ModelDefinition } from "../config/types.js";
+import { resolveModelFilePath } from "../config/configManager.js";
+import { getModelsDir } from "../utils/paths.js";
+import { logger } from "../utils/paths.js";
+
+export type DownloadProgress = {
+    totalSize: number;
+    downloadedSize: number;
+    estimatedTimeLeft: number;
+    averageSpeed: number;
+    percent?: number;
+};
+
+export type DownloadOptions = {
+    onProgress?: (progress: DownloadProgress) => void;
+    signal?: AbortSignal;
+};
+
+export function formatBytes(bytes: number): string {
+    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: number): string {
+    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: ModelDefinition,
+    options: DownloadOptions = {}
+): Promise<string> {
+    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);
+        }
+    });
+
+    const downloadedPath = await downloader.download({ signal: options.signal });
+    logger.info(`Model indirildi: ${downloadedPath}`);
+    return downloadedPath;
+}
+
+export function getModelFileSize(path: string): number {
+    try {
+        return statSync(path).size;
+    } catch {
+        return 0;
+    }
+}
+
+export function isDownloaded(model: ModelDefinition): boolean {
+    return existsSync(resolveModelFilePath(model));
+}

package/src/index.ts

@@ -0,0 +1,63 @@
+export { AjanAgent, type AgentOptions, type AgentEvents } from "./core/agent.js";
+export { AjanService, type ServiceEvents, type ModelWithStatus } from "./service.js";
+export { LlamaEngine } 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,
+    ReasoningMode,
+    ModelOverride
+} from "./config/types.js";
+export { getDataDir, getModelsDir, getConfigPath, getLogDir, setLogLevel, logger } from "./utils/paths.js";
+
+// IPC yüzeyi: tüketiciler motoru `AjanEngine` ile konuşturur, CLI gerekmez.
+export { AjanEngine, EngineError, type AskOptions, type EngineEventListener } from "./client/client.js";
+export {
+    PROTOCOL_VERSION,
+    isRequestFrame,
+    isEventFrame,
+    isResponseFrame,
+    type Request,
+    type RequestType,
+    type RequestFrame,
+    type ResponseFrame,
+    type ServerFrame,
+    type EventFrame,
+    type EventName,
+    type Result,
+    type StatusReport,
+    type GpuReport,
+    type ModelEntry,
+    type SessionSummary,
+    type HistoryMessage
+} from "./protocol/messages.js";
+export { defaultSocketPath, ClientChannel, serveChannel, send } from "./protocol/channel.js";

package/src/protocol/channel.ts

@@ -0,0 +1,151 @@
+/**
+ * Newline-JSON çerçeveleme.
+ *
+ * `net.Socket`, `worker_threads` veya `process.stdin` gibi herhangi bir ikili
+ * akışı üzerinde çalışır. Yazma tarafı parçalara bölünebilir, okuma tarafı
+ * parça sınırlarından bağımsız olarak satır birleştirir.
+ */
+import type { RequestFrame, ServerFrame } from "./messages.js";
+
+/** Yazılabilir akış: net.Socket veya benzeri herhangi bir duplex bağlantı */
+type Writable = NodeJS.ReadWriteStream & { write: (chunk: string) => unknown };
+
+/** Windows named pipe yolu; POSIX'te XDG_RUNTIME_DIR (yoksa tmp) kullanılır. */
+export function defaultSocketPath(app = "ajan-engine"): string {
+    if (process.platform === "win32") return `\\\\.\\pipe\\${app}`;
+    const dir = process.env.XDG_RUNTIME_DIR || "/tmp";
+    return `${dir}/${app}.sock`;
+}
+
+/**
+ * Sunucu tarafı: bağlantıdan satır satır okur, `onRequest` çağırır.
+ * Yazmak için `send` döner.
+ */
+export function serveChannel(
+    socket: Writable,
+    onRequest: (frame: RequestFrame, socket: Writable) => void,
+    onError?: (err: Error) => void
+): void {
+    let buffer = "";
+    socket.setEncoding?.("utf8");
+    socket.on("data", (chunk: string | Buffer) => {
+        buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        // Normalde tek satır gelir; uzun yazılar (diff, patch) bölünmüş gelebilir.
+        let index = buffer.indexOf("\n");
+        while (index !== -1) {
+            const line = buffer.slice(0, index).trim();
+            buffer = buffer.slice(index + 1);
+            if (line.length > 0) {
+                try {
+                    const parsed = JSON.parse(line) as unknown;
+                    onRequest(parsed as RequestFrame, socket);
+                } catch (err) {
+                    onError?.(new Error(`bozuk JSON: ${(err as Error).message}`));
+                }
+            }
+            index = buffer.indexOf("\n");
+        }
+    });
+    socket.on("error", (err) => onError?.(err as Error));
+}
+
+export function send(socket: Writable, frame: ServerFrame | RequestFrame): void {
+    socket.write(JSON.stringify(frame) + "\n");
+}
+
+/**
+ * İstemci tarafı: yanıt ve olayları ayırır, `id` eşleşen isteğe çözer.
+ * Bağlantı kurulmadan bağımsız çalışır; bağlanmayı `connect` yapar.
+ */
+export class ClientChannel {
+    private buffer = "";
+    private nextId = 1;
+    private socket: Writable | undefined;
+    private readonly pending = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+
+    constructor(
+        private readonly onEvent: (e: Extract<ServerFrame, { event: string }>) => void,
+        private readonly onClose: (reason?: Error) => void = () => {}
+    ) {}
+
+    /** Sokete bağlar ve akışı dinlemeye başlar. */
+    attach(socket: Writable): void {
+        this.socket = socket;
+        socket.setEncoding?.("utf8");
+        socket.on("data", (chunk: string | Buffer) => this.feed(typeof chunk === "string" ? chunk : chunk.toString("utf8")));
+        socket.on("error", (err) => {
+            // Koptuk: bekleyen istekler sonsuza kadar asılı kalmasın.
+            this.failAll((err as Error).message);
+            this.onClose(err as Error);
+        });
+        socket.on("close", () => {
+            this.failAll("bağlantı kapandı");
+            this.onClose();
+        });
+    }
+
+    /**
+     * Bağlantıyı kapatır ve bekleyen istekleri reddeder.
+     *
+     * `end` tek yönlü kapatır; istek yazan taraf da soketi kapatabilsin diye
+     * varsa `destroy` ile tamamen yok edilir. Zaten kapanmışsa bir şey yapılmaz.
+     */
+    close(): void {
+        this.failAll("istemci kapatildi");
+        const socket = this.socket as (Writable & { destroy?: () => void }) | undefined;
+        this.socket = undefined;
+        socket?.destroy?.();
+    }
+
+    request(req: RequestFrame["req"]): Promise<{ ok: true; result: unknown } | { ok: false; error: string }> {
+        if (!this.socket) return Promise.resolve({ ok: false, error: "kanal bağlı değil" });
+        const id = this.nextId++;
+        return new Promise((resolve) => {
+            // Kopma halinde asılı kalmayalım: reject değil, hata çözülür.
+            this.pending.set(id, {
+                resolve: resolve as (v: unknown) => void,
+                reject: (e) => resolve({ ok: false, error: e.message })
+            });
+            this.socket!.write(JSON.stringify({ id, req } satisfies RequestFrame) + "\n");
+        });
+    }
+
+    private feed(text: string): void {
+        this.buffer += text;
+        let index = this.buffer.indexOf("\n");
+        while (index !== -1) {
+            const line = this.buffer.slice(0, index).trim();
+            this.buffer = this.buffer.slice(index + 1);
+            if (line.length > 0) this.handle(line);
+            index = this.buffer.indexOf("\n");
+        }
+    }
+
+    private handle(line: string): void {
+        let frame: unknown;
+        try {
+            frame = JSON.parse(line);
+        } catch {
+            return; // bozuk satırı yoksay; bağlantıyı düşürme
+        }
+        const f = frame as { id?: number; event?: string };
+        if (typeof f.event === "string") {
+            this.onEvent(frame as Extract<ServerFrame, { event: string }>);
+            return;
+        }
+        if (typeof f.id === "number") {
+            const entry = this.pending.get(f.id);
+            if (!entry) return;
+            this.pending.delete(f.id);
+            const r = frame as { ok: true; result: unknown } | { ok: false; error: string };
+            if (r.ok) entry.resolve({ ok: true, result: r.result });
+            else entry.resolve({ ok: false, error: r.error });
+        }
+    }
+
+    /** Bağlantı koparken bekleyen istekleri reddet; çağıran takılmasın. */
+    failAll(error: string): void {
+        for (const [, entry] of this.pending) entry.reject(new Error(error));
+        this.pending.clear();
+    }
+}