atabey 0.0.11 → 0.0.13

package/framework-mcp/dist/src/shared/logger.js

@@ -0,0 +1,126 @@
+import chalk from "chalk";
+import path from "path";
+import { appendFile, ensureDir } from "./fs.js";
+import { containsPII, maskObject, maskText } from "./pii.js";
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["FATAL"] = 4] = "FATAL";
+})(LogLevel || (LogLevel = {}));
+export class EnterpriseLogger {
+    config;
+    static instance;
+    constructor() {
+        const isProd = process.env.NODE_ENV === "production";
+        this.config = {
+            minLevel: isProd ? LogLevel.INFO : LogLevel.DEBUG,
+            enableColors: !isProd,
+            jsonFormat: isProd,
+            enablePiiMasking: true, // KVKK: PII masking ON by default
+            piiWarning: true,
+        };
+    }
+    static getInstance() {
+        if (!EnterpriseLogger.instance) {
+            EnterpriseLogger.instance = new EnterpriseLogger();
+        }
+        return EnterpriseLogger.instance;
+    }
+    configure(config) {
+        this.config = { ...this.config, ...config };
+        if (this.config.logFile) {
+            try {
+                ensureDir(path.dirname(this.config.logFile));
+            }
+            catch (err) {
+                // Directly write to stderr — using console here would be circular
+                process.stderr.write(`[Logger] Failed to create log directory: ${err}\n`);
+            }
+        }
+    }
+    formatMessage(level, message, meta) {
+        const timestamp = new Date().toISOString();
+        const pid = process.pid;
+        // [KVKK] PII masking — mask sensitive data before logging
+        const safeMessage = this.config.enablePiiMasking ? maskText(message) : message;
+        const safeMeta = this.config.enablePiiMasking && meta ? maskObject(meta) : meta;
+        // [KVKK] Warn if PII detected in production
+        if (this.config.piiWarning && (containsPII(message) || (meta && containsPII(JSON.stringify(meta))))) {
+            process.stderr.write(`[PII WARNING] Potential PII detected in log at ${timestamp}\n`);
+        }
+        if (this.config.jsonFormat) {
+            return JSON.stringify({
+                timestamp,
+                level: LogLevel[level],
+                pid,
+                message: safeMessage,
+                meta: safeMeta,
+            });
+        }
+        const levelName = LogLevel[level].padEnd(5);
+        let coloredLevel = levelName;
+        if (this.config.enableColors) {
+            switch (level) {
+                case LogLevel.DEBUG:
+                    coloredLevel = chalk.blue(levelName);
+                    break;
+                case LogLevel.INFO:
+                    coloredLevel = chalk.green(levelName);
+                    break;
+                case LogLevel.WARN:
+                    coloredLevel = chalk.yellow(levelName);
+                    break;
+                case LogLevel.ERROR:
+                    coloredLevel = chalk.red(levelName);
+                    break;
+                case LogLevel.FATAL:
+                    coloredLevel = chalk.bgRed.white.bold(levelName);
+                    break;
+            }
+        }
+        const metaStr = safeMeta ? ` | Meta: ${JSON.stringify(safeMeta)}` : "";
+        return `[${timestamp}] [PID:${pid}] [${coloredLevel}]: ${safeMessage}${metaStr}`;
+    }
+    log(level, message, meta) {
+        if (level < this.config.minLevel)
+            return;
+        const formatted = this.formatMessage(level, message, meta);
+        // Route to stderr for ERROR/FATAL, stdout otherwise.
+        // Using process.write directly here is intentional — this IS the logger.
+        if (level >= LogLevel.ERROR) {
+            process.stderr.write(formatted + "\n");
+        }
+        else {
+            process.stdout.write(formatted + "\n");
+        }
+        // Output to file if configured
+        if (this.config.logFile) {
+            try {
+                appendFile(this.config.logFile, formatted + "\n");
+            }
+            catch (err) {
+                // Directly write to stderr — using console here would be circular
+                process.stderr.write(`[Logger] Failed to write to log file: ${err}\n`);
+            }
+        }
+    }
+    debug(message, meta) {
+        this.log(LogLevel.DEBUG, message, meta);
+    }
+    info(message, meta) {
+        this.log(LogLevel.INFO, message, meta);
+    }
+    warn(message, meta) {
+        this.log(LogLevel.WARN, message, meta);
+    }
+    error(message, meta) {
+        this.log(LogLevel.ERROR, message, meta);
+    }
+    fatal(message, meta) {
+        this.log(LogLevel.FATAL, message, meta);
+    }
+}
+export const logger = EnterpriseLogger.getInstance();

