atabey 0.0.1

package/framework-mcp/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@atabey/mcp",
+  "version": "0.0.1",
+  "description": "Agent Atabey Model Context Protocol (MCP) Server",
+  "author": "Yusuf BEKAR",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ysf-bkr/atabey.git"
+  },
+  "homepage": "https://github.com/ysf-bkr/atabey#readme",
+  "type": "module",
+  "scripts": {
+    "build": "npx tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "typescript": "^5.9.3"
+  }
+}

package/framework-mcp/src/constants.ts

@@ -0,0 +1,78 @@
+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",
+    // This is the hub for unified adapter layouts (e.g. .agents/gemini, .agents/claude)
+    UNIFIED_HUB_DIR: ".agents",
+    // This is the default directory to scaffold new apps into
+    APPS_DIR: "apps",
+    // This is where all skills are stored
+    SKILLS_DIR: "skills",
+};
+
+export const FRAMEWORK_SUBDIRS = {
+    AGENTS: "agents",
+    SKILLS: "skills",
+    KNOWLEDGE: "knowledge",
+    MESSAGES: "messages",
+    MEMORY: "memory",
+    MEMORY_GRAPH: "memory-graph",
+    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",
+    cursor: ".cursor/rules",
+    codex: ".agents/instructions",
+    grok: ".grok",
+    "antigravity-cli": ".antigravity/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 {
+    return path.join(...args);
+}
+
+function corePath(subdir: string, filename: string): string {
+    return pathJoin(FRAMEWORK.CORE_DIR, subdir, filename);
+}
+
+export function knowledgePath(filename: string): string {
+    return corePath(FRAMEWORK_SUBDIRS.KNOWLEDGE, filename);
+}

package/framework-mcp/src/declarations.d.ts

@@ -0,0 +1,17 @@
+declare module "@modelcontextprotocol/sdk/server/index.js" {
+    export class Server {
+        constructor(info: { name: string; version: string }, options: { capabilities: { tools: Record<string, never> } });
+        setRequestHandler(schema: unknown, handler: (request: unknown) => Promise<unknown>): void;
+        connect(transport: unknown): Promise<void>;
+        close(): Promise<void>;
+    }
+}
+
+declare module "@modelcontextprotocol/sdk/server/stdio.js" {
+    export class StdioServerTransport {}
+}
+
+declare module "@modelcontextprotocol/sdk/types.js" {
+    export const ListToolsRequestSchema: unknown;
+    export const CallToolRequestSchema: unknown;
+}

package/framework-mcp/src/index.ts

