@takimcizgisi/ajan 0.2.5

package/dist/tools/terminal.js

@@ -0,0 +1,130 @@
+import { spawn } from "node:child_process";
+import { limitOutput, resolveUserPath } from "./utils.js";
+const DEFAULT_BLOCKED_COMMANDS = [
+    "^(\\s*)(format|fdisk|diskpart|mkfs|shutdown)\\b",
+    "^\\s*(rm|del|erase|rd|rmdir|reg)\\s+.*(-rf|-r\\s+-f|/s|/q|delete)\\b",
+    "^\\s*taskkill\\s+/f\\s+/im\\s+system\\b",
+    "rm\\s+(-rf|-r\\s+-f)\\s+[/\\\\]"
+];
+function blockedBy(patterns, command) {
+    for (const pat of patterns) {
+        try {
+            if (new RegExp(pat, "i").test(command))
+                return pat;
+        }
+        catch {
+            /* geçersiz deseni yut */
+        }
+    }
+    return null;
+}
+export const runCommandTool = {
+    name: "run_command",
+    description: "Terminal komutu çalıştırır. cwd, komutun çalıştırılacağı dizindir (varsayılan: ajanın çalışma dizini). " +
+        "timeout ms cinsinden zaman aşımıdır (varsayılan: 60000). Çıktı maksimum uzunlukta kesilir.",
+    parameters: {
+        type: "object",
+        properties: {
+            command: { type: "string", description: "Çalıştırılacak terminal komutu" },
+            cwd: { type: "string", description: "Çalışma dizini (ajanın dizinine göre göreli veya mutlak yol)" },
+            timeout: { type: "integer", description: "Zaman aşımı milisaniye" }
+        },
+        required: ["command"]
+    },
+    handler: async (params, ctx) => {
+        const timeoutMs = params.timeout ?? ctx.config.toolTimeout ?? 60_000;
+        const cwd = params.cwd ? resolveUserPath(ctx.cwd, params.cwd) : ctx.cwd;
+        const blocked = blockedBy(ctx.config.blockedCommands ?? DEFAULT_BLOCKED_COMMANDS, params.command);
+        if (blocked) {
+            return {
+                ok: false,
+                output: `Komut engellendi (tehlikeli komut deseni: ${blocked}).\n` +
+                    `Engellenen komut: ${params.command}\n` +
+                    'İzin vermek için config.json\'daki "blockedCommands" alanını değiştirin ([] boş liste = tümü serbest).'
+            };
+        }
+        const result = await new Promise((resolvePromise) => {
+            const isWin = process.platform === "win32";
+            const shell = isWin ? "cmd.exe" : "/bin/sh";
+            const shellArgs = isWin ? ["/d", "/s", "/c"] : ["-c"];
+            const child = spawn(shell, [...shellArgs, params.command], {
+                cwd,
+                windowsHide: true,
+                detached: !isWin,
+                env: process.env,
+                stdio: ["ignore", "pipe", "pipe"]
+            });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            let settled = false;
+            const finish = (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                clearTimeout(safetyTimer);
+                resolvePromise({ code, stdout, stderr, timedOut });
+            };
+            const timer = setTimeout(() => {
+                timedOut = true;
+                try {
+                    if (isWin) {
+                        child.kill("SIGKILL");
+                    }
+                    else if (child.pid != null) {
+                        process.kill(-child.pid, "SIGKILL");
+                    }
+                }
+                catch {
+                    /* zaten ölmüş olabilir */
+                }
+                if (isWin && child.pid != null) {
+                    const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+                        windowsHide: true,
+                        stdio: "ignore"
+                    });
+                    killer.unref();
+                    killer.on("error", () => {
+                        /* taskkill başlatılamadıysa sessiz geç */
+                    });
+                }
+            }, timeoutMs);
+            // 'close' ancak süreç bitip tüm pipe'lar kapanınca tetiklenir; askıda kalmamak için
+            // güvenlik zamanlayıcısı pipe'ları serbest bırakıp sonucu zorla döndürür.
+            const safetyTimer = setTimeout(() => {
+                if (!settled) {
+                    child.stdout?.destroy();
+                    child.stderr?.destroy();
+                    finish(child.exitCode ?? null);
+                }
+            }, timeoutMs + 5_000);
+            child.stdout?.on("data", (chunk) => {
+                stdout += chunk.toString("utf8");
+                if (stdout.length > 2_000_000)
+                    child.stdout?.pause();
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderr += chunk.toString("utf8");
+                if (stderr.length > 2_000_000)
+                    child.stderr?.pause();
+            });
+            child.on("error", (err) => {
+                stderr += `Komut başlatılamadı: ${err.message}`;
+                finish(null);
+            });
+            child.on("close", (code) => finish(code));
+        });
+        const parts = [];
+        if (result.timedOut)
+            parts.push(`[ZAMAN AŞIMI ${timeoutMs}ms]`);
+        parts.push(`Çıkış kodu: ${result.code}`);
+        if (result.stdout.trim())
+            parts.push(`--- STDOUT ---\n${result.stdout.trimEnd()}`);
+        if (result.stderr.trim())
+            parts.push(`--- STDERR ---\n${result.stderr.trimEnd()}`);
+        const ok = result.code === 0 && !result.timedOut;
+        return { ok, output: limitOutput(parts.join("\n"), ctx.config.maxToolOutput) };
+    }
+};
+//# sourceMappingURL=terminal.js.map

