opentool 0.4.6 → 0.5.0

package/README.md

@@ -188,10 +188,9 @@ When you push a project with `opentool` dependency to GitHub and connect it to O
 
 ## Examples
 
-See the `examples/` directory for complete examples:
+See the `examples/` directory for a comprehensive example:
 
-- **`examples/full-metadata/`** - Complete metadata configuration with payment and discovery features
-- **`examples/minimal/`** - Minimal setup demonstrating smart defaults
+- **`examples/full-metadata/`** - Metadata configuration with payment and discovery features
 
 ### Testing Examples Locally
 
@@ -207,16 +206,16 @@ cd examples/full-metadata
 npm link opentool
 npm run build
 
-# Test the minimal example  
-cd ../minimal
-npm link opentool
-npm run build
-
 # Examine generated output
 cat dist/metadata.json
 
 # Test the MCP server
 echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}' | node dist/mcp-server.js
+
+# Quick regression helpers from the repo root
+npm run examples:build      # Build full metadata example (CJS+ESM)
+npm run examples:validate   # Validate example metadata and tools
+npm run examples:metadata   # Regenerate metadata.json without rebuilding tools
 ```
 
 ## Metadata System
@@ -229,6 +228,10 @@ OpenTool features a sophisticated **three-tier metadata system**:
 
 See [`METADATA.md`](./METADATA.md) for the complete guide to configuring metadata for on-chain registration and payments.
 
+## Future Work
+
+- Explore an esbuild-powered watch mode that keeps metadata and tool artifacts up to date for the dev server. This remains on the follow-up list once the new pipeline settles.
+
 ## Contributing
 
 We welcome contributions! Please see our [Contributing Guide](https://github.com/openpond/opentool/blob/master/CONTRIBUTING.md) for details.

package/dist/cli/build.d.ts

@@ -1,8 +1,23 @@
+import { InternalToolDefinition } from "../types";
+import { Metadata } from "../types/metadata";
 export interface BuildOptions {
     input: string;
     output: string;
     name?: string;
     version?: string;
 }
+interface BuildArtifacts {
+    metadata: Metadata;
+    defaultsApplied: string[];
+    tools: InternalToolDefinition[];
+    compiledTools: CompiledToolArtifact[];
+}
+interface CompiledToolArtifact {
+    name: string;
+    filename: string;
+    modulePath: string;
+}
 export declare function buildCommand(options: BuildOptions): Promise<void>;
+export declare function buildProject(options: BuildOptions): Promise<BuildArtifacts>;
+export {};
 //# sourceMappingURL=build.d.ts.map

package/dist/cli/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/cli/build.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA0EvE"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/cli/build.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAK7C,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,cAAc;IACtB,QAAQ,EAAE,QAAQ,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,aAAa,EAAE,oBAAoB,EAAE,CAAC;CACvC;AAED,UAAU,oBAAoB;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAYvE;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CA6CjF"}

package/dist/cli/build.js

@@ -34,101 +34,121 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildCommand = buildCommand;
+exports.buildProject = buildProject;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
-const util_1 = require("util");
+const esbuild_1 = require("../utils/esbuild");
+const metadata_1 = require("./shared/metadata");
 const validate_1 = require("./validate");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
 async function buildCommand(options) {
-    const timestamp = new Date().toISOString().replace("T", " ").slice(0, 19);
-    console.log(`[${timestamp}] Building OpenTool project...`);
-    const config = {
-        toolsDir: path.resolve(options.input),
-        outputDir: path.resolve(options.output),
-        serverName: options.name || "opentool-server",
-        serverVersion: options.version || "1.0.0",
-    };
+    const start = timestamp();
+    console.log(`[${start}] Building OpenTool project...`);
     try {
-        // Validate tools directory exists
-        if (!fs.existsSync(config.toolsDir)) {
-            throw new Error(`Tools directory not found: ${config.toolsDir}`);
-        }
-        // Load and validate tools (validation integrated into build)
-        console.log(`[${new Date()
-            .toISOString()
-            .replace("T", " ")
-            .slice(0, 19)}] 🔍 Validating tools...`);
-        const tools = await (0, validate_1.loadAndValidateTools)(config.toolsDir);
-        if (tools.length === 0) {
-            throw new Error("No valid tools found - build aborted");
-        }
-        console.log(`[${new Date().toISOString().replace("T", " ").slice(0, 19)}] ✅ Found ${tools.length} valid tools`);
-        // Create output directory
-        if (!fs.existsSync(config.outputDir)) {
-            fs.mkdirSync(config.outputDir, { recursive: true });
-        }
-        // Generate JavaScript MCP server
-        await generateJavaScriptMcpServer(tools, config);
-        // Copy and compile tools to output directory
-        await copyAndCompileTools(config.toolsDir, config.outputDir, tools);
-        // Generate metadata JSON
-        await generateMetadataJson(tools, config);
-        const endTimestamp = new Date()
-            .toISOString()
-            .replace("T", " ")
-            .slice(0, 19);
-        console.log(`[${endTimestamp}] Build completed successfully!`);
-        console.log(`Output directory: ${config.outputDir}`);
-        console.log("Generated files:");
-        console.log("  mcp-server.js - JavaScript MCP server");
-        console.log(`  tools/ - ${tools.length} compiled JavaScript tool files`);
-        console.log("  metadata.json - Metadata for on-chain registration");
-        console.log("\\nTest your MCP server:");
-        console.log(`  echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}' | node ${config.outputDir}/mcp-server.js`);
+        const artifacts = await buildProject(options);
+        logBuildSummary(artifacts, options);
     }
     catch (error) {
-        console.error(`[${new Date()
-            .toISOString()
-            .replace("T", " ")
-            .slice(0, 19)}] Build failed:`, error);
+        const end = timestamp();
+        console.error(`[${end}] Build failed:`, error);
         process.exit(1);
     }
 }
