atabey 0.0.16 → 0.0.18

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

@@ -1,134 +0,0 @@
-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/quality/check_lint.js

@@ -1,30 +0,0 @@
-import { exec } from "child_process";
-import { Metrics } from "../../utils/metrics.js";
-import { getBackendLanguage, getDefaultLintCommand } from "../../utils/cli.js";
-const TIMEOUT = 60000; // 60 seconds
-/**
- * Handles running the project's linter.
- */
-export function handleCheckLint(projectRoot, _args) {
-    const language = getBackendLanguage(projectRoot);
-    const lintCommand = getDefaultLintCommand(language);
-    return new Promise((resolve) => {
-        exec(lintCommand, { cwd: projectRoot, timeout: TIMEOUT }, (error, stdout, stderr) => {
-            const output = stdout + stderr;
-            const tokens = Metrics.estimateTokens(output);
-            if (error) {
-                const err = `Linting failed for ${language} with command: ${lintCommand}. ${error.message}`;
-                Metrics.logError(projectRoot, "@mcp", "check_lint", err);
-                resolve({
-                    isError: true,
-                    content: [{ type: "text", text: `[ERROR] Lint Errors Found (${language}):\n\n${output}` }]
-                });
-                return;
-            }
-            Metrics.logUsage(projectRoot, "@mcp", "check_lint", tokens);
-            resolve({
-                content: [{ type: "text", text: `[OK] Lint check passed successfully for ${language}:\n\n${output}` }]
-            });
-        });
-    });
-}

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

