atabey 0.0.11 → 0.0.13

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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,182 @@
+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().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().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().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).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().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"]).default("NORMAL"),
+    requiresApproval: z.boolean().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."),
+}).strict();
+// ─── LLM Gateway ────────────────────────────────────────────────────
+export const LLMGatewayQuerySchema = z.object({
+    messages: z.array(z.object({
+        role: z.enum(["system", "user", "assistant", "tool"]),
+        content: z.string().min(1),
+    })).min(1, "At least one message is required"),
+    system: z.string().optional(),
+    model: z.string().optional(),
+    provider: z.enum(["openai", "anthropic", "google", "grok", "ollama"]).optional(),
+    strategy: z.enum(["round-robin", "least-latency", "cost-optimized", "failover", "priority-based", "model-based"]).optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().int().positive().optional(),
+    traceId: z.string().optional(),
+}).strict();
+export const LLMGatewayStatusSchema = z.object({
+    detail: z.enum(["overview", "providers", "stats"]).optional().default("overview"),
+}).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();

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

@@ -0,0 +1,48 @@
+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

@@ -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] ${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

@@ -0,0 +1,78 @@
+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: `[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;
+                    }
+                    const content = fs.readFileSync(filePath, "utf8");
+                    if (new RegExp(pattern).test(content)) {
+                        if (results.length < 30) {
+                            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: `[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

@@ -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/framework-mcp/dist/framework-mcp/src/tools/shell/run_command.js

@@ -0,0 +1,121 @@
+import { exec } from "child_process";
+import { Metrics } from "../../utils/metrics.js";
+const COMMAND_ALLOW_LIST = [
+    // Package managers
+    "npm test",
+    "npm run",
+    "npm install",
+    "npm ci",
+    "npm audit",
+    "npx vitest",
+    "npx tsc",
+    "npx eslint",
+    "yarn test",
+    "yarn run",
+    "yarn install",
+    "pnpm test",
+    "pnpm run",
+    "pnpm install",
+    // Git
+    "git status",
+    "git diff",
+    "git log",
+    "git branch",
+    "git stash",
+    "git add",
+    "git commit",
+    "git push",
+    "git pull",
+    "git fetch",
+    "git merge",
+    "git rebase",
+    "git checkout",
+    "git reset",
+    // Build tools
+    "npm run build",
+    "npx tsc",
+    "npx vite build",
+    "npx webpack",
+    "npx rollup",
+    "npx esbuild",
+    "make",
+    "cmake",
+    "dotnet test",
+    "dotnet format",
+    "dotnet build",
+    "dotnet run",
+    "dotnet restore",
+    "go test",
+    "go fmt",
+    "go build",
+    "go run",
+    "go vet",
+    "go mod",
+    "pytest",
+    "ruff check",
+    "ruff format",
+    "mvn",
+    "./gradlew",
+    "cargo test",
+    "cargo build",
+    "cargo check",
+    "cargo fmt",
+    // 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",
+    "rmdir",
+    "cat",
+    "ls",
+    "touch",
+    "head",
+    "tail",
+    "wc",
+    "grep",
+    "find",
+    "sort",
+    "uniq",
+    "echo",
+    "pwd",
+    "which",
+    "file",
+    "du",
+    "df",
+];
+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/framework-mcp/dist/framework-mcp/src/tools/types.js

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

package/framework-mcp/dist/framework-mcp/src/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";
+}