agent-enderun 1.1.9 → 1.10.0

package/framework-mcp/src/tools/framework/audit_deps.ts

@@ -1,49 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { ToolArgs, ToolResult } from "../types.js";
-
-/**
- * Audits package.json for unused or duplicate-like packages.
- * Focuses on project health and cleanup.
- */
-export function handleAuditDependencies(projectRoot: string, _args: ToolArgs): ToolResult {
-    const pkgPath = path.join(projectRoot, "package.json");
-    if (!fs.existsSync(pkgPath)) {
-        throw new Error("package.json not found.");
-    }
-
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const depNames = Object.keys(deps);
-    
-    const results: string[] = [];
-
-    // 1. Look for similar packages (potential duplicates)
-    const similarityGroups: Record<string, string[]> = {
-        "CSS/Styling": ["tailwind", "panda", "styled-components", "emotion", "sass"],
-        "Testing": ["vitest", "jest", "mocha", "jasmine"],
-        "Fetching": ["axios", "ky", "fetch"]
-    };
-
-    for (const [group, patterns] of Object.entries(similarityGroups)) {
-        const found = depNames.filter(d => patterns.some(p => d.includes(p)));
-        if (found.length > 1) {
-            results.push(`⚠️  Potential redundancy in [${group}]: Found ${found.join(", ")}`);
-        }
-    }
-
-    // 2. Scan for "any" usage in package names (bad practice markers)
-    const legacyDeps = depNames.filter(d => d.includes("legacy") || d.includes("compat"));
-    if (legacyDeps.length > 0) {
-        results.push(`ℹ️  Legacy compatibility packages detected: ${legacyDeps.join(", ")}`);
-    }
-
-    return {
-        content: [{
-            type: "text",
-            text: results.length > 0 
-                ? `Dependency Audit Results:\n\n${results.join("\n")}`
-                : "✅ Dependencies look clean and consolidated."
-        }]
-    };
-}

package/framework-mcp/src/tools/framework/get_status.ts

@@ -1,7 +0,0 @@
-import { safeExec } from "../../utils/cli.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-export function handleGetFrameworkStatus(projectRoot: string, args: ToolArgs): ToolResult {
-    const output = safeExec("npx", ["agent-enderun", "status"], projectRoot, args.timeout);
-    return { content: [{ type: "text", text: output }] };
-}

package/framework-mcp/src/tools/framework/orchestrate.ts

@@ -1,7 +0,0 @@
-import { safeExec } from "../../utils/cli.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-export function handleOrchestrateLoop(projectRoot: string, args: ToolArgs): ToolResult {
-    const output = safeExec("npx", ["agent-enderun", "orchestrate"], projectRoot, args.timeout);
-    return { content: [{ type: "text", text: output }] };
-}

package/framework-mcp/src/tools/framework/run_tests.ts

@@ -1,28 +0,0 @@
-import { execSync } from "child_process";
-import { ToolArgs, ToolResult } from "../types.js";
-
-/**
- * Executes project tests and returns results for agent analysis.
- */
-export function handleRunTests(projectRoot: string, args: ToolArgs): ToolResult {
-    const testCommand = args.command as string || "npm test";
-    
-    try {
-        const output = execSync(testCommand, { cwd: projectRoot, encoding: "utf8", stdio: "pipe" });
-        return {
-            content: [{ type: "text", text: `✅ Tests passed successfully!\n\n${output}` }]
-        };
-    } catch (error: unknown) {
-        const err = error as { stderr?: Buffer; stdout?: Buffer };
-        const stderr = err.stderr?.toString() || "";
-        const stdout = err.stdout?.toString() || "";
-        
-        return {
-            isError: true,
-            content: [{ 
-                type: "text", 
-                text: `❌ Tests FAILED!\n\n--- STDOUT ---\n${stdout}\n\n--- STDERR ---\n${stderr}` 
-            }]
-        };
-    }
-}

package/framework-mcp/src/tools/framework/update_contract_hash.ts

@@ -1,7 +0,0 @@
-import { safeExec } from "../../utils/cli.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-export function handleUpdateContractHash(projectRoot: string, args: ToolArgs): ToolResult {
-    const output = safeExec("npx", ["agent-enderun", "update-contract"], projectRoot, args.timeout);
-    return { content: [{ type: "text", text: output }] };
-}

package/framework-mcp/src/tools/framework/update_memory.ts