package/dist/tools/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function limitOutput(text: string, maxChars?: number): string;
+export declare const SKIP_DIRS: Set<string>;
+/** Ağır veya gizli klasörlerde gezinmeyi atla (node_modules, dist, .git vb.) */
+export declare function shouldSkipDir(name: string): boolean;
+export declare function toMb(bytes: number): string;
+/** 'masaüstü', 'belgeler', 'indirilenler' gibi adları kullanıcının gerçek klasörlerine çözer */
+export declare function resolveUserPath(cwd: string, input: string): string;

package/dist/tools/utils.js

@@ -0,0 +1,63 @@
+import os from "node:os";
+import path from "node:path";
+import { existsSync } from "node:fs";
+export function limitOutput(text, maxChars) {
+    const limit = maxChars ?? 40_000;
+    if (text.length <= limit)
+        return text;
+    const truncated = text.slice(0, limit);
+    return `${truncated}\n... [çıktı ${text.length - limit} karakter kesildi]`;
+}
+export const SKIP_DIRS = new Set([
+    "node_modules", ".git", "dist", "build", ".next", ".cache",
+    "__pycache__", ".venv", "venv", ".idea", ".vscode", "coverage"
+]);
+/** Ağır veya gizli klasörlerde gezinmeyi atla (node_modules, dist, .git vb.) */
+export function shouldSkipDir(name) {
+    return name.startsWith(".") || SKIP_DIRS.has(name);
+}
+export function toMb(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function homeFolder(key) {
+    const candidates = [];
+    const home = os.homedir();
+    candidates.push(path.join(home, key));
+    const userProfile = process.env.USERPROFILE ?? process.env.HOME;
+    if (userProfile)
+        candidates.push(path.join(userProfile, key));
+    const oneDrive = process.env.ONEDRIVE;
+    if (oneDrive)
+        candidates.push(path.join(oneDrive, key));
+    for (const c of candidates) {
+        try {
+            if (existsSync(c))
+                return c;
+        }
+        catch {
+            /* yut */
+        }
+    }
+    return candidates[0] ?? null;
+}
+const FOLDER_PATTERNS = [
+    { regex: /masaüstü|masaustu|desktop/i, key: "Desktop" },
+    { regex: /belgeler|belgelerim|belge|documents/i, key: "Documents" },
+    { regex: /indirilenler|indirilen|indirmeler|downloads/i, key: "Downloads" }
+];
+/** 'masaüstü', 'belgeler', 'indirilenler' gibi adları kullanıcının gerçek klasörlerine çözer */
+export function resolveUserPath(cwd, input) {
+    const trimmed = input.trim();
+    for (const { regex, key } of FOLDER_PATTERNS) {
+        const match = trimmed.match(new RegExp(`^(${regex.source})(?:[\\\\/](.*))?$`, "i"));
+        if (!match)
+            continue;
+        const base = homeFolder(key);
+        if (!base)
+            continue;
+        const rest = match[2];
+        return rest ? path.resolve(base, rest) : base;
+    }
+    return path.isAbsolute(input) ? path.resolve(input) : path.resolve(cwd, input);
+}
+//# sourceMappingURL=utils.js.map

package/dist/tools/web.d.ts

@@ -0,0 +1,8 @@
+import type { AgentTool } from "../config/types.js";
+export type WebSearchResult = {
+    title: string;
+    url: string;
+    snippet: string;
+};
+export declare const webSearchTool: AgentTool;
+export declare const fetchUrlTool: AgentTool;

package/dist/tools/web.js

@@ -0,0 +1,181 @@
+import { limitOutput } from "./utils.js";
+function decodeEntities(text) {
+    return text
+        .replace(/&/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&#(\d+);/g, (_, code) => {
+        const cp = Number(code);
+        return cp > 0 ? String.fromCodePoint(cp) : "";
+    });
+}
+function stripTags(text) {
+    return decodeEntities(text.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim());
+}
+function decodeRedirectUrl(href) {
+    try {
+        if (href.startsWith("//"))
+            href = `https:${href}`;
+        const u = new URL(href);
+        if (u.hostname.includes("duckduckgo.com")) {
+            const target = u.searchParams.get("uddg");
+            if (target)
+                return decodeURIComponent(target);
+        }
+        return href;
+    }
+    catch {
+        return href;
+    }
+}
+function parseResults(html, maxResults) {
+    const results = [];
+    const resultRe = /<a[^>]*class="(?:result__a|result-link)"[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi;
+    const snippetRe = /<a[^>]*class="(?:result__snippet|result-snippet)"[^>]*>(.*?)<\/a>/gi;
+    let match;
+    const titles = [];
+    while ((match = resultRe.exec(html)) !== null && titles.length < maxResults) {
+        titles.push({ href: match[1] ?? "", title: stripTags(match[2] ?? "") });
+    }
+    if (titles.length === 0) {
+        const genericRe = /<a[^>]*href="(https?:\/\/[^"]+)"[^>]*>(.*?)<\/a>/gi;
+        while ((match = genericRe.exec(html)) !== null && titles.length < maxResults) {
+            const title = stripTags(match[2] ?? "");
+            if (!title)
+                continue;
+            titles.push({ href: match[1] ?? "", title });
+        }
+    }
+    const snippets = [];
+    while ((match = snippetRe.exec(html)) !== null && snippets.length < titles.length) {
+        snippets.push(stripTags(match[1] ?? ""));
+    }
+    for (let i = 0; i < titles.length; i++) {
+        const item = titles[i];
+        if (!item || !item.title)
+            continue;
+        results.push({
+            title: item.title,
+            url: decodeRedirectUrl(item.href),
+            snippet: snippets[i] ?? ""
+        });
+    }
+    return results;
+}
+export const webSearchTool = {
+    name: "web_search",
+    description: "Web'de arama yapar (DuckDuckGo, API anahtarı gerektirmez). Güncel bilgi, haber veya doküman bulmak için kullan. " +
+        "maxResults (varsayılan 5, en fazla 10) kadar sonuç döner: başlık, özet ve URL.",
+    parameters: {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Arama sorgusu (İngilizce daha iyi sonuç verir)" },
+            maxResults: { type: "integer", description: "Döndürülecek sonuç sayısı (varsayılan: 5, maks: 10)" }
+        },
+        required: ["query"]
+    },
+    handler: async (params, ctx) => {
+        const query = params.query.trim();
+        if (!query)
+            return { ok: false, output: "Arama sorgusu boş olamaz." };
+        const maxResults = Math.min(Math.max(params.maxResults ?? 5, 1), 10);
+        const timeoutMs = ctx.config.toolTimeout ?? 15_000;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        let html;
+        try {
+            const res = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
+                headers: {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36"
+                },
+                signal: controller.signal,
+                redirect: "follow"
+            });
+            if (!res.ok) {
+                return { ok: false, output: `Arama başarısız (HTTP ${res.status}): ${res.statusText}` };
+            }
+            html = await res.text();
+        }
+        catch (err) {
+            const aborted = controller.signal.aborted;
+            return {
+                ok: false,
+                output: aborted
+                    ? `Arama zaman aşımı (${timeoutMs}ms) veya iptal edildi.`
+                    : `Arama hatası: ${err.message}`
+            };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        const results = parseResults(html, maxResults);
+        if (results.length === 0) {
+            return { ok: true, output: `"${query}" için sonuç bulunamadı.` };
+        }
+        const lines = results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet || "(özet yok)"}`);
+        return { ok: true, output: limitOutput(lines.join("\n\n"), ctx.config.maxToolOutput) };
+    }
+};
+function htmlToText(html) {
+    return stripTags(html
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<(br|p|div|li|h[1-6]|tr)[^>]*>/gi, "\n"));
+}
+export const fetchUrlTool = {
+    name: "fetch_url",
+    description: "Bir URL'nin içeriğini indirip metin olarak döner. HTML sayfalar düz metne çevrilir. " +
+        "web_search ile bulunan bir sayfanın detayını okumak için kullan.",
+    parameters: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "İndirilecek adres (http/https)" },
+            maxLength: { type: "integer", description: "Döndürülecek maksimum karakter (varsayılan 12000, maks 40000)" }
+        },
+        required: ["url"]
+    },
+    handler: async (params, ctx) => {
+        const url = params.url?.trim();
+        if (!url || !/^https?:\/\//i.test(url)) {
+            return { ok: false, output: "Geçerli bir http(s) URL gerekli." };
+        }
+        const timeoutMs = ctx.config.toolTimeout ?? 20_000;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(url, {
+                headers: {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36"
+                },
+                signal: controller.signal,
+                redirect: "follow"
+            });
+            if (!res.ok) {
+                return { ok: false, output: `İndirme başarısız (HTTP ${res.status}): ${res.statusText}` };
+            }
+            const contentType = res.headers.get("content-type") ?? "";
+            const body = await res.text();
+            const isHtml = contentType.includes("text/html") || /^\s*<(!doctype|html)/i.test(body);
+            const text = isHtml ? htmlToText(body) : body;
+            const maxLen = Math.min(Math.max(params.maxLength ?? 12_000, 500), 40_000);
+            const header = `URL: ${url}\nTür: ${contentType || "bilinmiyor"}\nUzunluk: ${text.length} karakter\n\n`;
+            return { ok: true, output: limitOutput(header + text, maxLen + header.length + 100) };
+        }
+        catch (err) {
+            const aborted = controller.signal.aborted;
+            return {
+                ok: false,
+                output: aborted
+                    ? `Zaman aşımı (${timeoutMs}ms) veya iptal edildi.`
+                    : `İndirme hatası: ${err.message}`
+            };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+};
+//# sourceMappingURL=web.js.map

package/dist/utils/clipboard.d.ts

@@ -0,0 +1,2 @@
+/** Metni pano'ya kopyalar. Windows'ta PowerShell Set-Clipboard, diğerlerinde dosya fallback. */
+export declare function copyToClipboard(text: string): Promise<string>;

package/dist/utils/clipboard.js

@@ -0,0 +1,40 @@
+import { spawn } from "node:child_process";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getCacheDir } from "./paths.js";
+/** Metni pano'ya kopyalar. Windows'ta PowerShell Set-Clipboard, diğerlerinde dosya fallback. */
+export function copyToClipboard(text) {
+    if (process.platform === "win32") {
+        const b64 = Buffer.from(text, "utf16le").toString("base64");
+        const script = `Set-Clipboard -Value ([System.Text.Encoding]::Unicode.GetString([Convert]::FromBase64String('${b64}')))`;
+        return new Promise((resolve) => {
+            const child = spawn("powershell", ["-NoProfile", "-Command", script], {
+                windowsHide: true,
+                stdio: "ignore"
+            });
+            let failed = false;
+            child.on("error", () => {
+                failed = true;
+                resolve(fallbackCopy(text));
+            });
+            child.on("close", () => {
+                if (!failed)
+                    resolve("Pano'ya kopyalandı (Windows).");
+            });
+        });
+    }
+    return Promise.resolve(fallbackCopy(text));
+}
+function fallbackCopy(text) {
+    try {
+        const dir = getCacheDir();
+        mkdirSync(dir, { recursive: true });
+        const file = join(dir, "clipboard.txt");
+        writeFileSync(file, text, "utf8");
+        return `Panoya kopyalanamadı; içerik şuraya yazıldı: ${file}`;
+    }
+    catch {
+        return "Panoya kopyalama desteklenmiyor.";
+    }
+}
+//# sourceMappingURL=clipboard.js.map

package/dist/utils/lock.d.ts

@@ -0,0 +1,12 @@
+interface LockData {
+    pid: number;
+    type: "gui" | "tui";
+    startedAt: string;
+}
+export declare function acquireLock(type: "gui" | "tui"): {
+    ok: boolean;
+    error?: string;
+};
+export declare function releaseLock(): void;
+export declare function getLockInfo(): LockData | null;
+export {};

package/dist/utils/lock.js

@@ -0,0 +1,68 @@
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { getDataDir } from "./paths.js";
+function getLockPath() {
+    return join(getDataDir(), "ajan.lock");
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function acquireLock(type) {
+    const lockPath = getLockPath();
+    if (existsSync(lockPath)) {
+        try {
+            const data = JSON.parse(readFileSync(lockPath, "utf8"));
+            if (isProcessAlive(data.pid)) {
+                const runningType = data.type.toUpperCase();
+                return {
+                    ok: false,
+                    error: `AJAN ${runningType} zaten çalışıyor (PID: ${data.pid}).\nAynı anda yalnızca bir arayüz çalışabilir.`
+                };
+            }
+            // Stale lock — process ölü, temizle
+        }
+        catch {
+            // Bozuk lock dosyası, sil
+        }
+        try {
+            unlinkSync(lockPath);
+        }
+        catch { /* empty */ }
+    }
+    const lockData = {
+        pid: process.pid,
+        type,
+        startedAt: new Date().toISOString()
+    };
+    writeFileSync(lockPath, JSON.stringify(lockData, null, 2), "utf8");
+    return { ok: true };
+}
+export function releaseLock() {
+    const lockPath = getLockPath();
+    try {
+        if (existsSync(lockPath)) {
+            const data = JSON.parse(readFileSync(lockPath, "utf8"));
+            if (data.pid === process.pid) {
+                unlinkSync(lockPath);
+            }
+        }
+    }
+    catch { /* empty */ }
+}
+export function getLockInfo() {
+    const lockPath = getLockPath();
+    try {
+        if (existsSync(lockPath)) {
+            return JSON.parse(readFileSync(lockPath, "utf8"));
+        }
+    }
+    catch { /* empty */ }
+    return null;
+}
+//# sourceMappingURL=lock.js.map

package/dist/utils/paths.d.ts

@@ -0,0 +1,13 @@
+export type LogLevel = "silent" | "error" | "warn" | "info" | "debug";
+export declare function setLogLevel(level: LogLevel): void;
+export declare const logger: {
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+};
+export declare function getDataDir(): string;
+export declare function getModelsDir(): string;
+export declare function getConfigPath(): string;
+export declare function getCacheDir(): string;
+export declare function getLogDir(): string;

package/dist/utils/paths.js

@@ -0,0 +1,58 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import os from "node:os";
+let currentLevel = "info";
+export function setLogLevel(level) {
+    currentLevel = level;
+}
+const levelOrder = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+};
+function log(level, tag, ...args) {
+    if (levelOrder[level] > levelOrder[currentLevel])
+        return;
+    const prefix = `[${tag}]`;
+    if (level === "error") {
+        console.error(prefix, ...args);
+    }
+    else if (level === "warn") {
+        console.warn(prefix, ...args);
+    }
+    else {
+        console.log(prefix, ...args);
+    }
+}
+export const logger = {
+    error: (...args) => log("error", "hata", ...args),
+    warn: (...args) => log("warn", "uyari", ...args),
+    info: (...args) => log("info", "bilgi", ...args),
+    debug: (...args) => log("debug", "debug", ...args)
+};
+export function getDataDir() {
+    const base = process.env.AJAN_HOME ?? join(os.homedir(), ".ajan");
+    mkdirSync(base, { recursive: true });
+    return base;
+}
+export function getModelsDir() {
+    const dir = join(getDataDir(), "models");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function getConfigPath() {
+    return join(getDataDir(), "config.json");
+}
+export function getCacheDir() {
+    const dir = join(getDataDir(), "cache");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function getLogDir() {
+    const dir = join(getDataDir(), "logs");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+//# sourceMappingURL=paths.js.map

package/dist/utils/projectContext.d.ts

@@ -0,0 +1,2 @@
+/** cwd içinde AGENTS.md veya AJAN.md varsa içeriğini sistem promptuna eklenebilir metin olarak döndürür */
+export declare function loadProjectContext(cwd: string): string;

package/dist/utils/projectContext.js

@@ -0,0 +1,24 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+const MAX_CONTEXT_CHARS = 20_000;
+const CANDIDATES = ["AGENTS.md", "AJAN.md"];
+/** cwd içinde AGENTS.md veya AJAN.md varsa içeriğini sistem promptuna eklenebilir metin olarak döndürür */
+export function loadProjectContext(cwd) {
+    for (const name of CANDIDATES) {
+        const file = join(cwd, name);
+        if (!existsSync(file))
+            continue;
+        try {
+            const content = readFileSync(file, "utf8").trim();
+            if (!content)
+                return "";
+            const limited = content.length > MAX_CONTEXT_CHARS ? `${content.slice(0, MAX_CONTEXT_CHARS)}\n... [proje notları kesildi]` : content;
+            return `\n\n--- PROJE NOTLARI (${name}) ---\n${limited}\n--- PROJE NOTLARI SONU ---`;
+        }
+        catch {
+            /* okunamayan not dosyasını yut */
+        }
+    }
+    return "";
+}
+//# sourceMappingURL=projectContext.js.map

package/dist/utils/sacGuard.d.ts

@@ -0,0 +1,4 @@
+export type SacState = "kapali" | "engelleme" | "degerlendirme" | "yok";
+export declare function getSacState(): Promise<SacState>;
+export declare function describeSacState(state: SacState): string;
+export declare function isSacBlocking(state: SacState): boolean;

package/dist/utils/sacGuard.js

@@ -0,0 +1,47 @@
+import { execFile } from "node:child_process";
+const REG_PATH = "HKLM:\\SYSTEM\\CurrentControlSet\\Control\\CI\\Policy";
+const REG_NAME = "VerifiedAndReputablePolicyState";
+function execPowerShell(command, timeoutMs = 180000) {
+    return new Promise((resolve) => {
+        execFile("powershell.exe", ["-NoProfile", "-Command", command], { timeout: timeoutMs, windowsHide: true }, (err, stdout) => {
+            let code = 0;
+            if (err) {
+                const c = err.code;
+                code = typeof c === "number" ? c : err.killed ? 124 : 1;
+            }
+            resolve({ code, stdout: String(stdout ?? "") });
+        });
+    });
+}
+export async function getSacState() {
+    if (process.platform !== "win32")
+        return "yok";
+    const { code, stdout } = await execPowerShell(`(Get-ItemProperty -LiteralPath '${REG_PATH}' -Name '${REG_NAME}' -ErrorAction SilentlyContinue).${REG_NAME}`);
+    const raw = stdout.trim().split(/\r?\n/).pop()?.trim() ?? "";
+    if (code !== 0 || raw === "")
+        return "yok";
+    const value = raw.startsWith("0x") || raw.startsWith("0X") ? parseInt(raw, 16) : Number(raw);
+    if (value === 1)
+        return "engelleme";
+    if (value === 2)
+        return "degerlendirme";
+    if (value === 0)
+        return "kapali";
+    return "yok";
+}
+export function describeSacState(state) {
+    switch (state) {
+        case "engelleme":
+            return "açık (engelleme modu)";
+        case "degerlendirme":
+            return "değerlendirme modu";
+        case "kapali":
+            return "kapalı";
+        default:
+            return "yok / desteklenmiyor";
+    }
+}
+export function isSacBlocking(state) {
+    return process.platform === "win32" && state === "engelleme";
+}
+//# sourceMappingURL=sacGuard.js.map