agentinit 1.5.0 → 1.7.0

package/dist/cli.js

@@ -19950,27 +19950,27 @@ var require_windows = __commonJS((exports, module) => {
     return checkPathExt(path, options2);
   };
   var isexe = function(path, options2, cb) {
-    fs14.stat(path, function(er, stat) {
+    fs15.stat(path, function(er, stat) {
       cb(er, er ? false : checkStat(stat, path, options2));
     });
   };
   var sync = function(path, options2) {
-    return checkStat(fs14.statSync(path), path, options2);
+    return checkStat(fs15.statSync(path), path, options2);
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs14 = __require("fs");
+  var fs15 = __require("fs");
 });
 
 // node_modules/isexe/mode.js
 var require_mode = __commonJS((exports, module) => {
   var isexe = function(path, options2, cb) {
-    fs14.stat(path, function(er, stat) {
+    fs15.stat(path, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options2));
     });
   };
   var sync = function(path, options2) {
-    return checkStat(fs14.statSync(path), options2);
+    return checkStat(fs15.statSync(path), options2);
   };
   var checkStat = function(stat, options2) {
     return stat.isFile() && checkMode(stat, options2);
@@ -19990,7 +19990,7 @@ var require_mode = __commonJS((exports, module) => {
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs14 = __require("fs");
+  var fs15 = __require("fs");
 });
 
 // node_modules/isexe/index.js
@@ -20035,7 +20035,7 @@ var require_isexe = __commonJS((exports, module) => {
       }
     }
   };
-  var fs14 = __require("fs");
+  var fs15 = __require("fs");
   var core;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core = require_windows();
@@ -20242,14 +20242,14 @@ var require_readShebang = __commonJS((exports, module) => {
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs14.openSync(command, "r");
-      fs14.readSync(fd, buffer, 0, size, 0);
-      fs14.closeSync(fd);
+      fd = fs15.openSync(command, "r");
+      fs15.readSync(fd, buffer, 0, size, 0);
+      fs15.closeSync(fd);
     } catch (e) {
     }
     return shebangCommand(buffer.toString());
   };
-  var fs14 = __require("fs");
+  var fs15 = __require("fs");
   var shebangCommand = require_shebang_command();
   module.exports = readShebang;
 });
@@ -23001,6 +23001,7 @@ var getPackageVersion = function() {
   }
 };
 var DEFAULT_CONNECTION_TIMEOUT_MS = 30000;
+var MAX_RESOURCE_CONTENT_SIZE = 10 * 1024 * 1024;
 var MCP_VERIFIER_CONFIG = {
   name: "agentinit-verifier",
   version: getPackageVersion()
@@ -24862,6 +24863,179 @@ class CursorAgent extends Agent {
   }
 }
 