package/framework-mcp/dist/src/shared/pii.js

@@ -0,0 +1,121 @@
+/**
+ * [PII] Personally Identifiable Information Masking Service
+ *
+ * Detects and masks sensitive data in compliance with KVKK/GDPR.
+ * Used in audit log, logger, and storage layers.
+ *
+ * Supported patterns:
+ * - Email addresses
+ * - Phone numbers
+ * - TC Identification number
+ * - API keys / tokens
+ * - IP addresses
+ * - Credit card numbers
+ * - Custom names (optional)
+ */
+// Sensitive patterns to detect and mask
+const SENSITIVE_PATTERNS = [
+    // Email
+    { pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, replacement: "***@***" },
+    // Phone (international and Turkish)
+    { pattern: /(\+90|0)?\s?[0-9]{3}\s?[0-9]{3}\s?[0-9]{2}\s?[0-9]{2}/g, replacement: "***-***-****" },
+    // TC Kimlik (11 digits starting with 1-9)
+    { pattern: /\b[1-9][0-9]{10}\b/g, replacement: "***********" },
+    // API keys (common formats: sk-..., pk-..., xai-..., etc.)
+    { pattern: /\b(sk-[a-zA-Z0-9]{20,}|pk-[a-zA-Z0-9]{20,}|xai-[a-zA-Z0-9]{20,}|AIza[0-9A-Za-z_-]{35}|ghp_[a-zA-Z0-9]{36,}|gho_[a-zA-Z0-9]{36,})\b/g, replacement: "***-REDACTED-***" },
+    // Bearer tokens in Authorization headers
+    { pattern: /Bearer\s+[a-zA-Z0-9._-]+/g, replacement: "Bearer ***-REDACTED-***" },
+    // IP addresses
+    { pattern: /\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b/g, replacement: "***.***.***.***" },
+    // Credit card (16 digits, optional spaces/dashes)
+    { pattern: /\b(?:\d[ -]*?){13,16}\b/g, replacement: "****-****-****-****" },
+    // JWT tokens
+    { pattern: /eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/g, replacement: "***-JWT-REDACTED-***" },
+    // Password fields in JSON
+    { pattern: /"(password|passwd|secret|api_key|apiKey|apikey)"\s*:\s*"[^"]+"/gi, replacement: "\"$1\": \"***-REDACTED-***\"" },
+];
+// Fields that are considered sensitive and should always be redacted in structured data
+const SENSITIVE_FIELDS = [
+    "password", "passwd", "secret", "apiKey", "api_key", "apikey",
+    "token", "accessToken", "refreshToken", "authToken",
+    "authorization", "Authorization",
+    "email", "phone", "phoneNumber", "telephone",
+    "creditCard", "cvv", "ssn", "tcKimlik", "identityNumber",
+    "ipAddress",
+];
+/**
+ * Mask sensitive data in a text string.
+ */
+export function maskText(text) {
+    if (!text || typeof text !== "string")
+        return text;
+    let masked = text;
+    for (const { pattern, replacement } of SENSITIVE_PATTERNS) {
+        masked = masked.replace(pattern, replacement);
+    }
+    return masked;
+}
+/**
+ * Recursively mask sensitive fields in an object.
+ * Returns a new object with sensitive values redacted.
+ */
+export function maskObject(obj, depth = 0) {
+    if (depth > 10)
+        return obj; // Prevent infinite recursion
+    if (obj === null || obj === undefined)
+        return obj;
+    if (typeof obj === "string")
+        return maskText(obj);
+    if (typeof obj !== "object")
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.map(item => maskObject(item, depth + 1));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        // Check if the key itself is a sensitive field
+        if (SENSITIVE_FIELDS.includes(key)) {
+            result[key] = typeof value === "string" ? "***-REDACTED-***" : maskObject(value, depth + 1);
+        }
+        else if (typeof value === "string") {
+            result[key] = maskText(value);
+        }
+        else if (typeof value === "object") {
+            result[key] = maskObject(value, depth + 1);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Check if a string contains potential PII.
+ * Useful for warning before sending data to external APIs.
+ */
+export function containsPII(text) {
+    for (const { pattern } of SENSITIVE_PATTERNS) {
+        if (pattern.test(text))
+            return true;
+    }
+    return false;
+}
+/**
+ * Classify a piece of data based on content analysis.
+ */
+export function classifyData(text) {
+    if (!text)
+        return "public";
+    // Check for highly sensitive data
+    if (/\b(sk-[a-zA-Z0-9]{20,}|Bearer\s+|eyJ[a-zA-Z0-9_-]+\.)/.test(text) ||
+        /\b[1-9][0-9]{10}\b/.test(text) ||
+        /"(password|secret|apiKey)"/i.test(text)) {
+        return "restricted";
+    }
+    // Check for moderately sensitive data
+    if (/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/.test(text) ||
+        /(\+90|0)?\s?[0-9]{3}\s?[0-9]{3}\s?[0-9]{2}\s?[0-9]{2}/.test(text)) {
+        return "confidential";
+    }
+    return "internal";
+}

package/framework-mcp/dist/src/shared/storage.js

@@ -0,0 +1,211 @@
+import Database from "better-sqlite3";
+import fs from "fs";
+import path from "path";
+import { getFrameworkDir } from "../cli/utils/memory.js";
+import { logger } from "./logger.js";
+import { asAgentID, asLogID, asMessageID, asTaskID } from "./types.js";
+/**
+ * [DB] Atabey Storage Engine
+ * Central SQLite database for enterprise-scale agent state management.
+ */
+export class AtabeyStorage {
+    static db = null;
+    static getDB() {
+        if (!this.db) {
+            const frameworkDir = getFrameworkDir();
+            if (!fs.existsSync(frameworkDir)) {
+                fs.mkdirSync(frameworkDir, { recursive: true });
+            }
+            const dbPath = path.join(frameworkDir, "atabey.db");
+            this.db = new Database(dbPath);
+            this.initializeSchema();
+        }
+        return this.db;
+    }
+    static initializeSchema() {
+        const db = this.db;
+        // Agents Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS agents (
+                name TEXT PRIMARY KEY,
+                state TEXT DEFAULT 'READY',
+                task TEXT DEFAULT 'Idle',
+                last_updated DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        // Messages (Hermes) Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS messages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                sender TEXT,
+                receiver TEXT,
+                category TEXT,
+                content TEXT,
+                trace_id TEXT,
+                parent_id TEXT,
+                status TEXT DEFAULT 'PENDING',
+                priority TEXT DEFAULT 'NORMAL',
+                requires_approval BOOLEAN DEFAULT 0
+            )
+        `);
+        // Tasks Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS tasks (
+                id TEXT PRIMARY KEY,
+                trace_id TEXT,
+                description TEXT,
+                agent TEXT,
+                status TEXT DEFAULT 'PENDING',
+                priority TEXT DEFAULT 'NORMAL',
+                dependencies TEXT, -- JSON Array
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+        // Logs Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                agent TEXT,
+                action TEXT,
+                trace_id TEXT,
+                status TEXT,
+                summary TEXT,
+                findings TEXT
+            )
+        `);
+        // Metadata (State) Table
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS metadata (
+                key TEXT PRIMARY KEY,
+                value TEXT
+            )
+        `);
+    }
+    // --- Agent Operations ---
+    static updateAgentStatus(name, state, task, lastUpdated) {
+        const db = this.getDB();
+        const cleanName = name.replace("@", "");
+        const timestamp = lastUpdated || new Date().toISOString();
+        db.prepare(`
+            INSERT INTO agents (name, state, task, last_updated)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(name) DO UPDATE SET
+                state = excluded.state,
+                task = excluded.task,
+                last_updated = excluded.last_updated
+        `).run(cleanName, state, task, timestamp);
+    }
+    static getAllAgents() {
+        return this.getDB().prepare("SELECT * FROM agents").all();
+    }
+    // --- Message Operations ---
+    static saveMessage(msg) {
+        const db = this.getDB();
+        db.prepare(`
+            INSERT INTO messages (sender, receiver, category, content, trace_id, parent_id, status, priority, requires_approval)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(msg.from, msg.to, msg.category, msg.content, msg.traceId, msg.parentId || null, msg.status || "PENDING", msg.priority || "NORMAL", msg.requiresApproval ? 1 : 0);
+    }
+    static getPendingMessages() {
+        const rows = this.getDB().prepare("SELECT * FROM messages WHERE status IN ('PENDING', 'APPROVED') ORDER BY priority DESC, timestamp ASC").all();
+        return rows.map(r => ({
+            id: asMessageID(r.id),
+            timestamp: r.timestamp,
+            from: asAgentID(r.sender),
+            to: asAgentID(r.receiver),
+            category: r.category,
+            content: r.content,
+            traceId: r.trace_id,
+            parentId: r.parent_id ? asTaskID(r.parent_id) : undefined,
+            status: r.status,
+            priority: r.priority,
+            requiresApproval: r.requires_approval === 1
+        }));
+    }
+    static updateMessageStatus(id, status) {
+        this.getDB().prepare("UPDATE messages SET status = ? WHERE id = ?").run(status, id);
+    }
+    // --- Task Operations ---
+    static saveTask(task) {
+        const db = this.getDB();
+        db.prepare(`
+            INSERT INTO tasks (id, trace_id, description, agent, status, priority, dependencies)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+                status = excluded.status,
+                description = excluded.description
+        `).run(task.id, task.traceId, task.description, task.agent, task.status, task.priority, JSON.stringify(task.dependencies || []));
+    }
+    static getTasks(traceId) {
+        const db = this.getDB();
+        let rows;
+        if (traceId) {
+            rows = db.prepare("SELECT * FROM tasks WHERE trace_id = ?").all(traceId);
+        }
+        else {
+            rows = db.prepare("SELECT * FROM tasks").all();
+        }
+        return rows.map(r => {
+            let deps = [];
+            try {
+                const parsed = JSON.parse(r.dependencies || "[]");
+                // Handle cases where dependencies might be double-stringified or are raw JSON strings
+                deps = Array.isArray(parsed) ? parsed : JSON.parse(parsed);
+            }
+            catch (err) {
+                logger.warn("Failed to parse task dependencies, using empty array", err);
+            }
+            return {
+                id: asTaskID(r.id),
+                traceId: r.trace_id,
+                description: r.description,
+                agent: asAgentID(r.agent),
+                status: r.status,
+                priority: r.priority,
+                dependencies: deps
+            };
+        });
+    }
+    static getLogs(agentName) {
+        const db = this.getDB();
+        let rows;
+        const cleanName = agentName ? agentName.replace("@", "") : undefined;
+        if (cleanName) {
+            rows = db.prepare("SELECT * FROM logs WHERE agent = ? ORDER BY timestamp DESC").all(cleanName);
+        }
+        else {
+            rows = db.prepare("SELECT * FROM logs ORDER BY timestamp DESC").all();
+        }
+        return rows.map(r => ({
+            id: asLogID(r.id),
+            timestamp: r.timestamp,
+            agent: asAgentID(r.agent),
+            action: r.action,
+            trace_id: r.trace_id || undefined,
+            status: r.status,
+            summary: r.summary,
+            findings: r.findings || undefined
+        }));
+    }
+    // --- Metadata Operations ---
+    static setMetadata(key, value) {
+        this.getDB().prepare(`
+            INSERT INTO metadata (key, value) VALUES (?, ?)
+            ON CONFLICT(key) DO UPDATE SET value = excluded.value
+        `).run(key, value);
+    }
+    static getMetadata(key) {
+        const row = this.getDB().prepare("SELECT value FROM metadata WHERE key = ?").get(key);
+        return row ? row.value : null;
+    }
+    static reset() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+}
+/** @deprecated Use AtabeyStorage instead. Kept for backward compatibility. */
+export const Storage = AtabeyStorage;

package/framework-mcp/dist/src/shared/types.js

@@ -0,0 +1,16 @@
+/**
+ * Agent Atabey Framework — Internal Branded Types
+ * Used to enforce absolute type safety within the core orchestration logic.
+ */
+/**
+ * Casts a raw string to a Branded Type.
+ * Use this only at the boundaries of the system.
+ */
+export function asTraceID(val) { return val; }
+export function asAgentID(val) { return val; }
+export function asPhaseID(val) { return val; }
+export function asProjectPath(val) { return val; }
+export function asMessageID(val) { return val; }
+export function asTaskID(val) { return val; }
+export function asLogID(val) { return val; }
+export function asPlanID(val) { return val; }