atabey 0.0.12 → 0.0.14

package/framework-mcp/dist/framework-mcp/src/tools/quality/analyze_code_quality.js

@@ -0,0 +1,114 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { analyzePathQuality } from "../../utils/quality.js";
+/**
+ * Code quality analysis tool for Atabey MCP.
+ *
+ * Performs three checks on the provided source code:
+ * - TypeScript type checking (checkTypes)
+ * - Lint checking (checkLint)
+ * - Code complexity analysis (checkComplexity)
+ */
+export function handleAnalyzeCodeQuality(projectRoot, args) {
+    // Validate path parameter to prevent command injection
+    if (!/^[a-zA-Z0-9_./-]+$/.test(args.path)) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `[ERROR] Invalid path characters detected: ${args.path}` }]
+        };
+    }
+    const targetPath = path.resolve(projectRoot, args.path);
+    if (!fs.existsSync(targetPath)) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `[ERROR] Path does not exist: ${args.path}` }]
+        };
+    }
+    const results = ["# Code Quality Analysis Report", "", `**Target:** ${args.path}`, `**Timestamp:** ${new Date().toISOString()}`, ""];
+    let hasErrors = false;
+    // 1. TypeScript Type Check
+    if (args.checkTypes !== false) {
+        try {
+            execSync("npx tsc --noEmit", {
+                cwd: projectRoot,
+                stdio: "pipe",
+                timeout: 30000,
+                encoding: "utf8"
+            });
+            results.push("## ✅ TypeScript Check: PASSED");
+            results.push("No type errors found.");
+        }
+        catch (err) {
+            hasErrors = true;
+            const error = err;
+            const stderr = error.stderr || error.stdout || error.message || "Unknown error";
+            results.push("## ❌ TypeScript Check: FAILED");
+            results.push("```");
+            results.push(stderr.substring(0, 2000));
+            results.push("```");
+        }
+        results.push("");
+    }
+    // 2. Lint Check
+    if (args.checkLint !== false) {
+        try {
+            const lintOutput = execSync("npx eslint --format compact " + args.path, {
+                cwd: projectRoot,
+                stdio: "pipe",
+                timeout: 30000,
+                encoding: "utf8"
+            });
+            const lintStr = lintOutput.trim();
+            if (lintStr) {
+                results.push("## ⚠️ Lint Check: ISSUES FOUND");
+                results.push("```");
+                results.push(lintStr.substring(0, 2000));
+                results.push("```");
+            }
+            else {
+                results.push("## ✅ Lint Check: PASSED");
+                results.push("No lint issues found.");
+            }
+        }
+        catch (err) {
+            const error = err;
+            const stderr = error.stderr || error.stdout || error.message || "Unknown error";
+            // ESLint returns non-zero exit code when issues are found
+            if (stderr.includes("ESLint")) {
+                results.push("## ❌ Lint Check: FAILED");
+                results.push("```");
+                results.push(stderr.substring(0, 2000));
+                results.push("```");
+            }
+            else {
+                results.push("## ✅ Lint Check: PASSED (no ESLint config)");
+            }
+        }
+        results.push("");
+    }
+    // 3. Code Complexity Check (basic heuristic)
+    if (args.checkComplexity !== false) {
+        const qualityResult = analyzePathQuality(projectRoot, args.path);
+        const complexityIssues = qualityResult.issues.filter(issue => issue.type === "complexity");
+        if (complexityIssues.length > 0) {
+            hasErrors = true;
+            results.push(`## ⚠️ Code Complexity Issues (${complexityIssues.length})`);
+            complexityIssues.forEach(issue => {
+                results.push(`- ${issue.file}:${issue.line} — ${issue.message}`);
+            });
+        }
+        else {
+            results.push("## ✅ Code Complexity: OK");
+            results.push("No complexity issues found.");
+        }
+        results.push("");
+    }
+    // Summary
+    results.push("---");
+    results.push(`**Overall Status:** ${hasErrors ? "⚠️ Issues Found" : "✅ All Checks Passed"}`);
+    return {
+        content: [{ type: "text", text: results.join("\n") }],
+        isError: hasErrors
+    };
+}

package/framework-mcp/dist/framework-mcp/src/tools/quality/check_architecture_compliance.js

