veryfront 0.0.35 → 0.0.37

package/dist/ai/index.js

@@ -1675,14 +1675,15 @@ var LRU_DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.35",
+  version: "0.0.37",
   exclude: [
     "npm/",
     "dist/",
     "coverage/",
     "scripts/",
     "examples/",
-    "tests/"
+    "tests/",
+    "src/cli/templates/files/"
   ],
   exports: {
     ".": "./src/index.ts",
@@ -1692,6 +1693,7 @@ var deno_default = {
     "./components": "./src/react/components/index.ts",
     "./data": "./src/data/index.ts",
     "./config": "./src/core/config/index.ts",
+    "./platform": "./src/platform/index.ts",
     "./ai": "./src/ai/index.ts",
     "./ai/client": "./src/ai/client.ts",
     "./ai/react": "./src/ai/react/index.ts",
@@ -4048,7 +4050,362 @@ function createMockAdapter() {
   };
 }
 
+// src/platform/compat/fs.ts
+var NodeFileSystem = class {
+  constructor() {
+    this.fs = null;
+    this.os = null;
+    this.path = null;
+    this.initialized = false;
+  }
+  async ensureInitialized() {
+    if (this.initialized)
+      return;
+    if (!isNode) {
+      throw toError(createError({
+        type: "not_supported",
+        message: "Node.js fs modules not available",
+        feature: "Node.js"
+      }));
+    }
+    const [fsModule, osModule, pathModule] = await Promise.all([
+      import("node:fs/promises"),
+      import("node:os"),
+      import("node:path")
+    ]);
+    this.fs = fsModule;
+    this.os = osModule;
+    this.path = pathModule;
+    this.initialized = true;
+  }
+  async readTextFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path, { encoding: "utf8" });
+  }
+  async readFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data, { encoding: "utf8" });
+  }
+  async writeFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data);
+  }
+  async exists(path) {
+    await this.ensureInitialized();
+    try {
+      await this.fs.access(path);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    await this.ensureInitialized();
+    const stat = await this.fs.stat(path);
+    return {
+      isFile: stat.isFile(),
+      isDirectory: stat.isDirectory(),
+      isSymlink: stat.isSymbolicLink(),
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await this.ensureInitialized();
+    await this.fs.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    await this.ensureInitialized();
+    const entries = await this.fs.readdir(path, { withFileTypes: true });
+    for (const entry of entries) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile(),
+        isDirectory: entry.isDirectory()
+      };
+    }
+  }
+  async remove(path, options) {
+    await this.ensureInitialized();
+    await this.fs.rm(path, {
+      recursive: options?.recursive ?? false,
+      force: options?.recursive ?? false
+    });
+  }
+  async makeTempDir(options) {
+    await this.ensureInitialized();
+    const tempDir = this.path.join(
+      this.os.tmpdir(),
+      `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`
+    );
+    await this.fs.mkdir(tempDir, { recursive: true });
+    return tempDir;
+  }
+};
+var DenoFileSystem = class {
+  async readTextFile(path) {
+    return await Deno.readTextFile(path);
+  }
+  async readFile(path) {
+    return await Deno.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await Deno.writeTextFile(path, data);
+  }
+  async writeFile(path, data) {
+    await Deno.writeFile(path, data);
+  }
+  async exists(path) {
+    try {
+      await Deno.stat(path);
+      return true;
+    } catch (error) {
+      if (error instanceof Deno.errors.NotFound) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    const stat = await Deno.stat(path);
+    return {
+      isFile: stat.isFile,
+      isDirectory: stat.isDirectory,
+      isSymlink: stat.isSymlink,
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await Deno.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    for await (const entry of Deno.readDir(path)) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile,
+        isDirectory: entry.isDirectory
+      };
+    }
+  }
+  async remove(path, options) {
+    await Deno.remove(path, { recursive: options?.recursive ?? false });
+  }
+  async makeTempDir(options) {
+    return await Deno.makeTempDir({ prefix: options?.prefix });
+  }
+};
+function createFileSystem() {
+  if (isDeno) {
+    return new DenoFileSystem();
+  } else {
+    return new NodeFileSystem();
+  }
+}
+
+// src/platform/compat/path-helper.ts
+import nodePath from "node:path";
+var pathMod = null;
+if (typeof Deno === "undefined") {
+  pathMod = nodePath;
+} else {
+  import("node:path").then((mod) => {
+    pathMod = mod;
+  });
+}
+function getPathMod() {
+  if (pathMod)
+    return pathMod;
+  return nodePath;
+}
+var dirname = (path) => getPathMod().dirname(path);
+var join2 = (...paths) => getPathMod().join(...paths);
+var sep = nodePath.sep;
+
 // src/ai/utils/discovery.ts