@@ -1,178 +0,0 @@
-import { z } from "zod";
-/**
- * ─── ATABEY VALIDATED TYPES ────────────────────────────────────────
- * Zod schemas with regex + min-length validation for runtime safety.
- * NOTE: Brand types (intersection types) are defined in src/shared/types.ts.
- * These schemas provide runtime validation only; type branding is not
- * possible at runtime via Zod's .brand() — it's a no-op.
- */
-export const AgentIDSchema = z.string()
-    .regex(/^@[a-zA-Z0-9_-]+$/, "AgentID must start with '@' followed by alphanumeric characters/underscores.")
-    .min(2);
-export const TraceIDSchema = z.string()
-    .min(1, "TraceID cannot be empty");
-export const TaskIDSchema = z.string()
-    .regex(/^TASK-[0-9]+$/, "TaskID must follow the format 'TASK-001'.")
-    .min(1);
-export const PhaseIDSchema = z.enum(["PHASE_0", "PHASE_1", "PHASE_2", "PHASE_3", "PHASE_4"]);
-/**
- * ─── TOOL CONTRACTS ────────────────────────────────────────────────
- * Every tool must have a strict schema defining its boundary.
- * No unknown properties are allowed (.strict()).
- */
-// ─── File System
-export const ReadFileSchema = z.object({
-    path: z.string().min(1, "Path is required"),
-    startLine: z.number().int().positive().optional(),
-    endLine: z.number().int().positive().optional(),
-}).strict();
-export const WriteFileSchema = z.object({
-    path: z.string().min(1, "Path is required"),
-    content: z.string(),
-}).strict();
-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().optional().default(false),
-}).strict();
-// ─── Search & Exploration
-export const ListDirSchema = z.object({
-    path: z.string().default("."),
-}).strict();
-export const GrepSearchSchema = z.object({
-    pattern: z.string().min(1, "Pattern is required"),
-    includePattern: z.string().optional(),
-    excludePattern: z.string().optional(),
-}).strict();
-export const GetProjectMapSchema = z.object({
-    maxDepth: z.number().int().positive().default(3),
-    includeFiles: z.boolean().default(true),
-}).strict();
-export const GetProjectGapsSchema = z.object({
-    path: z.string().default("src"),
-}).strict();
-// ─── Batch & Patch
-export const BatchSurgicalEditSchema = z.object({
-    edits: z.array(z.object({
-        path: z.string().min(1),
-        oldText: z.string().min(1),
-        newText: z.string(),
-        allowMultiple: z.boolean().optional().default(false),
-    })),
-}).strict();
-export const PatchFileSchema = z.object({
-    path: z.string().min(1),
-    startLine: z.number().int().positive(),
-    endLine: z.number().int().positive(),
-    newContent: z.string(),
-}).strict();
-// ─── Framework & System
-export const RunShellCommandSchema = z.object({
-    command: z.string().min(1),
-}).strict();
-export const RunTestsSchema = z.object({
-    command: z.string().optional(),
-}).strict();
-export const GetSystemHealthSchema = z.object({}).strict();
-export const CheckPortsSchema = z.object({
-    filter: z.string().optional(),
-}).strict();
-export const GetFrameworkStatusSchema = z.object({}).strict();
-export const ReadProjectMemorySchema = z.object({}).strict();
-export const GetMemoryInsightsSchema = z.object({}).strict();
-export const UpdateProjectMemorySchema = z.object({
-    section: z.string().min(1),
-    content: z.string().min(1),
-}).strict();
-export const OrchestrateLoopSchema = z.object({}).strict();
-export const SubmitPlanSchema = z.object({
-    tasks: z.array(z.object({
-        id: TaskIDSchema,
-        agent: AgentIDSchema,
-        task: z.string().min(1),
-        dependencies: z.array(TaskIDSchema).optional(),
-    })),
-}).strict();
-export const AcquireLockSchema = z.object({
-    resource: z.string().min(1),
-    agent: AgentIDSchema,
-    ttl: z.number().int().positive().optional().default(60),
-}).strict();
-export const ReleaseLockSchema = z.object({
-    resource: z.string().min(1),
-    agent: AgentIDSchema,
-}).strict();
-export const RegisterAgentSchema = z.object({
-    agent: AgentIDSchema,
-    role: z.string().min(1),
-    capability: z.number().int().min(1).max(10).optional().default(5),
-    specialties: z.record(z.number()).optional(),
-}).strict();
-export const UpdateContractHashSchema = z.object({}).strict();
-export const AuditDependenciesSchema = z.object({}).strict();
-export const CheckLintSchema = z.object({}).strict();
-// ─── Memory (Core Memory)
-export const StoreKnowledgeSchema = z.object({
-    content: z.string().min(1, "Content is required"),
-    category: z.enum(["ARCHITECTURE", "DECISION", "CODE_SNIPPET", "RULE", "TASK_HISTORY"]),
-    tags: z.array(z.string()).optional(),
-    filePath: z.string().optional(),
-    traceId: z.string().optional(),
-}).strict();
-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().optional().default(5),
-}).strict();
-export const DeleteKnowledgeSchema = z.object({
-    id: z.string().optional(),
-    category: z.enum(["ARCHITECTURE", "DECISION", "CODE_SNIPPET", "RULE", "TASK_HISTORY"]).optional(),
-}).strict();
-// ─── Messaging (Hermes)
-export const SendAgentMessageSchema = z.object({
-    from: AgentIDSchema,
-    to: AgentIDSchema,
-    category: z.enum(["ACTION", "DELEGATION", "SUBTASK", "REPLY", "ALERT"]),
-    content: z.string().min(1, "Content cannot be empty"),
-    traceId: TraceIDSchema,
-    parentId: TaskIDSchema.optional(),
-    priority: z.enum(["HIGH", "NORMAL", "LOW"]).optional().default("NORMAL"),
-    requiresApproval: z.boolean().optional().default(false),
-}).strict();
-export const LogAgentActionSchema = z.object({
-    agent: AgentIDSchema,
-    action: z.string().min(1),
-    traceId: TraceIDSchema,
-    status: z.enum(["SUCCESS", "FAILURE"]),
-    summary: z.string().min(1),
-    findings: z.string().optional(),
-}).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/search/get_gaps.js

