@takimcizgisi/ajan 0.2.5

package/dist/config/configManager.d.ts

@@ -0,0 +1,18 @@
+import type { AjanConfig, ModelDefinition } from "./types.js";
+export declare const DEFAULT_CONFIG: AjanConfig;
+export declare function buildDefaultSystemPrompt(cwd: string): string;
+export declare function refreshRemoteModels(url?: string): Promise<ModelDefinition[]>;
+export declare function getModelsRegistry(): ModelDefinition[];
+export declare function getModelById(id: string): ModelDefinition | undefined;
+export declare function loadConfig(forceReload?: boolean): AjanConfig;
+export declare function saveConfig(config: AjanConfig): void;
+export declare function resolveModelFilePath(model: ModelDefinition): string;
+export declare function isModelInstalled(model: ModelDefinition): boolean;
+export declare function listInstalledModels(): {
+    model: ModelDefinition;
+    path: string;
+    installed: boolean;
+}[];
+export declare function removeModelFile(model: ModelDefinition): boolean;
+export declare function resolveAbsolutePath(cwd: string, inputPath: string): string;
+export declare function ensureConfigDir(): void;

package/dist/config/configManager.js

@@ -0,0 +1,204 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { join, basename, isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getConfigPath, getModelsDir, getCacheDir, getDataDir } from "../utils/paths.js";
+import { logger } from "../utils/paths.js";
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+export const DEFAULT_CONFIG = {
+    modelId: "gemma-4-e2b-q4-k-m",
+    contextSize: "auto",
+    gpuLayers: "auto",
+    gpu: "auto",
+    session: {
+        temperature: 0.6,
+        topK: 64,
+        topP: 0.9,
+        maxTokens: 8192
+    },
+    toolTimeout: 60_000,
+    maxToolOutput: 40_000,
+    contextTrimThreshold: 0.8,
+    maxSteps: 25,
+    beepOnComplete: true,
+    remoteModelsUrl: "https://raw.githubusercontent.com/takimcizgisi/ajan/main/config/models.json"
+};
+export function buildDefaultSystemPrompt(cwd) {
+    return [
+        "Sen AJAN AI'sin; TakimCizgisi Yazilim Gelistirme Grubu'nun OTONOM yerel kodlama ajanisin.",
+        "",
+        "ÇALIŞMA PROTOKOLÜ (her görev için):",
+        "1. Görevi parçalara böl; her parçayı ilgili araçla GERÇEKTEN uygula.",
+        "2. Her araç sonucunu gözlemle; hata varsa düzeltip tekrar dene. Pes etme, tarif etme — UYGULA.",
+        "3. Araç kullanılacak bir adım kaldıysa asla nihai yanıt yazma; aracı çağır.",
+        "4. Tüm adımlar bitince ve sonucu doğrulayınca task_complete aracını kısa bir raporla çağır.",
+        "5. Sohbet/soru ise doğrudan yanıtla (araç gerektirmiyorsa).",
+        "",
+        "KURALLAR:",
+        "- HER ZAMAN TÜRKÇE YANIT VER. Kullanıcı hangi dilde yazarsa yazsın yanıtların Türkçe olsun. Düşüncelerini de Türkçe yürüt.",
+        "- Bir aracı gerçekten çalıştırmadan 'yaptım', 'kaydettim', 'tamamlandı' deme.",
+        "- KRİTİK DÜRÜSTLÜK KURALI: Bir araç sonucu 'HATA' ile başlıyorsa işlem GERÇEKLEŞMEMİŞTİR. Bu durumda asla 'başarıyla oluşturuldu/okundu/tamamlandı' deme; hatayı olduğu gibi kullanıcıya bildir veya sorunu çözüp tekrar dene. Hata gördüğün halde başarı raporu vermek en ciddi hatadır.",
+        "- Dosya oluşturma/düzenlemede write_file, edit_file veya apply_patch kullan; dosyanın tam içeriğini yanıtta TEKRARLAMA, yalnızca yaptıklarını özetle.",
+        "- Bilgi eksikse makul varsayım yapıp devam et; kullanıcıya gereksiz soru sorma.",
+        "- CLI çıktısına uygun yaz: girinti yok, fazla boş satır yok, sıkı düzenli metin.",
+        "- Bir işlemi tamamladığını iddia etmeden önce doğrula: read_file/list_dir/run_command ile kontrol et; aracın döndürdüğü GERÇEK sonucu bildir.",
+        "- Küçük değişikliklerde edit_file; tam yeniden yazmada write_file kullan.",
+        `- Çalışma dizini: ${cwd}. Dosya yollarında göreli yol kullan (örn. src/index.ts).`,
+        "- Kullanıcı 'masaüstü', 'belgeler', 'indirilenler' derse gerçek Windows klasörleri (Desktop, Documents, Downloads) kastedilir.",
+        "- Kullanıcının kalıcı hafızası var: not_al/not_oku araçlarıyla önemli tercihleri saklayıp geri getirebilirsin."
+    ].join("\n");
+}
+const bundledModelsPath = join(__dirname, "..", "..", "config", "models.json");
+let cachedConfig;
+function readJson(path) {
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function resolveBundledModels() {
+    try {
+        const registry = readJson(bundledModelsPath);
+        if (Array.isArray(registry.models))
+            return registry.models;
+    }
+    catch (err) {
+        logger.debug(`Bundled models okunamadi: ${String(err)}`);
+    }
+    return [];
+}
+function resolveRemoteModels(url) {
+    if (!url)
+        return [];
+    const cachePath = join(getCacheDir(), "remote-models.json");
+    try {
+        const cached = readJson(cachePath);
+        if (cached && Array.isArray(cached.models)) {
+            logger.debug(`Remote models cache'ten okundu (${cached.models.length} model)`);
+            return cached.models;
+        }
+    }
+    catch {
+        /* cache yoksa umursama */
+    }
+    return [];
+}
+export async function refreshRemoteModels(url) {
+    const source = url ?? DEFAULT_CONFIG.remoteModelsUrl;
+    if (!source)
+        return [];
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 10_000);
+        const res = await fetch(source, { signal: controller.signal, redirect: "follow" });
+        clearTimeout(timer);
+        if (!res.ok) {
+            logger.debug(`Remote models fetch basarisiz: HTTP ${res.status}`);
+            return resolveRemoteModels(url);
+        }
+        const registry = (await res.json());
+        if (!Array.isArray(registry.models))
+            return [];
+        const cachePath = join(getCacheDir(), "remote-models.json");
+        writeFileSync(cachePath, JSON.stringify({ ...registry, updatedAt: new Date().toISOString() }, null, 2));
+        logger.info(`Remote model listesi guncellendi: ${registry.models.length} model`);
+        return registry.models;
+    }
+    catch (err) {
+        logger.debug(`Remote models guncelleme basarisiz: ${String(err)}`);
+        return resolveRemoteModels(url);
+    }
+}
+export function getModelsRegistry() {
+    const bundled = resolveBundledModels();
+    const remote = resolveRemoteModels(DEFAULT_CONFIG.remoteModelsUrl);
+    const merged = new Map();
+    for (const m of bundled)
+        merged.set(m.id, m);
+    for (const m of remote)
+        merged.set(m.id, m);
+    return [...merged.values()];
+}
+export function getModelById(id) {
+    return getModelsRegistry().find((m) => m.id === id);
+}
+export function loadConfig(forceReload = false) {
+    if (cachedConfig && !forceReload)
+        return cachedConfig;
+    const cfgPath = getConfigPath();
+    let fileCfg = {};
+    if (existsSync(cfgPath)) {
+        try {
+            fileCfg = readJson(cfgPath);
+        }
+        catch (err) {
+            logger.warn(`config.json parse hatasi (varsayilan kullaniliyor): ${String(err)}`);
+        }
+    }
+    // Donmuş/bayat sistem promptu diske asla yazılmaz ve okunmaz;
+    // içinde eski çalışma dizini kalabilir. Her açılışta taze üretilir.
+    delete fileCfg.systemPrompt;
+    cachedConfig = {
+        ...DEFAULT_CONFIG,
+        ...fileCfg,
+        session: { ...DEFAULT_CONFIG.session, ...fileCfg.session }
+    };
+    delete cachedConfig.cwd;
+    cachedConfig.systemPrompt = buildDefaultSystemPrompt(process.cwd());
+    return cachedConfig;
+}
+export function saveConfig(config) {
+    const cfgPath = getConfigPath();
+    const safe = JSON.parse(JSON.stringify(config));
+    delete safe.systemPrompt;
+    if (safe.session) {
+        for (const k of Object.keys(safe.session)) {
+            if (safe.session[k] == null)
+                delete safe.session[k];
+        }
+    }
+    writeFileSync(cfgPath, JSON.stringify(safe, null, 2));
+    cachedConfig = safe;
+}
+export function resolveModelFilePath(model) {
+    const modelsDir = getModelsDir();
+    const fileName = model.fileName ?? basename(model.uri);
+    return join(modelsDir, fileName);
+}
+export function isModelInstalled(model) {
+    return existsSync(resolveModelFilePath(model));
+}
+export function listInstalledModels() {
+    const modelsDir = getModelsDir();
+    if (!existsSync(modelsDir))
+        return [];
+    const entries = getModelsRegistry();
+    const result = [];
+    for (const model of entries) {
+        result.push({
+            model,
+            path: resolveModelFilePath(model),
+            installed: isModelInstalled(model)
+        });
+    }
+    return result;
+}
+export function removeModelFile(model) {
+    const file = resolveModelFilePath(model);
+    if (!existsSync(file))
+        return false;
+    try {
+        rmSync(file, { force: true });
+        return true;
+    }
+    catch (err) {
+        logger.error(`Model silinemedi: ${String(err)}`);
+        return false;
+    }
+}
+export function resolveAbsolutePath(cwd, inputPath) {
+    if (isAbsolute(inputPath))
+        return inputPath;
+    return join(cwd, inputPath);
+}
+export function ensureConfigDir() {
+    mkdirSync(getDataDir(), { recursive: true });
+    mkdirSync(getModelsDir(), { recursive: true });
+}
+//# sourceMappingURL=configManager.js.map