@@ -1,10 +0,0 @@
-import { safeExec } from "../../utils/cli.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-export function handleUpdateProjectMemory(projectRoot: string, args: ToolArgs): ToolResult {
-    const section = args.section as string;
-    const content = args.content as string;
-    // Using execFileSync with array args prevents command injection
-    safeExec("npx", ["agent-enderun", "update_project_memory", section, content], projectRoot, args.timeout);
-    return { content: [{ type: "text", text: `✅ Section ${section} updated.` }] };
-}

package/framework-mcp/src/tools/index.ts

@@ -1,60 +0,0 @@
-import { TOOLS } from "./definitions.js";
-import { handleReadFile } from "./file_system/read_file.js";
-import { handleWriteFile } from "./file_system/write_file.js";
-import { handleReplaceText } from "./file_system/replace_text.js";
-import { handleBatchSurgicalEdit } from "./file_system/batch_surgical_edit.js";
-import { handlePatchFile } from "./file_system/patch_file.js";
-import { handleGrepSearch } from "./search/grep_search.js";
-import { handleListDir } from "./search/list_dir.js";
-import { handleGetProjectGaps } from "./search/get_gaps.js";
-import { handleGetProjectMap } from "./search/get_map.js";
-import { handleGetFrameworkStatus } from "./framework/get_status.js";
-import { handleUpdateProjectMemory } from "./framework/update_memory.js";
-import { handleAuditDependencies } from "./framework/audit_deps.js";
-import { handleRunTests } from "./framework/run_tests.js";
-import { handleGetSystemHealth } from "./observability/get_health.js";
-import { handleCheckPorts } from "./observability/check_ports.js";
-import { handleStartDashboard } from "./dashboard/start_dashboard.js";
-import { handleOrchestrateLoop } from "./framework/orchestrate.js";
-import { handleUpdateContractHash } from "./framework/update_contract_hash.js";
-import { handleReadProjectMemory } from "./memory/read_memory.js";
-import { handleGetMemoryInsights } from "./memory/get_insights.js";
-import { handleSendAgentMessage } from "./messaging/send_message.js";
-import { handleLogAgentAction } from "./messaging/log_action.js";
-import { handleAcquireLock, handleReleaseLock } from "./control_plane/locking.js";
-import { handleRegisterAgent } from "./control_plane/registry.js";
-import { ToolResult, ToolArgs } from "./types.js";
-
-// Define a type for the tool handlers
-export type ToolHandler = (projectRoot: string, args: ToolArgs) => ToolResult | Promise<ToolResult>;
-
-// Map of tool names to their handler functions
-export const toolHandlers: Record<string, ToolHandler> = {
-    read_file: handleReadFile,
-    list_dir: handleListDir,
-    grep_search: handleGrepSearch,
-    get_project_map: handleGetProjectMap,
-    get_project_gaps: handleGetProjectGaps,
-    write_file: handleWriteFile,
-    replace_text: handleReplaceText,
-    batch_surgical_edit: handleBatchSurgicalEdit,
-    patch_file: handlePatchFile,
-    get_framework_status: handleGetFrameworkStatus,
-    read_project_memory: handleReadProjectMemory,
-    get_memory_insights: handleGetMemoryInsights,
-    update_project_memory: handleUpdateProjectMemory,
-    audit_dependencies: handleAuditDependencies,
-    run_tests: handleRunTests,
-    get_system_health: handleGetSystemHealth,
-    check_active_ports: handleCheckPorts,
-    start_dashboard: handleStartDashboard,
-    orchestrate_loop: handleOrchestrateLoop,
-    send_agent_message: handleSendAgentMessage,
-    log_agent_action: handleLogAgentAction,
-    update_contract_hash: handleUpdateContractHash,
-    acquire_lock: handleAcquireLock as ToolHandler,
-    release_lock: handleReleaseLock as ToolHandler,
-    register_agent: handleRegisterAgent as ToolHandler,
-};
-
-export { TOOLS };

package/framework-mcp/src/tools/memory/get_insights.ts