+// dist/agents/DroidAgent.js
+class DroidAgent extends Agent {
+  constructor() {
+    const definition = {
+      id: "droid",
+      name: "Droid (Factory)",
+      url: "https://factory.ai",
+      capabilities: {
+        mcp: {
+          stdio: true,
+          http: false,
+          sse: false
+        },
+        rules: true,
+        hooks: false,
+        commands: false,
+        subagents: false,
+        statusline: false
+      },
+      configFiles: [
+        {
+          path: "AGENTS.md",
+          purpose: "rules",
+          format: "markdown",
+          type: "file",
+          optional: true,
+          description: "Agent instructions and rules in markdown format"
+        }
+      ],
+      nativeConfigPath: ".factory/mcp.json",
+      globalConfigPath: "~/.factory/mcp.json"
+    };
+    super(definition);
+  }
+  async applyMCPConfig(projectPath, servers) {
+    await this.applyGlobalMCPConfig(servers);
+  }
+  async applyGlobalMCPConfig(servers) {
+    const globalPath = this.getGlobalMcpPath();
+    if (!globalPath) {
+      throw new Error(`Droid global configuration path could not be determined`);
+    }
+    await ensureDirectoryExists(globalPath);
+    const existingContent = await readFileIfExists(globalPath);
+    let existingConfig = { mcpServers: {} };
+    if (existingContent) {
+      try {
+        existingConfig = JSON.parse(existingContent);
+        if (!existingConfig.mcpServers) {
+          existingConfig.mcpServers = {};
+        }
+      } catch (error) {
+        console.warn("Warning: Existing ~/.factory/mcp.json is invalid, creating new configuration");
+        existingConfig = { mcpServers: {} };
+      }
+    }
+    for (const server of servers) {
+      const droidServer = {
+        type: "stdio"
+      };
+      if (server.command) {
+        droidServer.command = server.command;
+      }
+      if (server.args && server.args.length > 0) {
+        droidServer.args = server.args;
+      }
+      if (server.env && Object.keys(server.env).length > 0) {
+        droidServer.env = server.env;
+      }
+      droidServer.disabled = false;
+      existingConfig.mcpServers[server.name] = droidServer;
+    }
+    const configJson = JSON.stringify(existingConfig, null, 2);
+    await writeFile(globalPath, configJson);
+  }
+  filterMCPServers(servers) {
+    return servers.filter((server) => server.type === "stdio");
+  }
+  transformMCPServers(servers) {
+    return servers;
+  }
+  async applyRulesConfig(configPath, rules, existingContent) {
+    const rulesSection = this.generateRulesContent(rules.sections);
+    let content = existingContent;
+    if (content && !content.endsWith("\n")) {
+      content += "\n";
+    }
+    if (content) {
+      content += "\n";
+    }
+    content += rulesSection;
+    return content.trim() + "\n";
+  }
+  extractExistingRules(content) {
+    const ruleLines = content.split("\n").filter((line) => line.trim().startsWith("- "));
+    return ruleLines.map((line) => line.replace(/^- /, "").trim()).filter((rule) => rule.length > 0);
+  }
+  extractExistingSections(content) {
+    const lines = content.split("\n");
+    const sections = [];
+    let currentSection = null;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("## ") && trimmed.includes(" ")) {
+        if (currentSection) {
+          sections.push(currentSection);
+        }
+        const sectionName = trimmed.replace(/^##\s*/, "");
+        currentSection = {
+          templateId: sectionName.toLowerCase().replace(/\s+/g, "_"),
+          templateName: sectionName,
+          rules: []
+        };
+      } else if (currentSection && trimmed.startsWith("- ")) {
+        const rule = trimmed.replace(/^- /, "");
+        currentSection.rules.push(rule);
+      }
+    }
+    if (currentSection) {
+      sections.push(currentSection);
+    }
+    return sections;
+  }
+  generateRulesContent(sections) {
+    let content = "";
+    if (sections && sections.length > 0) {
+      for (const ruleSection of sections) {
+        content += `## ${ruleSection.templateName}\n\n`;
+        for (const rule of ruleSection.rules) {
+          content += `- ${rule}\n`;
+        }
+        content += "\n";
+      }
+    }
+    return content;
+  }
+  async getMCPServers(projectPath) {
+    const globalPath = this.getGlobalMcpPath();
+    if (!globalPath) {
+      return [];
+    }
+    const configContent = await readFileIfExists(globalPath);
+    if (!configContent) {
+      return [];
+    }
+    try {
+      const config = JSON.parse(configContent);
+      const servers = [];
+      if (config.mcpServers) {
+        for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+          const server = {
+            name,
+            type: "stdio"
+          };
+          if (serverConfig.command) {
+            server.command = serverConfig.command;
+          }
+          if (serverConfig.args) {
+            server.args = serverConfig.args;
+          }
+          if (serverConfig.env) {
+            server.env = serverConfig.env;
+          }
+          servers.push(server);
+        }
+      }
+      return servers;
+    } catch (error) {
+      return [];
+    }
+  }
+}
+
 // dist/core/agentManager.js
 class AgentManager {
   agents = [];
@@ -24874,7 +25048,8 @@ class AgentManager {
       new ClaudeDesktopAgent,
       new CodexCliAgent,
       new GeminiCliAgent,
-      new CursorAgent
+      new CursorAgent,
+      new DroidAgent
     ];
   }
   getAllAgents() {
@@ -32263,6 +32438,96 @@ class SSEClientTransport {
   }
 }
 