@@ -1,48 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { safePath } from "../../utils/security.js";
-/**
- * Scans the codebase for TODOs, FIXMEs, and empty function bodies.
- * Helps identify what's left and where the agent might have skipped logic.
- */
-export function handleGetProjectGaps(projectRoot, args) {
-    const srcDir = safePath(projectRoot, args.path || "src");
-    const results = [];
-    const walk = (dir) => {
-        if (!fs.existsSync(dir))
-            return;
-        const files = fs.readdirSync(dir);
-        for (const file of files) {
-            const fullPath = path.join(dir, file);
-            const relativePath = path.relative(projectRoot, fullPath);
-            if (fs.statSync(fullPath).isDirectory()) {
-                if (file !== "node_modules" && file !== "dist" && !file.startsWith(".")) {
-                    walk(fullPath);
-                }
-            }
-            else if (file.endsWith(".ts") || file.endsWith(".tsx")) {
-                const content = fs.readFileSync(fullPath, "utf8");
-                const lines = content.split("\n");
-                lines.forEach((line, index) => {
-                    // 1. Scan for markers
-                    if (line.includes("TODO") || line.includes("FIXME") || line.includes("!!!")) {
-                        results.push(`[${relativePath}:${index + 1}] Marker found: ${line.trim()}`);
-                    }
-                    // 2. Scan for empty function placeholders (heuristic)
-                    if (line.includes("throw new Error(\"Not implemented") || line.includes("// ... rest of code")) {
-                        results.push(`[${relativePath}:${index + 1}] Gap found: ${line.trim()}`);
-                    }
-                });
-            }
-        }
-    };
-    walk(srcDir);
-    return {
-        content: [{
-                type: "text",
-                text: results.length > 0
-                    ? `Found ${results.length} gaps/todos:\n\n${results.join("\n")}`
-                    : "[OK] No major gaps or TODOs found in the scanned directory."
-            }]
-    };
-}

package/framework-mcp/dist/framework-mcp/src/tools/search/get_map.js

@@ -1,43 +0,0 @@
-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] ${file}`);
-            }
-        });
-        return results;
-    };
-    try {
-        const tree = buildTree(projectRoot, 0);
-        return {
-            content: [{
-                    type: "text",
-                    text: `[MAP] **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/framework-mcp/dist/framework-mcp/src/tools/search/grep_search.js

@@ -1,85 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Metrics } from "../../utils/metrics.js";
-import { verifyReadPermission } from "../../utils/permissions.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: `[ERROR] ${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: `[ERROR] ${err}` }] };
-    }
-    const walk = (dir) => {
-        if (results.length >= 30)
-            return;
-        try {
-            const files = fs.readdirSync(dir);
-            for (const file of files) {
-                if (results.length >= 30)
-                    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;
-                    }
-                    try {
-                        verifyReadPermission(projectRoot, filePath);
-                        const content = fs.readFileSync(filePath, "utf8");
-                        if (new RegExp(pattern).test(content)) {
-                            if (results.length < 30) {
-                                results.push(filePath);
-                            }
-                        }
-                    }
-                    catch {
-                        // Silently skip files without read permissions
-                    }
-                }
-            }
-        }
-        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: `[ERROR] ${err}` }] };
-    }
-    let responseText = results.length > 0
-        ? `Found ${results.length} matches:\n\n${results.join("\n")}`
-        : "No matches found.";
-    if (results.length >= 30) {
-        responseText += "\n\n[TOKEN ECONOMY GUARD] Search truncated at 30 matches to save tokens. Please use a more specific 'pattern' or 'includePattern'.";
-    }
-    return {
-        content: [{
-                type: "text",
-                text: responseText
-            }]
-    };
-}

package/framework-mcp/dist/framework-mcp/src/tools/search/list_dir.js

@@ -1,31 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { safePath } from "../../utils/security.js";
-import { verifyReadPermission } from "../../utils/permissions.js";
-/**
- * Lists the contents of a directory.
- */
-export function handleListDir(projectRoot, args) {
-    const dirPath = safePath(projectRoot, args.path || ".");
-    // ENFORCE READ PERMISSION MATRIX FOR DIRECTORY
-    verifyReadPermission(projectRoot, path.join(args.path || ".", "placeholder"));
-    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")}`
-            }]
-    };
-}