@@ -1,41 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-/**
- * Extracts key insights from the project memory to minimize token usage.
- * Returns only the active phase, trace, and the last 5 decisions/tasks.
- */
-export function handleGetMemoryInsights(projectRoot: string, _args: ToolArgs): ToolResult {
-    try {
-        const frameworkDir = resolveFrameworkDir(projectRoot);
-        const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
-
-        if (!fs.existsSync(memoryPath)) {
-            return { content: [{ type: "text", text: "New project: No history available." }] };
-        }
-
-        const content = fs.readFileSync(memoryPath, "utf8");
-        const lines = content.split("\n");
-        
-        const activePhase = lines.find(l => l.includes("Active Phase:"))?.split(":")[1]?.trim() || "Unknown";
-        const activeTrace = lines.find(l => l.includes("Active Trace:"))?.split(":")[1]?.trim() || "None";
-        
-        // Find the last 5 history items (heuristic)
-        const historyStartIndex = lines.findIndex(l => l.includes("## History"));
-        let recentHistory = "No history found.";
-        if (historyStartIndex !== -1) {
-            recentHistory = lines.slice(historyStartIndex + 1, historyStartIndex + 15)
-                .filter(l => l.trim().startsWith("-"))
-                .slice(-5)
-                .join("\n");
-        }
-
-        const insights = `🧠 **Memory Insights**\n- **Phase:** ${activePhase}\n- **Trace:** ${activeTrace}\n\n**Recent Actions:**\n${recentHistory}`;
-        
-        return { content: [{ type: "text", text: insights }] };
-    } catch (e) {
-        return { isError: true, content: [{ type: "text", text: `Failed to extract insights: ${String(e)}` }] };
-    }
-}

package/framework-mcp/src/tools/memory/read_memory.ts

@@ -1,31 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-/**
- * Reads the project's central memory (PROJECT_MEMORY.md).
- * This is the "brain" of the project.
- */
-export function handleReadProjectMemory(projectRoot: string, _args: ToolArgs): ToolResult {
-    try {
-        const frameworkDir = resolveFrameworkDir(projectRoot);
-        const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
-
-        if (!fs.existsSync(memoryPath)) {
-            return {
-                content: [{ type: "text", text: "ℹ️ Project memory file not found. It might be a new project." }]
-            };
-        }
-
-        const content = fs.readFileSync(memoryPath, "utf8");
-        return {
-            content: [{ type: "text", text: content }]
-        };
-    } catch (e) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `Failed to read project memory: ${String(e)}` }]
-        };
-    }
-}

package/framework-mcp/src/tools/messaging/log_action.ts

@@ -1,28 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-export function handleLogAgentAction(projectRoot: string, args: ToolArgs): ToolResult {
-    const { agent, action, traceId, status, summary } = args as Required<Pick<ToolArgs, "agent" | "action" | "traceId" | "status" | "summary">>;
-    const findings = args.findings ? args.findings.split(",").map(f => f.trim()) : [];
-
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const agentName = (agent as string).replace("@", "");
-    const logPath = path.join(projectRoot, frameworkDir, "logs", `${agentName}.json`);
-
-    const logEntry = {
-        timestamp: new Date().toISOString(),
-        agent,
-        action,
-        requestId: traceId,
-        status,
-        summary,
-        findings
-    };
-
-    fs.mkdirSync(path.dirname(logPath), { recursive: true });
-    fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
-
-    return { content: [{ type: "text", text: `✅ Action logged for ${agent} to ${path.join(frameworkDir, "logs", `${agentName}.json`)}` }] };
-}

package/framework-mcp/src/tools/messaging/send_message.ts

@@ -1,76 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-export async function handleSendAgentMessage(projectRoot: string, args: ToolArgs): Promise<ToolResult> {
-    const { to, category, content, traceId } = args as Required<Pick<ToolArgs, "to" | "category" | "content" | "traceId">>;
-    const from = (args.from as string) || "@mcp";
-
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const messagesDir = path.join(projectRoot, frameworkDir, "messages");
-    const agentName = to.replace("@", "");
-    const messagePath = path.join(messagesDir, `${agentName}.json`);
-    const lockPath = path.join(messagesDir, `${agentName}.lock`);
-
-    // Hermes Lock Protocol: Retry 3 times with 500ms delay
-    let retries = 3;
-    let acquired = false;
-    while (retries > 0) {
-        try {
-            if (fs.existsSync(lockPath)) {
-                try {
-                    const stats = fs.statSync(lockPath);
-                    if (Date.now() - stats.mtimeMs > 5000) {
-                        fs.unlinkSync(lockPath);
-                    }
-                } catch {
-                    // ignore if concurrently unlinked
-                }
-            }
-            fs.mkdirSync(messagesDir, { recursive: true });
-            fs.writeFileSync(lockPath, `Locked by ${from} at ${new Date().toISOString()}`, { flag: "wx" });
-            acquired = true;
-            break;
-        } catch (err: unknown) {
-            const error = err as { code?: string; message?: string };
-            if (error.code === "EEXIST") {
-                retries--;
-                if (retries > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, 500));
-                }
-            } else {
-                return { content: [{ type: "text", text: `❌ Unexpected lock acquisition error: ${error.message || String(err)}` }], isError: true };
-            }
-        }
-    }
-
-    if (!acquired) {
-        return { content: [{ type: "text", text: `❌ Could not send message to ${to}: Hermes lock is busy.` }], isError: true };
-    }
-
-    try {
-        const defaultPriority = (category === "ALERT" || category === "ACTION") ? "HIGH" : "NORMAL";
-        const message = {
-            timestamp: new Date().toISOString(),
-            from,
-            to,
-            category,
-            traceId,
-            content,
-            priority: args.priority || defaultPriority,
-            status: "PENDING"
-        };
-
-        fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
-        return { content: [{ type: "text", text: `✅ Message sent to ${to} (from: ${from})` }] };
-    } finally {
-        if (acquired && fs.existsSync(lockPath)) {
-            try {
-                fs.unlinkSync(lockPath);
-            } catch {
-                // ignore
-            }
-        }
-    }
-}

