agent-enderun 1.1.6 → 1.1.8

package/framework-mcp/dist/tools/definitions.js

@@ -12,6 +12,29 @@ export const TOOLS = [
             required: ["path"],
         },
     },
+    {
+        name: "list_dir",
+        description: "List the contents of a directory. Essential for codebase exploration.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the directory relative to project root (default: '.')" },
+            },
+        },
+    },
+    {
+        name: "grep_search",
+        description: "Perform a recursive regex search across the codebase to find functions, variables, or patterns.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "The regex pattern to search for" },
+                includePattern: { type: "string", description: "Optional: Filter files by extension (e.g., '.ts')" },
+                excludePattern: { type: "string", description: "Optional: Directory pattern to exclude (default: 'node_modules')" },
+            },
+            required: ["pattern"],
+        },
+    },
     {
         name: "write_file",
         description: "Write content to a file. Creates directories if missing.",
@@ -33,10 +56,34 @@ export const TOOLS = [
                 path: { type: "string", description: "Path to the file" },
                 oldText: { type: "string", description: "The exact text to find" },
                 newText: { type: "string", description: "The text to replace it with" },
+                allowMultiple: { type: "boolean", description: "Allow multiple replacements if oldText is not unique." }
             },
             required: ["path", "oldText", "newText"],
         },
     },
+    {
+        name: "batch_surgical_edit",
+        description: "Perform multiple surgical text replacements across multiple files in a single batch request. More efficient for cross-cutting changes.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                edits: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path to the file" },
+                            oldText: { type: "string", description: "The exact text to find" },
+                            newText: { type: "string", description: "The text to replace it with" },
+                            allowMultiple: { type: "boolean", description: "Allow multiple replacements in this file." }
+                        },
+                        required: ["path", "oldText", "newText"]
+                    }
+                }
+            },
+            required: ["edits"],
+        },
+    },
     {
         name: "patch_file",
         description: "Safely update a file by replacing a specific line range with new content.",
@@ -51,11 +98,82 @@ export const TOOLS = [
             required: ["path", "startLine", "endLine", "newContent"],
         },
     },
+    {
+        name: "get_project_map",
+        description: "Generate a tree-view map of the project structure to visualize the layout. Useful for onboarding and architectural analysis.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                maxDepth: { type: "number", description: "Maximum directory depth to scan (default: 3)" },
+                includeFiles: { type: "boolean", description: "Whether to include files in the map (default: true)" }
+            }
+        }
+    },
+    {
+        name: "get_project_gaps",
+        description: "Scans the codebase for TODOs, FIXMEs, and empty function bodies. Helps identify what is left and where the agent might have skipped logic.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the source directory (default: 'src')" },
+            },
+        },
+    },
+    {
+        name: "audit_dependencies",
+        description: "Audits package.json for unused, redundant, or duplicate-like packages to ensure a clean dependency tree.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "run_tests",
+        description: "Execute project test suites (Vitest, Playwright, etc.) and capture detailed pass/fail reports for analysis.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "The test command to run (default: 'npm test')" }
+            }
+        }
+    },
+    {
+        name: "get_system_health",
+        description: "Retrieve real-time system metrics like CPU load, RAM usage, and uptime.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "check_active_ports",
+        description: "Identify which network ports are currently active and listening. Helps verify if the dev server or API is running.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filter: { type: "string", description: "Optional: Filter results by port number or service name (e.g., ':3000')" }
+            }
+        }
+    },
+    {
+        name: "start_dashboard",
+        description: "Start the Enderun Web Dashboard (Command Center) to visualize real-time agent status, logs, and system metrics in the browser.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                port: { type: "number", description: "Optional: Port to run the dashboard on (default: 5858)" }
+            }
+        }
+    },
     {
         name: "get_framework_status",
         description: "Get the current project phase, active traces, and agent states.",
         inputSchema: { type: "object", properties: {} },
     },
