@takimcizgisi/ajan 0.2.5 → 0.3.0

package/dist/discord/presence.js

@@ -0,0 +1,401 @@
+import { randomUUID } from "node:crypto";
+import { Client } from "@xhayper/discord-rpc";
+import { logger } from "../utils/paths.js";
+const PHASE_TIME_KEY = {
+    idle: 0,
+    chat: 0,
+    thinking: 0,
+    loading: 0,
+    error: 0
+};
+/**
+ * AJAN etkinliklerini Discord Rich Presence'a (profildeki "Oynuyor" alanı)
+ * dönüştürür. Discord masaüstü uygulaması çalışıyorken IPC üzerinden bağlanır.
+ *
+ * Kullanım: config.json içinde `discord.enabled = true` ve `discord.clientId`
+ * ayarlanmalıdır. Client ID, https://discord.com/developers/applications
+ * adresinden alınır; görseller Rich Presence > Art Assets sekmesine yüklenir.
+ */
+export class DiscordPresence {
+    client = null;
+    config;
+    phaseTime = { ...PHASE_TIME_KEY };
+    sessionStartedAt = null;
+    sessionTitle = "";
+    currentTool = null;
+    currentStep = 0;
+    maxSteps = 0;
+    lastError = null;
+    thinkingText = "";
+    lastToolCallAt = 0;
+    loadingPercent = null;
+    partyId = null;
+    joinSecret = null;
+    spectateSecret = null;
+    connected = false;
+    disposed = false;
+    reconnectTimer = null;
+    heartbeat = null;
+    reconnectAttempt = 0;
+    refreshTimer = null;
+    lastErrorLogAt = 0;
+    lastErrorLogMsg = "";
+    constructor(config) {
+        this.config = {
+            enabled: config.enabled ?? false,
+            clientId: config.clientId ?? "",
+            transport: config.transport ?? "ipc",
+            showToolCalls: config.showToolCalls ?? true,
+            showThinking: config.showThinking ?? false,
+            largeImageKey: config.largeImageKey ?? "ajan-logo",
+            largeImageText: config.largeImageText ?? "AJAN AI",
+            smallImageKeys: config.smallImageKeys ?? {}
+        };
+        this.markPhase("idle");
+    }
+    get isEnabled() {
+        return this.config.enabled === true && !!this.config.clientId;
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    /** Discord IPC'ye bağlanır; başarısız olursa sessizce devam eder. */
+    async connect() {
+        if (!this.isEnabled || this.disposed)
+            return false;
+        if (this.connected)
+            return true;
+        try {
+            this.client = new Client({
+                clientId: this.config.clientId,
+                transport: { type: this.config.transport ?? "websocket" }
+            });
+            this.client.on("connected", () => {
+                this.connected = true;
+                logger.info("Discord Rich Presence bağlandı.");
+            });
+            this.client.on("ready", () => {
+                this.connected = true;
+                void this.scheduleRefresh();
+            });
+            this.client.on("disconnected", () => {
+                this.connected = false;
+                logger.debug("Discord Rich Presence bağlantısı koptu.");
+                void this.reconnect();
+            });
+            await this.client.connect();
+            // Kullanıcı oturumu (RPC HELLO/READY) hazır olana kadar bekle; ancak
+            // o zaman `client.user` set olur ve aktivite gönderilebilir.
+            // 5 sn içinde READY gelmezse askıda kalmadan devam et.
+            if (!this.client.user) {
+                await Promise.race([
+                    new Promise((resolve) => this.client.once("ready", () => resolve())),
+                    new Promise((resolve) => setTimeout(resolve, 5000))
+                ]);
+            }
+            this.connected = true;
+            await this.flushRefresh();
+            this.startHeartbeat();
+            return this.connected;
+        }
+        catch (err) {
+            this.connected = false;
+            logger.debug(`Discord Rich Presence bağlanamadı: ${err.message}`);
+            void this.reconnect();
+            return false;
+        }
+    }
+    async disconnect() {
+        this.disposed = true;
+        this.stopTimers();
+        if (this.client) {
+            try {
+                await this.client.destroy();
+            }
+            catch {
+                /* yoksay */
+            }
+            this.client = null;
+        }
+        this.connected = false;
+    }
+    /** Bağlantı koptuğunda üstel gecikmeyle yeniden bağlanmayı dener. */
+    async reconnect() {
+        if (this.disposed)
+            return;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        const delay = Math.min(30_000, 2000 * 2 ** this.reconnectAttempt);
+        this.reconnectTimer = setTimeout(() => {
+            void (async () => {
+                if (this.disposed)
+                    return;
+                try {
+                    await this.client?.destroy();
+                }
+                catch {
+                    /* yoksay */
+                }
+                this.client = null;
+                this.connected = false;
+                const ok = await this.connect();
+                if (ok) {
+                    this.reconnectAttempt = 0;
+                }
+                else {
+                    void this.reconnect();
+                }
+            })();
+        }, delay);
+    }
+    /** Activity'yi Discord ile canlı tutmak için düzenli tazeleme. */
+    startHeartbeat() {
+        if (this.heartbeat)
+            return;
+        this.heartbeat = setInterval(() => {
+            if (this.connected && this.client?.user && !this.disposed) {
+                void this.scheduleRefresh();
+            }
+        }, 45_000);
+        this.heartbeat.unref?.();
+    }
+    stopTimers() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.heartbeat) {
+            clearInterval(this.heartbeat);
+            this.heartbeat = null;
+        }
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+    }
+    // ── Durum güncellemeleri ──
+    onSessionStart(title) {
+        this.sessionStartedAt = Date.now();
+        this.sessionTitle = title.trim() || "Yeni Sohbet";
+        this.thinkingText = "";
+        this.currentTool = null;
+        this.currentStep = 0;
+        this.maxSteps = 0;
+        this.lastError = null;
+        // Oyun daveti/katılımı için her oturuma özel party anahtarları üret.
+        this.partyId = randomUUID();
+        this.joinSecret = randomUUID();
+        this.spectateSecret = randomUUID();
+        this.markPhase("chat");
+        void this.scheduleRefresh();
+    }
+    onSessionEnd() {
+        this.sessionStartedAt = null;
+        this.sessionTitle = "";
+        this.thinkingText = "";
+        this.currentTool = null;
+        this.currentStep = 0;
+        this.maxSteps = 0;
+        this.lastError = null;
+        this.partyId = null;
+        this.joinSecret = null;
+        this.spectateSecret = null;
+        this.markPhase("idle");
+        void this.scheduleRefresh();
+    }
+    onThinking(text) {
+        if (!this.config.showThinking || this.disposed)
+            return;
+        this.thinkingText = text.slice(0, 120);
+        this.markPhase("thinking");
+        void this.scheduleRefresh();
+    }
+    onToolCall(name) {
+        if (this.disposed)
+            return;
+        this.currentTool = name;
+        if (this.config.showThinking)
+            this.thinkingText = "";
+        this.markPhase("chat");
+        this.lastToolCallAt = Date.now();
+        void this.scheduleRefresh();
+    }
+    onToolResult() {
+        if (this.disposed)
+            return;
+        this.currentTool = null;
+        // Araç sonucunda düşünce moduna dönme; bir sonraki tur beklentisi.
+        void this.scheduleRefresh();
+    }
+    onStepStart(step, maxSteps) {
+        if (this.disposed)
+            return;
+        this.currentStep = step;
+        this.maxSteps = maxSteps;
+        this.markPhase("chat");
+        void this.scheduleRefresh();
+    }
+    onComplete() {
+        if (this.disposed)
+            return;
+        this.currentTool = null;
+        this.thinkingText = "";
+        this.markPhase("chat");
+        void this.scheduleRefresh();
+    }
+    onError(message) {
+        if (this.disposed)
+            return;
+        this.lastError = message.slice(0, 120);
+        this.markPhase("error");
+        void this.scheduleRefresh();
+    }
+    onModelLoadProgress(pct) {
+        if (this.disposed)
+            return;
+        this.loadingPercent = pct;
+        this.markPhase("loading");
+        void this.scheduleRefresh();
+    }
+    onModelLoadComplete() {
+        if (this.disposed)
+            return;
+        this.loadingPercent = null;
+        this.markPhase("idle");
+        void this.scheduleRefresh();
+    }
+    onTextChunk(text) {
+        if (this.disposed || !this.config.showThinking)
+            return;
+        // Akış halindeki son metni durumda kısa tutarız.
+        this.thinkingText = text.replace(/\s+/g, " ").slice(0, 120);
+        this.markPhase("chat");
+        void this.scheduleRefresh();
+    }
+    // ── Etkinlik üretimi ──
+    markPhase(phase) {
+        this.phaseTime[phase] = Date.now();
+    }
+    buildActivity() {
+        const cfg = this.config;
+        const small = cfg.smallImageKeys ?? {};
+        const base = {
+            type: 0, // Playing
+            name: "AJAN AI",
+            largeImageKey: cfg.largeImageKey,
+            largeImageText: cfg.largeImageText ?? "AJAN AI"
+        };
+        if (this.sessionStartedAt) {
+            base.startTimestamp = this.sessionStartedAt;
+        }
+        // Oyun daveti / katılım arayüzü: oturum aktifken party + join/spectate.
+        if (this.partyId && this.joinSecret) {
+            base.partyId = this.partyId;
+            base.partySize = 1;
+            base.partyMax = 4;
+            base.joinSecret = this.joinSecret;
+            base.spectateSecret = this.spectateSecret ?? undefined;
+        }
+        // GitHub benzeri buton (config'de url doluysa göster)
+        const btn = cfg.buttons ?? {};
+        if (btn.url && btn.url.trim()) {
+            base.buttons = [
+                {
+                    label: btn.label?.trim() || "GitHub",
+                    url: btn.url.trim()
+                }
+            ];
+        }
+        // Durum metnini hazırla
+        let details;
+        let state;
+        let smallImageKey;
+        let smallImageText;
+        if (this.loadingPercent != null) {
+            details = "Model yükleniyor";
+            state = `%${Math.round(this.loadingPercent)}`;
+            smallImageKey = small.loading;
+            smallImageText = "Model yükleniyor";
+        }
+        else if (this.lastError) {
+            details = "Hata oluştu";
+            state = this.lastError;
+            smallImageKey = small.error;
+            smallImageText = "Hata";
+        }
+        else if (this.thinkingText && this.config.showThinking) {
+            details = "Düşünüyor...";
+            state = this.thinkingText;
+            smallImageKey = small.task;
+            smallImageText = "Düşünüyor";
+        }
+        else if (this.currentTool) {
+            details = "Görev yürütülüyor";
+            const showTool = cfg.showToolCalls !== false;
+            state = showTool
+                ? this.currentStep > 0
+                    ? `Adım ${this.currentStep}/${this.maxSteps} · ${this.currentTool}`
+                    : this.currentTool
+                : undefined;
+            smallImageKey = small.task;
+            smallImageText = "Araç kullanılıyor";
+        }
+        else if (this.sessionTitle) {
+            details = "Sohbet modunda";
+            state = this.sessionTitle;
+            smallImageKey = small.chat;
+            smallImageText = "Oturum açık";
+        }
+        else {
+            details = "Oturum bekleniyor";
+            state = undefined;
+            smallImageKey = small.idle;
+            smallImageText = "Hazır";
+        }
+        if (details)
+            base.details = details;
+        if (state)
+            base.state = state;
+        if (smallImageKey)
+            base.smallImageKey = smallImageKey;
+        if (smallImageText)
+            base.smallImageText = smallImageText;
+        return base;
+    }
+    /** Son durum değişikliğini 250ms'de bir tek sefere birleştirir (fırtına önleyici). */
+    scheduleRefresh() {
+        if (this.disposed)
+            return;
+        if (this.refreshTimer)
+            return;
+        this.refreshTimer = setTimeout(() => {
+            this.refreshTimer = null;
+            void this.flushRefresh();
+        }, 250);
+    }
+    /** Aktiviteyi Discord'a gönderir; hata durumunu (tekrarı kısıtlanmış şekilde) yutar. */
+    async flushRefresh() {
+        if (this.disposed)
+            return;
+        if (!this.connected || !this.client?.user)
+            return;
+        try {
+            await this.client.user.setActivity(this.buildActivity());
+        }
+        catch (err) {
+            const msg = err.message;
+            const now = Date.now();
+            if (now - this.lastErrorLogAt > 5000 || msg !== this.lastErrorLogMsg) {
+                this.lastErrorLogAt = now;
+                this.lastErrorLogMsg = msg;
+                logger.debug(`Discord aktivite güncellenemedi: ${msg}`);
+            }
+        }
+    }
+    /** Açık oturum yokken "boşta" durumunu göster. */
+    async showIdle() {
+        this.markPhase("idle");
+        await this.flushRefresh();
+    }
+}
+//# sourceMappingURL=presence.js.map

