atabey 0.0.16 → 0.0.18

package/framework-mcp/dist/tools/observability/check_ports.js

@@ -1,26 +0,0 @@
-import { execSync } from "child_process";
-/**
- * Checks for active network ports and their status.
- */
-export function handleCheckPorts(projectRoot, args) {
-    const filter = args.filter || ""; // Optional filter (e.g., ":3000")
-    try {
-        // Using 'lsof -i -P -n' to list open files and network connections
-        // Note: may require permissions or behave differently on non-Unix systems
-        const command = process.platform === "win32"
-            ? `netstat -ano | findstr LISTENING ${filter ? `| findstr ${filter}` : ""}`
-            : `lsof -i -P -n | grep LISTEN ${filter ? `| grep ${filter}` : ""}`;
-        const output = execSync(command, { encoding: "utf8" });
-        return {
-            content: [{
-                    type: "text",
-                    text: `[SIGNAL] **Active Listening Ports:**\n\n${output || "No active listening ports found matching filter."}`
-                }]
-        };
-    }
-    catch (_e) {
-        return {
-            content: [{ type: "text", text: "ℹ️ No active ports found or command failed (this is normal if nothing is listening)." }]
-        };
-    }
-}

package/framework-mcp/dist/tools/observability/get_health.js

@@ -1,19 +0,0 @@
-import os from "os";
-/**
- * Retrieves system health metrics including CPU load and memory usage.
- */
-export function handleGetSystemHealth(_projectRoot, _args) {
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
-    const usedMem = totalMem - freeMem;
-    const memUsagePercent = ((usedMem / totalMem) * 100).toFixed(2);
-    const loadAvg = os.loadavg(); // [1, 5, 15] minute averages
-    const healthReport = `🖥️ **System Health Report**
-- **Memory:** ${memUsagePercent}% used (${(usedMem / 1024 / 1024 / 1024).toFixed(2)} GB / ${(totalMem / 1024 / 1024 / 1024).toFixed(2)} GB)
-- **CPU Load (1m, 5m, 15m):** ${loadAvg.map(l => l.toFixed(2)).join(", ")}
-- **Platform:** ${os.platform()} (${os.release()})
-- **Uptime:** ${(os.uptime() / 3600).toFixed(2)} hours`;
-    return {
-        content: [{ type: "text", text: healthReport }]
-    };
-}

package/framework-mcp/dist/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/tools/schemas.js

@@ -1,133 +0,0 @@
-import { z } from "zod";
-/**
- * ─── ATABEY BRANDED TYPES ─────────────────────────────────────────
- * Using Zod's .brand() to ensure compile-time and runtime safety.
- * These types represent the "System DNA".
- */
-export const AgentIDSchema = z.string()
-    .regex(/^@[a-zA-Z0-9_-]+$/, "AgentID must start with '@' followed by alphanumeric characters/underscores.")
-    .brand();
-export const TraceIDSchema = z.string()
-    .min(1, "TraceID cannot be empty")
-    .brand();
-export const TaskIDSchema = z.string()
-    .regex(/^TASK-[0-9]+$/, "TaskID must follow the format 'TASK-001'.")
-    .brand();
-export const PhaseIDSchema = z.enum(["PHASE_0", "PHASE_1", "PHASE_2", "PHASE_3", "PHASE_4"])
-    .brand();
-/**
- * ─── 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();
-// ─── 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();

package/framework-mcp/dist/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/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}`);
-            }
-        });
-        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/framework-mcp/dist/tools/search/grep_search.js

@@ -1,75 +0,0 @@
-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 > 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: `[ERROR] ${err}` }] };
-    }
-    return {
-        content: [{
-                type: "text",
-                text: results.length > 0
-                    ? `Found ${results.length} matches:\n\n${results.join("\n")}`
-                    : "No matches found."
-            }]
-    };
-}

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

@@ -1,28 +0,0 @@
-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/tools/shell/run_command.js

@@ -1,56 +0,0 @@
-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/framework-mcp/dist/tools/types.js

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

package/framework-mcp/dist/utils/cli.js

@@ -1,59 +0,0 @@
-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";
-}