opentool 0.8.7 → 0.8.9

package/README.md

@@ -73,7 +73,7 @@ For private tools, say for internal trading apps:
 
 - GET-only (scheduled default profile)
 - POST-only (one-off, parameterized with Zod)
- - `profile.category` defaults to `tracker` if omitted; set to `strategy` for PnL/automation tools.
+- `profile.category` defaults to `tracker` if omitted; set to `strategy` or `orchestator` for PnL/automation tools.
 
 GET-only (scheduled default)
 

package/dist/cli/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { M as Metadata, I as InternalToolDefinition } from '../validate-3e5UvzfQ.js';
-export { G as GenerateMetadataOptions, a as GenerateMetadataResult, V as ValidateOptions, b as generateMetadata, g as generateMetadataCommand, l as loadAndValidateTools, v as validateCommand, c as validateFullCommand } from '../validate-3e5UvzfQ.js';
+import { M as Metadata, I as InternalToolDefinition } from '../validate-M_QdV0J3.js';
+export { G as GenerateMetadataOptions, a as GenerateMetadataResult, V as ValidateOptions, b as generateMetadata, g as generateMetadataCommand, l as loadAndValidateTools, v as validateCommand, c as validateFullCommand } from '../validate-M_QdV0J3.js';
 import 'zod';
 import '../x402/index.js';
 import 'viem';

package/dist/cli/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
+import * as path6 from 'path';
+import path6__default from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { program } from 'commander';
 import * as fs4 from 'fs';
 import { promises } from 'fs';
-import * as path5 from 'path';
-import path5__default from 'path';
 import { tmpdir } from 'os';
 import { build } from 'esbuild';
 import { z } from 'zod';
 import { createRequire } from 'module';
-import { fileURLToPath, pathToFileURL } from 'url';
 import { zodToJsonSchema } from '@alcyone-labs/zod-to-json-schema';
 import 'viem';
 import 'viem/accounts';
@@ -19,8 +19,10 @@ import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprot
 import * as http2 from 'http';
 import dotenv from 'dotenv';
 