package/dist/engine/llama.d.ts

@@ -21,6 +21,11 @@ export declare class LlamaEngine {
     private readonly onProgress?;
     private readonly signal?;
     constructor(options: LlamaEngineOptions);
+    /**
+     * 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();
     static detectSupportedGpus(): Promise<string[]>;
     init(): Promise<void>;

package/dist/engine/llama.js

@@ -20,12 +20,26 @@ export class LlamaEngine {
         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.
+     */
     get gpuOption() {
-        if (!this.gpuBackend)
-            return undefined;
-        if (this.gpuBackend === "auto")
-            return { type: "auto" };
-        return 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";
+        }
     }
     static async detectSupportedGpus() {
         try {

package/dist/engine/modelManager.d.ts

@@ -8,7 +8,6 @@ export type DownloadProgress = {
 };
 export type DownloadOptions = {
     onProgress?: (progress: DownloadProgress) => void;
-    showProgress?: boolean;
     signal?: AbortSignal;
 };
 export declare function formatBytes(bytes: number): string;

package/dist/engine/modelManager.js

@@ -45,17 +45,9 @@ export async function downloadModel(model, options = {}) {
         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;
 }

package/dist/index.d.ts

@@ -7,3 +7,4 @@ 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";
+export { DiscordPresence, type PresencePhase } from "./discord/presence.js";

package/dist/index.js

@@ -6,4 +6,5 @@ export { DEFAULT_CONFIG, loadConfig, saveConfig, getModelsRegistry, getModelById
 export { createCoreTools, buildSessionFunctions } from "./tools/registry.js";
 export { parseUnifiedDiff } from "./tools/patch.js";
 export { getDataDir, getModelsDir, getConfigPath, getLogDir, setLogLevel, logger } from "./utils/paths.js";
+export { DiscordPresence } from "./discord/presence.js";
 //# sourceMappingURL=index.js.map

package/dist/service.js

@@ -164,7 +164,6 @@ export class AjanService {
         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)

package/dist/tools/playground.d.ts

@@ -0,0 +1,4 @@
+import type { AgentTool } from "../config/types.js";
+export declare const openPlaygroundTool: AgentTool;
+export declare const setTodosTool: AgentTool;
+export declare const getTodosTool: AgentTool;

package/dist/tools/playground.js

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

package/dist/tools/registry.d.ts

@@ -5,6 +5,5 @@ export type ToolEvents = {
     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

@@ -7,6 +7,7 @@ import { moveFileTool, deleteFileTool } from "./filesys.js";
 import { readDataTool, unzipFileTool } from "./data.js";
 import { noteAddTool, noteReadTool } from "./memory.js";
 import { taskCompleteTool } from "./taskComplete.js";
+import { openPlaygroundTool, setTodosTool, getTodosTool } from "./playground.js";
 import { logger } from "../utils/paths.js";
 export function createCoreTools(ctx) {
     return [
@@ -26,12 +27,12 @@ export function createCoreTools(ctx) {
         fetchUrlTool,
         noteAddTool,
         noteReadTool,
-        taskCompleteTool
+        taskCompleteTool,
+        openPlaygroundTool,
+        setTodosTool,
+        getTodosTool
     ];
 }
-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) {