stone-lang 0.1.0

package/frontend/utils/moduleResolver.js

@@ -0,0 +1,479 @@
+/**
+ * Stone Module Resolver
+ *
+ * Resolution order:
+ * 1. Built-in modules (primitives, plots)
+ * 2. Standard library (.stn builtins: math, array, stats, etc.)
+ * 3. Local stone_modules/ (at project root, where package.son lives)
+ * 4. Global ~/.stone/stone_modules/
+ * 5. File-based resolution (relative paths, filesSource)
+ */
+
+import {
+  resolvePath,
+  resolveRelative,
+  getDirectory,
+} from '../../../utils/filePathResolver.js';
+import { extractCodeSection } from '../../fileFormat/stoneFileParser.js';
+
+// Import standard library modules
+import primitives from '../../standard-library/primitives.js';
+
+// Embedded .stn standard library content (generated from .stn files)
+// To regenerate: node scripts/build-stn-content.js
+import { STN_BUILTIN_CONTENT } from '../../standard-library/stn-content.generated.js';
+
+/**
+ * Module cache for tracking loaded modules
+ */
+class ModuleCache {
+  constructor() {
+    this.modules = new Map();
+    this.loading = new Set();
+  }
+
+  has(modulePath) {
+    return this.modules.has(modulePath);
+  }
+
+  get(modulePath) {
+    return this.modules.get(modulePath);
+  }
+
+  set(modulePath, moduleData) {
+    this.modules.set(modulePath, moduleData);
+  }
+
+  isLoading(modulePath) {
+    return this.loading.has(modulePath);
+  }
+
+  startLoading(modulePath) {
+    this.loading.add(modulePath);
+  }
+
+  finishLoading(modulePath) {
+    this.loading.delete(modulePath);
+  }
+
+  clear() {
+    this.modules.clear();
+    this.loading.clear();
+  }
+
+  entries() {
+    return this.modules.entries();
+  }
+
+  // Custom serialization - only export minimal dependency data
+  toJSON() {
+    const modules = {};
+    for (const [key, value] of this.modules) {
+      modules[key] = {
+        fileId: value.fileId,
+        modulePath: value.modulePath,
+        isBuiltin: value.isBuiltin
+      };
+    }
+    return { modules, loading: [] };
+  }
+}
+
+export class ModuleResolver {
+  constructor(options = {}) {
+    this.cache = new ModuleCache();
+    this.filesSource = options.filesSource || null;
+    this.currentFilePath = null;
+    this.fileLoader = options.fileLoader || null;
+    this.builtinModules = this.createBuiltinModules();
+
+    // Package system support (optional)
+    // PackageContext handles stone_modules resolution
+    this.packageContext = options.packageContext || null;
+  }
+
+  /**
+   * Set the package context for stone_modules resolution
+   */
+  setPackageContext(context) {
+    this.packageContext = context;
+  }
+
+  /**
+   * Create built-in module exports
+   * Imports from standard-library/ modules
+   * Note: Most standard library modules are now .stn (in STN_BUILTIN_CONTENT)
+   */
+  createBuiltinModules() {
+    return {
+      // Primitives module (JS) - all primitives with overload wrappers
+      'primitives': primitives,
+      // Note: stats, math, builtins are now .stn modules (see STN_BUILTIN_CONTENT)
+      // Other modules (array, string, linalg, complex, random) being migrated to .stn
+
+      // Plots module - runtime terminal constructors (actual exports bound by executor)
+      // This is a placeholder so the module resolver recognizes 'plots' as valid
+      'plots': {
+        graph2d: null,  // Bound at runtime by executor
+        graph3d: null,  // Bound at runtime by executor
+      },
+
+      // Note: 'file' module is now a .stn builtin (see STN_BUILTIN_CONTENT)
+    };
+  }
+
+  /**
+   * Check if a module is a runtime module (needs executor binding)
+   */
+  isRuntimeModule(modulePath) {
+    return modulePath === 'plots';
+  }
+
+  /**
+   * Check if a module is a .stn builtin
+   */
+  isStnBuiltinModule(modulePath) {
+    return modulePath in STN_BUILTIN_CONTENT;
+  }
+
+  /**
+   * Get .stn builtin content
+   */
+  getStnBuiltinContent(modulePath) {
+    return STN_BUILTIN_CONTENT[modulePath];
+  }
+
+  setFilesSource(filesSource) {
+    this.filesSource = filesSource;
+  }
+
+  setCurrentFilePath(path) {
+    this.currentFilePath = path;
+  }
+
+  setFileLoader(loader) {
+    this.fileLoader = loader;
+  }
+
+  getCurrentFilePath() {
+    return this.currentFilePath;
+  }
+
+  resolveModulePath(modulePath) {
+    const currentFilePath = this.currentFilePath;
+
+    if ((modulePath.startsWith('./') || modulePath.startsWith('../')) && currentFilePath) {
+      const currentDir = getDirectory(currentFilePath);
+      return resolveRelative(currentDir, modulePath);
+    }
+
+    return modulePath.replace(/^\.\//, '');
+  }
+
+  isBuiltinModule(modulePath) {
+    return this.builtinModules.hasOwnProperty(modulePath);
+  }
+
+  getBuiltinModule(modulePath) {
+    return this.builtinModules[modulePath];
+  }
+
+  /**
+   * Check if a file ID corresponds to an actual .stn file (not a folder)
+   */
+  isStoneFile(fileId) {
+    if (!fileId || !this.filesSource) return false;
+    const files = this.filesSource instanceof Map
+      ? Array.from(this.filesSource.values())
+      : Array.isArray(this.filesSource) ? this.filesSource : [];
+    const file = files.find(f => (f._id || f.id) === fileId);
+    return file && file.name && file.name.endsWith('.stn');
+  }
+
+  /**
+   * Resolve module path to file ID
+   * @param {string} modulePath - The module path to resolve
+   * @param {string|null} inferredFilename - Optional filename to append for directory imports
+   *        (e.g., for "import stats from 'dir'" -> tries "dir/stats.stn")
+   * @returns {string|null} The resolved file ID or null if not found
+   */
+  resolveToFileId(modulePath, inferredFilename = null) {
+    // If no filesSource but we have a fileLoader, use resolveModulePath
+    // This supports file-based loading with relative paths
+    if (!this.filesSource && this.fileLoader) {
+      return this.resolveModulePath(modulePath);
+    }
+
+    if (!this.filesSource) {
+      return null;
+    }
+
+    const currentFilePath = this.currentFilePath;
+
+    // 1. Try exact path first (must be an actual .stn file, not a folder)
+    let fileId = resolvePath(modulePath, this.filesSource, currentFilePath);
+    if (fileId && this.isStoneFile(fileId)) {
+      return fileId;
+    }
+
+    // 2. Try with inferred filename (directory + inferred filename resolution)
+    // This enables: import stats from "core logic/math" -> "core logic/math/stats.stn"
+    if (inferredFilename) {
+      const inferredPath = `${modulePath}/${inferredFilename}`;
+      fileId = resolvePath(inferredPath, this.filesSource, currentFilePath);
+      if (fileId && this.isStoneFile(fileId)) {
+        return fileId;
+      }
+    }
+
+    // 3. Try index.stn fallback
+    fileId = resolvePath(modulePath + '/index.stn', this.filesSource, currentFilePath);
+    if (fileId && this.isStoneFile(fileId)) {
+      return fileId;
+    }
+
+    return null;
+  }
+
+  /**
+   * Load a module by path
+   * @param {string} modulePath - The module path to load
+   * @param {function} parseFunction - Function to parse source code
+   * @param {string|null} inferredFilename - Optional filename for directory inference
+   */
+  async loadModule(modulePath, parseFunction, inferredFilename = null) {
+    // Check JS builtins first (fast path)
+    if (this.isBuiltinModule(modulePath)) {
+      return {
+        isBuiltin: true,
+        exports: this.getBuiltinModule(modulePath),
+        modulePath,
+      };
+    }
+
+    if (this.cache.has(modulePath)) {
+      return this.cache.get(modulePath);
+    }
+
+    // Check .stn builtins - these are parsed and executed like regular modules
+    if (this.isStnBuiltinModule(modulePath)) {
+
+      if (this.cache.isLoading(modulePath)) {
+        const error = new Error(`Circular dependency detected: ${modulePath}`);
+        error.stage = 'module_load';
+        error.type = 'module';
+        error.module = modulePath;
+        throw error;
+      }
+
+      this.cache.startLoading(modulePath);
+
+      try {
+        const stnContent = this.getStnBuiltinContent(modulePath);
+        const ast = parseFunction(stnContent, { filename: `<builtin:${modulePath}>` });
+
+        const moduleData = {
+          isBuiltin: false, // Treated as regular module for execution
+          isStnBuiltin: true, // Mark as .stn builtin for reference
+          ast,
+          fileId: null,
+          modulePath,
+          exports: null,
+        };
+
+        this.cache.set(modulePath, moduleData);
+        this.cache.finishLoading(modulePath);
+
+        return moduleData;
+      } catch (error) {
+        this.cache.finishLoading(modulePath);
+        const parseErr = new Error(`Failed to parse .stn builtin '${modulePath}': ${error.message}`);
+        parseErr.stage = 'module_load';
+        parseErr.type = 'module';
+        parseErr.module = modulePath;
+        throw parseErr;
+      }
+    }
+
+    if (this.cache.isLoading(modulePath)) {
+      const error = new Error(`Circular dependency detected: ${modulePath}`);
+      error.stage = 'module_load';
+      error.type = 'module';
+      error.module = modulePath;
+      throw error;
+    }
+
+    // Try stone_modules resolution first (if package context is available)
+    // This handles: import foo from bar -> stone_modules/bar/main.stn
+    if (this.packageContext && !modulePath.startsWith('./') && !modulePath.startsWith('../')) {
+      const packagePath = await this.packageContext.resolveModule(
+        modulePath,
+        this.currentFilePath,
+        { isBuiltin: (m) => this.isBuiltinModule(m) || this.isStnBuiltinModule(m) }
+      );
+
+      if (packagePath) {
+        // Load from resolved package path
+        return this.loadModuleFromPath(packagePath, modulePath, parseFunction);
+      }
+    }
+
+    // Pass inferredFilename for directory + inferred filename resolution
+    const fileId = this.resolveToFileId(modulePath, inferredFilename);
+    if (!fileId) {
+      // Provide helpful error message for inferred paths
+      let errorMsg = `Module not found: ${modulePath}`;
+      if (inferredFilename) {
+        errorMsg += ` (also tried ${modulePath}/${inferredFilename}.stn)`;
+      }
+      if (this.packageContext) {
+        errorMsg += ` (also checked stone_modules)`;
+      }
+      const error = new Error(errorMsg);
+      error.stage = 'module_load';
+      error.type = 'module';
+      error.module = modulePath;
+      throw error;
+    }
+
+    this.cache.startLoading(modulePath);
+
+    try {
+      if (!this.fileLoader) {
+        const error = new Error('No file loader configured for module resolver');
+        error.stage = 'module_load';
+        error.type = 'module';
+        throw error;
+      }
+
+      const fileContent = await this.fileLoader(fileId);
+      if (!fileContent) {
+        const error = new Error(`Failed to load module content: ${modulePath}`);
+        error.stage = 'module_load';
+        error.type = 'module';
+        error.module = modulePath;
+        throw error;
+      }
+
+      const rawContent = fileContent.content || fileContent.code || fileContent.data || fileContent;
+      const codeOnly = typeof rawContent === 'string' ? extractCodeSection(rawContent) : rawContent;
+      const ast = parseFunction(codeOnly, { filename: modulePath });
+
+      const moduleData = {
+        isBuiltin: false,
+        ast,
+        fileId,
+        modulePath,
+        exports: null,
+      };
+
+      this.cache.set(modulePath, moduleData);
+      this.cache.finishLoading(modulePath);
+
+      return moduleData;
+    } catch (error) {
+      this.cache.finishLoading(modulePath);
+      throw error;
+    }
+  }
+
+  /**
+   * Load a module from a resolved file path (used by package resolution)
+   */
+  async loadModuleFromPath(filePath, modulePath, parseFunction) {
+    this.cache.startLoading(modulePath);
+
+    try {
+      // Read file content using package context
+      let fileContent = null;
+
+      if (this.packageContext && this.packageContext.readFile) {
+        fileContent = await this.packageContext.readFile(filePath);
+      } else if (this.fileLoader) {
+        fileContent = await this.fileLoader(filePath);
+      }
+
+      if (!fileContent) {
+        const error = new Error(`Failed to load module content: ${modulePath} (${filePath})`);
+        error.stage = 'module_load';
+        error.type = 'module';
+        error.module = modulePath;
+        throw error;
+      }
+
+      const rawContent = typeof fileContent === 'string' ? fileContent :
+        (fileContent.content || fileContent.code || fileContent.data || fileContent);
+      const codeOnly = typeof rawContent === 'string' ? extractCodeSection(rawContent) : rawContent;
+      const ast = parseFunction(codeOnly, { filename: filePath });
+
+      const moduleData = {
+        isBuiltin: false,
+        isPackageModule: true,
+        ast,
+        fileId: filePath,
+        modulePath,
+        exports: null,
+      };
+
+      this.cache.set(modulePath, moduleData);
+      this.cache.finishLoading(modulePath);
+
+      return moduleData;
+    } catch (error) {
+      this.cache.finishLoading(modulePath);
+      throw error;
+    }
+  }
+
+  getModuleName(modulePath) {
+    const segments = modulePath.split('/');
+    return segments[segments.length - 1];
+  }
+
+  getExportedNames(ast) {
+    if (!ast || !ast.exports) return [];
+
+    return ast.exports.map(exportStmt => {
+      const decl = exportStmt.declaration;
+      if (decl.type === 'FunctionDefinition') return decl.name;
+      if (decl.type === 'Assignment') return decl.target;
+      return null;
+    }).filter(Boolean);
+  }
+
+  clearCache() {
+    this.cache.clear();
+  }
+
+  // Custom serialization - exclude filesSource to avoid serializing entire file system
+  toJSON() {
+    return {
+      cache: this.cache,
+      // filesSource excluded - runtime context only, not needed for serialization
+    };
+  }
+}
+
+export function createModuleResolver(options = {}) {
+  return new ModuleResolver(options);
+}
+
+/**
+ * Create a module resolver with package support for Node.js
+ * @param {object} options - Resolver options
+ * @returns {Promise<ModuleResolver>} Configured module resolver
+ */
+export async function createPackageAwareResolver(options = {}) {
+  const resolver = new ModuleResolver(options);
+
+  // Try to set up package context
+  try {
+    const { createNodePackageContext } = await import('../../packages/packageResolver.js');
+    const packageContext = await createNodePackageContext();
+    resolver.setPackageContext(packageContext);
+  } catch (e) {
+    // Package support not available, continue without it
+  }
+
+  return resolver;
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "stone-lang",
+  "version": "0.1.0",
+  "description": "Stone - A modern programming language for data science and numerical computing",
+  "keywords": [
+    "stone",
+    "programming-language",
+    "data-science",
+    "numerical-computing",
+    "interpreter",
+    "cli"
+  ],
+  "author": "Alvei",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alvei/stone-lang"
+  },
+  "homepage": "https://stone-lang.dev",
+  "bugs": {
+    "url": "https://github.com/alvei/stone-lang/issues"
+  },
+  "type": "module",
+  "bin": {
+    "stone": "./cli/entry.js"
+  },
+  "main": "./StoneEngine.js",
+  "exports": {
+    ".": "./StoneEngine.js",
+    "./engine": "./StoneEngine.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "files": [
+    "cli/",
+    "frontend/",
+    "backend/",
+    "adapters/",
+    "stdlib/",
+    "packages/",
+    "daemon/",
+    "StoneEngine.js",
+    "StoneEngineService.js",
+    "README.md"
+  ]
+}