-async function generateJavaScriptMcpServer(tools, config) {
-    // Generate JavaScript MCP server for stdio transport
-    await generateJavaScriptMcpServerFile(tools, config);
+async function buildProject(options) {
+    const toolsDir = path.resolve(options.input);
+    if (!fs.existsSync(toolsDir)) {
+        throw new Error(`Tools directory not found: ${toolsDir}`);
+    }
+    const projectRoot = path.dirname(toolsDir);
+    const outputDir = path.resolve(options.output);
+    fs.mkdirSync(outputDir, { recursive: true });
+    const serverName = options.name ?? "opentool-server";
+    const serverVersion = options.version ?? "1.0.0";
+    const tools = await (0, validate_1.loadAndValidateTools)(toolsDir, { projectRoot });
+    if (tools.length === 0) {
+        throw new Error("No valid tools found - build aborted");
+    }
+    const { metadata, defaultsApplied } = await (0, metadata_1.buildMetadataArtifact)({
+        projectRoot,
+        tools,
+    });
+    const metadataPath = path.join(outputDir, "metadata.json");
+    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+    const compiledTools = await emitTools(tools, {
+        projectRoot,
+        outputDir,
+    });
+    await writeServer({
+        outputDir,
+        serverName,
+        serverVersion,
+        metadata,
+        compiledTools,
+    });
+    return {
+        metadata,
+        defaultsApplied,
+        tools,
+        compiledTools,
+    };
+}
+async function emitTools(tools, config) {
+    const toolsOutDir = path.join(config.outputDir, "tools");
+    if (fs.existsSync(toolsOutDir)) {
+        fs.rmSync(toolsOutDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(toolsOutDir, { recursive: true });
+    const entryPoints = tools.map((tool) => {
+        if (!tool.sourcePath) {
+            throw new Error(`Missing sourcePath for tool ${tool.filename}`);
+        }
+        return tool.sourcePath;
+    });
+    await (0, esbuild_1.transpileWithEsbuild)({
+        entryPoints,
+        projectRoot: config.projectRoot,
+        format: "cjs",
+        outDir: toolsOutDir,
+    });
+    const compiled = tools.map((tool) => {
+        if (!tool.sourcePath) {
+            throw new Error(`Missing sourcePath for tool ${tool.filename}`);
+        }
+        const base = path.basename(tool.sourcePath).replace(/\.[^.]+$/, "");
+        const modulePath = path.join("tools", `${base}.js`);
+        if (!fs.existsSync(path.join(config.outputDir, modulePath))) {
+            throw new Error(`Expected compiled output missing: ${modulePath}`);
+        }
+        return {
+            name: tool.metadata?.name ?? tool.filename,
+            filename: base,
+            modulePath,
+        };
+    });
+    return compiled;
 }
-async function generateJavaScriptMcpServerFile(tools, config) {
-    const mcpServerCode = `#!/usr/bin/env node
-// Auto-generated JavaScript MCP server with stdio transport
+function renderServer(options) {
+    const toolImports = options.compiledTools
+        .map((tool, index) => `const tool${index} = require('./${tool.modulePath}');`)
+        .join("\n");
+    const registry = options.compiledTools
+        .map((_, index) => `  { meta: metadata.tools[${index}], module: tool${index} },`)
+        .join("\n");
+    return `#!/usr/bin/env node
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
 const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
 const { CallToolRequestSchema, ListToolsRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
-const { zodToJsonSchema } = require('zod-to-json-schema');
+const metadata = require('./metadata.json');
 
-// Import tools
-${tools
-        .map((tool, index) => `const tool${index} = require('./tools/${tool.filename}.js');`)
-        .join("\n")}
+${toolImports}
 
-const tools = [
-${tools
-        .map((tool, index) => `  {
-    schema: tool${index}.schema,
-    metadata: tool${index}.metadata,
-    handler: tool${index}.TOOL,
-    filename: '${tool.filename}'
-  },`)
-        .join("\n")}
+const toolRegistry = [
+${registry}
 ];
 
-// Create MCP server
 const server = new Server(
   {
-    name: '${config.serverName}',
-    version: '${config.serverVersion}',
+    name: '${escapeForJs(options.serverName)}',
+    version: '${escapeForJs(options.serverVersion)}',
   },
   {
     capabilities: {
@@ -137,79 +157,32 @@ const server = new Server(
   }
 );
 
-// Register list tools handler
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: tools.map((tool, index) => {
-    // Convert Zod schema to JSON Schema format
-    let inputSchema = { type: 'object' };
-    const toolName = tool.metadata?.name || tool.filename;
-    
-    try {
-      inputSchema = zodToJsonSchema(tool.schema, {
-        name: \`\${toolName}Schema\`,
-        target: 'jsonSchema7',
-        $refStrategy: 'none'
-      });
-    } catch (error) {
-      console.warn(\`Failed to convert schema for tool \${toolName}:\`, error);
-      inputSchema = { type: 'object' };
-    }
-
-    const toolDef = {
-      name: toolName,
-      description: tool.metadata?.description || \`Tool \${index}\`,
-      inputSchema
-    };
-
-    // Add annotations if they exist
-    if (tool.metadata?.annotations) {
-      toolDef.annotations = tool.metadata.annotations;
-    }
-
-    return toolDef;
-  }),
+  tools: toolRegistry.map(({ meta }) => meta),
 }));
 
-// Register call tool handler
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const tool = tools.find(t => {
-    const toolName = t.metadata?.name || t.filename;
-    return toolName === request.params.name;
-  });
-  if (!tool) {
-    throw new Error(\`Tool \${request.params.name} not found\`);
+  const entry = toolRegistry.find(({ meta }) => meta.name === request.params.name);
+  if (!entry) {
+    throw new Error('Tool ' + request.params.name + ' not found');
   }
 
   try {
-    const validatedParams = tool.schema.parse(request.params.arguments);
-    const result = await tool.handler(validatedParams);
-    
-    // Handle both string and object responses
+    const validated = entry.module.schema.parse(request.params.arguments);
+    const result = await entry.module.TOOL(validated);
     if (typeof result === 'string') {
-      return {
-        content: [{ type: 'text', text: result }],
-        isError: false,
-      };
-    } else if (result && typeof result === 'object' && result.content) {
-      return {
-        content: result.content,
-        isError: result.isError || false,
-      };
-    } else {
-      return {
-        content: [{ type: 'text', text: String(result) }],
-        isError: false,
-      };
+      return { content: [{ type: 'text', text: result }], isError: false };
     }
+    return { content: result.content, isError: result.isError || false };
   } catch (error) {
+    const message = (error && error.message) || String(error);
     return {
-      content: [{ type: 'text', text: \`Error: \${error.message || error}\` }],
+      content: [{ type: 'text', text: 'Error: ' + message }],
       isError: true,
     };
   }
 });
 
-// Start server with stdio transport
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -219,290 +192,32 @@ if (require.main === module) {
   main().catch(console.error);
 }
 
-module.exports = { server, tools };
+module.exports = { server };
 `;
-    const mcpServerPath = path.join(config.outputDir, "mcp-server.js");
-    fs.writeFileSync(mcpServerPath, mcpServerCode);
-    // Make executable
-    fs.chmodSync(mcpServerPath, 0o755);
 }
-async function copyAndCompileTools(sourceDir, outputDir, _tools) {
-    const toolsOutputDir = path.join(outputDir, "tools");
-    if (!fs.existsSync(toolsOutputDir)) {
-        fs.mkdirSync(toolsOutputDir, { recursive: true });
-    }
-    // Use the same temp compilation approach as in loadTools
-    const tempDir = path.join(sourceDir, ".opentool-temp");
-    if (fs.existsSync(tempDir)) {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-    fs.mkdirSync(tempDir, { recursive: true });
-    try {
-        const files = fs.readdirSync(sourceDir);
-        const tsFiles = files.filter((file) => file.endsWith(".ts"));
-        if (tsFiles.length > 0) {
-            console.log(`  Compiling ${tsFiles.length} TypeScript files to JavaScript...`);
-            // Copy all files to temp directory
-            for (const file of files) {
-                if (file.endsWith(".ts") || file.endsWith(".js")) {
-                    fs.copyFileSync(path.join(sourceDir, file), path.join(tempDir, file));
-                }
-            }
-            // Compile TypeScript files
-            try {
-                await execAsync(`npx tsc --target es2020 --module commonjs --esModuleInterop --skipLibCheck --moduleResolution node --outDir ${tempDir} ${tsFiles
-                    .map((f) => path.join(tempDir, f))
-                    .join(" ")}`);
-            }
-            catch (tscError) {
-                console.warn("TypeScript compilation failed, trying with relaxed settings...");
-                await execAsync(`npx tsc --target es2020 --module commonjs --esModuleInterop --skipLibCheck --moduleResolution node --noImplicitAny false --strict false --outDir ${tempDir} ${tsFiles
-                    .map((f) => path.join(tempDir, f))
-                    .join(" ")}`);
-            }
-        }
-        // Copy compiled JavaScript files to output
-        for (const file of files) {
-            if (file.endsWith(".ts")) {
-                const jsFile = file.replace(".ts", ".js");
-                const sourcePath = path.join(tempDir, jsFile);
-                const outputPath = path.join(toolsOutputDir, jsFile);
-                if (fs.existsSync(sourcePath)) {
-                    fs.copyFileSync(sourcePath, outputPath);
-                    console.log(`  Compiled and copied ${jsFile}`);
-                }
-            }
-            else if (file.endsWith(".js")) {
-                const sourcePath = path.join(sourceDir, file);
-                const outputPath = path.join(toolsOutputDir, file);
-                fs.copyFileSync(sourcePath, outputPath);
-                console.log(`  Copied ${file}`);
-            }
-        }
-    }
-    finally {
-        // Clean up temp directory
-        if (fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        }
-    }
+async function writeServer(options) {
+    const serverCode = renderServer(options);
+    const serverPath = path.join(options.outputDir, "mcp-server.js");
+    fs.writeFileSync(serverPath, serverCode);
+    fs.chmodSync(serverPath, 0o755);
 }
-// Helper function to read package.json for fallback values
-function readPackageJson(projectRoot) {
-    try {
-        const packagePath = path.join(projectRoot, "package.json");
-        if (fs.existsSync(packagePath)) {
-            const packageContent = fs.readFileSync(packagePath, "utf8");
-            return JSON.parse(packageContent);
-        }
+function logBuildSummary(artifacts, options) {
+    const end = timestamp();
+    console.log(`[${end}] Build completed successfully!`);
+    console.log(`Output directory: ${path.resolve(options.output)}`);
+    console.log("Generated files:");
+    console.log("  • mcp-server.js (stdio server)");
+    console.log(`  • tools/ (${artifacts.compiledTools.length} compiled tools)`);
+    console.log("  • metadata.json (registry artifact)");
+    if (artifacts.defaultsApplied.length > 0) {
+        console.log("\nDefaults applied during metadata synthesis:");
+        artifacts.defaultsApplied.forEach((entry) => console.log(`  • ${entry}`));
     }
-    catch (error) {
-        console.warn("  Failed to read package.json:", error);
-    }
-    return {};
 }
-async function generateMetadataJson(tools, config) {
-    console.log(`[${new Date()
-        .toISOString()
-        .replace("T", " ")
-        .slice(0, 19)}] Generating metadata JSON...`);
-    const projectRoot = path.dirname(config.toolsDir);
-    // Try to load metadata from metadata.ts (or fall back to discovery.ts for backwards compatibility)
-    let rootMetadata = {};
-    const metadataTsPath = path.join(projectRoot, "metadata.ts");
-    const metadataJsPath = path.join(projectRoot, "metadata.js");
-    const discoveryPath = path.join(projectRoot, "discovery.ts"); // backwards compatibility
-    const discoveryJsPath = path.join(projectRoot, "discovery.js");
-    // Check for metadata.ts first, then discovery.ts for backwards compatibility
-    const metadataFilePath = fs.existsSync(metadataTsPath)
-        ? metadataTsPath
-        : fs.existsSync(discoveryPath)
-            ? discoveryPath
-            : null;
-    const metadataJsFilePath = fs.existsSync(metadataJsPath)
-        ? metadataJsPath
-        : fs.existsSync(discoveryJsPath)
-            ? discoveryJsPath
-            : null;
-    if (metadataFilePath) {
-        try {
-            // Use the same temp compilation approach as tools
-            const tempDir = path.join(projectRoot, ".opentool-temp");
-            if (!fs.existsSync(tempDir)) {
-                fs.mkdirSync(tempDir, { recursive: true });
-            }
-            // Copy metadata file to temp directory
-            const tempFileName = path.basename(metadataFilePath);
-            const tempFilePath = path.join(tempDir, tempFileName);
-            fs.copyFileSync(metadataFilePath, tempFilePath);
-            // Compile TypeScript file
-            try {
-                await execAsync(`npx tsc --target es2020 --module commonjs --esModuleInterop --skipLibCheck --moduleResolution node --outDir ${tempDir} ${tempFilePath}`);
-            }
-            catch (tscError) {
-                console.warn(`TypeScript compilation failed for ${tempFileName}, trying with relaxed settings...`);
-                await execAsync(`npx tsc --target es2020 --module commonjs --esModuleInterop --skipLibCheck --moduleResolution node --noImplicitAny false --strict false --outDir ${tempDir} ${tempFilePath}`);
-            }
-            // Load the compiled JS file
-            const compiledFileName = tempFileName.replace(".ts", ".js");
-            const compiledPath = path.join(tempDir, compiledFileName);
-            if (fs.existsSync(compiledPath)) {
-                delete require.cache[require.resolve(compiledPath)];
-                const metadataModule = require(compiledPath);
-                // Support both 'metadata' and 'discovery' exports for backwards compatibility
-                rootMetadata =
-                    metadataModule.metadata || metadataModule.discovery || {};
-                console.log(`  Loaded metadata from ${tempFileName}`);
-            }
-            // Clean up temp directory
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        }
-        catch (error) {
-            console.warn(`  Failed to load ${path.basename(metadataFilePath)}:`, error);
-        }
-    }
-    else if (metadataJsFilePath) {
-        try {
-            // For JavaScript files, use require directly
-            delete require.cache[require.resolve(metadataJsFilePath)];
-            const metadataModule = require(metadataJsFilePath);
-            // Support both 'metadata' and 'discovery' exports for backwards compatibility
-            rootMetadata = metadataModule.metadata || metadataModule.discovery || {};
-            console.log(`  Loaded metadata from ${path.basename(metadataJsFilePath)}`);
-        }
-        catch (error) {
-            console.warn(`  Failed to load ${path.basename(metadataJsFilePath)}:`, error);
-        }
-    }
-    else {
-        console.log("  No metadata.ts found, using smart defaults");
-    }
-    // Read package.json for fallback values
-    const packageInfo = readPackageJson(projectRoot);
-    // Generate smart defaults from folder name and package.json
-    const folderName = path.basename(projectRoot);
-    const smartDefaults = {
-        name: rootMetadata.name || packageInfo.name || folderName,
-        displayName: rootMetadata.displayName ||
-            (packageInfo.name
-                ? packageInfo.name
-                    .split("-")
-                    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-                    .join(" ")
-                : folderName
-                    .split("-")
-                    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-                    .join(" ")),
-        version: rootMetadata.version || parseFloat(packageInfo.version || "1.0"),
-        description: rootMetadata.description ||
-            packageInfo.description ||
-            `OpenTool agent built from ${folderName}`,
-        author: rootMetadata.author || packageInfo.author || "Unknown",
-        repository: rootMetadata.repository ||
-            packageInfo.repository?.url ||
-            packageInfo.repository ||
-            "",
-        website: rootMetadata.website || packageInfo.homepage || "",
-        category: rootMetadata.category || rootMetadata.categories?.[0] || "utility",
-        termsOfService: rootMetadata.termsOfService || "Please review terms before use.",
-    };
-    // Convert tools to metadata format
-    const metadataTools = tools.map((tool) => {
-        // Use tool metadata name, fallback to filename without extension
-        const toolName = tool.metadata?.name || tool.filename.replace(/\.(ts|js)$/, "");
-        const toolDescription = tool.metadata?.description || `${toolName} tool`;
-        // Generate clean schema for metadata (same as MCP server)
-        let metadataInputSchema = { type: 'object' };
-        try {
-            metadataInputSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema, {
-                name: `${toolName}Schema`,
-                target: 'jsonSchema7',
-                $refStrategy: 'none'
-            });
-        }
-        catch (error) {
-            console.warn(`Failed to convert schema for metadata tool ${toolName}:`, error);
-            metadataInputSchema = { type: 'object' };
-        }
-        // Build metadata tool object
-        const metadataTool = {
-            name: toolName,
-            description: toolDescription,
-            inputSchema: metadataInputSchema,
-        };
-        // Add annotations if they exist
-        if (tool.metadata?.annotations) {
-            metadataTool.annotations = tool.metadata.annotations;
-        }
-        // Add payment config (tool-level overrides agent-level)
-        if (tool.metadata?.payment) {
-            metadataTool.payment = tool.metadata.payment;
-        }
-        else if (rootMetadata.payment) {
-            // Use agent-level payment as default
-            metadataTool.payment = rootMetadata.payment;
-        }
-        // Add discovery metadata if it exists
-        if (tool.metadata?.discovery) {
-            metadataTool.discovery = tool.metadata.discovery;
-        }
-        return metadataTool;
-    });
-    // Build complete metadata JSON with new structure
-    const metadataJson = {
-        // Core fields using smart defaults
-        name: smartDefaults.name,
-        displayName: smartDefaults.displayName,
-        version: smartDefaults.version,
-        description: smartDefaults.description,
-        author: smartDefaults.author,
-        repository: smartDefaults.repository,
-        website: smartDefaults.website,
-        category: smartDefaults.category,
-        termsOfService: smartDefaults.termsOfService,
-        // Tools array (always populated by build process)
-        tools: metadataTools,
-        // UI Enhancement fields
-        ...(rootMetadata.promptExamples && {
-            promptExamples: rootMetadata.promptExamples,
-        }),
-        ...(rootMetadata.iconPath && { iconPath: rootMetadata.iconPath }),
-        ...(rootMetadata.videoPath && { videoPath: rootMetadata.videoPath }),
-        // Agent-level payment defaults (create from pricing if exists)
-        ...(rootMetadata.pricing && {
-            payment: {
-                amountUSDC: rootMetadata.pricing.defaultAmount || 0.01,
-                description: rootMetadata.pricing.description || "",
-                x402: true,
-                openpondDirect: true,
-                acceptedMethods: ["ETH", "USDC"],
-                chainIds: [8453], // Base
-            },
-        }),
-        // Discovery section (only include if metadata has discovery fields)
-        ...((rootMetadata.keywords ||
-            rootMetadata.categories ||
-            rootMetadata.useCases ||
-            rootMetadata.capabilities ||
-            rootMetadata.requirements ||
-            rootMetadata.pricing ||
-            rootMetadata.compatibility ||
-            rootMetadata.discovery) && {
-            discovery: {
-                keywords: rootMetadata.keywords || [],
-                category: rootMetadata.categories?.[0] || smartDefaults.category,
-                useCases: rootMetadata.useCases || [],
-                capabilities: rootMetadata.capabilities || [],
-                requirements: rootMetadata.requirements || {},
-                pricing: rootMetadata.pricing || {},
-                compatibility: rootMetadata.compatibility || {},
-                ...(rootMetadata.discovery || {}), // Include any nested discovery fields too
-            },
-        }),
-    };
-    // Write metadata JSON to output directory
-    const outputMetadataPath = path.join(config.outputDir, "metadata.json");
-    fs.writeFileSync(outputMetadataPath, JSON.stringify(metadataJson, null, 2));
-    console.log(`  Generated metadata.json with ${metadataTools.length} tools`);
+function timestamp() {
+    return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+function escapeForJs(value) {
+    return value.replace(/'/g, "\\'");
 }
 //# sourceMappingURL=build.js.map