agentinit 1.2.1 → 1.4.0

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+# [1.4.0](https://github.com/agentinit/agentinit/compare/v1.3.0...v1.4.0) (2025-09-26)
+
+
+### Bug Fixes
+
+* address comments ([b4a63e7](https://github.com/agentinit/agentinit/commit/b4a63e79b376d059e2403ad396b779912e8ca50e))
+* dirty fix with token calcs ([e7d3ef9](https://github.com/agentinit/agentinit/commit/e7d3ef98ea700937f2ccbd448ff18da02e65d1cd))
+* **mcp:** improve token calculation accuracy for different schema types ([6f85f8b](https://github.com/agentinit/agentinit/commit/6f85f8b8448e8a391029f7bd50f975be5818ff7e))
+* **mcp:** use minified JSON to prevent token inflation ([c5885c2](https://github.com/agentinit/agentinit/commit/c5885c277ac920781919178786386130b04b7633))
+
+
+### Features
+
+* improve token calc ([107a8d7](https://github.com/agentinit/agentinit/commit/107a8d7b5b849a7dfc4dd776474c7d0bcd11c179))
+* **mcp:** significantly improve token calculation accuracy ([c7c5137](https://github.com/agentinit/agentinit/commit/c7c51377565e2ab110262c859d05a988a39a80ee))
+
+# [1.3.0](https://github.com/agentinit/agentinit/compare/v1.2.1...v1.3.0) (2025-09-24)
+
+
+### Bug Fixes
+
+* address review comments ([e337f07](https://github.com/agentinit/agentinit/commit/e337f072bd41794756c72a3cdba96ebaff033e5f))
+* address review comments ([6be5b93](https://github.com/agentinit/agentinit/commit/6be5b937ec6fcbf924ea93f378156ba44a46b9d5))
+
+
+### Features
+
+* centralize constants and add timeout support to apply command ([d35a6fc](https://github.com/agentinit/agentinit/commit/d35a6fc2dd76923c82ca7f26b4503260f25e944f))
+
 ## [1.2.1](https://github.com/agentinit/agentinit/compare/v1.2.0...v1.2.1) (2025-09-20)
 
 

package/README.md

@@ -94,25 +94,16 @@ agentinit mcp --install <name>     # Install specific MCP
 
 ### `agentinit verify_mcp`
 
-Verify MCP server installations and list their capabilities.
-
-```bash
-agentinit verify_mcp --all              # Verify all configured MCP servers
-agentinit verify_mcp --mcp-name <name>  # Verify specific MCP server
-```
+Verify MCP server installations and get their tools with token usage.
 
 **Examples:**
 ```bash
 # Verify all MCPs in project
 agentinit verify_mcp --all
-
-# Verify specific server
-agentinit verify_mcp --mcp-name everything
-
-# Test MCP configuration directly
+# Verify STDIO server
 agentinit verify_mcp --mcp-stdio everything "npx -y @modelcontextprotocol/server-everything"
-
-agentinit verify_mcp --mcp-http
+# Verify HTTP server
+agentinit verify_mcp --mcp-http notion_api "https://mcp.notion.com/mcp"  --timeout 30000
 ```
 
 Shows connection status, response time, and available tools/resources/prompts for each MCP server.
@@ -181,7 +172,13 @@ This generates `.agentinit/agentinit.toml` with your MCP configurations.
 - `--header "KEY:VALUE"` - Adds custom headers in KEY:VALUE format (can be used multiple times)
 - Both flags can be combined for APIs requiring multiple authentication methods
 
-**MCP Verification**: Use the `--verify-mcp` flag to test MCP servers immediately after configuration. This ensures servers are reachable and shows their available tools, resources, and prompts.
+**MCP Verification**: Use the `--verify-mcp` flag to test MCP servers immediately after configuration. This ensures servers are reachable and shows their available tools, resources, and prompts. Use `--timeout <ms>` to set a custom connection timeout (default: 30000ms).
+
+```bash
+# Verify with custom timeout
+npx agentinit apply --verify-mcp --timeout 30000 \
+  --mcp-stdio chrome-mcp "bunx -y chrome-devtools-mcp@latest"
+```
 
 #### Rules Configuration
 

package/dist/index.js

@@ -22985,16 +22985,48 @@ class MCPParser {
   }
 }
 
+// src/constants/mcp.ts
+import {readFileSync} from "fs";
+import {fileURLToPath} from "url";
+import {dirname as dirname3, join as join2} from "path";
+var getPackageVersion = function() {
+  try {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = dirname3(__filename2);
+    const packageJsonPath = join2(__dirname2, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version || "1.0.0";
+  } catch {
+    return "1.0.0";
+  }
+};
+var DEFAULT_CONNECTION_TIMEOUT_MS = 30000;
+var MCP_VERIFIER_CONFIG = {
+  name: "agentinit-verifier",
+  version: getPackageVersion()
+};
+
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+// src/constants/tokens.ts
+var TOKEN_COUNT_THRESHOLDS = {
+  LOW: 5000,
+  MEDIUM: 15000
+};
 // src/core/rulesParser.ts
-import {readFileSync as readFileSync2} from "fs";
+import {readFileSync as readFileSync3} from "fs";
 
 // src/core/rulesTemplateLoader.ts
 var toml = __toESM(require_toml(), 1);
-import {resolve as resolve5, dirname as dirname3} from "path";
-import {fileURLToPath} from "url";
-import {readFileSync, readdirSync, existsSync} from "fs";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname3(__filename2);
+import {resolve as resolve5, dirname as dirname4} from "path";
+import {fileURLToPath as fileURLToPath2} from "url";
+import {readFileSync as readFileSync2, readdirSync, existsSync} from "fs";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname4(__filename2);
 
 class RulesTemplateLoader {
   templatesPath;
@@ -23011,7 +23043,7 @@ class RulesTemplateLoader {
     for (const file of files) {
       try {
         const filePath = resolve5(this.templatesPath, file);
-        const content = readFileSync(filePath, "utf-8");
+        const content = readFileSync2(filePath, "utf-8");
         const parsed = toml.default.parse(content);
         const template = {
           id: parsed.template.id,
@@ -23159,7 +23191,7 @@ class RulesParser {
       throw new RulesParseError(`Rules file not found: ${filePath}`);
     }
     try {
-      const content = readFileSync2(filePath, "utf-8");
+      const content = readFileSync3(filePath, "utf-8");
       if (filePath.endsWith(".json")) {
         const parsed = JSON.parse(content);
         return this.extractRulesFromObject(parsed);
@@ -23185,12 +23217,17 @@ class RulesParser {
         }
       }
       const controller = new AbortController;
-      const timeoutId = setTimeout(() => controller.abort(), options2.timeout || 1e4);
-      const response = await fetch(options2.url, {
-        headers,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
+      const timeoutMs = options2.timeout ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      let response;
+      try {
+        response = await fetch(options2.url, {
+          headers,
+          signal: controller.signal
+        });
+      } finally {
+        clearTimeout(timeoutId);
+      }
       if (!response.ok) {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
@@ -23395,7 +23432,7 @@ class TOMLGenerator {
 import {resolve as resolve8} from "path";
 
 // src/utils/paths.ts
-import {resolve as resolve6, join as join2} from "path";
+import {resolve as resolve6, join as join3} from "path";
 import {homedir} from "os";
 function getHomeDirectory() {
   return homedir();
@@ -23414,7 +23451,7 @@ function getPlatform() {
 }
 function expandTilde(path) {
   if (path.startsWith("~/")) {
-    return join2(getHomeDirectory(), path.slice(2));
+    return join3(getHomeDirectory(), path.slice(2));
   }
   if (path === "~") {
     return getHomeDirectory();
@@ -32236,37 +32273,50 @@ class MCPVerificationError extends Error {
   }
 }
 
-class TimeoutError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TimeoutError";
-  }
-}
-
 class MCPVerifier {
   defaultTimeout;
-  constructor(defaultTimeout = 1e4) {
+  constructor(defaultTimeout = DEFAULT_CONNECTION_TIMEOUT_MS) {
     this.defaultTimeout = defaultTimeout;
   }
   colorizeTokenCount(tokenCount) {
-    if (tokenCount <= 5000)
+    if (tokenCount <= TOKEN_COUNT_THRESHOLDS.LOW)
       return green(tokenCount.toString());
-    if (tokenCount <= 15000)
+    if (tokenCount <= TOKEN_COUNT_THRESHOLDS.MEDIUM)
       return yellow(tokenCount.toString());
     return red(tokenCount.toString());
   }
-  calculateToolTokens(tools) {
+  calculateToolTokens(tools, serverName) {
     const toolTokenCounts = new Map;
     let totalToolTokens = 0;
     for (const tool of tools) {
       try {
+        const rawSchema = tool.inputSchema && typeof tool.inputSchema === "object" ? tool.inputSchema : undefined;
+        const schemaType = rawSchema?.type;
+        const parameters = {
+          $schema: "http://json-schema.org/draft-07/schema#",
+          ...rawSchema ?? {}
+        };
+        const hasObjectHints = rawSchema !== undefined && ["properties", "required", "additionalProperties", "patternProperties"].some((key) => (key in rawSchema));
+        const isObjectSchema = rawSchema === undefined || schemaType === "object" || Array.isArray(schemaType) && schemaType.includes("object") || hasObjectHints;
+        if (isObjectSchema) {
+          if (!("type" in parameters))
+            parameters.type = "object";
+          if (!("properties" in parameters))
+            parameters.properties = {};
+          if (!("required" in parameters))
+            parameters.required = [];
+          if (!("additionalProperties" in parameters))
+            parameters.additionalProperties = false;
+        }
+        const prefixedToolName = `mcp__${serverName}__${tool.name}`;
         const toolForCounting = {
-          name: tool.name,
-          description: tool.description || "",
-          inputSchema: tool.inputSchema || {}
+          name: prefixedToolName,
+          ...tool.description !== undefined ? { description: tool.description } : {},
+          parameters
         };
-        const toolText = JSON.stringify(toolForCounting, null, 2);
-        const tokenCount = countTokens(toolText);
+        const functionDefinition = JSON.stringify(toolForCounting);
+        const claudeToolRepresentation = `<function>${functionDefinition}</function>`;
+        const tokenCount = countTokens(claudeToolRepresentation) * 3;
         toolTokenCounts.set(tool.name, tokenCount);
         totalToolTokens += tokenCount;
       } catch (error) {
@@ -32285,8 +32335,8 @@ class MCPVerifier {
     try {
       transport = await this.createTransport(server);
       client2 = new Client({
-        name: "agentinit-verifier",
-        version: "1.0.0"
+        name: MCP_VERIFIER_CONFIG.name,
+        version: MCP_VERIFIER_CONFIG.version
       });
       const timeoutPromise = new Promise((_, reject) => {
         const timeoutId = setTimeout(async () => {
@@ -32459,7 +32509,7 @@ class MCPVerifier {
         }));
       } catch (error) {
       }
-      const { toolTokenCounts, totalToolTokens } = this.calculateToolTokens(tools);
+      const { toolTokenCounts, totalToolTokens } = this.calculateToolTokens(tools, server.name);
       return {
         tools,
         resources,
@@ -32542,12 +32592,10 @@ class MCPVerifier {
 
 // src/commands/apply.ts
 var colorizeTokenCount = function(tokenCount) {
-  if (tokenCount <= 5000)
+  if (tokenCount <= TOKEN_COUNT_THRESHOLDS.LOW)
     return green(tokenCount.toString());
-  if (tokenCount <= 15000)
+  if (tokenCount <= TOKEN_COUNT_THRESHOLDS.MEDIUM)
     return yellow(tokenCount.toString());
-  if (tokenCount <= 30000)
-    return red(tokenCount.toString());
   return red(tokenCount.toString());
 };
 var colorizeTokenDiff = function(diff) {
@@ -32566,6 +32614,10 @@ async function applyCommand(args) {
   const specifiedClient = clientArgIndex >= 0 && clientArgIndex + 1 < args.length ? args[clientArgIndex + 1] : null;
   const isGlobal = args.includes("--global");
   const verifyMcp = args.includes("--verify-mcp");
+  const timeoutIndex = args.findIndex((arg) => arg === "--timeout");
+  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;
   if (!hasMcpArgs && !hasRulesArgs) {
     logger.info("Usage: agentinit apply [options]");
     logger.info("");
@@ -32575,6 +32627,7 @@ async function applyCommand(args) {
     logger.info("  --global            Apply configuration globally (requires --agent)");
     logger.info("                      If not specified, auto-detects agents in the project");
     logger.info("  --verify-mcp        Verify MCP servers after configuration");
+    logger.info(`  --timeout <ms>      Connection timeout in milliseconds for MCP verification (default: ${DEFAULT_CONNECTION_TIMEOUT_MS})`);
     logger.info("");
     logger.info("Rules Configuration Options:");
     logger.info("  --rules <templates>     Apply rule templates (comma-separated)");
@@ -32631,11 +32684,11 @@ async function applyCommand(args) {
   const spinner = ora("Parsing configurations...").start();
   try {
     const mcpArgs = args.filter((arg, index) => {
-      if (arg === "--client" || arg === "--agent" || arg === "--global" || arg === "--verify-mcp")
+      if (arg === "--client" || arg === "--agent" || arg === "--global" || arg === "--verify-mcp" || arg === "--timeout")
         return false;
       if (arg === "--rules" || arg === "--rule-raw" || arg === "--rules-file" || arg === "--rules-remote")
         return false;
-      if (index > 0 && (args[index - 1] === "--client" || args[index - 1] === "--agent"))
+      if (index > 0 && (args[index - 1] === "--client" || args[index - 1] === "--agent" || args[index - 1] === "--timeout"))
         return false;
       if (index > 0 && (args[index - 1] === "--rules" || args[index - 1] === "--rule-raw" || args[index - 1] === "--rules-file" || args[index - 1] === "--rules-remote"))
         return false;
@@ -32786,8 +32839,8 @@ async function applyCommand(args) {
       logger.info("");
       const verifySpinner = ora(`Verifying ${mcpParsed.servers.length} MCP server(s)...`).start();
       try {
-        const verifier = new MCPVerifier;
-        const verificationResults = await verifier.verifyServers(mcpParsed.servers);
+        const verifier = new MCPVerifier(timeout);
+        const verificationResults = await verifier.verifyServers(mcpParsed.servers, timeout);
         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;
@@ -32821,7 +32874,17 @@ async function applyCommand(args) {
         if (server.type === "stdio" && server.command) {
           logger.info(`    Command: ${server.command} ${server.args?.join(" ") || ""}`);
         } else if (server.url) {
-          logger.info(`    URL: ${server.url}`);
+          let sanitizedUrl;
+          try {
+            const parsedUrl = new URL(server.url);
+            parsedUrl.username = "";
+            parsedUrl.password = "";
+            parsedUrl.search = "";
+            sanitizedUrl = parsedUrl.toString();
+          } catch {
+            sanitizedUrl = server.url.split("?")[0] || "invalid-url";
+          }
+          logger.info(`    URL: ${sanitizedUrl}`);
         }
       });
     }
@@ -32937,7 +33000,7 @@ async function verifyMcpCommand(args) {
   const timeoutIndex = args.findIndex((arg) => arg === "--timeout");
   const timeoutArg = timeoutIndex >= 0 && timeoutIndex + 1 < args.length ? args[timeoutIndex + 1] : null;
   const parsedTimeout = timeoutArg ? parseInt(timeoutArg, 10) : NaN;
-  const timeout = timeoutArg && !Number.isNaN(parsedTimeout) && Number.isFinite(parsedTimeout) ? parsedTimeout : undefined;
+  const timeout = timeoutArg && Number.isFinite(parsedTimeout) && parsedTimeout > 0 ? parsedTimeout : undefined;
   const hasMcpArgs = args.some((arg) => arg.startsWith("--mcp-"));
   if (mcpName && hasAll) {
     logger.error("Cannot use --mcp-name and --all together. Choose one option.");
@@ -32953,7 +33016,7 @@ async function verifyMcpCommand(args) {
     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: 10000)");
+    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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentinit",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "A CLI tool for managing and configuring AI coding agents",
   "main": "dist/index.js",
   "type": "module",