kadins-personal-mcp 1.0.0 → 1.0.1

package/tools/fileSearch.ts

@@ -1,88 +0,0 @@
-import { z } from "zod";
-
-export const name = "file_search";
-export const description = "Search for files by name, content, or pattern in a directory";
-export const parameters = {
-  pattern: z.string().describe("The pattern to search for (file name or content)"),
-  directory: z.string().describe("The directory to search in").optional().default("."),
-  searchInContent: z.boolean().describe("Whether to search in file content (true) or just filenames (false)").optional().default(false)
-};
-export const handler = async (params: { pattern: string; directory: string; searchInContent: boolean }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    const searchDir = params.directory || ".";
-    const resolvedDir = path.resolve(searchDir);
-    
-    // Check if the directory is within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedDir.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Directory traversal is not allowed" }]
-      };
-    }
-    
-    if (!fs.existsSync(resolvedDir)) {
-      return {
-        content: [{ type: "text", text: `Error: Directory does not exist: ${resolvedDir}` }]
-      };
-    }
-    
-    if (!fs.statSync(resolvedDir).isDirectory()) {
-      return {
-        content: [{ type: "text", text: `Error: Path is not a directory: ${resolvedDir}` }]
-      };
-    }
-    
-    const results: string[] = [];
-    
-    function searchRecursive(dir: string) {
-      const items = fs.readdirSync(dir);
-      
-      for (const item of items) {
-        const itemPath = path.join(dir, item);
-        const stat = fs.statSync(itemPath);
-        
-        if (stat.isDirectory()) {
-          // Skip node_modules and other common directories that shouldn't be searched
-          if (item !== "node_modules" && !item.startsWith(".")) {
-            searchRecursive(itemPath);
-          }
-        } else {
-          // Check filename match
-          if (item.includes(params.pattern)) {
-            results.push(itemPath);
-          }
-          // Check content match if requested
-          else if (params.searchInContent) {
-            try {
-              const content = fs.readFileSync(itemPath, "utf-8");
-              if (content.includes(params.pattern)) {
-                results.push(itemPath);
-              }
-            } catch (e) {
-              // Skip binary files or files that can't be read
-            }
-          }
-        }
-      }
-    }
-    
-    searchRecursive(resolvedDir);
-    
-    if (results.length === 0) {
-      return {
-        content: [{ type: "text", text: `No files found matching pattern: ${params.pattern}` }]
-      };
-    }
-    
-    return {
-      content: [{ type: "text", text: `Found ${results.length} file(s):\n${results.join("\n")}` }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error searching files: ${(error as Error).message}` }]
-    };
-  }
-};

package/tools/fileWrite.ts

@@ -1,50 +0,0 @@
-import { z } from "zod";
-
-export const name = "file_write";
-export const description = "Write content to a file (with safety checks to prevent overwrites)";
-export const parameters = {
-  path: z.string().describe("The path to the file to write"),
-  content: z.string().describe("The content to write to the file"),
-  overwrite: z.boolean().describe("Whether to overwrite an existing file").optional().default(false)
-};
-export const handler = async (params: { path: string; content: string; overwrite: boolean }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    // Resolve the path relative to the current working directory
-    const resolvedPath = path.resolve(params.path);
-    
-    // Check if the path is within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedPath.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Path traversal is not allowed" }]
-      };
-    }
-    
-    // Check if file exists and overwrite is not allowed
-    if (fs.existsSync(resolvedPath) && !params.overwrite) {
-      return {
-        content: [{ type: "text", text: `Error: File already exists at ${params.path}. Use overwrite=true to overwrite.` }]
-      };
-    }
-    
-    // Create directory if it doesn't exist
-    const dir = path.dirname(resolvedPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    
-    // Write the content to the file
-    fs.writeFileSync(resolvedPath, params.content, "utf-8");
-    
-    return {
-      content: [{ type: "text", text: `Successfully wrote ${params.content.length} characters to ${params.path}` }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error writing file: ${(error as Error).message}` }]
-    };
-  }
-};

package/tools/readFile.ts

@@ -1,39 +0,0 @@
-import { z } from "zod";
-
-export const name = "read_file";
-export const description = "Read the contents of a file";
-export const parameters = {
-  path: z.string().describe("The path to the file to read")
-};
-export const handler = async (params: { path: string }) => {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    
-    // Resolve the path relative to the current working directory
-    const resolvedPath = path.resolve(params.path);
-    
-    // Check if the path is within the current working directory to prevent path traversal
-    const cwd = process.cwd();
-    if (!resolvedPath.startsWith(cwd)) {
-      return {
-        content: [{ type: "text", text: "Error: Path traversal is not allowed" }]
-      };
-    }
-    
-    if (!fs.existsSync(resolvedPath)) {
-      return {
-        content: [{ type: "text", text: `Error: File does not exist: ${params.path}` }]
-      };
-    }
-    
-    const content = fs.readFileSync(resolvedPath, "utf-8");
-    return {
-      content: [{ type: "text", text: content }]
-    };
-  } catch (error) {
-    return {
-      content: [{ type: "text", text: `Error reading file: ${error.message}` }]
-    };
-  }
-};

package/tools/runCommand.ts

@@ -1,38 +0,0 @@
-import { z } from "zod";
-
-export const name = "run_command";
-export const description = "Execute a shell command on the system";
-export const parameters = {
-  command: z.string().describe("The shell command to execute")
-};
-export const handler = async (params: { command: string }) => {
-  try {
-    // Dynamically import child_process
-    const { exec } = await import("child_process");
-    const util = await import("util");
-    
-    // Use util.promisify to convert exec to a promise-based function
-    const execPromise = util.promisify(exec);
-    
-    // Execute the command with a timeout for safety
-    const { stdout, stderr } = await Promise.race([
-      execPromise(params.command),
-      new Promise((_, reject) => 
-        setTimeout(() => reject(new Error('Command timed out after 10 seconds')), 10000)
-      )
-    ]);
-    
-    // Return both stdout and stderr
-    return {
-      content: [
-        { type: "text", text: `Command: ${params.command}\n\nOutput:\n${stdout || stderr || 'Command executed successfully with no output'}` }
-      ]
-    };
-  } catch (error) {
-    return {
-      content: [
-        { type: "text", text: `Error executing command: ${params.command}\n\nError: ${(error as Error).message}` }
-      ]
-    };
-  }
-};

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "esModuleInterop": true,
-    "isolatedModules": true,
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "exclude": ["node_modules", "dist"],
-  "include": ["src/**/*", "package.json"]
-}