atabey-mcp 0.0.7 → 0.0.9

package/{src/constants.ts → dist/constants.js}

@@ -1,12 +1,9 @@
 import path from "path";
-
 /**
  * Agent Atabey — Single Source of Truth for framework constants.
  * Import from here instead of hardcoding paths, phases, or directory names.
  */
-
 // ─── Framework identity ───────────────────────────────────────────────────
-
 export const FRAMEWORK = {
     NAME: "Agent Atabey",
     CORE_DIR: ".atabey",
@@ -17,7 +14,6 @@ export const FRAMEWORK = {
     // This is where all skills are stored
     SKILLS_DIR: "skills",
 };
-
 export const FRAMEWORK_SUBDIRS = {
     AGENTS: "agents",
     SKILLS: "skills",
@@ -28,26 +24,22 @@ export const FRAMEWORK_SUBDIRS = {
     LOGS: "logs",
     CONFIG: "config",
 };
-
 export const ROOT_CONFIG_FILES = {
     MCP: "mcp.json",
     NATIVE_MODULES: "native-modules.json",
     TSCONFIG: "tsconfig.json",
     ESLINT: "eslint.config.js",
 };
-
 export const MCP = {
     // Environment variable used by MCP to identify project root
     PROJECT_ROOT_ENV: "ATABEY_PROJECT_ROOT",
     // Environment variable for test mode
     TEST_DIR_ENV: "ATABEY_TEST_DIR",
 };
-
 export const MEMORY_FILES = {
     STATE: "state.json",
     SHARED_FACTS: "shared_facts.json",
 };
-
 export const NATIVE_AGENT_PATHS = {
     gemini: ".gemini/agents",
     claude: ".claude/agents",
@@ -56,23 +48,17 @@ export const NATIVE_AGENT_PATHS = {
     grok: ".grok",
     "antigravity-cli": ".agents/agents",
 };
-
 // ─── Backward-compatible aliases ──────────────────────────────────────────
-
 export const CORE_FRAMEWORK_DIR = FRAMEWORK.CORE_DIR;
 export const UNIFIED_HUB_DIR = FRAMEWORK.UNIFIED_HUB_DIR;
 export const SKILLS_HUB_PATH = pathJoin(UNIFIED_HUB_DIR, FRAMEWORK_SUBDIRS.SKILLS);
-
 // ─── Path Helpers ─────────────────────────────────────────────────────────
-
-function pathJoin(...args: string[]): string {
+function pathJoin(...args) {
     return path.join(...args);
 }
-
-function corePath(subdir: string, filename: string): string {
+function corePath(subdir, filename) {
     return pathJoin(FRAMEWORK.CORE_DIR, subdir, filename);
 }
-
-export function knowledgePath(filename: string): string {
+export function knowledgePath(filename) {
     return corePath(FRAMEWORK_SUBDIRS.KNOWLEDGE, filename);
 }

package/dist/framework-mcp/src/resources/index.js

@@ -1,4 +1,4 @@
-import { Storage } from "../../../src/shared/storage.js";
+import { Storage } from "../utils/storage.js";
 /**
  * [DATA] MCP Resource Definitions
  */
@@ -43,7 +43,7 @@ export async function handleReadResource(uri) {
     if (uri === "atabey://memory/project") {
         const fs = await import("fs");
         const path = await import("path");
-        const { getFrameworkDir } = await import("../../../src/cli/utils/memory.js");
+        const { getFrameworkDir } = await import("../utils/memory.js");
         const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
         const fwDir = getFrameworkDir();
         const p = path.isAbsolute(fwDir)

package/dist/framework-mcp/src/utils/errors.js

@@ -0,0 +1,68 @@
+/**
+ * Enterprise Base Error class for the Agent Atabey Framework.
+ */
+export class AtabeyBaseError extends Error {
+    code;
+    timestamp;
+    details;
+    solution;
+    constructor(message, code = "ATABEY_INTERNAL_ERROR", details, solution) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.timestamp = new Date();
+        this.details = details;
+        this.solution = solution;
+        // Ensure proper prototype chain and capture stack trace
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Converts the error into a structured JSON log format.
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            timestamp: this.timestamp.toISOString(),
+            details: this.details,
+            solution: this.solution,
+            stack: this.stack,
+        };
+    }
+}
+/**
+ * Thrown when configuration loading or validation fails.
+ */
+export class ConfigurationError extends AtabeyBaseError {
+    constructor(message, details, solution) {
+        super(message, "CONFIGURATION_ERROR", details, solution);
+    }
+}
+/**
+ * Thrown when data schema or payload validation fails.
+ */
+export class ValidationError extends AtabeyBaseError {
+    constructor(message, details, solution) {
+        super(message, "VALIDATION_ERROR", details, solution);
+    }
+}
+/**
+ * Thrown when adapter initialization or execution fails.
+ */
+export class AdapterError extends AtabeyBaseError {
+    constructor(message, adapterId, details, solution) {
+        super(`Adapter '${adapterId}' failure: ${message}`, "ADAPTER_ERROR", details, solution);
+    }
+}
+/**
+ * Thrown when orchestration or agent communication fails.
+ */
+export class OrchestrationError extends AtabeyBaseError {
+    constructor(message, details, solution) {
+        super(message, "ORCHESTRATION_ERROR", details, solution);
+    }
+}

package/dist/framework-mcp/src/utils/memory.js

@@ -0,0 +1,74 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+const CWD = process.cwd();
+const HOME = os.homedir();
+const FRAMEWORK = {
+    CORE_DIR: ".atabey",
+};
+const FRAMEWORK_DIR_CANDIDATES = [
+    ".atabey",
+    ".agents",
+    ".claude",
+    ".gemini",
+    ".grok",
+    ".cursor",
+];
+const MCP = {
+    TEST_DIR_ENV: "ATABEY_TEST_DIR",
+};
+function findFrameworkDir(basePath) {
+    try {
+        const pkgPath = path.join(basePath, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            if (pkg.atabey && typeof pkg.atabey.frameworkDir === "string") {
+                const customDir = path.join(basePath, pkg.atabey.frameworkDir);
+                if (fs.existsSync(customDir))
+                    return customDir;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+export function isFrameworkDevelopmentRepo() {
+    try {
+        const pkgPath = path.join(CWD, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            if (pkg.name === "atabey") {
+                return true;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return false;
+}
+export function getConfigDir() {
+    const localDir = findFrameworkDir(CWD);
+    if (localDir)
+        return localDir;
+    // Check for standard local directories if package.json doesn't specify
+    const localCandidates = [...FRAMEWORK_DIR_CANDIDATES, ".agent"];
+    for (const cand of localCandidates) {
+        const p = path.join(CWD, cand);
+        if (fs.existsSync(p))
+            return p;
+    }
+    // In dev repo, don't fall back to global dir. Point to local default.
+    if (isFrameworkDevelopmentRepo()) {
+        return path.join(CWD, FRAMEWORK.CORE_DIR);
+    }
+    return path.join(HOME, FRAMEWORK.CORE_DIR);
+}
+export function getFrameworkDir() {
+    const testDir = process.env[MCP.TEST_DIR_ENV];
+    if (testDir)
+        return testDir;
+    return getConfigDir();
+}

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

@@ -0,0 +1,207 @@
+import Database from "better-sqlite3";
+import path from "path";
+import fs from "fs";
+import { getFrameworkDir } from "./memory.js";
+/**
+ * [DB] Atabey Storage Engine
+ * Central SQLite database for enterprise-scale agent state management.
+ */
+export class Storage {
+    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: r.id,
+            timestamp: r.timestamp,
+            from: r.sender,
+            to: r.receiver,
+            category: r.category,
+            content: r.content,
+            traceId: r.trace_id,
+            parentId: 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 {
+                // Keep empty array
+            }
+            return {
+                id: r.id,
+                traceId: r.trace_id,
+                description: r.description,
+                agent: 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: r.id,
+            timestamp: r.timestamp,
+            agent: 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;
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+/**
+ * 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; }

package/{src/index.ts → dist/index.js}

@@ -4,55 +4,39 @@ import path from "path";
 import { fileURLToPath } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-    CallToolRequestSchema,
-    ListToolsRequestSchema,
-    ListResourcesRequestSchema,
-    ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { TOOLS, toolHandlers } from "./tools/index.js";
 import { RESOURCES, handleReadResource } from "./resources/index.js";
-
-
 // ─── Server Setup ─────────────────────────────────────────────────
-
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
 // Robustly find package.json by walking up from __dirname
-function findPackageJson(startDir: string): string {
+function findPackageJson(startDir) {
     let currentDir = startDir;
     while (currentDir !== path.parse(currentDir).root) {
         const pkgPath = path.join(currentDir, "package.json");
-        if (fs.existsSync(pkgPath)) return pkgPath;
+        if (fs.existsSync(pkgPath))
+            return pkgPath;
         currentDir = path.dirname(currentDir);
     }
     throw new Error("Could not find package.json for atabey-mcp");
 }
-
 const pkgPath = findPackageJson(__dirname);
 const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
 const serverVersion = pkg.version;
-
-const server = new Server(
-    {
-        name: "atabey-mcp",
-        version: serverVersion,
+const server = new Server({
+    name: "atabey-mcp",
+    version: serverVersion,
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
     },
-    {
-        capabilities: {
-            tools: {},
-            resources: {},
-        },
-    }
-);
-
+});
 // Basic Schema Validator for Required Fields
-function validateArgs(toolName: string, args: Record<string, unknown>): string | null {
+function validateArgs(toolName, args) {
     const definition = TOOLS.find(t => t.name === toolName);
-    if (!definition) return `Unknown tool: ${toolName}`;
-    
+    if (!definition)
+        return `Unknown tool: ${toolName}`;
     const required = definition.inputSchema.required || [];
     for (const field of required) {
         if (args[field] === undefined || args[field] === null || args[field] === "") {
@@ -61,22 +45,19 @@ function validateArgs(toolName: string, args: Record<string, unknown>): string |
     }
     return null;
 }
-
 server.setRequestHandler(ListToolsRequestSchema, async (request) => {
     // 2026 Stateless Spec: Log client info from metadata if available
-    const meta = (request as { _meta?: { client?: { name?: string; version?: string } } })._meta;
+    const meta = request._meta;
     if (meta) {
         process.stderr.write(`[MCP] Stateless ListTools from ${meta.client?.name || "unknown"} v${meta.client?.version || "?.?"}\n`);
     }
     return { tools: TOOLS };
 });
-
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
     return { resources: RESOURCES };
 });
-
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const uri = (request as { params: { uri: string } }).params.uri;
+    const uri = request.params.uri;
     try {
         const content = await handleReadResource(uri);
         return {
@@ -88,84 +69,75 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
                 },
             ],
         };
-    } catch (error: unknown) {
+    }
+    catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to read resource: ${message}`, { cause: error });
     }
 });
-
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const req = request as { params: { name: string, arguments?: Record<string, unknown> } };
+    const req = request;
     const { name, arguments: args } = req.params;
-    const meta = (request as { _meta?: { client?: { name?: string; version?: string } } })._meta;
-    
+    const meta = request._meta;
     // 2026 Stateless Spec: Prioritize metadata-driven context
     if (meta) {
         process.stderr.write(`[MCP] Stateless CallTool: ${name} (Client: ${meta.client?.name || "unknown"})\n`);
     }
-
     const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
-
     try {
         const handler = toolHandlers[name];
         if (!handler) {
             return {
                 isError: true,
-                content: [{ type: "text" as const, text: `[ERROR] Unknown tool: ${name}` }],
+                content: [{ type: "text", text: `[ERROR] Unknown tool: ${name}` }],
             };
         }
-
         // [SECURITY] Runtime Validation
         const validationError = validateArgs(name, args || {});
         if (validationError) {
             return {
                 isError: true,
-                content: [{ type: "text" as const, text: `[ERROR] Validation Error: ${validationError}` }],
+                content: [{ type: "text", text: `[ERROR] Validation Error: ${validationError}` }],
             };
         }
-        
         return await handler(projectRoot, args || {});
-    } catch (error: unknown) {
+    }
+    catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error occurred";
         return {
             isError: true,
-            content: [{ type: "text" as const, text: `[ERROR] Execution failed: ${message}` }],
+            content: [{ type: "text", text: `[ERROR] Execution failed: ${message}` }],
         };
     }
 });
-
 // ─── Graceful Startup & Shutdown ──────────────────────────────────
-
 async function run() {
     const transport = new StdioServerTransport();
-
     // Prevent unhandled errors from crashing the MCP stream
-    process.on("uncaughtException", (error: Error) => {
+    process.on("uncaughtException", (error) => {
         process.stderr.write(`[atabey-mcp] Uncaught exception: ${error.message}
 `);
     });
-    process.on("unhandledRejection", (reason: unknown) => {
+    process.on("unhandledRejection", (reason) => {
         const message = reason instanceof Error ? reason.message : String(reason);
         process.stderr.write(`[atabey-mcp] Unhandled rejection: ${message}
 `);
     });
-
     // Graceful shutdown on SIGINT/SIGTERM
     const shutdown = async () => {
         try {
             await server.close();
-        } catch {
+        }
+        catch {
             // Already closed or failed — safe to ignore
         }
         process.exit(0);
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
-
     await server.connect(transport);
 }
-
-run().catch((error: Error) => {
+run().catch((error) => {
     process.stderr.write(`[atabey-mcp] Fatal startup error: ${error.message}
 `);
     process.exit(1);