@@ -0,0 +1,134 @@
+import fs from "fs";
+import path from "path";
+/**
+ * [TOOL] check_architecture_compliance
+ *
+ * Checks architectural compliance for code at the specified path:
+ * - Controller/Service/Repository layer separation
+ * - Import rules (controller → service → repository)
+ * - Circular dependencies
+ */
+export function handleCheckArchitectureCompliance(projectRoot, args) {
+    const targetPath = path.resolve(projectRoot, args.path);
+    if (!fs.existsSync(targetPath)) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `[ERROR] Path does not exist: ${args.path}` }]
+        };
+    }
+    const results = [
+        "# Architecture Compliance Report",
+        "",
+        `**Target:** ${args.path}`,
+        `**Timestamp:** ${new Date().toISOString()}`,
+        ""
+    ];
+    const violations = [];
+    const allFiles = [];
+    // Collect all relevant files
+    function collectFiles(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith("node_modules") && !entry.name.startsWith(".")) {
+                collectFiles(fullPath);
+            }
+            else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"))) {
+                allFiles.push(fullPath);
+            }
+        }
+    }
+    collectFiles(targetPath);
+    // Analyze each file for architectural violations
+    for (const file of allFiles) {
+        const relativePath = path.relative(projectRoot, file);
+        const content = fs.readFileSync(file, "utf8");
+        const lines = content.split("\n");
+        const fileName = path.basename(file, path.extname(file));
+        const fileDir = path.dirname(file);
+        // 1. Layer naming convention check
+        const isController = fileName.endsWith(".controller") || fileName.endsWith("Controller");
+        const isService = fileName.endsWith(".service") || fileName.endsWith("Service");
+        const isRepository = fileName.endsWith(".repository") || fileName.endsWith("Repository");
+        const isModel = fileName.endsWith(".model") || fileName.endsWith("Model");
+        // 2. Controller → Service → Repository dependency direction
+        for (const line of lines) {
+            const importMatch = line.match(/import\s+.*\s+from\s+['"](.+)['"]/);
+            if (!importMatch)
+                continue;
+            const importPath = importMatch[1];
+            const importedFileName = path.basename(importPath, path.extname(importPath));
+            // Controller importing Repository directly (should go through Service)
+            if (isController && (importedFileName.endsWith(".repository") || importedFileName.endsWith("Repository"))) {
+                violations.push(`- ${relativePath}: Controller \`${fileName}\` directly imports Repository \`${importedFileName}\`. ` +
+                    "Use Service layer instead.");
+            }
+            // Repository importing Controller
+            if (isRepository && (importedFileName.endsWith(".controller") || importedFileName.endsWith("Controller"))) {
+                violations.push(`- ${relativePath}: Repository \`${fileName}\` imports Controller \`${importedFileName}\`. ` +
+                    "Reverse dependency detected.");
+            }
+            // Service importing Controller
+            if (isService && (importedFileName.endsWith(".controller") || importedFileName.endsWith("Controller"))) {
+                violations.push(`- ${relativePath}: Service \`${fileName}\` imports Controller \`${importedFileName}\`. ` +
+                    "Service should not depend on Controller.");
+            }
+            // Model importing Controller/Service/Repository
+            if (isModel && (importedFileName.endsWith("Controller") || importedFileName.endsWith("Service") || importedFileName.endsWith("Repository"))) {
+                violations.push(`- ${relativePath}: Model \`${fileName}\` imports \`${importedFileName}\`. ` +
+                    "Models should not depend on other layers.");
+            }
+        }
+        // 3. Check for barrel index imports that might cause circular dependencies
+        if (fileName === "index" && fileDir.includes("modules")) {
+            const indexContent = fs.readFileSync(file, "utf8");
+            const exports = indexContent.match(/export\s+\*?\s*from\s+['"].+['"]/g) || [];
+            if (exports.length > 10) {
+                violations.push(`- ${relativePath}: Barrel file exports ${exports.length} modules. ` +
+                    "Consider splitting into smaller barrels to prevent circular dependencies.");
+            }
+        }
+    }
+    // 4. Strict mode check
+    let hasStrictMode = false;
+    const tsConfigPath = path.join(projectRoot, "tsconfig.json");
+    if (fs.existsSync(tsConfigPath)) {
+        try {
+            const tsConfig = JSON.parse(fs.readFileSync(tsConfigPath, "utf8"));
+            if (tsConfig.compilerOptions?.strict) {
+                hasStrictMode = true;
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    if (!hasStrictMode) {
+        violations.push("- tsconfig.json: `strict` mode is not enabled. Atabey requires strict type checking.");
+    }
+    // Report
+    if (violations.length > 0) {
+        results.push(`## ❌ Architecture Violations (${violations.length})`);
+        results.push("");
+        results.push(...violations);
+        results.push("");
+        results.push("---");
+        results.push(`**Status:** ❌ FAILED — ${violations.length} architectural violations found.`);
+    }
+    else {
+        results.push("## ✅ Architecture Compliance: PASSED");
+        results.push("");
+        results.push("- All layer dependencies are correctly oriented.");
+        results.push("- No circular dependencies detected.");
+        results.push("- Strict mode is enabled.");
+        results.push("");
+        results.push("---");
+        results.push("**Status:** ✅ All architecture checks passed.");
+    }
+    return {
+        content: [{ type: "text", text: results.join("\n") }],
+        isError: violations.length > 0
+    };
+}

package/framework-mcp/dist/framework-mcp/src/tools/schemas.js

@@ -34,7 +34,7 @@ export const ReplaceTextSchema = z.object({
     path: z.string().min(1, "Path is required"),
     oldText: z.string().min(1, "oldText is required"),
     newText: z.string(),
-    allowMultiple: z.boolean().default(false),
+    allowMultiple: z.boolean().optional().default(false),
 }).strict();
 // ─── Search & Exploration
 export const ListDirSchema = z.object({
@@ -58,7 +58,7 @@ export const BatchSurgicalEditSchema = z.object({
         path: z.string().min(1),
         oldText: z.string().min(1),
         newText: z.string(),
-        allowMultiple: z.boolean().default(false),
+        allowMultiple: z.boolean().optional().default(false),
     })),
 }).strict();
 export const PatchFileSchema = z.object({
@@ -97,7 +97,7 @@ export const SubmitPlanSchema = z.object({
 export const AcquireLockSchema = z.object({
     resource: z.string().min(1),
     agent: AgentIDSchema,
-    ttl: z.number().int().positive().default(60),
+    ttl: z.number().int().positive().optional().default(60),
 }).strict();
 export const ReleaseLockSchema = z.object({
     resource: z.string().min(1),
@@ -106,7 +106,7 @@ export const ReleaseLockSchema = z.object({
 export const RegisterAgentSchema = z.object({
     agent: AgentIDSchema,
     role: z.string().min(1),
-    capability: z.number().int().min(1).max(10).default(5),
+    capability: z.number().int().min(1).max(10).optional().default(5),
     specialties: z.record(z.number()).optional(),
 }).strict();
 export const UpdateContractHashSchema = z.object({}).strict();
@@ -123,7 +123,7 @@ export const StoreKnowledgeSchema = z.object({
 export const SearchKnowledgeSchema = z.object({
     query: z.string().min(1, "Query is required"),
     category: z.enum(["ARCHITECTURE", "DECISION", "CODE_SNIPPET", "RULE", "TASK_HISTORY"]).optional(),
-    limit: z.number().int().positive().default(5),
+    limit: z.number().int().positive().optional().default(5),
 }).strict();
 export const DeleteKnowledgeSchema = z.object({
     id: z.string().optional(),
@@ -137,8 +137,8 @@ export const SendAgentMessageSchema = z.object({
     content: z.string().min(1, "Content cannot be empty"),
     traceId: TraceIDSchema,
     parentId: TaskIDSchema.optional(),
-    priority: z.enum(["HIGH", "NORMAL", "LOW"]).default("NORMAL"),
-    requiresApproval: z.boolean().default(false),
+    priority: z.enum(["HIGH", "NORMAL", "LOW"]).optional().default("NORMAL"),
+    requiresApproval: z.boolean().optional().default(false),
 }).strict();
 export const LogAgentActionSchema = z.object({
     agent: AgentIDSchema,
@@ -150,4 +150,29 @@ export const LogAgentActionSchema = z.object({
 }).strict();
 export const AskHumanSchema = z.object({
     question: z.string().min(10, "Question must be clear and detailed."),
+    timeoutSeconds: z.number().int().positive().optional().default(120),
+}).strict();
+export const ApproveOperationSchema = z.object({
+    action: z.enum(["approve", "reject", "list"]),
+    traceId: z.string().optional(),
+    reason: z.string().optional(),
+}).strict();
+// ─── Code Quality Analysis ──────────────────────────────────────────
+export const AnalyzeCodeQualitySchema = z.object({
+    path: z.string().min(1, "Path to analyze is required"),
+    checkTypes: z.boolean().optional().default(true),
+    checkLint: z.boolean().optional().default(true),
+    checkComplexity: z.boolean().optional().default(true),
+}).strict();
+// ─── Architecture Compliance ────────────────────────────────────────
+export const CheckArchitectureComplianceSchema = z.object({
+    path: z.string().min(1, "Path to check is required"),
+    rules: z.array(z.string()).optional(),
+}).strict();
+// ─── PII / Compliance ───────────────────────────────────────────────
+export const MaskPIISchema = z.object({
+    text: z.string().optional(),
+    data: z.record(z.unknown()).optional(),
+    mode: z.enum(["text", "object", "auto"]).optional().default("auto"),
+    strictMode: z.boolean().optional().default(false),
 }).strict();

package/framework-mcp/dist/framework-mcp/src/tools/shell/run_command.js

@@ -60,8 +60,8 @@ const COMMAND_ALLOW_LIST = [
     "cargo build",
     "cargo check",
     "cargo fmt",
-    // File operations (safe) — NOTA: "rm -rf" ve "rm -r" KASITLI olarak yok.
-    // "rm -rf /" gibi tehlikeli komutları engellemek için sadece "rmdir" izinli.
+    // File operations (safe) — NOTE: "rm -rf" and "rm -r" intentionally excluded.
+    // Only "rmdir" is allowed to prevent dangerous commands like "rm -rf /".
     "mkdir",
     "cp",
     "mv",
@@ -95,6 +95,16 @@ export function handleRunCommand(projectRoot, args) {
             isError: true,
         });
     }
+    // Harden to prevent shell command injection / chaining
+    const hasShellMetacharacters = /[;&|><$`\n\r]/.test(command);
+    if (hasShellMetacharacters) {
+        const errorMsg = "Command rejected: Shell metacharacters are forbidden to prevent command injection.";
+        Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command} (denied: metacharacters)`, 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;

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

@@ -1 +1,2 @@
+// Import types locally for ToolArgs union usage
 export {};

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

@@ -0,0 +1,78 @@
+/**
+ * ─── MCP AUTHENTICATION ──────────────────────────────────────────
+ *
+ * Simple API key authentication for MCP server.
+ * When MCP_AUTH_TOKEN is set, all MCP and API requests require
+ * Authorization: Bearer <token> header.
+ *
+ * Environment Variables:
+ *   MCP_AUTH_TOKEN     - API key for authentication (optional)
+ *   MCP_AUTH_USERS     - Comma-separated list of user:token pairs (optional)
+ *                        Example: "alice:key1,bob:key2"
+ *
+ * If neither is set, authentication is disabled (open access).
+ */
+let authUsers = [];
+let masterToken = null;
+/**
+ * Initialize authentication from environment variables.
+ */
+export function initAuth() {
+    masterToken = process.env.MCP_AUTH_TOKEN || null;
+    const usersStr = process.env.MCP_AUTH_USERS || "";
+    if (usersStr) {
+        authUsers = usersStr.split(",").map(pair => {
+            const [name, token] = pair.split(":");
+            return { name: name?.trim() || "unknown", token: token?.trim() || "" };
+        }).filter(u => u.token);
+    }
+    if (masterToken) {
+        console.error(`[AUTH] Master token configured (${masterToken.length} chars)`);
+    }
+    if (authUsers.length > 0) {
+        console.error(`[AUTH] ${authUsers.length} user(s) configured: ${authUsers.map(u => u.name).join(", ")}`);
+    }
+    if (!masterToken && authUsers.length === 0) {
+        console.error("[AUTH] No authentication configured - OPEN ACCESS");
+        console.error("[AUTH] Set MCP_AUTH_TOKEN=<key> or MCP_AUTH_USERS=user1:key1,user2:key2 to enable");
+    }
+}
+/**
+ * Authenticate a request using the Authorization header.
+ * Returns the authenticated user name or null if unauthorized.
+ */
+export function authenticate(req) {
+    if (!masterToken && authUsers.length === 0) {
+        // Auth disabled - allow all
+        return { authenticated: true, user: "anonymous" };
+    }
+    const authHeader = req.headers["authorization"];
+    if (!authHeader) {
+        return { authenticated: false, user: "" };
+    }
+    // Support both "Bearer <key>" and "<key>" formats
+    const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
+    // Check master token first
+    if (masterToken && token === masterToken) {
+        return { authenticated: true, user: "admin" };
+    }
+    // Check user tokens
+    for (const user of authUsers) {
+        if (token === user.token) {
+            return { authenticated: true, user: user.name };
+        }
+    }
+    return { authenticated: false, user: "" };
+}
+/**
+ * Generate authentication headers for MCP client configuration.
+ */
+export function getAuthHeader(user, token) {
+    return `Bearer ${token}`;
+}
+/**
+ * Check if authentication is enabled.
+ */
+export function isAuthEnabled() {
+    return !!masterToken || authUsers.length > 0;
+}