+// dist/utils/packageVersion.js
+function extractExplicitVersion(packageSpec) {
+  const versionMatch = packageSpec.match(/@([\d]+\.[\d]+\.[\d]+(?:[-+].+)?$)/);
+  if (versionMatch && versionMatch[1]) {
+    logger.debug(`[extractExplicitVersion] Found explicit version: ${versionMatch[1]} in "${packageSpec}"`);
+    return versionMatch[1];
+  }
+  return null;
+}
+function extractPackageName(packageSpec) {
+  return packageSpec.replace(/@[\d]+\.[\d]+\.[\d]+(?:[-+].+)?$/, "").replace(/@latest$/, "").replace(/@next$/, "").replace(/@canary$/, "");
+}
+function extractPackageFromCommand(command, args) {
+  if (!command || !args || args.length === 0) {
+    return null;
+  }
+  const packageManagers = ["npx", "bunx", "pnpm", "yarn"];
+  if (!packageManagers.includes(command)) {
+    logger.debug(`[extractPackageFromCommand] Not a package manager command: ${command}`);
+    return null;
+  }
+  for (const arg of args) {
+    if (arg.startsWith("-")) {
+      continue;
+    }
+    if (arg === "dlx" || arg === "exec") {
+      continue;
+    }
+    const packagePattern = /^(@[a-z0-9-]+\/)?[a-z0-9_-]+(@[\w.-]+)?$/i;
+    if (packagePattern.test(arg)) {
+      logger.debug(`[extractPackageFromCommand] Found package: ${arg}`);
+      return arg;
+    }
+  }
+  logger.debug(`[extractPackageFromCommand] No package found in args: ${args.join(" ")}`);
+  return null;
+}
+async function fetchLatestVersion(packageSpec, options2 = {}) {
+  const { timeout = 5000, useCache = true } = options2;
+  const explicitVersion = extractExplicitVersion(packageSpec);
+  if (explicitVersion) {
+    return explicitVersion;
+  }
+  const cleanPackageName = extractPackageName(packageSpec);
+  if (useCache) {
+    const cached = versionCache.get(cleanPackageName);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+      logger.debug(`[fetchLatestVersion] Cache hit for: ${cleanPackageName} -> ${cached.version}`);
+      return cached.version;
+    }
+  }
+  try {
+    logger.debug(`[fetchLatestVersion] Fetching from npm registry: ${cleanPackageName}`);
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const url = `https://registry.npmjs.org/${cleanPackageName}/latest`;
+    const response = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      logger.debug(`[fetchLatestVersion] npm registry returned ${response.status} for ${cleanPackageName}`);
+      return null;
+    }
+    const data = await response.json();
+    if (!data.version) {
+      logger.debug(`[fetchLatestVersion] No version field in response for ${cleanPackageName}`);
+      return null;
+    }
+    versionCache.set(cleanPackageName, {
+      version: data.version,
+      timestamp: Date.now()
+    });
+    logger.debug(`[fetchLatestVersion] Success: ${cleanPackageName}@${data.version}`);
+    return data.version;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        logger.debug(`[fetchLatestVersion] Timeout fetching version for ${cleanPackageName}`);
+      } else {
+        logger.debug(`[fetchLatestVersion] Error fetching version: ${error.message}`);
+      }
+    }
+    return null;
+  }
+}
+var versionCache = new Map;
+var CACHE_TTL_MS = 5 * 60 * 1000;
+
 // dist/core/mcpClient.js
 class MCPVerificationError extends Error {
   serverName;
@@ -32285,6 +32550,83 @@ class MCPVerifier {
       return yellow(tokenCount.toString());
     return red(tokenCount.toString());
   }
+  hasValidInputSchema(tool) {
+    return tool.inputSchema !== undefined && typeof tool.inputSchema === "object" && Object.keys(tool.inputSchema.properties || {}).length > 0;
+  }
+  formatType(schema) {
+    const type = schema.type || "any";
+    return Array.isArray(type) ? type.join(" | ") : type;
+  }
+  formatNumberRange(schema) {
+    const min = schema.minimum !== undefined ? schema.minimum : "-\u221E";
+    const max = schema.maximum !== undefined ? schema.maximum : "\u221E";
+    return `(${min}-${max})`;
+  }
+  formatStringLength(schema) {
+    const minLen = schema.minLength !== undefined ? schema.minLength : 0;
+    const maxLen = schema.maxLength !== undefined ? schema.maxLength : "\u221E";
+    return `length: ${minLen}-${maxLen}`;
+  }
+  formatArrayConstraints(schema) {
+    const constraints = [];
+    if (schema.items) {
+      const itemType = schema.items.type;
+      const itemTypeStr = itemType ? Array.isArray(itemType) ? itemType.join(" | ") : itemType : "any";
+      constraints.push(`items: ${itemTypeStr}`);
+      if (schema.minItems !== undefined || schema.maxItems !== undefined) {
+        const minItems = schema.minItems !== undefined ? schema.minItems : 0;
+        const maxItems = schema.maxItems !== undefined ? schema.maxItems : "\u221E";
+        constraints.push(`(${minItems}-${maxItems} items)`);
+      }
+    }
+    return constraints;
+  }
+  formatConstraints(schema, typeInfo) {
+    const constraints = [];
+    if (schema.enum && Array.isArray(schema.enum)) {
+      constraints.push(`[${schema.enum.join(", ")}]`);
+    }
+    if (schema.minimum !== undefined || schema.maximum !== undefined) {
+      constraints.push(this.formatNumberRange(schema));
+    }
+    if (schema.default !== undefined) {
+      constraints.push(`default: ${JSON.stringify(schema.default)}`);
+    }
+    if (schema.minLength !== undefined || schema.maxLength !== undefined) {
+      constraints.push(this.formatStringLength(schema));
+    }
+    if (schema.pattern) {
+      constraints.push(`pattern: ${schema.pattern}`);
+    }
+    const isArray = Array.isArray(schema.type) ? schema.type.includes("array") : schema.type === "array";
+    if (isArray) {
+      constraints.push(...this.formatArrayConstraints(schema));
+    }
+    return constraints;
+  }
+  formatParameter(name, schema, isRequired) {
+    const parts = [];
+    const typeInfo = this.formatType(schema);
+    parts.push(`${name} (${isRequired ? "required" : "optional"})`);
+    parts.push(typeInfo);
+    if (schema.description) {
+      parts.push(schema.description);
+    }
+    const constraints = this.formatConstraints(schema, typeInfo);
+    if (constraints.length > 0) {
+      parts.push(constraints.join(", "));
+    }
+    return `      \u2022 ${parts.join(" - ")}`;
+  }
+  formatToolParameters(tool) {
+    if (!this.hasValidInputSchema(tool)) {
+      return [];
+    }
+    const schema = tool.inputSchema;
+    const properties = schema.properties || {};
+    const required = schema.required || [];
+    return Object.entries(properties).map(([name, prop]) => this.formatParameter(name, prop, required.includes(name)));
+  }
   calculateToolTokens(tools, serverName) {
     const toolTokenCounts = new Map;
     let totalToolTokens = 0;
@@ -32316,19 +32658,19 @@ class MCPVerifier {
         };
         const functionDefinition = JSON.stringify(toolForCounting);
         const claudeToolRepresentation = `<function>${functionDefinition}</function>`;
-        const tokenCount = countTokens(claudeToolRepresentation) * 5;
+        const tokenCount = countTokens(claudeToolRepresentation) * 9;
         toolTokenCounts.set(tool.name, tokenCount);
         totalToolTokens += tokenCount;
       } catch (error) {
-        console.warn(`Failed to count tokens for tool ${tool.name}:`, error);
+        logger.error(`Failed to count tokens for tool ${tool.name}: ${error instanceof Error ? error.message : String(error)}`);
         toolTokenCounts.set(tool.name, 0);
       }
     }
     return { toolTokenCounts, totalToolTokens };
   }