+var transpileCache = /* @__PURE__ */ new Map();
+async function importModule(file, context) {
+  const cacheKey = file;
+  if (transpileCache.has(cacheKey)) {
+    return transpileCache.get(cacheKey);
+  }
+  const fs2 = createFileSystem();
+  const filePath = file.replace("file://", "");
+  let source;
+  try {
+    source = await fs2.readTextFile(filePath);
+  } catch (error) {
+    throw new Error(`Failed to read file ${filePath}: ${error}`);
+  }
+  const isTsx = filePath.endsWith(".tsx");
+  const isJsx = filePath.endsWith(".jsx");
+  const loader = isTsx ? "tsx" : isJsx ? "jsx" : filePath.endsWith(".ts") ? "ts" : "js";
+  const { build } = await import("esbuild");
+  const result = await build({
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    resolveExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"],
+    external: [
+      "ai",
+      "ai/*",
+      "@ai-sdk/*",
+      "zod",
+      "node:*",
+      "veryfront",
+      "veryfront/*",
+      "@opentelemetry/*",
+      "path"
+    ],
+    stdin: {
+      contents: source,
+      loader,
+      resolveDir: dirname(filePath),
+      sourcefile: filePath
+    }
+  });
+  if (result.errors && result.errors.length > 0) {
+    const first = result.errors[0]?.text || "unknown error";
+    throw new Error(`Failed to transpile ${filePath}: ${first}`);
+  }
+  const js = result.outputFiles?.[0]?.text ?? "export {}";
+  const tempDir = await fs2.makeTempDir({ prefix: "vf-discovery-" });
+  const tempFile = join2(tempDir, "module.mjs");
+  let transformedCode;
+  if (isDeno) {
+    transformedCode = rewriteForDeno(js);
+  } else {
+    transformedCode = await rewriteDiscoveryImports(js, context.baseDir || ".", fs2);
+  }
+  await fs2.writeTextFile(tempFile, transformedCode);
+  try {
+    const module = await import(`file://${tempFile}?v=${Date.now()}`);
+    transpileCache.set(cacheKey, module);
+    return module;
+  } finally {
+    await fs2.remove(tempDir, { recursive: true });
+  }
+}
+function rewriteForDeno(code) {
+  let transformed = code;
+  const npmPackages = [
+    { pattern: /from\s+["']ai["']/g, replacement: 'from "npm:ai"' },
+    { pattern: /from\s+["']ai\/([^"']+)["']/g, replacement: 'from "npm:ai/$1"' },
+    { pattern: /from\s+["']@ai-sdk\/([^"']+)["']/g, replacement: 'from "npm:@ai-sdk/$1"' },
+    { pattern: /from\s+["']zod["']/g, replacement: 'from "npm:zod"' },
+    { pattern: /import\s*\(\s*["']ai["']\s*\)/g, replacement: 'import("npm:ai")' },
+    { pattern: /import\s*\(\s*["']zod["']\s*\)/g, replacement: 'import("npm:zod")' }
+  ];
+  for (const { pattern, replacement } of npmPackages) {
+    transformed = transformed.replace(pattern, replacement);
+  }
+  return transformed;
+}
+async function rewriteDiscoveryImports(code, projectDir, fs2) {
+  let transformed = code;
+  try {
+    const { pathToFileURL } = await import("node:url");
+    const resolvePackageToFileUrl = async (packageName) => {
+      const packagePath = join2(projectDir, "node_modules", packageName);
+      const packageJsonPath = join2(packagePath, "package.json");
+      try {
+        const pkgJson = JSON.parse(await fs2.readTextFile(packageJsonPath));
+        let entryPoint;
+        if (pkgJson.exports) {
+          const dotExport = pkgJson.exports["."];
+          if (typeof dotExport === "string") {
+            entryPoint = dotExport;
+          } else if (dotExport?.import) {
+            entryPoint = dotExport.import;
+          } else if (dotExport?.default) {
+            entryPoint = dotExport.default;
+          }
+        }
+        if (!entryPoint) {
+          entryPoint = pkgJson.module || pkgJson.main || "index.js";
+        }
+        if (!entryPoint) {
+          return null;
+        }
+        const resolvedPath = join2(packagePath, entryPoint);
+        return pathToFileURL(resolvedPath).href;
+      } catch {
+        return null;
+      }
+    };
+    const externalPackagesToResolve = [
+      "zod",
+      "ai",
+      "@ai-sdk/anthropic",
+      "@ai-sdk/openai",
+      "@ai-sdk/google",
+      "@ai-sdk/mistral",
+      "@ai-sdk/provider",
+      "@ai-sdk/provider-utils"
+    ];
+    for (const pkg of externalPackagesToResolve) {
+      const escapedPkg = pkg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const staticImportRegex = new RegExp(`from\\s+["']${escapedPkg}["']`, "g");
+      if (staticImportRegex.test(transformed)) {
+        const resolvedUrl = await resolvePackageToFileUrl(pkg);
+        if (resolvedUrl) {
+          transformed = transformed.replace(staticImportRegex, `from "${resolvedUrl}"`);
+        }
+      }
+      const dynamicImportRegex = new RegExp(`import\\s*\\(\\s*["']${escapedPkg}["']\\s*\\)`, "g");
+      if (dynamicImportRegex.test(transformed)) {
+        const resolvedUrl = await resolvePackageToFileUrl(pkg);
+        if (resolvedUrl) {
+          transformed = transformed.replace(dynamicImportRegex, `import("${resolvedUrl}")`);
+        }
+      }
+    }
+    const vfPackagePath = join2(projectDir, "node_modules", "veryfront");
+    const vfPackageJsonPath = join2(vfPackagePath, "package.json");
+    let exportsMap = {};
+    try {
+      const pkgJson = JSON.parse(await fs2.readTextFile(vfPackageJsonPath));
+      exportsMap = pkgJson.exports || {};
+    } catch {
+    }
+    transformed = transformed.replace(
+      /from\s+["'](veryfront\/[^"']+)["']/g,
+      (_match, fullSpecifier) => {
+        const subpath = "./" + fullSpecifier.replace("veryfront/", "");
+        const exportEntry = exportsMap[subpath];
+        if (exportEntry?.import) {
+          const resolvedPath = join2(vfPackagePath, exportEntry.import);
+          return `from "${pathToFileURL(resolvedPath).href}"`;
+        }
+        return _match;
+      }
+    );
+    transformed = transformed.replace(
+      /from\s+["']veryfront["']/g,
+      () => {
+        const exportEntry = exportsMap["."];
+        if (exportEntry?.import) {
+          const resolvedPath = join2(vfPackagePath, exportEntry.import);
+          return `from "${pathToFileURL(resolvedPath).href}"`;
+        }
+        return 'from "veryfront"';
+      }
+    );
+  } catch {
+  }
+  return transformed;
+}
 async function discoverAll(config) {
   let aiDir = config.aiDir;
   const baseDir = config.baseDir;
@@ -4063,7 +4420,8 @@ async function discoverAll(config) {
   }
   const context = {
     platform: detectPlatform(),
-    fsAdapter: config.fsAdapter
+    fsAdapter: config.fsAdapter,
+    baseDir
   };
   const result = {
     tools: /* @__PURE__ */ new Map(),
@@ -4097,7 +4455,7 @@ async function discoverTools(dir, result, context, verbose) {
   }
   for (const file of files) {
     try {
-      const module = await import(file);
+      const module = await importModule(file, context);
       const tool2 = module.default;
       if (!tool2 || typeof tool2.execute !== "function") {
         if (verbose) {
@@ -4130,7 +4488,7 @@ async function discoverAgents(dir, result, context, verbose) {
   }
   for (const file of files) {
     try {
-      const module = await import(file);
+      const module = await importModule(file, context);
       const agent2 = module.default;
       if (!agent2 || typeof agent2.generate !== "function") {
         if (verbose) {
@@ -4163,7 +4521,7 @@ async function discoverResources(dir, result, context, verbose) {
   }
   for (const file of files) {
     try {
-      const module = await import(file);
+      const module = await importModule(file, context);
       const resource2 = module.default;
       if (!resource2 || typeof resource2.load !== "function") {
         if (verbose) {
@@ -4197,7 +4555,7 @@ async function discoverPrompts(dir, result, context, verbose) {
   }
   for (const file of files) {
     try {
-      const module = await import(file);
+      const module = await importModule(file, context);
       const promptInstance = module.default;
       if (!promptInstance || typeof promptInstance.getContent !== "function") {
         if (verbose) {
@@ -4350,166 +4708,6 @@ function toAISDKTools(tools) {
   return aiTools;
 }
 
-// src/platform/compat/fs.ts
-var NodeFileSystem = class {
-  constructor() {
-    this.fs = null;
-    this.os = null;
-    this.path = null;
-    this.initialized = false;
-  }
-  async ensureInitialized() {
-    if (this.initialized)
-      return;
-    if (!isNode) {
-      throw toError(createError({
-        type: "not_supported",
-        message: "Node.js fs modules not available",
-        feature: "Node.js"
-      }));
-    }
-    const [fsModule, osModule, pathModule] = await Promise.all([
-      import("node:fs/promises"),
-      import("node:os"),
-      import("node:path")
-    ]);
-    this.fs = fsModule;
-    this.os = osModule;
-    this.path = pathModule;
-    this.initialized = true;
-  }
-  async readTextFile(path) {
-    await this.ensureInitialized();
-    return await this.fs.readFile(path, { encoding: "utf8" });
-  }
-  async readFile(path) {
-    await this.ensureInitialized();
-    return await this.fs.readFile(path);
-  }
-  async writeTextFile(path, data) {
-    await this.ensureInitialized();
-    await this.fs.writeFile(path, data, { encoding: "utf8" });
-  }
-  async writeFile(path, data) {
-    await this.ensureInitialized();
-    await this.fs.writeFile(path, data);
-  }
-  async exists(path) {
-    await this.ensureInitialized();
-    try {
-      await this.fs.access(path);
-      return true;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    }
-  }
-  async stat(path) {
-    await this.ensureInitialized();
-    const stat = await this.fs.stat(path);
-    return {
-      isFile: stat.isFile(),
-      isDirectory: stat.isDirectory(),
-      isSymlink: stat.isSymbolicLink(),
-      size: stat.size,
-      mtime: stat.mtime
-    };
-  }
-  async mkdir(path, options) {
-    await this.ensureInitialized();
-    await this.fs.mkdir(path, { recursive: options?.recursive ?? false });
-  }
-  async *readDir(path) {
-    await this.ensureInitialized();
-    const entries = await this.fs.readdir(path, { withFileTypes: true });
-    for (const entry of entries) {
-      yield {
-        name: entry.name,
-        isFile: entry.isFile(),
-        isDirectory: entry.isDirectory()
-      };
-    }
-  }
-  async remove(path, options) {
-    await this.ensureInitialized();
-    await this.fs.rm(path, {
-      recursive: options?.recursive ?? false,
-      force: options?.recursive ?? false
-    });
-  }
-  async makeTempDir(options) {
-    await this.ensureInitialized();
-    const tempDir = this.path.join(
-      this.os.tmpdir(),
-      `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`
-    );
-    await this.fs.mkdir(tempDir, { recursive: true });
-    return tempDir;
-  }
-};
-var DenoFileSystem = class {
-  async readTextFile(path) {
-    return await Deno.readTextFile(path);
-  }
-  async readFile(path) {
-    return await Deno.readFile(path);
-  }
-  async writeTextFile(path, data) {
-    await Deno.writeTextFile(path, data);
-  }
-  async writeFile(path, data) {
-    await Deno.writeFile(path, data);
-  }
-  async exists(path) {
-    try {
-      await Deno.stat(path);
-      return true;
-    } catch (error) {
-      if (error instanceof Deno.errors.NotFound) {
-        return false;
-      }
-      throw error;
-    }
-  }
-  async stat(path) {
-    const stat = await Deno.stat(path);
-    return {
-      isFile: stat.isFile,
-      isDirectory: stat.isDirectory,
-      isSymlink: stat.isSymlink,
-      size: stat.size,
-      mtime: stat.mtime
-    };
-  }
-  async mkdir(path, options) {
-    await Deno.mkdir(path, { recursive: options?.recursive ?? false });
-  }
-  async *readDir(path) {
-    for await (const entry of Deno.readDir(path)) {
-      yield {
-        name: entry.name,
-        isFile: entry.isFile,
-        isDirectory: entry.isDirectory
-      };
-    }
-  }
-  async remove(path, options) {
-    await Deno.remove(path, { recursive: options?.recursive ?? false });
-  }
-  async makeTempDir(options) {
-    return await Deno.makeTempDir({ prefix: options?.prefix });
-  }
-};
-function createFileSystem() {
-  if (isDeno) {
-    return new DenoFileSystem();
-  } else {
-    return new NodeFileSystem();
-  }
-}
-
 // src/ai/utils/setup.ts
 var fs = createFileSystem();
 async function setupAI(options = {}) {
@@ -5911,18 +6109,6 @@ function waitForApproval(id, options = {}) {
   };
 }
 
-// src/platform/compat/path-helper.ts
-import nodePath from "node:path";
-var pathMod = null;
-if (typeof Deno === "undefined") {
-  pathMod = nodePath;
-} else {
-  import("node:path").then((mod) => {
-    pathMod = mod;
-  });
-}
-var sep = nodePath.sep;
-
 // src/ai/workflow/backends/types.ts
 function hasLockSupport(backend) {
   return typeof backend.acquireLock === "function" && typeof backend.releaseLock === "function";