atabey 0.0.6 → 0.0.8

package/framework-mcp/{src/tools/observability/get_health.ts → dist/framework-mcp/src/tools/observability/get_health.js}

@@ -1,23 +1,18 @@
 import os from "os";
-import { ToolArgs, ToolResult } from "../types.js";
-
 /**
  * Retrieves system health metrics including CPU load and memory usage.
  */
-export function handleGetSystemHealth(_projectRoot: string, _args: ToolArgs): ToolResult {
+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/{src/tools/quality/check_lint.ts → dist/framework-mcp/src/tools/quality/check_lint.js}

@@ -1,35 +1,29 @@
 import { exec } from "child_process";
-import { ToolArgs, ToolResult } from "../types.js";
 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: string, _args: ToolArgs): Promise<ToolResult> {
+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: `❌ Lint Errors Found (${language}):\n\n${output}` }]
+                    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: `✅ Lint check passed successfully for ${language}:\n\n${output}` }]
+                content: [{ type: "text", text: `[OK] Lint check passed successfully for ${language}:\n\n${output}` }]
             });
         });
     });

package/framework-mcp/{src/tools/search/get_gaps.ts → dist/framework-mcp/src/tools/search/get_gaps.js}

@@ -1,37 +1,33 @@
 import fs from "fs";
 import path from "path";
 import { safePath } from "../../utils/security.js";
-import { GetProjectGapsArgs, ToolResult } from "../types.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: string, args: GetProjectGapsArgs): ToolResult {
+export function handleGetProjectGaps(projectRoot, args) {
     const srcDir = safePath(projectRoot, args.path || "src");
-    const results: string[] = [];
-
-    const walk = (dir: string) => {
-        if (!fs.existsSync(dir)) return;
+    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")) {
+            }
+            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()}`);
@@ -40,15 +36,13 @@ export function handleGetProjectGaps(projectRoot: string, args: GetProjectGapsAr
             }
         }
     };
-
     walk(srcDir);
-
     return {
         content: [{
-            type: "text",
-            text: results.length > 0 
-                ? `Found ${results.length} gaps/todos:\n\n${results.join("\n")}`
-                : "✅ No major gaps or TODOs found in the scanned directory."
-        }]
+                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/{src/tools/search/get_map.ts → dist/framework-mcp/src/tools/search/get_map.js}

@@ -1,48 +1,43 @@
 import fs from "fs";
 import path from "path";
-import { GetProjectMapArgs, ToolResult } from "../types.js";
-
 /**
  * Generates a tree-view map of the project structure.
  * Helps agents visualize the entire project layout quickly.
  */
-export function handleGetProjectMap(projectRoot: string, args: GetProjectMapArgs): ToolResult {
+export function handleGetProjectMap(projectRoot, args) {
     const maxDepth = args.maxDepth || 3;
     const includeFiles = args.includeFiles !== false;
-
-    const buildTree = (dir: string, depth: number): string[] => {
-        if (depth > maxDepth) return [];
-
-        const results: string[] = [];
+    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;
-
+            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) {
+            }
+            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")}`
-            }]
+                    type: "text",
+                    text: `🗺️ **Project Map (Depth: ${maxDepth})**\n\n${tree.join("\n")}`
+                }]
         };
-    } catch (e) {
+    }
+    catch (e) {
         return { isError: true, content: [{ type: "text", text: `Failed to map project: ${String(e)}` }] };
     }
 }

package/framework-mcp/{src/tools/search/grep_search.ts → dist/framework-mcp/src/tools/search/grep_search.js}

@@ -1,37 +1,35 @@
 import fs from "fs";
 import path from "path";
-import { GrepSearchArgs, ToolResult } from "../types.js";
 import { Metrics } from "../../utils/metrics.js";
-
 /**
  * Searches for a regex pattern within files in the project.
  */
