atabey-mcp 0.0.4

package/dist/tools/search/get_map.js

@@ -0,0 +1,43 @@
+import fs from "fs";
+import path from "path";
+/**
+ * Generates a tree-view map of the project structure.
+ * Helps agents visualize the entire project layout quickly.
+ */
+export function handleGetProjectMap(projectRoot, args) {
+    const maxDepth = args.maxDepth || 3;
+    const includeFiles = args.includeFiles !== false;
+    const buildTree = (dir, depth) => {
+        if (depth > maxDepth)
+            return [];
+        const results = [];
+        const files = fs.readdirSync(dir);
+        files.forEach(file => {
+            if (file === "node_modules" || file === ".git" || file === "dist" || file.startsWith("."))
+                return;
+            const fullPath = path.join(dir, file);
+            const stat = fs.statSync(fullPath);
+            const indent = "  ".repeat(depth);
+            if (stat.isDirectory()) {
+                results.push(`${indent}📁 ${file}/`);
+                results.push(...buildTree(fullPath, depth + 1));
+            }
+            else if (includeFiles) {
+                results.push(`${indent}📄 ${file}`);
+            }
+        });
+        return results;
+    };
+    try {
+        const tree = buildTree(projectRoot, 0);
+        return {
+            content: [{
+                    type: "text",
+                    text: `🗺️ **Project Map (Depth: ${maxDepth})**\n\n${tree.join("\n")}`
+                }]
+        };
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Failed to map project: ${String(e)}` }] };
+    }
+}

package/dist/tools/search/grep_search.js

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import { Metrics } from "../../utils/metrics.js";
+/**
+ * Searches for a regex pattern within files in the project.
+ */
+export function handleGrepSearch(projectRoot, args) {
+    const pattern = args.pattern;
+    const includePattern = args.includePattern || ""; // e.g., ".ts"
+    const excludePattern = args.excludePattern || "node_modules";
+    if (!pattern) {
+        const err = "Search pattern is required.";
+        Metrics.logError(projectRoot, "@mcp", "grep_search", err);
+        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+    }
+    const results = [];
+    try {
+        new RegExp(pattern);
+    }
+    catch (e) {
+        const err = `Invalid regex pattern: ${String(e)}`;
+        Metrics.logError(projectRoot, "@mcp", "grep_search", err);
+        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+    }
+    const walk = (dir) => {
+        if (results.length > 100)
+            return;
+        try {
+            const files = fs.readdirSync(dir);
+            for (const file of files) {
+                if (results.length > 100)
+                    return;
+                const filePath = path.join(dir, file);
+                if (excludePattern && filePath.includes(excludePattern)) {
+                    continue;
+                }
+                const stat = fs.statSync(filePath);
+                if (stat.isDirectory()) {
+                    walk(filePath);
+                }
+                else if (stat.isFile()) {
+                    if (includePattern && !filePath.endsWith(includePattern)) {
+                        continue;
+                    }
+                    const content = fs.readFileSync(filePath, "utf8");
+                    // Create a new regex object for each line to avoid state issues with /g
+                    if (new RegExp(pattern).test(content)) {
+                        if (results.length < 100) {
+                            results.push(filePath);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore directories that cannot be read
+        }
+    };
+    try {
+        walk(projectRoot);
+    }
+    catch (e) {
+        const err = `Search failed: ${String(e)}`;
+        Metrics.logError(projectRoot, "@mcp", "grep_search", err);
+        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+    }
+    return {
+        content: [{
+                type: "text",
+                text: results.length > 0
+                    ? `Found ${results.length} matches:\n\n${results.join("\n")}`
+                    : "No matches found."
+            }]
+    };
+}

package/dist/tools/search/list_dir.js

@@ -0,0 +1,28 @@
+import fs from "fs";
+import path from "path";
+import { safePath } from "../../utils/security.js";
+/**
+ * Lists the contents of a directory.
+ */
+export function handleListDir(projectRoot, args) {
+    const dirPath = safePath(projectRoot, args.path || ".");
+    if (!fs.existsSync(dirPath)) {
+        throw new Error(`Directory not found: ${args.path}`);
+    }
+    const stats = fs.statSync(dirPath);
+    if (!stats.isDirectory()) {
+        throw new Error(`Path is not a directory: ${args.path}`);
+    }
+    const files = fs.readdirSync(dirPath);
+    const results = files.map(file => {
+        const fullPath = path.join(dirPath, file);
+        const isDir = fs.statSync(fullPath).isDirectory();
+        return `${isDir ? "[DIR] " : "      "}${file}`;
+    });
+    return {
+        content: [{
+                type: "text",
+                text: `Directory listing for ${args.path || "."}:\n\n${results.join("\n")}`
+            }]
+    };
+}

package/dist/tools/shell/run_command.js

@@ -0,0 +1,56 @@
+import { exec } from "child_process";
+import { Metrics } from "../../utils/metrics.js";
+const COMMAND_ALLOW_LIST = [
+    "npm test",
+    "npm run lint",
+    "npm run build",
+    "git status",
+    "git diff",
+    "npx vitest run",
+    "go test",
+    "go fmt",
+    "go build",
+    "pytest",
+    "ruff check",
+    "dotnet test",
+    "dotnet format",
+    "dotnet build",
+    "./gradlew",
+    "mvn",
+];
+const TIMEOUT = 30000; // 30 seconds
+export function handleRunCommand(projectRoot, args) {
+    const command = args.command;
+    const isAllowed = COMMAND_ALLOW_LIST.some(allowedCmd => command.startsWith(allowedCmd));
+    if (!isAllowed) {
+        const errorMsg = `Command not allowed: "${command}". Only commands starting with the following are allowed: ${COMMAND_ALLOW_LIST.join(", ")}`;
+        Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command} (denied)`, errorMsg);
+        return Promise.resolve({
+            content: [{ type: "text", text: `ERROR: ${errorMsg}` }],
+            isError: true,
+        });
+    }
+    return new Promise((resolve) => {
+        exec(command, { cwd: projectRoot, timeout: TIMEOUT }, (error, stdout, stderr) => {
+            const output = stdout + stderr;
+            const tokens = Metrics.estimateTokens(output);
+            Metrics.logUsage(projectRoot, "@mcp", `run_shell_command: ${command}`, tokens);
+            if (error) {
+                const errorMsg = `Command failed with exit code ${error.code}: ${error.message}.`;
+                Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command}`, errorMsg);
+                resolve({
+                    content: [{ type: "text", text: `ERROR: ${errorMsg}. Output: ${output}` }],
+                    isError: true,
+                });
+                return;
+            }
+            // Truncate long outputs
+            const MAX_OUTPUT_LENGTH = 5000;
+            let truncatedOutput = output;
+            if (output.length > MAX_OUTPUT_LENGTH) {
+                truncatedOutput = output.substring(0, MAX_OUTPUT_LENGTH) + "... [TRUNCATED] ..."; // Simplified
+            }
+            resolve({ content: [{ type: "text", text: truncatedOutput }] });
+        });
+    });
+}

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/cli.js

@@ -0,0 +1,59 @@
+import fs from "fs";
+import path from "path";
+import { execFileSync } from "child_process";
+/**
+ * Executes a command safely and returns the output.
+ */
+export function safeExec(cmd, args, cwd, timeout = 30000) {
+    try {
+        return execFileSync(cmd, args, { cwd, timeout, encoding: "utf8", stdio: "pipe" });
+    }
+    catch (err) {
+        const error = err;
+        return error.stdout?.toString() || error.stderr?.toString() || error.message || String(err);
+    }
+}
+/**
+ * Detects the backend language from the framework configuration.
+ */
+export function getBackendLanguage(projectRoot) {
+    try {
+        const configPath = path.join(projectRoot, ".atabey", "config.json");
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            return config.backendLanguage || "Node.js (TypeScript)";
+        }
+    }
+    catch {
+        // Fallback to default
+    }
+    return "Node.js (TypeScript)";
+}
+/**
+ * Returns the default lint command for the given language.
+ */
+export function getDefaultLintCommand(language) {
+    if (language.includes("Go"))
+        return "go fmt ./...";
+    if (language.includes("Java"))
+        return "./gradlew check"; // or mvn check
+    if (language.includes("Python"))
+        return "ruff check .";
+    if (language.includes(".NET"))
+        return "dotnet format";
+    return "npm run lint";
+}
+/**
+ * Returns the default test command for the given language.
+ */
+export function getDefaultTestCommand(language) {
+    if (language.includes("Go"))
+        return "go test ./...";
+    if (language.includes("Java"))
+        return "./gradlew test"; // or mvn test
+    if (language.includes("Python"))
+        return "pytest";
+    if (language.includes(".NET"))
+        return "dotnet test";
+    return "npm test";
+}

package/dist/utils/compliance.js

@@ -0,0 +1,78 @@
+import ts from "typescript";
+/**
+ * Enterprise Compliance Guardrail
+ * Checks content against corporate standards using AST analysis before allowing file mutations.
+ */
+export function verifyCorporateCompliance(content, filePath) {
+    // Skip compliance checks for non-source files or specific ignored files
+    if (filePath.endsWith(".json") || filePath.endsWith(".md") || filePath.endsWith(".env.example")) {
+        return;
+    }
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const errors = [];
+    /**
+     * Recursive AST Visitor
+     */
+    function visit(node) {
+        // 1. Zero Console Policy
+        if (ts.isPropertyAccessExpression(node)) {
+            const expression = node.expression;
+            const name = node.name.text;
+            if (ts.isIdentifier(expression) && expression.text === "console") {
+                if (["log", "warn", "error"].includes(name)) {
+                    // Check if file is exempt
+                    if (!filePath.includes("logger.ts") && !filePath.includes("check.ts") && !filePath.includes("cli.ts")) {
+                        errors.push(`❌ Corporate Compliance Breach: 'console.${name}' usage is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
+                    }
+                }
+            }
+        }
+        // 2. No Explicit Any Policy
+        if (ts.isTypeReferenceNode(node)) {
+            if (ts.isIdentifier(node.typeName) && node.typeName.text === "any") {
+                if (!filePath.includes("definitions.ts") && !filePath.includes("types.ts")) {
+                    errors.push(`❌ Corporate Compliance Breach: 'any' type is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
+                }
+            }
+        }
+        // 3. Zero UI Library Policy (No @chakra-ui, mui, @shadcn)
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier)) {
+                const forbiddenLibs = ["@chakra-ui", "mui", "@shadcn", "antd", "bootstrap"];
+                const lib = forbiddenLibs.find(l => moduleSpecifier.text.includes(l));
+                if (lib) {
+                    errors.push(`❌ Corporate Compliance Breach: External UI library '${lib}' usage is FORBIDDEN at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}. Build atomic components manually instead.`);
+                }
+            }
+        }
+        // Handle 'any' as a keyword type (e.g., parameter: any)
+        if (node.kind === ts.SyntaxKind.AnyKeyword) {
+            if (!filePath.includes("definitions.ts") && !filePath.includes("types.ts")) {
+                errors.push(`❌ Corporate Compliance Breach: 'any' keyword is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    // 3. Hardcoded Secrets & PII Guard
+    const piiKeywords = [
+        { regex: /API_KEY\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded API Key" },
+        { regex: /SECRET\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded Secret" },
+        { regex: /PASSWORD\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded Password" },
+        { regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/, msg: "PII Detected: Email Address" },
+        { regex: /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/, msg: "PII Detected: Credit Card Pattern" }
+    ];
+    for (const { regex, msg } of piiKeywords) {
+        if (regex.test(content)) {
+            // Allow emails in specific files like README or package.json
+            if (msg.includes("Email") && (filePath.endsWith("README.md") || filePath.endsWith("package.json") || filePath.includes("CONTRIBUTING"))) {
+                continue;
+            }
+            errors.push(`❌ Corporate Compliance Breach: ${msg} detected.`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(errors.join("\n"));
+    }
+}

package/dist/utils/fs.js

@@ -0,0 +1,44 @@
+import fs from "fs";
+import path from "path";
+/**
+ * Ensures directory existence.
+ */
+export function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Atomically writes a text file.
+ */
+export function writeTextFileAtomic(filePath, content) {
+    const dir = path.dirname(filePath);
+    ensureDir(dir);
+    const tempPath = `${filePath}.${Math.random().toString(36).slice(2, 9)}.tmp`;
+    const finalContent = content.endsWith("\n") ? content : `${content}\n`;
+    try {
+        fs.writeFileSync(tempPath, finalContent, "utf8");
+        fs.renameSync(tempPath, filePath);
+    }
+    catch (err) {
+        if (fs.existsSync(tempPath)) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch { /* ignore */ }
+        }
+        throw err;
+    }
+}
+/**
+ * Atomically appends to a file (if supported by OS) or simulates it.
+ * Note: Real atomic append on POSIX is a single write() call with O_APPEND.
+ * For simplicity and robustness across platforms, we use a simple append here
+ * as the risk of corruption is lower than a full rewrite, but for logs
+ * it's acceptable.
+ */
+export function appendFileSafe(filePath, content) {
+    const dir = path.dirname(filePath);
+    ensureDir(dir);
+    fs.appendFileSync(filePath, content, "utf8");
+}

package/dist/utils/metrics.js

@@ -0,0 +1,56 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "./security.js";
+export const Metrics = {
+    /**
+     * Estimates tokens based on character count (rough heuristic: 1 token ~= 4 chars).
+     */
+    estimateTokens: (text) => {
+        return Math.ceil(text.length / 4);
+    },
+    /**
+     * Logs the token usage and action to the observability metrics file.
+     */
+    logUsage: (projectRoot, agent, action, tokens) => {
+        Metrics.saveMetric(projectRoot, {
+            timestamp: new Date().toISOString(),
+            agent,
+            action,
+            estimatedTokens: tokens
+        });
+    },
+    /**
+     * Logs an error occurrence to the observability metrics file.
+     */
+    logError: (projectRoot, agent, action, error) => {
+        Metrics.saveMetric(projectRoot, {
+            timestamp: new Date().toISOString(),
+            agent,
+            action: `ERROR: ${action}`,
+            estimatedTokens: 0,
+            error
+        });
+    },
+    /**
+     * Internal helper to save metric entries.
+     */
+    saveMetric: (projectRoot, entry) => {
+        const frameworkDir = resolveFrameworkDir(projectRoot);
+        const metricsPath = path.join(projectRoot, frameworkDir, "observability/metrics.json");
+        try {
+            const metricsDir = path.dirname(metricsPath);
+            if (!fs.existsSync(metricsDir))
+                fs.mkdirSync(metricsDir, { recursive: true });
+            let currentMetrics = [];
+            if (fs.existsSync(metricsPath)) {
+                currentMetrics = JSON.parse(fs.readFileSync(metricsPath, "utf8"));
+            }
+            currentMetrics.push(entry);
+            // Keep only last 100 entries to save space
+            if (currentMetrics.length > 100)
+                currentMetrics.shift();
+            fs.writeFileSync(metricsPath, JSON.stringify(currentMetrics, null, 2));
+        }
+        catch { /* ignore: metrics should not block the main process */ }
+    }
+};

package/dist/utils/security.js

@@ -0,0 +1,60 @@
+import path from "path";
+import fs from "fs";
+import { FRAMEWORK, MCP, UNIFIED_HUB_DIR } from "../constants.js"; // New import
+import os from "os"; // Need os.homedir()
+/**
+ * Validates and resolves a user-provided path to prevent path traversal attacks.
+ * Ensures the resolved path stays within the project root boundary.
+ */
+export function safePath(projectRoot, userPath) {
+    const resolved = path.resolve(projectRoot, userPath);
+    const normalizedRoot = path.resolve(projectRoot);
+    if (!resolved.startsWith(normalizedRoot + path.sep) && resolved !== normalizedRoot) {
+        throw new Error(`Access denied: path "${userPath}" escapes project root.`);
+    }
+    return resolved;
+}
+/**
+ * Resolves the active framework directory.
+ * Priority: ATABEY_TEST_DIR (env) -> package.json `atabey.frameworkDir` -> `.atabey` -> other adapter dirs -> global HOME.
+ */
+export function resolveFrameworkDir(projectRoot) {
+    // For test environments, use the explicitly set test directory.
+    const testDir = process.env[MCP.TEST_DIR_ENV];
+    if (testDir)
+        return testDir;
+    // 1. Authoritative source: read from package.json if present
+    try {
+        const pkgPath = path.join(projectRoot, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            const atabeyConfig = pkg["atabey"];
+            if (atabeyConfig && typeof atabeyConfig["frameworkDir"] === "string") {
+                // Ensure the path is relative if it's within the project, otherwise use as-is.
+                const resolvedDir = path.resolve(projectRoot, atabeyConfig["frameworkDir"]);
+                if (resolvedDir.startsWith(path.resolve(projectRoot))) {
+                    return path.relative(projectRoot, resolvedDir);
+                }
+                return atabeyConfig["frameworkDir"];
+            }
+        }
+    }
+    catch {
+        // ignore — fall through to filesystem scan
+    }
+    // 2. Filesystem scan in projectRoot for common framework directories
+    const localCandidates = [
+        FRAMEWORK.CORE_DIR, // .atabey
+        UNIFIED_HUB_DIR, // .agents
+        // Add other adapter specific directories if needed, or remove if unified is strictly enforced
+    ];
+    for (const candidate of localCandidates) {
+        const candidatePath = path.join(projectRoot, candidate);
+        if (fs.existsSync(candidatePath)) {
+            return candidate;
+        }
+    }
+    // 3. Fallback to global home directory.
+    const homeDir = os.homedir();
+    return path.join(homeDir, FRAMEWORK.CORE_DIR);
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "atabey-mcp",
+  "version": "0.0.4",
+  "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/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/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;
+}