veryfront 0.0.57 → 0.0.58

package/dist/ai/index.js

@@ -1675,7 +1675,7 @@ var LRU_DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.57",
+  version: "0.0.58",
   exclude: [
     "npm/",
     "dist/",
@@ -4255,20 +4255,105 @@ function getPathMod() {
 var dirname = (path) => getPathMod().dirname(path);
 var join2 = (...paths) => getPathMod().join(...paths);
 var resolve = (...paths) => getPathMod().resolve(...paths);
+var extname = (path) => getPathMod().extname(path);
 var sep = nodePath.sep;
 
 // src/ai/utils/discovery.ts
 var transpileCache = /* @__PURE__ */ new Map();
+function createFsAdapterPlugin(fsAdapter) {
+  const existsCache = /* @__PURE__ */ new Map();
+  async function checkExists(filePath) {
+    if (existsCache.has(filePath)) {
+      return existsCache.get(filePath);
+    }
+    const exists = await fsAdapter.exists(filePath);
+    existsCache.set(filePath, exists);
+    return exists;
+  }
+  async function resolveWithExtensions(basePath) {
+    if (/\.(ts|tsx|js|jsx|mjs|json)$/i.test(basePath)) {
+      if (await checkExists(basePath)) {
+        return basePath;
+      }
+      return null;
+    }
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+    for (const ext of extensions) {
+      const fullPath = basePath + ext;
+      if (await checkExists(fullPath)) {
+        return fullPath;
+      }
+    }
+    for (const ext of extensions) {
+      const indexPath = join2(basePath, `index${ext}`);
+      if (await checkExists(indexPath)) {
+        return indexPath;
+      }
+    }
+    return null;
+  }
+  return {
+    name: "veryfront-fsadapter",
+    // deno-lint-ignore no-explicit-any
+    setup(build) {
+      build.onResolve(
+        { filter: /^\.\.?\// },
+        async (args) => {
+          const importerDir = args.importer ? dirname(args.importer) : args.resolveDir;
+          const basePath = resolve(importerDir, args.path);
+          const resolvedPath = await resolveWithExtensions(basePath);
+          if (resolvedPath) {
+            return {
+              path: resolvedPath,
+              namespace: "fsadapter"
+            };
+          }
+          return {
+            errors: [{
+              text: `Could not resolve "${args.path}" from "${importerDir}" via fsAdapter`
+            }]
+          };
+        }
+      );
+      build.onLoad(
+        { filter: /.*/, namespace: "fsadapter" },
+        async (args) => {
+          try {
+            const content = await fsAdapter.readFile(args.path);
+            const ext = extname(args.path).toLowerCase();
+            const loader = ext === ".tsx" ? "tsx" : ext === ".jsx" ? "jsx" : ext === ".ts" ? "ts" : "js";
+            return {
+              contents: content,
+              loader,
+              // Set resolveDir for nested imports from this file
+              resolveDir: dirname(args.path)
+            };
+          } catch (error) {
+            return {
+              errors: [{
+                text: `Failed to load "${args.path}" from fsAdapter: ${error}`
+              }]
+            };
+          }
+        }
+      );
+    }
+  };
+}
 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);
+    if (context.fsAdapter) {
+      source = await context.fsAdapter.readFile(filePath);
+    } else {
+      const fs2 = createFileSystem();
+      source = await fs2.readTextFile(filePath);
+    }
   } catch (error) {
     throw new Error(`Failed to read file ${filePath}: ${error}`);
   }
@@ -4277,14 +4362,18 @@ async function importModule(file, context) {
   const loader = isTsx ? "tsx" : isJsx ? "jsx" : filePath.endsWith(".ts") ? "ts" : "js";
   const { build } = await import("esbuild");
   const fileDir = dirname(filePath);
-  const relativeImportPattern = /from\s+["'](\.\.[^"']+)["']/g;
   const relativeImports = [];
-  let match;
-  while ((match = relativeImportPattern.exec(source)) !== null) {
-    if (match[1]) {
-      relativeImports.push(match[1]);
+  if (isDeno) {
+    const relativeImportPattern = /from\s+["'](\.\.[^"']+)["']/g;
+    let match;
+    while ((match = relativeImportPattern.exec(source)) !== null) {
+      if (match[1]) {
+        relativeImports.push(match[1]);
+      }
     }
   }
+  const usePlugin = !isDeno && !!context.fsAdapter;
+  const plugins = usePlugin ? [createFsAdapterPlugin(context.fsAdapter)] : [];
   const result = await build({
     bundle: true,
     write: false,
@@ -4294,6 +4383,7 @@ async function importModule(file, context) {
     jsx: "automatic",
     jsxImportSource: "react",
     resolveExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"],
+    plugins,
     external: [
       "ai",
       "ai/*",
@@ -4304,7 +4394,7 @@ async function importModule(file, context) {
       "veryfront/*",
       "@opentelemetry/*",
       "path",
-      // Mark relative imports as external to avoid filesystem access issues
+      // Only mark relative imports as external in Deno (plugin handles them in Node.js)
       ...relativeImports
     ],
     stdin: {
@@ -4319,21 +4409,22 @@ async function importModule(file, context) {
     throw new Error(`Failed to transpile ${filePath}: ${first}`);
   }
   const js = result.outputFiles?.[0]?.text ?? "export {}";
-  const tempDir = await fs2.makeTempDir({ prefix: "vf-discovery-" });
+  const localFs = createFileSystem();
+  const tempDir = await localFs.makeTempDir({ prefix: "vf-discovery-" });
   const tempFile = join2(tempDir, "module.mjs");
   let transformedCode;
   if (isDeno) {
     transformedCode = rewriteForDeno(js, fileDir);
   } else {
-    transformedCode = await rewriteDiscoveryImports(js, context.baseDir || ".", fs2, fileDir);
+    transformedCode = await rewriteDiscoveryImports(js, context.baseDir || ".", localFs, fileDir);
   }
-  await fs2.writeTextFile(tempFile, transformedCode);
+  await localFs.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 });
+    await localFs.remove(tempDir, { recursive: true });
   }
 }
 function rewriteForDeno(code, fileDir) {