@@ -0,0 +1,144 @@
+import fs from "fs";
+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,
+} from "@modelcontextprotocol/sdk/types.js";
+
+
+import { TOOLS, toolHandlers } from "./tools/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 {
+    let currentDir = startDir;
+    while (currentDir !== path.parse(currentDir).root) {
+        const pkgPath = path.join(currentDir, "package.json");
+        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,
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+// Basic Schema Validator for Required Fields
+function validateArgs(toolName: string, args: Record<string, unknown>): string | null {
+    const definition = TOOLS.find(t => t.name === 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] === "") {
+            return `Missing required argument: '${field}' for tool '${toolName}'`;
+        }
+    }
+    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;
+    if (meta) {
+        process.stderr.write(`[MCP] Stateless ListTools from ${meta.client?.name || "unknown"} v${meta.client?.version || "?.?"}\n`);
+    }
+    return { tools: TOOLS };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const req = request as { params: { name: string, arguments?: Record<string, unknown> } };
+    const { name, arguments: args } = req.params;
+    const meta = (request as { _meta?: { client?: { name?: string; version?: string } } })._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: `❌ Unknown tool: ${name}` }],
+            };
+        }
+
+        // 🛡️ Runtime Validation
+        const validationError = validateArgs(name, args || {});
+        if (validationError) {
+            return {
+                isError: true,
+                content: [{ type: "text" as const, text: `❌ Validation Error: ${validationError}` }],
+            };
+        }
+        
+        return await handler(projectRoot, args || {});
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : "Unknown error occurred";
+        return {
+            isError: true,
+            content: [{ type: "text" as const, text: `❌ 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.stderr.write(`[atabey-mcp] Uncaught exception: ${error.message}
+`);
+    });
+    process.on("unhandledRejection", (reason: unknown) => {
+        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 {
+            // 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) => {
+    process.stderr.write(`[atabey-mcp] Fatal startup error: ${error.message}
+`);
+    process.exit(1);
+});

package/framework-mcp/src/tools/control_plane/locking.ts

@@ -0,0 +1,89 @@
+import fs from "fs";
+import path from "path";
+import { ToolResult, AcquireLockArgs, ReleaseLockArgs } from "../types.js";
+import { resolveFrameworkDir } from "../../utils/security.js";
+
+/**
+ * Handles acquiring a stateful lock on a resource.
+ */
+export async function handleAcquireLock(projectRoot: string, args: AcquireLockArgs): Promise<ToolResult> {
+    const { resource, agent, ttl = 60 } = args;
+    const frameworkDir = resolveFrameworkDir(projectRoot);
+    const lockDir = path.join(projectRoot, frameworkDir, "locks");
+    const lockPath = path.join(lockDir, `${resource}.lock`);
+
+    try {
+        if (!fs.existsSync(lockDir)) fs.mkdirSync(lockDir, { recursive: true });
+
+        // Check for stale lock first
+        if (fs.existsSync(lockPath)) {
+            const stat = fs.statSync(lockPath);
+            const now = new Date().getTime();
+            const age = (now - stat.mtimeMs) / 1000;
+
+            if (age < ttl) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Resource '${resource}' is currently locked by another agent.` }]
+                };
+            }
+            // Lock expired, safe to override by renaming first (POSIX atomic operation)
+            const tempLockPath = `${lockPath}.${Math.random().toString(36).substring(2)}.old`;
+            try {
+                fs.renameSync(lockPath, tempLockPath);
+                fs.unlinkSync(tempLockPath);
+            } catch {
+                // If rename failed, it means another agent already evicting/deleting it.
+                // Do not delete anything else; proceed and let writeFileSync (wx flag) fail if a new lock exists.
+            }
+        }
+
+        // Use 'wx' flag for atomic file creation
+        const lockData = JSON.stringify({ agent, timestamp: new Date().toISOString() });
+        fs.writeFileSync(lockPath, lockData, { flag: "wx" });
+        
+        return {
+            content: [{ type: "text", text: `✅ Lock acquired for resource '${resource}' by ${agent}.` }]
+        };
+    } catch (e) {
+        const error = e as { code?: string };
+        if (error.code === "EEXIST") {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Resource '${resource}' was just acquired by another agent.` }]
+            };
+        }
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to acquire lock: ${String(e)}` }]
+        };
+    }
+}
+
+/**
+ * Handles releasing a lock.
+ */
+export async function handleReleaseLock(projectRoot: string, args: ReleaseLockArgs): Promise<ToolResult> {
+    const { resource, agent } = args;
+    const frameworkDir = resolveFrameworkDir(projectRoot);
+    const lockPath = path.join(projectRoot, frameworkDir, "locks", `${resource}.lock`);
+
+    try {
+        if (!fs.existsSync(lockPath)) {
+            return { content: [{ type: "text", text: `ℹ️ No lock found for resource '${resource}'.` }] };
+        }
+
+        const lockData = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+        if (lockData.agent !== agent) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `❌ Denied: You do not own the lock for '${resource}'. Owned by ${lockData.agent}.` }]
+            };
+        }
+
+        fs.unlinkSync(lockPath);
+        return { content: [{ type: "text", text: `✅ Lock released for resource '${resource}' by ${agent}.` }] };
+    } catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Failed to release lock: ${String(e)}` }] };
+    }
+}

package/framework-mcp/src/tools/control_plane/registry.ts

@@ -0,0 +1,38 @@
+import fs from "fs";
+import path from "path";
+import { ToolResult, RegisterAgentArgs } from "../types.js";
+import { resolveFrameworkDir } from "../../utils/security.js";
+
+/**
+ * Handles agent registration with the Control Plane.
+ * This can be used to validate permissions and active status.
+ */
+export async function handleRegisterAgent(projectRoot: string, args: RegisterAgentArgs): Promise<ToolResult> {
+    const { agent, role, capability = 5 } = args;
+    const frameworkDir = resolveFrameworkDir(projectRoot);
+    const registryDir = path.join(projectRoot, frameworkDir, "registry");
+    const agentFile = path.join(registryDir, `${agent.replace("@", "")}_active.json`);
+
+    try {
+        if (!fs.existsSync(registryDir)) fs.mkdirSync(registryDir, { recursive: true });
+
+        const agentData = {
+            agent,
+            role,
+            capability,
+            last_seen: new Date().toISOString(),
+            status: "ACTIVE"
+        };
+
+        fs.writeFileSync(agentFile, JSON.stringify(agentData, null, 2));
+        
+        return {
+            content: [{ type: "text", text: `🎖️ Agent ${agent} (${role}) registered successfully in the Atabey Control Plane.` }]
+        };
+    } catch (e) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to register agent: ${String(e)}` }]
+        };
+    }
+}