+var getFilename = () => fileURLToPath(import.meta.url);
+var __filename = /* @__PURE__ */ getFilename();
 function resolveTsconfig(projectRoot) {
-  const candidate = path5.join(projectRoot, "tsconfig.json");
+  const candidate = path6.join(projectRoot, "tsconfig.json");
   if (fs4.existsSync(candidate)) {
     return candidate;
   }
@@ -31,7 +33,7 @@ async function transpileWithEsbuild(options) {
     throw new Error("No entry points provided for esbuild transpilation");
   }
   const projectRoot = options.projectRoot;
-  const tempBase = options.outDir ?? fs4.mkdtempSync(path5.join(tmpdir(), "opentool-"));
+  const tempBase = options.outDir ?? fs4.mkdtempSync(path6.join(tmpdir(), "opentool-"));
   if (!fs4.existsSync(tempBase)) {
     fs4.mkdirSync(tempBase, { recursive: true });
   }
@@ -75,7 +77,7 @@ async function transpileWithEsbuild(options) {
   }
   await build(buildOptions);
   if (options.format === "esm") {
-    const packageJsonPath = path5.join(tempBase, "package.json");
+    const packageJsonPath = path6.join(tempBase, "package.json");
     if (!fs4.existsSync(packageJsonPath)) {
       fs4.writeFileSync(packageJsonPath, JSON.stringify({ type: "module" }), "utf8");
     }
@@ -139,7 +141,7 @@ var DiscoveryMetadataSchema = z.object({
   compatibility: z.record(z.string(), z.any()).optional(),
   documentation: z.union([z.string(), z.array(z.string())]).optional()
 }).catchall(z.any());
-var ToolCategorySchema = z.enum(["strategy", "tracker"]);
+var ToolCategorySchema = z.enum(["strategy", "tracker", "orchestator"]);
 var ToolMetadataOverridesSchema = z.object({
   name: z.string().optional(),
   description: z.string().optional(),
@@ -208,10 +210,12 @@ var BuildMetadataSchema = z.object({
   animation_url: z.string().optional(),
   chains: z.array(z.union([z.string(), z.number()])).optional()
 }).strict();
-createRequire(import.meta.url);
+createRequire(
+  typeof __filename !== "undefined" ? __filename : import.meta.url
+);
 function resolveCompiledPath(outDir, originalFile, extension = ".js") {
-  const baseName = path5.basename(originalFile).replace(/\.[^.]+$/, "");
-  return path5.join(outDir, `${baseName}${extension}`);
+  const baseName = path6.basename(originalFile).replace(/\.[^.]+$/, "");
+  return path6.join(outDir, `${baseName}${extension}`);
 }
 async function importFresh(modulePath) {
   const fileUrl = pathToFileURL(modulePath).href;
@@ -223,13 +227,13 @@ async function importFresh(modulePath) {
 // src/cli/shared/metadata.ts
 var METADATA_ENTRY = "metadata.ts";
 async function loadMetadata(projectRoot) {
-  const absPath = path5.join(projectRoot, METADATA_ENTRY);
+  const absPath = path6.join(projectRoot, METADATA_ENTRY);
   if (!fs4.existsSync(absPath)) {
     throw new Error(
       `metadata.ts not found in ${projectRoot}. Create metadata.ts to describe your agent.`
     );
   }
-  const tempDir = path5.join(projectRoot, ".opentool-temp");
+  const tempDir = path6.join(projectRoot, ".opentool-temp");
   if (fs4.existsSync(tempDir)) {
     fs4.rmSync(tempDir, { recursive: true, force: true });
   }
@@ -270,7 +274,7 @@ function extractMetadataExport(moduleExports) {
   return moduleExports;
 }
 function readPackageJson(projectRoot) {
-  const packagePath = path5.join(projectRoot, "package.json");
+  const packagePath = path6.join(projectRoot, "package.json");
   if (!fs4.existsSync(packagePath)) {
     return {};
   }
@@ -286,7 +290,7 @@ async function buildMetadataArtifact(options) {
   const packageInfo = readPackageJson(projectRoot);
   const { metadata: authored, sourcePath } = await loadMetadata(projectRoot);
   const defaultsApplied = [];
-  const folderName = path5.basename(projectRoot);
+  const folderName = path6.basename(projectRoot);
   const name = resolveField(
     "name",
     authored.name,
@@ -999,11 +1003,11 @@ var SUPPORTED_EXTENSIONS = [
 async function validateCommand(options) {
   console.log("\u{1F50D} Validating OpenTool metadata...");
   try {
-    const toolsDir = path5.resolve(options.input);
+    const toolsDir = path6.resolve(options.input);
     if (!fs4.existsSync(toolsDir)) {
       throw new Error(`Tools directory not found: ${toolsDir}`);
     }
-    const projectRoot = path5.dirname(toolsDir);
+    const projectRoot = path6.dirname(toolsDir);
     const tools = await loadAndValidateTools(toolsDir, { projectRoot });
     if (tools.length === 0) {
       throw new Error("No valid tools found - metadata validation aborted");
@@ -1022,11 +1026,11 @@ async function validateCommand(options) {
 async function validateFullCommand(options) {
   console.log("\u{1F50D} Running full OpenTool validation...\n");
   try {
-    const toolsDir = path5.resolve(options.input);
+    const toolsDir = path6.resolve(options.input);
     if (!fs4.existsSync(toolsDir)) {
       throw new Error(`Tools directory not found: ${toolsDir}`);
     }
-    const projectRoot = path5.dirname(toolsDir);
+    const projectRoot = path6.dirname(toolsDir);
     const tools = await loadAndValidateTools(toolsDir, { projectRoot });
     if (tools.length === 0) {
       throw new Error("No tools discovered in the target directory");
@@ -1054,12 +1058,12 @@ async function validateFullCommand(options) {
   }
 }
 async function loadAndValidateTools(toolsDir, options = {}) {
-  const files = fs4.readdirSync(toolsDir).filter((file) => SUPPORTED_EXTENSIONS.includes(path5.extname(file)));
+  const files = fs4.readdirSync(toolsDir).filter((file) => SUPPORTED_EXTENSIONS.includes(path6.extname(file)));
   if (files.length === 0) {
     return [];
   }
-  const projectRoot = options.projectRoot ?? path5.dirname(toolsDir);
-  const tempDir = path5.join(toolsDir, ".opentool-temp");
+  const projectRoot = options.projectRoot ?? path6.dirname(toolsDir);
+  const tempDir = path6.join(toolsDir, ".opentool-temp");
   if (fs4.existsSync(tempDir)) {
     fs4.rmSync(tempDir, { recursive: true, force: true });
   }
@@ -1069,7 +1073,7 @@ async function loadAndValidateTools(toolsDir, options = {}) {
       throw new Error(`Tool filename must be kebab-case: ${f}`);
     }
   }
-  const entryPoints = files.map((file) => path5.join(toolsDir, file));
+  const entryPoints = files.map((file) => path6.join(toolsDir, file));
   const { outDir, cleanup } = await transpileWithEsbuild({
     entryPoints,
     projectRoot,
@@ -1110,7 +1114,7 @@ async function loadAndValidateTools(toolsDir, options = {}) {
       const schedule = toolModule?.profile?.schedule;
       const profileNotifyEmail = typeof toolModule?.profile?.notifyEmail === "boolean" ? toolModule.profile.notifyEmail : void 0;
       const profileCategoryRaw = typeof toolModule?.profile?.category === "string" ? toolModule.profile.category : void 0;
-      const allowedProfileCategories = /* @__PURE__ */ new Set(["strategy", "tracker"]);
+      const allowedProfileCategories = /* @__PURE__ */ new Set(["strategy", "tracker", "orchestator"]);
       if (profileCategoryRaw && !allowedProfileCategories.has(profileCategoryRaw)) {
         throw new Error(
           `${file}: profile.category must be one of ${Array.from(allowedProfileCategories).join(", ")}`
@@ -1181,7 +1185,7 @@ async function loadAndValidateTools(toolsDir, options = {}) {
         httpHandlers,
         mcpConfig: normalizeMcpConfig(toolModule.mcp, file),
         filename: toBaseName(file),
-        sourcePath: path5.join(toolsDir, file),
+        sourcePath: path6.join(toolsDir, file),
         handler: async (params) => adapter(params),
         payment: paymentExport ?? null,
         schedule: normalizedSchedule,
@@ -1386,12 +1390,12 @@ async function buildCommand(options) {
   }
 }
 async function buildProject(options) {
-  const toolsDir = path5.resolve(options.input);
+  const toolsDir = path6.resolve(options.input);
   if (!fs4.existsSync(toolsDir)) {
     throw new Error(`Tools directory not found: ${toolsDir}`);
   }
-  const projectRoot = path5.dirname(toolsDir);
-  const outputDir = path5.resolve(options.output);
+  const projectRoot = path6.dirname(toolsDir);
+  const outputDir = path6.resolve(options.output);
   fs4.mkdirSync(outputDir, { recursive: true });
   const serverName = options.name ?? "opentool-server";
   const serverVersion = options.version ?? "1.0.0";
@@ -1403,7 +1407,7 @@ async function buildProject(options) {
     projectRoot,
     tools
   });
-  const metadataPath = path5.join(outputDir, "metadata.json");
+  const metadataPath = path6.join(outputDir, "metadata.json");
   fs4.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
   const compiledTools = await emitTools(tools, {
     projectRoot,
@@ -1430,7 +1434,7 @@ async function buildProject(options) {
       serverVersion,
       compiledTools});
   } else {
-    const serverPath = path5.join(outputDir, "mcp-server.js");
+    const serverPath = path6.join(outputDir, "mcp-server.js");
     if (fs4.existsSync(serverPath)) {
       fs4.rmSync(serverPath);
     }
@@ -1446,7 +1450,7 @@ async function buildProject(options) {
   };
 }
 async function emitTools(tools, config) {
-  const toolsOutDir = path5.join(config.outputDir, "tools");
+  const toolsOutDir = path6.join(config.outputDir, "tools");
   if (fs4.existsSync(toolsOutDir)) {
     fs4.rmSync(toolsOutDir, { recursive: true, force: true });
   }
@@ -1468,9 +1472,9 @@ async function emitTools(tools, config) {
     if (!tool.sourcePath) {
       throw new Error(`Missing sourcePath for tool ${tool.filename}`);
     }
-    const base = path5.basename(tool.sourcePath).replace(/\.[^.]+$/, "");
-    const modulePath = path5.join("tools", `${base}.js`);
-    if (!fs4.existsSync(path5.join(config.outputDir, modulePath))) {
+    const base = path6.basename(tool.sourcePath).replace(/\.[^.]+$/, "");
+    const modulePath = path6.join("tools", `${base}.js`);
+    if (!fs4.existsSync(path6.join(config.outputDir, modulePath))) {
       throw new Error(`Expected compiled output missing: ${modulePath}`);
     }
     const defaultMcpMethod = tool.mcpConfig?.defaultMethod;
@@ -1487,7 +1491,7 @@ async function emitTools(tools, config) {
   return compiled;
 }
 async function emitSharedModules(config) {
-  const srcDir = path5.join(config.projectRoot, "src");
+  const srcDir = path6.join(config.projectRoot, "src");
   if (!fs4.existsSync(srcDir)) {
     return null;
   }
@@ -1495,7 +1499,7 @@ async function emitSharedModules(config) {
   if (sharedFiles.length === 0) {
     return null;
   }
-  const sharedOutDir = path5.join(config.outputDir, "src");
+  const sharedOutDir = path6.join(config.outputDir, "src");
   await transpileWithEsbuild({
     entryPoints: sharedFiles,
     projectRoot: config.projectRoot,
@@ -1513,7 +1517,7 @@ function collectSourceFiles(dir) {
   const ignoreDirs = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".opentool-temp"]);
   const entries = fs4.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path5.join(dir, entry.name);
+    const fullPath = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (ignoreDirs.has(entry.name)) {
         continue;
@@ -1521,7 +1525,7 @@ function collectSourceFiles(dir) {
       results.push(...collectSourceFiles(fullPath));
       continue;
     }
-    const ext = path5.extname(entry.name);
+    const ext = path6.extname(entry.name);
     if (supported.has(ext) && !entry.name.endsWith(".d.ts")) {
       results.push(fullPath);
     }
@@ -1623,14 +1627,14 @@ module.exports = { server };
 }
 async function writeMcpServer(options) {
   const serverCode = renderMcpServer(options);
-  const serverPath = path5.join(options.outputDir, "mcp-server.js");
+  const serverPath = path6.join(options.outputDir, "mcp-server.js");
   fs4.writeFileSync(serverPath, serverCode);
   fs4.chmodSync(serverPath, 493);
 }
 function writeCronManifest(options) {
   const scheduledTools = options.tools.filter((tool) => tool.schedule?.expression);
-  const manifestDir = path5.join(options.outputDir, ".well-known", "opentool");
-  const manifestPath = path5.join(manifestDir, "cron.json");
+  const manifestDir = path6.join(options.outputDir, ".well-known", "opentool");
+  const manifestPath = path6.join(manifestDir, "cron.json");
   if (scheduledTools.length === 0) {
     if (fs4.existsSync(manifestPath)) {
       fs4.rmSync(manifestPath);
@@ -1680,7 +1684,7 @@ function writeCronManifest(options) {
 function logBuildSummary(artifacts, options) {
   const end = timestamp();
   console.log(`[${end}] Build completed successfully!`);
-  console.log(`Output directory: ${path5.resolve(options.output)}`);
+  console.log(`Output directory: ${path6.resolve(options.output)}`);
   console.log("Generated files:");
   const hasMcp = artifacts.compiledTools.some((tool) => tool.mcpEnabled);
   if (hasMcp) {
@@ -1722,7 +1726,7 @@ function logBuildSummary(artifacts, options) {
   }
 }
 async function buildWorkflowsIfPresent(options) {
-  const workflowsDir = options.workflowsDir ?? path5.join(options.projectRoot, "workflows");
+  const workflowsDir = options.workflowsDir ?? path6.join(options.projectRoot, "workflows");
   if (!fs4.existsSync(workflowsDir)) {
     return null;
   }
@@ -1769,11 +1773,11 @@ Reason: ${error.message}` : "";
         "Creating OpenTool workflow steps bundle at",
         this.config.stepsBundlePath
       );
-      const stepsBundlePath2 = path5.resolve(
+      const stepsBundlePath2 = path6.resolve(
         this.config.workingDir,
         this.config.stepsBundlePath
       );
-      await fs4.promises.mkdir(path5.dirname(stepsBundlePath2), { recursive: true });
+      await fs4.promises.mkdir(path6.dirname(stepsBundlePath2), { recursive: true });
       await this.createStepsBundle({
         outfile: stepsBundlePath2,
         ...options2
@@ -1784,11 +1788,11 @@ Reason: ${error.message}` : "";
         "Creating OpenTool workflow bundle at",
         this.config.workflowsBundlePath
       );
-      const workflowBundlePath = path5.resolve(
+      const workflowBundlePath = path6.resolve(
         this.config.workingDir,
         this.config.workflowsBundlePath
       );
-      await fs4.promises.mkdir(path5.dirname(workflowBundlePath), {
+      await fs4.promises.mkdir(path6.dirname(workflowBundlePath), {
         recursive: true
       });
       await this.createWorkflowsBundle({
@@ -1802,11 +1806,11 @@ Reason: ${error.message}` : "";
         "Creating OpenTool workflow webhook bundle at",
         this.config.webhookBundlePath
       );
-      const webhookBundlePath2 = path5.resolve(
+      const webhookBundlePath2 = path6.resolve(
         this.config.workingDir,
         this.config.webhookBundlePath
       );
-      await fs4.promises.mkdir(path5.dirname(webhookBundlePath2), {
+      await fs4.promises.mkdir(path6.dirname(webhookBundlePath2), {
         recursive: true
       });
       await this.createWebhookBundle({ outfile: webhookBundlePath2 });
@@ -1815,11 +1819,11 @@ Reason: ${error.message}` : "";
       if (!this.config?.clientBundlePath) {
         return;
       }
-      const clientBundlePath2 = path5.resolve(
+      const clientBundlePath2 = path6.resolve(
         this.config.workingDir,
         this.config.clientBundlePath
       );
-      await fs4.promises.mkdir(path5.dirname(clientBundlePath2), {
+      await fs4.promises.mkdir(path6.dirname(clientBundlePath2), {
         recursive: true
       });
       await this.createWorkflowsBundle({
@@ -1828,17 +1832,17 @@ Reason: ${error.message}` : "";
       });
     }
   }
-  const relativeSourceDir = path5.relative(options.projectRoot, workflowsDir) || ".";
-  const outputBase = path5.join(
+  const relativeSourceDir = path6.relative(options.projectRoot, workflowsDir) || ".";
+  const outputBase = path6.join(
     options.outputDir,
     ".well-known",
     "workflow",
     "v1"
   );
-  const stepsBundlePath = path5.join(outputBase, "step.js");
-  const workflowsBundlePath = path5.join(outputBase, "flow.js");
-  const webhookBundlePath = path5.join(outputBase, "webhook.js");
-  const manifestPath = path5.join(outputBase, "manifest.json");
+  const stepsBundlePath = path6.join(outputBase, "step.js");
+  const workflowsBundlePath = path6.join(outputBase, "flow.js");
+  const webhookBundlePath = path6.join(outputBase, "webhook.js");
+  const manifestPath = path6.join(outputBase, "manifest.json");
   const builder = new OpenToolWorkflowBuilder({
     workingDir: options.projectRoot,
     dirs: [relativeSourceDir],
@@ -1874,13 +1878,13 @@ function hasWorkflowSourceFiles(directory) {
   const entries = fs4.readdirSync(directory, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      if (hasWorkflowSourceFiles(path5.join(directory, entry.name))) {
+      if (hasWorkflowSourceFiles(path6.join(directory, entry.name))) {
         return true;
       }
       continue;
     }
     if (entry.isFile()) {
-      const extension = path5.extname(entry.name).toLowerCase();
+      const extension = path6.extname(entry.name).toLowerCase();
       if (WORKFLOW_SOURCE_EXTENSIONS.has(extension)) {
         return true;
       }
@@ -1904,9 +1908,9 @@ function timestamp() {
 function escapeForJs(value) {
   return value.replace(/'/g, "\\'");
 }
-var __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
+var __dirname2 = path6.dirname(fileURLToPath(import.meta.url));
 var packageJson = JSON.parse(
-  fs4.readFileSync(path5.resolve(__dirname2, "../../package.json"), "utf-8")
+  fs4.readFileSync(path6.resolve(__dirname2, "../../package.json"), "utf-8")
 );
 var cyan = "\x1B[36m";
 var bold = "\x1B[1m";
@@ -1919,11 +1923,11 @@ async function devCommand(options) {
   const log = enableStdio ? (_message) => {
   } : (message) => console.log(message);
   try {
-    const toolsDir = path5.resolve(options.input);
+    const toolsDir = path6.resolve(options.input);
     if (!fs4.existsSync(toolsDir)) {
       throw new Error(`Tools directory not found: ${toolsDir}`);
     }
-    const projectRoot = path5.dirname(toolsDir);
+    const projectRoot = path6.dirname(toolsDir);
     loadEnvFiles(projectRoot);
     let toolDefinitions = await loadToolDefinitions(toolsDir, projectRoot);
     if (toolDefinitions.length === 0) {
@@ -1933,7 +1937,7 @@ async function devCommand(options) {
     const stdioController = enableStdio ? await startMcpServer(() => toolDefinitions) : null;
     if (watch2) {
       const reloadableExtensions = /\.(ts|js|mjs|cjs|tsx|jsx)$/i;
-      const tempDir = path5.join(toolsDir, ".opentool-temp");
+      const tempDir = path6.join(toolsDir, ".opentool-temp");
       const watchTargets = /* @__PURE__ */ new Set([toolsDir]);
       if (projectRoot !== toolsDir) {
         watchTargets.add(projectRoot);
@@ -1964,11 +1968,11 @@ Detected change in ${changedPath ?? "tools directory"}, reloading...${reset}`
           if (filename && !reloadableExtensions.test(filename)) {
             return;
           }
-          const fullPath = filename ? path5.join(target, filename) : void 0;
+          const fullPath = filename ? path6.join(target, filename) : void 0;
           if (fullPath && fullPath.startsWith(tempDir)) {
             return;
           }
-          const displayPath = fullPath ? path5.relative(projectRoot, fullPath) || path5.basename(fullPath) : path5.relative(projectRoot, target) || path5.basename(target);
+          const displayPath = fullPath ? path6.relative(projectRoot, fullPath) || path6.basename(fullPath) : path6.relative(projectRoot, target) || path6.basename(target);
           await scheduleReload(displayPath);
         });
       }
@@ -2201,7 +2205,7 @@ function routeName(tool) {
 function loadEnvFiles(projectRoot) {
   const envFiles = [".env.local", ".env"];
   for (const file of envFiles) {
-    const candidate = path5.join(projectRoot, file);
+    const candidate = path6.join(projectRoot, file);
     if (fs4.existsSync(candidate)) {
       dotenv.config({ path: candidate, override: false });
     }
@@ -2272,17 +2276,17 @@ async function generateMetadataCommand(options) {
   }
 }
 async function generateMetadata(options) {
-  const toolsDir = path5.resolve(options.input);
+  const toolsDir = path6.resolve(options.input);
   if (!fs4.existsSync(toolsDir)) {
     throw new Error(`Tools directory not found: ${toolsDir}`);
   }
-  const projectRoot = path5.dirname(toolsDir);
+  const projectRoot = path6.dirname(toolsDir);
   const tools = await loadAndValidateTools(toolsDir, { projectRoot });
   const { metadata, defaultsApplied } = await buildMetadataArtifact({
     projectRoot,
     tools
   });
-  const outputPath = options.output ? path5.resolve(options.output) : path5.join(projectRoot, "metadata.json");
+  const outputPath = options.output ? path6.resolve(options.output) : path6.join(projectRoot, "metadata.json");
   fs4.writeFileSync(outputPath, JSON.stringify(metadata, null, 2));
   return {
     metadata,
@@ -2295,8 +2299,8 @@ function timestamp2() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
 }
 function resolveTemplateDir() {
-  const here = path5__default.dirname(fileURLToPath(import.meta.url));
-  return path5__default.resolve(here, "../../templates/base");
+  const here = path6__default.dirname(fileURLToPath(import.meta.url));
+  return path6__default.resolve(here, "../../templates/base");
 }
 async function directoryIsEmpty(targetDir) {
   try {
@@ -2313,8 +2317,8 @@ async function copyDir(src, dest) {
   await promises.mkdir(dest, { recursive: true });
   const entries = await promises.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path5__default.join(src, entry.name);
-    const destPath = path5__default.join(dest, entry.name);
+    const srcPath = path6__default.join(src, entry.name);
+    const destPath = path6__default.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDir(srcPath, destPath);
     } else if (entry.isFile()) {
@@ -2329,7 +2333,7 @@ function toDisplayName(value) {
   return value.trim().replace(/[-_]+/g, " ").replace(/\b\w/g, (ch) => ch.toUpperCase()) || "OpenTool Project";
 }
 async function updatePackageJson(targetDir, name, description) {
-  const filePath = path5__default.join(targetDir, "package.json");
+  const filePath = path6__default.join(targetDir, "package.json");
   const raw = await promises.readFile(filePath, "utf-8");
   const pkg = JSON.parse(raw);
   pkg.name = toPackageName(name);
@@ -2340,7 +2344,7 @@ async function updatePackageJson(targetDir, name, description) {
 `, "utf-8");
 }
 async function updateMetadata(targetDir, name, description) {
-  const filePath = path5__default.join(targetDir, "metadata.ts");
+  const filePath = path6__default.join(targetDir, "metadata.ts");
   const raw = await promises.readFile(filePath, "utf-8");
   const displayName = toDisplayName(name);
   const resolvedDescription = description || "OpenTool project";
@@ -2348,7 +2352,7 @@ async function updateMetadata(targetDir, name, description) {
   await promises.writeFile(filePath, updated, "utf-8");
 }
 async function initCommand(options) {
-  const targetDir = path5__default.resolve(process.cwd(), options.dir || ".");
+  const targetDir = path6__default.resolve(process.cwd(), options.dir || ".");
   const templateDir = resolveTemplateDir();
   const empty = await directoryIsEmpty(targetDir);
   if (!empty && !options.force) {
@@ -2357,7 +2361,7 @@ async function initCommand(options) {
     );
   }
   await copyDir(templateDir, targetDir);
-  const projectName = options.name || path5__default.basename(targetDir);
+  const projectName = options.name || path6__default.basename(targetDir);
   const description = options.description;
   await updatePackageJson(targetDir, projectName, description);
   await updateMetadata(targetDir, projectName, description);