package/dist/config/types.d.ts

@@ -0,0 +1,98 @@
+export type ChatWrapperName = "auto" | "gemma4" | "gemma" | "qwen3" | "llama3" | "mistral" | "functionary" | "chatml";
+export type GpuBackend = "auto" | "metal" | "cuda" | "vulkan" | "webgpu" | "cuda-llama" | "vulkan-llama";
+export type ModelDefinition = {
+    /** Benzersiz model kimliği */
+    id: string;
+    /** Görünen ad */
+    name: string;
+    /** Açıklama */
+    description?: string;
+    /** İndirme URI'si (hf:..., https://...) */
+    uri: string;
+    /** Yerel dosya adı (yoksa uri'den türetilir) */
+    fileName?: string;
+    /** Bağlam penceresi boyutu */
+    contextSize?: number | "auto";
+    /** GPU katman sayısı */
+    gpuLayers?: number | "auto" | "max";
+    /** Chat sarmalayıcı adı */
+    chatWrapper?: ChatWrapperName;
+    /** Muhakeme (reasoning) modu */
+    reasoning?: boolean;
+    /** Multimodal (görüntü) desteği */
+    multimodal?: boolean;
+    /** Dosya boyutu (bayt) — indirme kontrolü için */
+    size?: number;
+    /** Dosya sha256 sağlaması */
+    sha256?: string;
+    /** Özel yapılandırma (modele özgü parametreler) */
+    options?: Record<string, unknown>;
+};
+export type RemoteModelsRegistry = {
+    version: number;
+    source?: string;
+    updatedAt?: string;
+    models: ModelDefinition[];
+};
+export type SessionConfig = {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxTokens?: number;
+    seed?: number;
+    repeatPenalty?: number;
+    dryRepeatPenalty?: boolean;
+};
+export type AjanConfig = {
+    /** Seçili model kimliği */
+    modelId: string;
+    /** Sistem promptu */
+    systemPrompt?: string;
+    /** Bağlam boyutu */
+    contextSize?: number | "auto";
+    /** GPU katman sayısı */
+    gpuLayers?: number | "auto" | "max";
+    /** GPU arka ucu */
+    gpu?: GpuBackend;
+    /** Oturum parametreleri */
+    session?: SessionConfig;
+    /** Araç çalıştırma zaman aşımı (ms) */
+    toolTimeout?: number;
+    /** Araçlarda döndürülen maks. çıktı uzunluğu (karakter) */
+    maxToolOutput?: number;
+    /** Context dolunca eski turların kırpılacağı eşik (0-1, contextSize oranı) */
+    contextTrimThreshold?: number;
+    /** Otonom görev başına maksimum araç-adımı (varsayılan 25) */
+    maxSteps?: number;
+    /** Çalıştırılması engellenecek komut desenleri (regex) */
+    blockedCommands?: string[];
+    /** Görev tamamlanınca bip çal */
+    beepOnComplete?: boolean;
+    /** Remote models.json kaynağı (GitHub vb.) */
+    remoteModelsUrl?: string;
+    /** Kayıtlı projeler (klasör yolları) */
+    projects?: string[];
+    /** Aktif proje yolu */
+    activeProject?: string;
+};
+export type ToolHandler<Params = any> = (params: Params, ctx: ToolExecutionContext) => Promise<ToolExecutionResult> | ToolExecutionResult;
+export type ToolExecutionSignal = {
+    /** task_complete aracı çağrıldığında true olur */
+    taskCompleted?: boolean;
+};
+export type ToolExecutionContext = {
+    cwd: string;
+    config: AjanConfig;
+    signals?: ToolExecutionSignal;
+};
+export type ToolExecutionResult = {
+    ok: boolean;
+    output: string;
+    error?: string;
+};
+export type AgentTool = {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    handler: ToolHandler;
+};

