@aigencydev/cli 0.2.0 → 0.3.0

package/dist/agent/checkpoints.js

@@ -0,0 +1,147 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { getCheckpointDir } from "../config/paths.js";
+import { log } from "../utils/logger.js";
+const MAX_CHECKPOINT_BYTES = 2 * 1024 * 1024;
+export async function captureCheckpoint(sessionId, absPath, operation, projectRoot) {
+    try {
+        let beforeContent = "";
+        let existed = false;
+        let size = 0;
+        try {
+            const stat = await fs.stat(absPath);
+            if (stat.isFile()) {
+                size = stat.size;
+                if (size > MAX_CHECKPOINT_BYTES) {
+                    log.debug(`checkpoint: ${absPath} çok büyük (${size}b), snapshot atlandı`);
+                    return null;
+                }
+                beforeContent = await fs.readFile(absPath, "utf8");
+                existed = true;
+            }
+        }
+        catch {
+        }
+        const relPath = path.relative(projectRoot, absPath) || path.basename(absPath);
+        const checkpoint = {
+            relPath,
+            absPath,
+            ts: new Date().toISOString(),
+            operation,
+            beforeContent,
+            existed,
+        };
+        const pathHash = crypto
+            .createHash("sha256")
+            .update(absPath)
+            .digest("hex")
+            .slice(0, 12);
+        const ts = Date.now();
+        const snapshotFile = path.join(getCheckpointDir(sessionId, projectRoot), `${pathHash}-${ts}.snapshot`);
+        await fs.mkdir(path.dirname(snapshotFile), { recursive: true });
+        await fs.writeFile(snapshotFile, JSON.stringify(checkpoint), "utf8");
+        return {
+            relPath,
+            ts: checkpoint.ts,
+            operation,
+            existed,
+            snapshotFile,
+        };
+    }
+    catch (err) {
+        log.debug(`checkpoint hatası: ${err.message}`);
+        return null;
+    }
+}
+export async function findLatestCheckpoint(sessionId, projectRoot) {
+    const dir = getCheckpointDir(sessionId, projectRoot);
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return null;
+    }
+    const files = entries.filter((f) => f.endsWith(".snapshot"));
+    if (files.length === 0)
+        return null;
+    let latest = null;
+    for (const file of files) {
+        const match = /-(\d+)\.snapshot$/.exec(file);
+        if (!match)
+            continue;
+        const ts = parseInt(match[1], 10);
+        if (!latest || ts > latest.ts) {
+            latest = { file, ts };
+        }
+    }
+    if (!latest)
+        return null;
+    try {
+        const raw = await fs.readFile(path.join(dir, latest.file), "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function restoreCheckpoint(checkpoint) {
+    try {
+        if (checkpoint.existed) {
+            await fs.mkdir(path.dirname(checkpoint.absPath), { recursive: true });
+            await fs.writeFile(checkpoint.absPath, checkpoint.beforeContent, "utf8");
+            return {
+                ok: true,
+                message: `${checkpoint.relPath} önceki haline geri döndürüldü`,
+            };
+        }
+        else {
+            try {
+                await fs.unlink(checkpoint.absPath);
+            }
+            catch {
+            }
+            return {
+                ok: true,
+                message: `${checkpoint.relPath} silindi (yeni oluşturulmuştu)`,
+            };
+        }
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: `Geri alma hatası: ${err.message}`,
+        };
+    }
+}
+export async function listCheckpoints(sessionId, projectRoot) {
+    const dir = getCheckpointDir(sessionId, projectRoot);
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const metadata = [];
+    for (const file of entries) {
+        if (!file.endsWith(".snapshot"))
+            continue;
+        try {
+            const raw = await fs.readFile(path.join(dir, file), "utf8");
+            const cp = JSON.parse(raw);
+            metadata.push({
+                relPath: cp.relPath,
+                ts: cp.ts,
+                operation: cp.operation,
+                existed: cp.existed,
+                snapshotFile: path.join(dir, file),
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return metadata.sort((a, b) => (a.ts > b.ts ? -1 : 1));
+}

package/dist/agent/chunker.js

@@ -1,25 +1,9 @@
-/**
- * AIGENCY CLI — kullanıcı prompt'u ve history için basit chunker.
- *
- * Faz 4 scope'u: basit token budget kontrolü + history trim.
- * Faz 5'te gelişmiş chunked streaming (proje dosyalarını parçalara bölüp
- * ardışık stream istekleriyle göndermek) eklenecek.
- *
- * Şu an:
- *   - Toplam token (history + prompt) tahmin et
- *   - Budget üstü ise en eski mesajları kırp
- *   - Kalan budget prompt + 20% response için yeterli değilse uyar
- */
-/** Basit token tahmini — 1 token ≈ 4 karakter */
 export function approxTokens(text) {
     return Math.ceil(text.length / 4);
 }
-const DEFAULT_MAX_CONTEXT = 120_000; // Güvenli sınır — çoğu model destekler
+const DEFAULT_MAX_CONTEXT = 120_000;
 const DEFAULT_RESERVE_RESPONSE = 8_000;
 const DEFAULT_RESERVE_SYSTEM = 4_000;
-/**
- * History'yi budget'a sığdırır — eskiden başlayarak kırpar.
- */
 export function prepareChunk(prompt, history, options = {}) {
     const maxContext = options.maxContextTokens || DEFAULT_MAX_CONTEXT;
     const reserveResponse = options.reserveForResponse || DEFAULT_RESERVE_RESPONSE;
@@ -34,7 +18,6 @@ export function prepareChunk(prompt, history, options = {}) {
             warning: `Prompt tek başına ${promptTokens} token — context limiti (${available}) aşılıyor. Komutunuzu kısaltın.`,
         };
     }
-    // Sondan başa doğru ekle (son mesajlar daha önemli)
     const reversed = [...history].reverse();
     const selected = [];
     let total = promptTokens;
@@ -56,4 +39,3 @@ export function prepareChunk(prompt, history, options = {}) {
         warning,
     };
 }
-//# sourceMappingURL=chunker.js.map

package/dist/agent/history.js

@@ -1,16 +1,9 @@
-/**
- * AIGENCY CLI — sohbet geçmişi ring buffer.
- *
- * Kullanıcı + asistan mesajlarını tutar. /clear komutu sıfırlar.
- * Chunked streaming sırasında bu history stream endpoint'ine gönderilir.
- */
 const MAX_HISTORY = 40;
 export class ChatHistory {
     messages = [];
     push(msg) {
         const approxTokens = msg.approxTokens ?? Math.ceil((msg.content || "").length / 4);
         this.messages.push({ ...msg, approxTokens });
-        // Ring buffer — en eski mesajları kırp
         while (this.messages.length > MAX_HISTORY) {
             this.messages.shift();
         }
@@ -24,7 +17,6 @@ export class ChatHistory {
     length() {
         return this.messages.length;
     }
-    /** Son N mesajı döner — stream endpoint'ine bunu gönderiyoruz */
     tail(n) {
         return this.messages.slice(-n);
     }
@@ -32,4 +24,3 @@ export class ChatHistory {
         return this.messages.reduce((acc, m) => acc + (m.approxTokens || 0), 0);
     }
 }
-//# sourceMappingURL=history.js.map

package/dist/agent/instructions.js

@@ -0,0 +1,94 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getUserInstructionsFile, getProjectInstructionsFile, getProjectAigencyDir, } from "../config/paths.js";
+import { log } from "../utils/logger.js";
+const MAX_PER_FILE = 32 * 1024;
+const MAX_TOTAL = 96 * 1024;
+const MAX_WALK_DEPTH = 10;
+export async function loadInstructions(projectRoot, cwd = process.cwd()) {
+    const sources = [];
+    let totalBytes = 0;
+    const tryAdd = async (label, filePath) => {
+        if (totalBytes >= MAX_TOTAL)
+            return;
+        const content = await readFileIfExists(filePath);
+        if (!content)
+            return;
+        const trimmed = content.slice(0, MAX_PER_FILE);
+        const remaining = MAX_TOTAL - totalBytes;
+        const finalContent = trimmed.slice(0, remaining);
+        sources.push({
+            label,
+            path: filePath,
+            content: finalContent,
+            sizeBytes: finalContent.length,
+        });
+        totalBytes += finalContent.length;
+    };
+    await tryAdd("global", getUserInstructionsFile());
+    await tryAdd("project", getProjectInstructionsFile(projectRoot));
+    await tryAdd("local", path.join(getProjectAigencyDir(projectRoot), "AIGENCY.local.md"));
+    const rootInstructions = path.join(projectRoot, "AIGENCY.md");
+    if (rootInstructions !== getProjectInstructionsFile(projectRoot)) {
+        await tryAdd("project-root", rootInstructions);
+    }
+    if (isInside(cwd, projectRoot) && cwd !== projectRoot) {
+        let current = path.resolve(cwd);
+        const root = path.resolve(projectRoot);
+        let depth = 0;
+        while (current !== root && depth < MAX_WALK_DEPTH) {
+            const local = path.join(current, ".aigency", "AIGENCY.md");
+            const bare = path.join(current, "AIGENCY.md");
+            await tryAdd(`cwd:${path.relative(root, current)}`, local);
+            await tryAdd(`cwd-root:${path.relative(root, current)}`, bare);
+            const parent = path.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+            depth++;
+        }
+    }
+    return {
+        sources,
+        totalBytes,
+        combinedText: buildCombinedText(sources),
+    };
+}
+async function readFileIfExists(p) {
+    try {
+        const stat = await fs.stat(p);
+        if (!stat.isFile())
+            return null;
+        const raw = await fs.readFile(p, "utf8");
+        return raw.includes("\u0000") ? null : raw;
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code && code !== "ENOENT") {
+            log.debug(`AIGENCY.md okuma hatası: ${err.message}`);
+        }
+        return null;
+    }
+}
+function isInside(child, parent) {
+    const rel = path.relative(path.resolve(parent), path.resolve(child));
+    return !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function buildCombinedText(sources) {
+    if (sources.length === 0)
+        return "";
+    const parts = [
+        "## Kullanıcı Talimatları (AIGENCY.md)",
+        "Projede geçerli olan ve her oturumda zorunlu uygulanan talimatlar aşağıdadır.",
+        "",
+    ];
+    for (const src of sources) {
+        parts.push(`### Kaynak: ${src.label}`);
+        parts.push("```markdown");
+        parts.push(src.content.trim());
+        parts.push("```");
+        parts.push("");
+    }
+    parts.push("Yukarıdaki talimatlar SİSTEM KURALLARINDAN sonra, kullanıcı mesajından ÖNCE geçerlidir.", "Birden fazla kaynak çelişirse: lokal (kişisel) > proje > global sırasıyla öncelik ver.");
+    return parts.join("\n");
+}

package/dist/agent/loop.js

@@ -1,17 +1,3 @@
-/**
- * AIGENCY CLI — agent loop orchestrator.
- *
- * Akış:
- *   1. Kullanıcı prompt → request_id üret → stream endpoint'ine POST
- *   2. SSE event'lerini dinle
- *   3. cli_tool_dispatch gelirse:
- *      - Yerel tool registry'den handler'ı bul
- *      - Permission callback ile kullanıcıya sor (gerekirse)
- *      - Çalıştır → ToolResult
- *      - POST /api/cli/stream/tool-result ile sunucuya döndür
- *   4. agent_message, cli_token_usage, cli_quota_warning event'leri UI'a iletilir
- *   5. done veya error → loop biter
- */
 import crypto from "node:crypto";
 import { openStream, sendToolResult } from "../api-client/stream.js";
 import { dispatchLocalTool, hasLocalTool } from "../tools/registry.js";
@@ -24,17 +10,12 @@ function generateRequestId() {
 function cwdHash(cwd) {
     return crypto.createHash("sha256").update(cwd).digest("hex").slice(0, 32);
 }
-/**
- * Session-level permission cache — "a" (oturum boyunca kabul) için.
- */
 const SESSION_APPROVED_TOOLS = new Set();
 function wrapPermission(originalRequestPermission, mode) {
     return async (req) => {
-        // Plan mode zaten tool seviyesinde reddediyor, ama ekstra guard
         if (mode === "plan" && (req.toolName === "write_file" || req.toolName === "edit_file")) {
             return { decision: "reject" };
         }
-        // Session'da zaten kabul edilmişse tekrar sorma
         if (SESSION_APPROVED_TOOLS.has(req.toolName)) {
             return { decision: "approve" };
         }
@@ -55,12 +36,13 @@ export async function runAgentLoop(params) {
     let aborted = false;
     const toolCtx = {
         cwd: params.workingDirectory,
+        projectRoot: params.projectRoot,
+        sessionId: params.sessionId,
         mode: params.mode,
         signal: params.signal,
         requestPermission: wrapPermission(params.requestPermission, params.mode),
         onLiveOutput: params.onLiveOutput,
     };
-    // History'yi hazırla + chunk'la
     const chunk = prepareChunk(params.prompt, params.history.getAll());
     if (chunk.warning) {
         log.debug(`chunker: ${chunk.warning}`);
@@ -72,7 +54,6 @@ export async function runAgentLoop(params) {
         tool_calls: m.tool_calls,
     }));
     const onEvent = async (event) => {
-        // Her event UI'a iletilir (UI render eder)
         params.onEvent(event);
         switch (event.type) {
             case "agent_message":
@@ -88,10 +69,8 @@ export async function runAgentLoop(params) {
                 outputTokens = event.output;
                 break;
             case "cli_tool_dispatch": {
-                // Sunucu LLM'den gelen tool call'u bize devretti — yerel çalıştır
                 toolCalls++;
                 if (!hasLocalTool(event.toolName)) {
-                    // Bilinmeyen tool — server'a hata dön
                     const errorResult = {
                         success: false,
                         output: "",
@@ -108,7 +87,6 @@ export async function runAgentLoop(params) {
                     });
                     return;
                 }
-                // PreToolUse hook
                 if (params.settings) {
                     await runHooks("preToolUse", params.settings, {
                         toolName: event.toolName,
@@ -128,10 +106,7 @@ export async function runAgentLoop(params) {
                         duration: 0,
                     };
                 }
-                // approvalState'i ToolResult'a ekleme — backend schema'sında yok,
-                // ayrı parametre olarak gönder
                 const approvalState = result.approvalState ?? 2;
-                // PostToolUse hook
                 if (params.settings) {
                     await runHooks("postToolUse", params.settings, {
                         toolName: event.toolName,
@@ -163,7 +138,6 @@ export async function runAgentLoop(params) {
             }
             case "error":
             case "agent_error":
-                // UI error event'i gösterecek — burada ek bir şey yapmaya gerek yok
                 break;
             case "done":
                 if (event.fullContent)
@@ -192,7 +166,6 @@ export async function runAgentLoop(params) {
             throw err;
         }
     }
-    // Stop hook — oturum bitişinde
     if (params.settings) {
         try {
             await runHooks("stop", params.settings, {
@@ -200,7 +173,6 @@ export async function runAgentLoop(params) {
             });
         }
         catch {
-            // ignore
         }
     }
     return {
@@ -211,10 +183,6 @@ export async function runAgentLoop(params) {
         aborted,
     };
 }
-/**
- * Test veya /clear için session kabul cache'ini sıfırla.
- */
 export function clearSessionApprovalCache() {
     SESSION_APPROVED_TOOLS.clear();
 }
-//# sourceMappingURL=loop.js.map