+    {
+        name: "read_project_memory",
+        description: "Read the full project central memory (PROJECT_MEMORY.md). Use this at the start of a session to gain context.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "get_memory_insights",
+        description: "Retrieve a summarized version of the project memory (active phase, trace, and last 5 actions) to save tokens.",
+        inputSchema: { type: "object", properties: {} },
+    },
     {
         name: "update_project_memory",
         description: "Update a specific section in PROJECT_MEMORY.md.",

package/framework-mcp/dist/tools/file_system/batch_surgical_edit.js

@@ -0,0 +1,50 @@
+import fs from "fs";
+import { safePath } from "../../utils/security.js";
+import { Metrics } from "../../utils/metrics.js";
+import { verifyCorporateCompliance } from "../../utils/compliance.js";
+/**
+ * Performs multiple surgical text replacements across multiple files in a single batch.
+ */
+export function handleBatchSurgicalEdit(projectRoot, args) {
+    const edits = args.edits;
+    if (!Array.isArray(edits) || edits.length === 0) {
+        throw new Error("No edits provided in the batch request.");
+    }
+    const results = [];
+    let totalTokens = 0;
+    for (const edit of edits) {
+        const filePath = safePath(projectRoot, edit.path);
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${edit.path}`);
+        }
+        const content = fs.readFileSync(filePath, "utf8");
+        const { oldText, newText, allowMultiple = false } = edit;
+        if (!content.includes(oldText)) {
+            throw new Error(`Text not found in file ${edit.path}: "${oldText.slice(0, 50)}..."`);
+        }
+        // Surgical precision guard
+        if (!allowMultiple) {
+            const firstIndex = content.indexOf(oldText);
+            const lastIndex = content.lastIndexOf(oldText);
+            if (firstIndex !== lastIndex) {
+                throw new Error(`Ambiguous replacement in ${edit.path}: "${oldText.slice(0, 50)}..." found multiple times.`);
+            }
+        }
+        const newContent = allowMultiple
+            ? content.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newText)
+            : content.replace(oldText, newText);
+        // ENFORCE CORPORATE COMPLIANCE
+        verifyCorporateCompliance(newContent, edit.path);
+        fs.writeFileSync(filePath, newContent);
+        const tokens = Metrics.estimateTokens(newText);
+        totalTokens += tokens;
+        results.push(`✅ Edited ${edit.path}`);
+    }
+    Metrics.logUsage(projectRoot, "@mcp", `batch_surgical_edit: ${edits.length} files`, totalTokens);
+    return {
+        content: [{
+                type: "text",
+                text: `Successfully performed ${edits.length} edits:\n${results.join("\n")}`
+            }]
+    };
+}

package/framework-mcp/dist/tools/file_system/replace_text.js

@@ -1,9 +1,10 @@
 import fs from "fs";
 import { safePath } from "../../utils/security.js";
 import { Metrics } from "../../utils/metrics.js";
+import { verifyCorporateCompliance } from "../../utils/compliance.js";
 export function handleReplaceText(projectRoot, args) {
     const filePath = safePath(projectRoot, args.path);
-    let content = fs.readFileSync(filePath, "utf8");
+    const content = fs.readFileSync(filePath, "utf8");
     const oldText = args.oldText;
     const newText = args.newText;
     const allowMultiple = args.allowMultiple || false; // Default to false
@@ -21,13 +22,16 @@ export function handleReplaceText(projectRoot, args) {
         }
     }
     // Perform replacement(s)
+    let newContent;
     if (allowMultiple) {
-        content = content.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newText);
+        newContent = content.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newText);
     }
     else {
-        content = content.replace(oldText, newText);
+        newContent = content.replace(oldText, newText);
     }
-    fs.writeFileSync(filePath, content);
+    // ENFORCE CORPORATE COMPLIANCE
+    verifyCorporateCompliance(newContent, args.path);
+    fs.writeFileSync(filePath, newContent);
     const tokens = Metrics.estimateTokens(newText);
     Metrics.logUsage(projectRoot, "@mcp", `replace_text: ${args.path}`, tokens);
     return { content: [{ type: "text", text: `✅ Surgical edit successful in ${args.path}` }] };

package/framework-mcp/dist/tools/file_system/write_file.js

@@ -2,9 +2,12 @@ import fs from "fs";
 import path from "path";
 import { safePath, resolveFrameworkDir } from "../../utils/security.js";
 import { Metrics } from "../../utils/metrics.js";
+import { verifyCorporateCompliance } from "../../utils/compliance.js";
 export function handleWriteFile(projectRoot, args) {
     const filePath = safePath(projectRoot, args.path);
     const content = args.content;
+    // ENFORCE CORPORATE COMPLIANCE
+    verifyCorporateCompliance(content, args.path);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, content);
     // AUTO-LOGGING & METRICS

package/framework-mcp/dist/tools/framework/audit_deps.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import path from "path";
+/**
+ * Audits package.json for unused or duplicate-like packages.
+ * Focuses on project health and cleanup.
+ */
+export function handleAuditDependencies(projectRoot, _args) {
+    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 = [];
+    // 1. Look for similar packages (potential duplicates)
+    const similarityGroups = {
+        "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/dist/tools/framework/run_tests.js

@@ -0,0 +1,25 @@
+import { execSync } from "child_process";
+/**
+ * Executes project tests and returns results for agent analysis.
+ */
+export function handleRunTests(projectRoot, args) {
+    const testCommand = args.command || "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) {
+        const err = error;
+        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/dist/tools/index.js

@@ -2,11 +2,23 @@ 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";
@@ -14,11 +26,23 @@ import { handleRegisterAgent } from "./control_plane/registry.js";
 // Map of tool names to their handler functions
 export const toolHandlers = {
     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,

package/framework-mcp/dist/tools/memory/get_insights.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "../../utils/security.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, _args) {
+    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/dist/tools/memory/read_memory.js

@@ -0,0 +1,28 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "../../utils/security.js";
+/**
+ * Reads the project's central memory (PROJECT_MEMORY.md).
+ * This is the "brain" of the project.
+ */
+export function handleReadProjectMemory(projectRoot, _args) {
+    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/dist/tools/messaging/send_message.js

@@ -8,7 +8,7 @@ export async function handleSendAgentMessage(projectRoot, args) {
     const messagesDir = path.join(projectRoot, frameworkDir, "messages");
     const agentName = to.replace("@", "");
     const messagePath = path.join(messagesDir, `${agentName}.json`);
-    const lockPath = path.join(messagesDir, ".lock");
+    const lockPath = path.join(messagesDir, `${agentName}.lock`);
     // Hermes Lock Protocol: Retry 3 times with 500ms delay
     let retries = 3;
     let acquired = false;

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

@@ -0,0 +1,26 @@
+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: `📡 **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

@@ -0,0 +1,19 @@
+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/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")}`
+                    : "✅ No major gaps or TODOs found in the scanned directory."
+            }]
+    };
+}

package/framework-mcp/dist/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 = Number(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

@@ -0,0 +1,59 @@
+import fs from "fs";
+import path from "path";
+/**
+ * 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) {
+        throw new Error("Search pattern is required.");
+    }
+    const results = [];
+    const regex = new RegExp(pattern, "g");
+    const walk = (dir) => {
+        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/dist/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")}`
+            }]
+    };
+}