-  async verifyServer(server, timeout) {
+  async verifyServer(server, options2) {
     const startTime = Date.now();
-    const timeoutMs = timeout || this.defaultTimeout;
+    const timeoutMs = options2?.timeout || this.defaultTimeout;
     const abortController = new AbortController;
     let client2 = null;
     let transport = null;
@@ -32356,7 +32698,7 @@ class MCPVerifier {
           clearTimeout(timeoutId);
         });
       });
-      const connectPromise = this.connectAndVerify(client2, transport, server, abortController.signal);
+      const connectPromise = this.connectAndVerify(client2, transport, server, abortController.signal, options2);
       const capabilities = await Promise.race([connectPromise, timeoutPromise]);
       const connectionTime = Date.now() - startTime;
       return {
@@ -32388,8 +32730,8 @@ class MCPVerifier {
       }
     }
   }
-  async verifyServers(servers, timeout) {
-    const results = await Promise.allSettled(servers.map((server) => this.verifyServer(server, timeout)));
+  async verifyServers(servers, options2) {
+    const results = await Promise.allSettled(servers.map((server) => this.verifyServer(server, options2)));
     return results.map((result, index) => {
       if (result.status === "fulfilled") {
         return result.value;
@@ -32440,17 +32782,39 @@ class MCPVerifier {
         throw new MCPVerificationError(`Unsupported server type: ${server.type}`, server.name);
     }
   }
-  async connectAndVerify(client2, transport, server, abortSignal) {
+  async connectAndVerify(client2, transport, server, abortSignal, options2) {
     try {
       if (abortSignal?.aborted) {
         throw new Error("Operation aborted");
       }
       await client2.connect(transport);
+      const serverVersion = client2.getServerVersion();
+      logger.debug(`[Version Detection] MCP protocol returned: ${JSON.stringify(serverVersion)}`);
       const serverInfo = {
-        name: server.name,
-        version: "unknown",
+        name: serverVersion?.name || server.name,
+        version: serverVersion?.version || "unknown",
         protocolVersion: "unknown"
       };
+      if (serverInfo.version === "unknown" && server.type === MCPServerType.STDIO) {
+        logger.debug(`[Version Detection] Version unknown, attempting npm registry fallback for STDIO server`);
+        const packageSpec = extractPackageFromCommand(server.command, server.args);
+        if (packageSpec) {
+          logger.debug(`[Version Detection] Extracted package: ${packageSpec}`);
+          try {
+            const registryVersion = await fetchLatestVersion(packageSpec, { timeout: 3000 });
+            if (registryVersion) {
+              serverInfo.version = registryVersion;
+              logger.debug(`[Version Detection] npm registry returned: ${registryVersion}`);
+            } else {
+              logger.debug(`[Version Detection] npm registry returned no version for: ${packageSpec}`);
+            }
+          } catch (error) {
+            logger.debug(`[Version Detection] npm registry lookup failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+          }
+        } else {
+          logger.debug(`[Version Detection] Could not extract package name from command: ${server.command} ${server.args?.join(" ")}`);
+        }
+      }
       if (abortSignal?.aborted) {
         throw new Error("Operation aborted");
       }
@@ -32473,7 +32837,7 @@ class MCPVerifier {
       const resources = [];
       try {
         const resourcesResponse = await client2.listResources();
-        resources.push(...resourcesResponse.resources.map((resource) => {
+        const resourcePromises = resourcesResponse.resources.map(async (resource) => {
           const mcpResource = { uri: resource.uri };
           if (resource.name !== undefined)
             mcpResource.name = resource.name;
@@ -32481,8 +32845,34 @@ class MCPVerifier {
             mcpResource.description = resource.description;
           if (resource.mimeType !== undefined)
             mcpResource.mimeType = resource.mimeType;
+          if (options2?.includeResourceContents) {
+            try {
+              const resourceData = await client2.readResource({ uri: resource.uri });
+              if (resourceData.contents && resourceData.contents.length > 0) {
+                const content = resourceData.contents[0];
+                if (content && "text" in content && typeof content.text === "string") {
+                  const contentSize = Buffer.byteLength(content.text, "utf8");
+                  if (contentSize > MAX_RESOURCE_CONTENT_SIZE) {
+                    logger.debug(`Resource content too large for ${resource.uri}: ${contentSize} bytes (max: ${MAX_RESOURCE_CONTENT_SIZE})`);
+                  } else {
+                    mcpResource.contents = content.text;
+                  }
+                } else if (content && "blob" in content && typeof content.blob === "string") {
+                  const blobBuffer = Buffer.from(content.blob, "base64");
+                  if (blobBuffer.length > MAX_RESOURCE_CONTENT_SIZE) {
+                    logger.debug(`Resource content too large for ${resource.uri}: ${blobBuffer.length} bytes (max: ${MAX_RESOURCE_CONTENT_SIZE})`);
+                  } else {
+                    mcpResource.contents = new Uint8Array(blobBuffer);
+                  }
+                }
+              }
+            } catch (resourceError) {
+              logger.debug(`Failed to fetch resource content for ${resource.uri}: ${resourceError instanceof Error ? resourceError.message : "Unknown error"}`);
+            }
+          }
           return mcpResource;
-        }));
+        });
+        resources.push(...await Promise.all(resourcePromises));
       } catch (error) {
       }
       if (abortSignal?.aborted) {
@@ -32491,7 +32881,7 @@ class MCPVerifier {
       const prompts2 = [];
       try {
         const promptsResponse = await client2.listPrompts();
-        prompts2.push(...promptsResponse.prompts.map((prompt) => {
+        const promptPromises = promptsResponse.prompts.map(async (prompt) => {
           const mcpPrompt = { name: prompt.name };
           if (prompt.description !== undefined)
             mcpPrompt.description = prompt.description;
@@ -32505,19 +32895,40 @@ class MCPVerifier {
               return mcpArg;
             });
           }
+          if (options2?.includePromptDetails) {
+            try {
+              const promptData = await client2.getPrompt({ name: prompt.name, arguments: {} });
+              if (promptData.messages && promptData.messages.length > 0) {
+                mcpPrompt.template = promptData.messages.map((msg) => {
+                  if (typeof msg.content === "string")
+                    return msg.content;
+                  if (typeof msg.content === "object" && "text" in msg.content)
+                    return msg.content.text;
+                  return JSON.stringify(msg.content);
+                }).join("\n\n");
+              }
+            } catch (promptError) {
+              logger.debug(`Failed to fetch prompt template for ${prompt.name}: ${promptError instanceof Error ? promptError.message : "Unknown error"}`);
+            }
+          }
           return mcpPrompt;
-        }));
+        });
+        prompts2.push(...await Promise.all(promptPromises));
       } catch (error) {
       }
-      const { toolTokenCounts, totalToolTokens } = this.calculateToolTokens(tools, server.name);
-      return {
+      const shouldIncludeTokenCounts = options2?.includeTokenCounts !== false;
+      const tokenData = shouldIncludeTokenCounts ? this.calculateToolTokens(tools, server.name) : undefined;
+      const capabilities = {
         tools,
         resources,
         prompts: prompts2,
-        serverInfo,
-        toolTokenCounts,
-        totalToolTokens
+        serverInfo
       };
+      if (tokenData) {
+        capabilities.toolTokenCounts = tokenData.toolTokenCounts;
+        capabilities.totalToolTokens = tokenData.totalToolTokens;
+      }
+      return capabilities;
     } finally {
       try {
         await client2.close();
@@ -32543,20 +32954,42 @@ class MCPVerifier {
             const tokenCount = capabilities.toolTokenCounts?.get(tool.name) || 0;
             const tokenDisplay = tokenCount > 0 ? ` (${tokenCount} tokens)` : "";
             output.push(`   \u2022 ${tool.name}${tokenDisplay}${tool.description ? ` - ${tool.description}` : ""}`);
+            const parameters = this.formatToolParameters(tool);
+            if (parameters.length > 0) {
+              parameters.forEach((param) => output.push(param));
+            }
           });
         }
-        if (isDebugMode && capabilities.resources.length > 0) {
-          output.push(`   \n   Resources (${capabilities.resources.length}):`);
-          capabilities.resources.forEach((resource) => {
-            const resourceName = resource.name || resource.uri.split("/").pop() || resource.uri;
-            output.push(`   \u2022 ${resourceName}${resource.description ? ` - ${resource.description}` : ""}`);
-          });
+        if (capabilities.resources.length > 0) {
+          const hasContents = capabilities.resources.some((r) => r.contents !== undefined);
+          if (isDebugMode || hasContents) {
+            output.push(`   \n   Resources (${capabilities.resources.length}):`);
+            capabilities.resources.forEach((resource) => {
+              const resourceName = resource.name || resource.uri.split("/").pop() || resource.uri;
+              output.push(`   \u2022 ${resourceName}${resource.description ? ` - ${resource.description}` : ""}`);
+              if (resource.contents) {
+                const contentStr = typeof resource.contents === "string" ? resource.contents : `<binary data: ${resource.contents.length} bytes>`;
+                const preview = contentStr.length > 100 ? contentStr.slice(0, 100) + "..." : contentStr;
+                output.push(`     Content: ${preview}`);
+              }
+            });
+          }
         }
-        if (isDebugMode && capabilities.prompts.length > 0) {
-          output.push(`   \n   Prompts (${capabilities.prompts.length}):`);
-          capabilities.prompts.forEach((prompt) => {
-            output.push(`   \u2022 ${prompt.name}${prompt.description ? ` - ${prompt.description}` : ""}`);
-          });
+        if (capabilities.prompts.length > 0) {
+          const hasTemplates = capabilities.prompts.some((p) => p.template !== undefined);
+          if (isDebugMode || hasTemplates) {
+            output.push(`   \n   Prompts (${capabilities.prompts.length}):`);
+            capabilities.prompts.forEach((prompt) => {
+              output.push(`   \u2022 ${prompt.name}${prompt.description ? ` - ${prompt.description}` : ""}`);
+              if (prompt.template) {
+                const preview = prompt.template.length > 100 ? prompt.template.slice(0, 100) + "..." : prompt.template;
+                output.push(`     Template: ${preview}`);
+              }
+              if (prompt.arguments && prompt.arguments.length > 0) {
+                output.push(`     Arguments: ${prompt.arguments.map((a) => `${a.name}${a.required ? "*" : ""}`).join(", ")}`);
+              }
+            });
+          }
         }
         if (capabilities.tools.length === 0 && capabilities.resources.length === 0 && capabilities.prompts.length === 0) {
           output.push(`   \u26A0\uFE0F  No tools, resources, or prompts available`);
@@ -32839,8 +33272,8 @@ async function applyCommand(args) {
       logger.info("");
       const verifySpinner = ora(`Verifying ${mcpParsed.servers.length} MCP server(s)...`).start();
       try {
-        const verifier = new MCPVerifier(timeout);
-        const verificationResults = await verifier.verifyServers(mcpParsed.servers, timeout);
+        const verifier = new MCPVerifier;
+        const verificationResults = await verifier.verifyServers(mcpParsed.servers, timeout ? { timeout } : undefined);
         const successCount = verificationResults.filter((r) => r.status === "success").length;
         const errorCount = verificationResults.filter((r) => r.status === "error").length;
         const timeoutCount = verificationResults.filter((r) => r.status === "timeout").length;
@@ -33001,6 +33434,9 @@ async function verifyMcpCommand(args) {
   const timeoutArg = timeoutIndex >= 0 && timeoutIndex + 1 < args.length ? args[timeoutIndex + 1] : null;
   const parsedTimeout = timeoutArg ? parseInt(timeoutArg, 10) : NaN;
   const timeout = timeoutArg && Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : undefined;
+  const includeResources = args.includes("--include-resources");
+  const includePrompts = args.includes("--include-prompts");
+  const noTokens = args.includes("--no-tokens");
   const hasMcpArgs = args.some((arg) => arg.startsWith("--mcp-"));
   if (mcpName && hasAll) {
     logger.error("Cannot use --mcp-name and --all together. Choose one option.");
@@ -33014,9 +33450,9 @@ async function verifyMcpCommand(args) {
     logger.info("Usage: agentinit verify_mcp [options]");
     logger.info("");
     logger.info("Verify existing configurations:");
-    logger.info("  --mcp-name <name>    Verify specific MCP server by name");
-    logger.info("  --all                Verify all configured MCP servers");
-    logger.info(`  --timeout <ms>       Connection timeout in milliseconds (default: ${DEFAULT_CONNECTION_TIMEOUT_MS})`);
+    logger.info("  --mcp-name <name>       Verify specific MCP server by name");
+    logger.info("  --all                   Verify all configured MCP servers");
+    logger.info(`  --timeout <ms>          Connection timeout in milliseconds (default: ${DEFAULT_CONNECTION_TIMEOUT_MS})`);
     logger.info("");
     logger.info("Verify direct MCP configuration:");
     logger.info("  --mcp-stdio <name> <command>     Verify STDIO MCP server");
@@ -33026,6 +33462,11 @@ async function verifyMcpCommand(args) {
     logger.info("  --env <env_vars>                 Environment variables for server");
     logger.info("  --auth <token>                   Authentication token for HTTP/SSE");
     logger.info("");
+    logger.info("Advanced options:");
+    logger.info("  --include-resources     Fetch actual resource contents (may be slow)");
+    logger.info("  --include-prompts       Fetch prompt templates");
+    logger.info("  --no-tokens             Skip token counting");
+    logger.info("");
     logger.info("Examples:");
     logger.info("  # Verify existing configurations");
     logger.info("  agentinit verify_mcp --all");
@@ -33034,6 +33475,9 @@ async function verifyMcpCommand(args) {
     logger.info("  # Verify direct configuration");
     logger.info('  agentinit verify_mcp --mcp-stdio everything "npx -y @modelcontextprotocol/server-everything"');
     logger.info('  agentinit verify_mcp --mcp-http github "https://api.github.com/mcp" --auth "Bearer token"');
+    logger.info("");
+    logger.info("  # Fetch resource contents and prompt templates");
+    logger.info("  agentinit verify_mcp --all --include-resources --include-prompts");
     return;
   }
   let spinner;
@@ -33110,7 +33554,16 @@ async function verifyMcpCommand(args) {
       }
     }
     const verifier = new MCPVerifier(timeout);
-    const results = await verifier.verifyServers(serversToVerify, timeout);
+    const options2 = {};
+    if (timeout)
+      options2.timeout = timeout;
+    if (includeResources)
+      options2.includeResourceContents = true;
+    if (includePrompts)
+      options2.includePromptDetails = true;
+    if (noTokens)
+      options2.includeTokenCounts = false;
+    const results = await verifier.verifyServers(serversToVerify, Object.keys(options2).length > 0 ? options2 : undefined);
     const successCount = results.filter((r) => r.status === "success").length;
     const errorCount = results.filter((r) => r.status === "error").length;
     const timeoutCount = results.filter((r) => r.status === "timeout").length;