package/dist/config/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/agent.d.ts

@@ -0,0 +1,88 @@
+import type { ChatHistoryItem } from "node-llama-cpp";
+import type { AgentTool, AjanConfig, ModelDefinition } from "../config/types.js";
+export type AgentEvents = {
+    /** Model token token üretirken (akış) */
+    onTextChunk?: (text: string) => void;
+    /** Model düşünce/akıl yürütme segmentleri üretirken (akış) */
+    onThinkingChunk?: (text: string) => void;
+    /** Bir araç çağrılmadan önce */
+    onToolCall?: (name: string, params: unknown) => void;
+    /** Bir araç sonucu döndüğünde */
+    onToolResult?: (name: string, ok: boolean, output: string) => void;
+    /** Nihai yanıt tamamlandığında */
+    onComplete?: (response: string) => void;
+    /** Otonom bir adım başladığında */
+    onStepStart?: (step: number, maxSteps: number) => void;
+    /** Otonom adım bittiğinde (o turdaki araç çağrısı sayısıyla) */
+    onStepEnd?: (step: number, maxSteps: number, toolCalls: number) => void;
+    /** Context sıkıştırıldığında (eski turlar kırpıldı) */
+    onContextTrimmed?: (removedItems: number) => void;
+    /** Hata oluştuğunda */
+    onError?: (error: Error) => void;
+};
+export type AgentOptions = {
+    model?: ModelDefinition;
+    config?: AjanConfig;
+    modelPath?: string;
+    systemPrompt?: string;
+    tools?: AgentTool[];
+    events?: AgentEvents;
+    onLoadProgress?: (pct: number) => void;
+    onLoadComplete?: () => void;
+    signal?: AbortSignal;
+    temperature?: number;
+};
+export declare class AjanAgent {
+    private engine;
+    private session;
+    private readonly model;
+    private readonly config;
+    private readonly modelPath;
+    private systemPrompt;
+    private readonly tools;
+    private readonly events;
+    private readonly onLoadProgress?;
+    private readonly onLoadComplete?;
+    private readonly signal?;
+    private readonly temperature?;
+    private pendingHistory;
+    constructor(options: AgentOptions);
+    get engineInfo(): {
+        modelPath: string;
+        modelId: string;
+    };
+    /** TUI göstergesi için bağlam doluluk bilgisi */
+    getContextStats(): {
+        usedTokens: number;
+        contextSize: number;
+    } | null;
+    private ensureSession;
+    prompt(userPrompt: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /**
+     * Otonom görev yürütme: model araç çağrılarıyla görevi adım adım tamamlar.
+     * Döngü şuralarda biter: task_complete aracı, araçsız bir tur (nihai özet),
+     * adım bütçesi dolması veya iptal sinyali.
+     */
+    promptTask(userPrompt: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        response: string;
+        steps: number;
+        maxSteps: number;
+        completed: boolean;
+        budgetExhausted: boolean;
+    }>;
+    /** Context eşiğini aşınca eski konuşma turlarını baştan kırpar (system promptu korunur) */
+    private trimContextIfNeeded;
+    /** Oturumdaki geçmişi temizler (yeni konuşma) */
+    resetConversation(): void;
+    /** Aktif oturumun geçmişini döndürür (oturum yoksa bekleyen geçmişi) */
+    getChatHistory(): ChatHistoryItem[];
+    /** Oturum geçmişini yükler; oturum henüz kurulmadıysa ilk kurulumda uygulanır */
+    setChatHistory(history: ChatHistoryItem[]): void;
+    /** Sistem promptunu değiştirir; aktif oturum varsa geçmiş temizlenip yeni sistem promptuyla yeniden kurulur */
+    setSystemPrompt(prompt: string): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/core/agent.js

@@ -0,0 +1,222 @@
+import { LlamaEngine } from "../engine/llama.js";
+import { buildSessionFunctions, createCoreTools } from "../tools/registry.js";
+import { getModelById, loadConfig, resolveModelFilePath, buildDefaultSystemPrompt } from "../config/configManager.js";
+import { loadProjectContext } from "../utils/projectContext.js";
+import { logger } from "../utils/paths.js";
+function historyItemText(item) {
+    if (item.type === "system" || item.type === "user") {
+        return typeof item.text === "string" ? item.text : JSON.stringify(item.text);
+    }
+    return item.response.filter((p) => typeof p === "string").join("\n");
+}
+export class AjanAgent {
+    engine;
+    session;
+    model;
+    config;
+    modelPath;
+    systemPrompt;
+    tools;
+    events;
+    onLoadProgress;
+    onLoadComplete;
+    signal;
+    temperature;
+    pendingHistory;
+    constructor(options) {
+        const config = options.config ?? loadConfig();
+        this.config = config;
+        this.events = options.events ?? {};
+        this.onLoadProgress = options.onLoadProgress;
+        this.onLoadComplete = options.onLoadComplete;
+        this.signal = options.signal;
+        this.temperature = options.temperature;
+        if (options.model) {
+            this.model = options.model;
+        }
+        else {
+            const id = config.modelId;
+            const found = getModelById(id);
+            if (!found) {
+                throw new Error(`Model bulunamadı: ${id}. 'ajan model list' ile uygun modelleri görün.`);
+            }
+            this.model = found;
+        }
+        this.modelPath = options.modelPath ?? resolveModelFilePath(this.model);
+        // Sistem promptu her açılışta güncel çalışma diziniyle taze üretilir;
+        // config.systemPrompt yok sayılır (bayat cwd içermesin diye).
+        this.systemPrompt =
+            (options.systemPrompt ?? buildDefaultSystemPrompt(process.cwd())) +
+                loadProjectContext(process.cwd());
+        this.tools = options.tools ?? createCoreTools({ cwd: process.cwd(), config });
+    }
+    get engineInfo() {
+        return { modelPath: this.modelPath, modelId: this.model.id };
+    }
+    /** TUI göstergesi için bağlam doluluk bilgisi */
+    getContextStats() {
+        if (!this.engine)
+            return null;
+        return {
+            usedTokens: this.engine.getUsedContextTokens(),
+            contextSize: this.engine.contextSize
+        };
+    }
+    async ensureSession(signal) {
+        if (this.session)
+            return this.session;
+        this.engine = new LlamaEngine({
+            modelPath: this.modelPath,
+            config: this.config,
+            chatWrapperName: this.model.chatWrapper,
+            onProgress: (pct) => this.onLoadProgress?.(pct),
+            signal: signal ?? this.signal
+        });
+        await this.engine.createContext();
+        this.onLoadComplete?.();
+        this.session = this.engine.createSession(this.systemPrompt);
+        if (this.pendingHistory) {
+            this.session.setChatHistory(this.pendingHistory);
+            this.pendingHistory = undefined;
+        }
+        return this.session;
+    }
+    async prompt(userPrompt, options) {
+        const result = await this.promptTask(userPrompt, options);
+        return result.response;
+    }
+    /**
+     * Otonom görev yürütme: model araç çağrılarıyla görevi adım adım tamamlar.
+     * Döngü şuralarda biter: task_complete aracı, araçsız bir tur (nihai özet),
+     * adım bütçesi dolması veya iptal sinyali.
+     */
+    async promptTask(userPrompt, options) {
+        const session = await this.ensureSession(options?.signal ?? this.signal);
+        const signals = {};
+        const ctx = {
+            cwd: process.cwd(),
+            config: this.config,
+            signals
+        };
+        let toolCallsThisRound = 0;
+        const toolEvents = {
+            onToolCall: (name, params) => {
+                toolCallsThisRound++;
+                this.events.onToolCall?.(name, params);
+            },
+            onToolResult: (name, ok, output) => this.events.onToolResult?.(name, ok, output)
+        };
+        const functions = buildSessionFunctions(this.tools, ctx, toolEvents);
+        const sessionOpts = this.config.session ?? {};
+        const maxSteps = Math.max(1, this.config.maxSteps ?? 25);
+        const activeSignal = options?.signal ?? this.signal;
+        const runRound = (promptText) => {
+            toolCallsThisRound = 0;
+            this.trimContextIfNeeded();
+            logger.debug(`Prompt gonderiliyor (${promptText.length} karakter)`);
+            return session.prompt(promptText, {
+                functions,
+                documentFunctionParams: true,
+                temperature: this.temperature ?? sessionOpts.temperature,
+                topP: sessionOpts.topP,
+                topK: sessionOpts.topK,
+                maxTokens: sessionOpts.maxTokens,
+                seed: sessionOpts.seed,
+                onTextChunk: (text) => this.events.onTextChunk?.(text),
+                onResponseChunk: (chunk) => {
+                    if (chunk.type === "segment" && chunk.segmentType === "thought") {
+                        this.events.onThinkingChunk?.(chunk.text);
+                    }
+                },
+                signal: activeSignal
+            });
+        };
+        const continuePrompt = "Devam et. Görevin kalan adımlarını araçlarla tamamla; her şey bitip doğrulanınca task_complete aracını raporla çağır.";
+        let step = 0;
+        let response = "";
+        while (step < maxSteps) {
+            if (activeSignal?.aborted)
+                break;
+            step++;
+            this.events.onStepStart?.(step, maxSteps);
+            try {
+                response = await runRound(step === 1 ? userPrompt : continuePrompt);
+            }
+            finally {
+                this.events.onStepEnd?.(step, maxSteps, toolCallsThisRound);
+            }
+            if (signals.taskCompleted)
+                break;
+            if (toolCallsThisRound === 0)
+                break;
+        }
+        const budgetExhausted = !signals.taskCompleted && step >= maxSteps;
+        this.events.onComplete?.(response);
+        return { response, steps: step, maxSteps, completed: signals.taskCompleted === true, budgetExhausted };
+    }
+    /** Context eşiğini aşınca eski konuşma turlarını baştan kırpar (system promptu korunur) */
+    trimContextIfNeeded() {
+        if (!this.engine || !this.session)
+            return;
+        const contextSize = this.engine.contextSize;
+        const used = this.engine.getUsedContextTokens();
+        if (contextSize <= 0 || used <= 0)
+            return;
+        const threshold = this.config.contextTrimThreshold ?? 0.8;
+        if (used <= contextSize * threshold)
+            return;
+        const history = this.session.getChatHistory();
+        if (history.length <= 1)
+            return;
+        const budget = Math.floor(contextSize * threshold * 0.6);
+        const kept = [];
+        let total = 0;
+        for (let i = history.length - 1; i >= 0; i--) {
+            const item = history[i];
+            const tokens = Math.ceil(historyItemText(item).length / 3.2);
+            if (kept.length > 0 && total + tokens > budget)
+                break;
+            kept.unshift(item);
+            total += tokens;
+        }
+        const removed = history.length - kept.length;
+        if (removed > 0) {
+            this.session.setChatHistory(kept);
+            logger.info(`Context sıkıştırıldı: ${removed} mesaj kırpıldı (${used} token)`);
+            this.events.onContextTrimmed?.(removed);
+        }
+    }
+    /** Oturumdaki geçmişi temizler (yeni konuşma) */
+    resetConversation() {
+        this.session?.resetChatHistory();
+    }
+    /** Aktif oturumun geçmişini döndürür (oturum yoksa bekleyen geçmişi) */
+    getChatHistory() {
+        if (this.session)
+            return this.session.getChatHistory();
+        return this.pendingHistory ?? [];
+    }
+    /** Oturum geçmişini yükler; oturum henüz kurulmadıysa ilk kurulumda uygulanır */
+    setChatHistory(history) {
+        if (this.session) {
+            this.session.setChatHistory(history);
+            this.pendingHistory = undefined;
+        }
+        else {
+            this.pendingHistory = history;
+        }
+    }
+    /** Sistem promptunu değiştirir; aktif oturum varsa geçmiş temizlenip yeni sistem promptuyla yeniden kurulur */
+    async setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+        if (this.engine && this.session) {
+            this.session = await this.engine.resetSession(prompt);
+        }
+    }
+    async dispose() {
+        await this.engine?.dispose();
+        this.engine = undefined;
+        this.session = undefined;
+    }
+}
+//# sourceMappingURL=agent.js.map

package/dist/electron/main.d.ts

@@ -0,0 +1 @@
+export {};