package/framework-mcp/src/tools/observability/check_ports.ts

@@ -1,30 +0,0 @@
-import { execSync } from "child_process";
-import { ToolArgs, ToolResult } from "../types.js";
-
-/**
- * Checks for active network ports and their status.
- */
-export function handleCheckPorts(projectRoot: string, args: ToolArgs): ToolResult {
-    const filter = args.filter as string || ""; // 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: `📡 **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/src/tools/observability/get_health.ts

@@ -1,24 +0,0 @@
-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 {
-    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/search/get_gaps.ts

@@ -1,54 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { safePath } from "../../utils/security.js";
-import { ToolArgs, 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: ToolArgs): ToolResult {
-    const srcDir = safePath(projectRoot, args.path as string || "src");
-    const results: string[] = [];
-
-    const walk = (dir: string) => {
-        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")}`
-                : "✅ No major gaps or TODOs found in the scanned directory."
-        }]
-    };
-}

package/framework-mcp/src/tools/search/get_map.ts

@@ -1,48 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { ToolArgs, 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: ToolArgs): ToolResult {
-    const maxDepth = Number(args.maxDepth) || 3;
-    const includeFiles = args.includeFiles !== false;
-
-    const buildTree = (dir: string, depth: number): string[] => {
-        if (depth > maxDepth) return [];
-
-        const results: string[] = [];
-        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/src/tools/search/grep_search.ts

@@ -1,65 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { ToolArgs, ToolResult } from "../types.js";
-
-/**
- * Searches for a regex pattern within files in the project.
- */
-export function handleGrepSearch(projectRoot: string, args: ToolArgs): ToolResult {
-    const pattern = args.pattern as string;
-    const includePattern = args.includePattern as string || ""; // e.g., ".ts"
-    const excludePattern = args.excludePattern as string || "node_modules";
-
-    if (!pattern) {
-        throw new Error("Search pattern is required.");
-    }
-
-    const results: string[] = [];
-    const regex = new RegExp(pattern, "g");
-
-    const walk = (dir: string) => {
-        const files = fs.readdirSync(dir);
-        for (const file of files) {
-            const fullPath = path.join(dir, file);
-            const relativePath = path.relative(projectRoot, fullPath);
-
-            // Skip excluded directories/files
-            if (relativePath.includes(excludePattern)) continue;
-
-            try {
-                const stat = fs.statSync(fullPath);
-                if (stat.isDirectory()) {
-                    walk(fullPath);
-                } else if (stat.isFile()) {
-                    // Check include pattern
-                    if (includePattern && !file.endsWith(includePattern)) continue;
-
-                    const content = fs.readFileSync(fullPath, "utf8");
-                    const lines = content.split("\n");
-                    lines.forEach((line, index) => {
-                        if (regex.test(line)) {
-                            results.push(`${relativePath}:${index + 1}: ${line.trim()}`);
-                            // Reset regex lastIndex because of 'g' flag
-                            regex.lastIndex = 0;
-                        }
-                    });
-                }
-            } catch {
-                // Ignore read errors
-            }
-
-            if (results.length > 100) break; // Limit results
-        }
-    };
-
-    walk(projectRoot);
-
-    return {
-        content: [{
-            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

@@ -1,34 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { safePath } from "../../utils/security.js";
-import { ToolArgs, ToolResult } from "../types.js";
-
-/**
- * Lists the contents of a directory.
- */
-export function handleListDir(projectRoot: string, args: ToolArgs): ToolResult {
-    const dirPath = safePath(projectRoot, args.path as string || ".");
-    
-    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")}`
-        }]
-    };
-}