-export function handleGrepSearch(projectRoot: string, args: GrepSearchArgs): ToolResult {
-    const pattern = args.pattern as string;
-    const includePattern = args.includePattern as string || ""; // e.g., ".ts"
-    const excludePattern = args.excludePattern as string || "node_modules";
-
+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}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
-
-    const results: string[] = [];
+    const results = [];
     try {
         new RegExp(pattern);
-    } catch (e) {
+    }
+    catch (e) {
         const err = `Invalid regex pattern: ${String(e)}`;
         Metrics.logError(projectRoot, "@mcp", "grep_search", err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${err}` }] };
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
     }
-
-    const walk = (dir: string) => {
-        if (results.length > 100) return;
+    const walk = (dir) => {
+        if (results.length > 100)
+            return;
         try {
             const files = fs.readdirSync(dir);
             for (const file of files) {
-                if (results.length > 100) return;
+                if (results.length > 100)
+                    return;
                 const filePath = path.join(dir, file);
                 if (excludePattern && filePath.includes(excludePattern)) {
                     continue;
@@ -39,7 +37,8 @@ export function handleGrepSearch(projectRoot: string, args: GrepSearchArgs): Too
                 const stat = fs.statSync(filePath);
                 if (stat.isDirectory()) {
                     walk(filePath);
-                } else if (stat.isFile()) {
+                }
+                else if (stat.isFile()) {
                     if (includePattern && !filePath.endsWith(includePattern)) {
                         continue;
                     }
@@ -52,24 +51,25 @@ export function handleGrepSearch(projectRoot: string, args: GrepSearchArgs): Too
                     }
                 }
             }
-        } catch {
+        }
+        catch {
             // Ignore directories that cannot be read
         }
     };
     try {
         walk(projectRoot);
-    } catch (e) {
+    }
+    catch (e) {
         const err = `Search failed: ${String(e)}`;
         Metrics.logError(projectRoot, "@mcp", "grep_search", err);
-        return { isError: true, content: [{ type: "text", text: `❌ ${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."
-        }]
+                type: "text",
+                text: results.length > 0
+                    ? `Found ${results.length} matches:\n\n${results.join("\n")}`
+                    : "No matches found."
+            }]
     };
 }

package/framework-mcp/{src/tools/search/list_dir.ts → dist/framework-mcp/src/tools/search/list_dir.js}

@@ -1,34 +1,28 @@
 import fs from "fs";
 import path from "path";
 import { safePath } from "../../utils/security.js";
-import { ListDirArgs, ToolResult } from "../types.js";
-
 /**
  * Lists the contents of a directory.
  */
-export function handleListDir(projectRoot: string, args: ListDirArgs): ToolResult {
+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")}`
-        }]
+                type: "text",
+                text: `Directory listing for ${args.path || "."}:\n\n${results.join("\n")}`
+            }]
     };
 }

package/framework-mcp/{src/tools/shell/run_command.ts → dist/framework-mcp/src/tools/shell/run_command.js}

@@ -1,7 +1,5 @@
 import { exec } from "child_process";
-import { RunCommandArgs, ToolResult } from "../types.js";
 import { Metrics } from "../../utils/metrics.js";
-
 const COMMAND_ALLOW_LIST = [
     "npm test",
     "npm run lint",
@@ -20,14 +18,10 @@ const COMMAND_ALLOW_LIST = [
     "./gradlew",
     "mvn",
 ];
-
 const TIMEOUT = 30000; // 30 seconds
-
-export function handleRunCommand(projectRoot: string, args: RunCommandArgs): Promise<ToolResult> {
+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);
@@ -36,13 +30,11 @@ export function handleRunCommand(projectRoot: string, args: RunCommandArgs): Pro
             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);
@@ -52,14 +44,12 @@ export function handleRunCommand(projectRoot: string, args: RunCommandArgs): Pro
                 });
                 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/{src/utils/cli.ts → dist/framework-mcp/src/utils/cli.js}

@@ -1,53 +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: string, args: string[], cwd: string, timeout = 30000): string {
+export function safeExec(cmd, args, cwd, timeout = 30000) {
     try {
         return execFileSync(cmd, args, { cwd, timeout, encoding: "utf8", stdio: "pipe" });
-    } catch (err: unknown) {
-        const error = err as { stdout?: Buffer | string; stderr?: Buffer | string; message?: string };
+    }
+    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: string): string {
+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 {
+    }
+    catch {
         // Fallback to default
     }
     return "Node.js (TypeScript)";
 }
-
 /**
  * Returns the default lint command for the given language.
  */
-export function getDefaultLintCommand(language: string): string {
-    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";
+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: string): string {
-    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";
+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";
 }