stone-lang 0.1.0

package/packages/packageResolver.js

@@ -0,0 +1,356 @@
+/**
+ * Stone Package-Aware Module Resolver
+ *
+ * Extends the base module resolver to support:
+ * - package.son project root detection
+ * - stone_modules resolution
+ * - Global ~/.stone/stone_modules fallback
+ */
+
+import { parseSON } from '../frontend/parsing/sonParser.js';
+
+// Platform-specific path utilities
+const isWindows = typeof process !== 'undefined' && process.platform === 'win32';
+const pathSep = isWindows ? '\\' : '/';
+
+/**
+ * Normalize path separators
+ */
+function normalizePath(p) {
+  if (!p) return p;
+  return p.replace(/[\\/]+/g, pathSep);
+}
+
+/**
+ * Join path segments
+ */
+function joinPath(...segments) {
+  return segments.filter(Boolean).join(pathSep).replace(/[\\/]+/g, pathSep);
+}
+
+/**
+ * Get parent directory
+ */
+function getParentDir(p) {
+  if (!p) return null;
+  const normalized = normalizePath(p);
+  const lastSep = normalized.lastIndexOf(pathSep);
+  if (lastSep <= 0) return null;
+  return normalized.substring(0, lastSep);
+}
+
+/**
+ * Check if path is at filesystem root
+ */
+function isRoot(p) {
+  if (!p) return true;
+  const normalized = normalizePath(p);
+  // Unix root
+  if (normalized === '/') return true;
+  // Windows root (C:\)
+  if (/^[A-Za-z]:[\\/]?$/.test(normalized)) return true;
+  return false;
+}
+
+/**
+ * Get user home directory
+ */
+function getHomeDir() {
+  if (typeof process !== 'undefined') {
+    return process.env.HOME || process.env.USERPROFILE || '';
+  }
+  return '';
+}
+
+/**
+ * Get global Stone directory (~/.stone)
+ */
+function getStoneHome() {
+  // Check environment variable first
+  if (typeof process !== 'undefined' && process.env.STONE_HOME) {
+    return process.env.STONE_HOME;
+  }
+  // Default to ~/.stone
+  const home = getHomeDir();
+  if (home) {
+    return joinPath(home, '.stone');
+  }
+  return null;
+}
+
+/**
+ * Package Resolution Context
+ */
+export class PackageContext {
+  constructor(options = {}) {
+    // File system access functions
+    this.fileExists = options.fileExists || (() => false);
+    this.readFile = options.readFile || (() => null);
+    this.listDir = options.listDir || (() => []);
+
+    // Cache
+    this.projectRootCache = new Map();
+    this.manifestCache = new Map();
+    this.resolvedModules = new Map();
+  }
+
+  /**
+   * Find project root by walking up to find package.son
+   * @param {string} startPath - Starting directory path
+   * @returns {string|null} Project root path or null
+   */
+  async findProjectRoot(startPath) {
+    if (!startPath) return null;
+
+    // Check cache
+    if (this.projectRootCache.has(startPath)) {
+      return this.projectRootCache.get(startPath);
+    }
+
+    let currentDir = normalizePath(startPath);
+
+    // Walk up until we find package.son or hit root
+    while (currentDir && !isRoot(currentDir)) {
+      const manifestPath = joinPath(currentDir, 'package.son');
+
+      if (await this.fileExists(manifestPath)) {
+        this.projectRootCache.set(startPath, currentDir);
+        return currentDir;
+      }
+
+      currentDir = getParentDir(currentDir);
+    }
+
+    // No package.son found
+    this.projectRootCache.set(startPath, null);
+    return null;
+  }
+
+  /**
+   * Get package manifest for a directory
+   */
+  async getManifest(dir) {
+    if (!dir) return null;
+
+    const manifestPath = joinPath(dir, 'package.son');
+
+    if (this.manifestCache.has(manifestPath)) {
+      return this.manifestCache.get(manifestPath);
+    }
+
+    try {
+      const content = await this.readFile(manifestPath);
+      if (!content) {
+        this.manifestCache.set(manifestPath, null);
+        return null;
+      }
+
+      const manifest = parseSON(content, manifestPath);
+      this.manifestCache.set(manifestPath, manifest);
+      return manifest;
+    } catch (e) {
+      this.manifestCache.set(manifestPath, null);
+      return null;
+    }
+  }
+
+  /**
+   * Resolve a module from stone_modules
+   * @param {string} moduleName - Module name (not a path)
+   * @param {string} projectRoot - Project root directory
+   * @returns {string|null} Path to module's entry file
+   */
+  async resolveFromStoneModules(moduleName, projectRoot) {
+    if (!moduleName || !projectRoot) return null;
+
+    const stoneModulesDir = joinPath(projectRoot, 'stone_modules', moduleName);
+
+    // Check if module directory exists
+    const moduleManifestPath = joinPath(stoneModulesDir, 'package.son');
+    if (await this.fileExists(moduleManifestPath)) {
+      // Get entry point from manifest
+      const manifest = await this.getManifest(stoneModulesDir);
+      const entry = manifest?.entry || 'main.stn';
+      const entryPath = joinPath(stoneModulesDir, entry);
+
+      if (await this.fileExists(entryPath)) {
+        return entryPath;
+      }
+    }
+
+    // Try direct .stn file
+    const directPath = joinPath(projectRoot, 'stone_modules', `${moduleName}.stn`);
+    if (await this.fileExists(directPath)) {
+      return directPath;
+    }
+
+    // Try main.stn in directory without manifest
+    const mainPath = joinPath(stoneModulesDir, 'main.stn');
+    if (await this.fileExists(mainPath)) {
+      return mainPath;
+    }
+
+    return null;
+  }
+
+  /**
+   * Resolve from global stone_modules
+   */
+  async resolveFromGlobal(moduleName) {
+    const stoneHome = getStoneHome();
+    if (!stoneHome) return null;
+
+    return this.resolveFromStoneModules(moduleName, stoneHome);
+  }
+
+  /**
+   * Full module resolution
+   * @param {string} moduleName - Module name to resolve
+   * @param {string} fromPath - Path of the importing file
+   * @param {object} options - Resolution options
+   * @returns {string|null} Resolved module path
+   */
+  async resolveModule(moduleName, fromPath, options = {}) {
+    // Skip relative imports - handled by base resolver
+    if (moduleName.startsWith('./') || moduleName.startsWith('../')) {
+      return null; // Let base resolver handle it
+    }
+
+    // Skip built-ins (handled by base resolver)
+    if (options.isBuiltin?.(moduleName)) {
+      return null;
+    }
+
+    const cacheKey = `${fromPath}:${moduleName}`;
+    if (this.resolvedModules.has(cacheKey)) {
+      return this.resolvedModules.get(cacheKey);
+    }
+
+    // Find project root
+    const startDir = getParentDir(fromPath) || fromPath;
+    const projectRoot = await this.findProjectRoot(startDir);
+
+    // 1. Try local stone_modules (at project root)
+    if (projectRoot) {
+      const localPath = await this.resolveFromStoneModules(moduleName, projectRoot);
+      if (localPath) {
+        this.resolvedModules.set(cacheKey, localPath);
+        return localPath;
+      }
+    }
+
+    // 2. Try global stone_modules
+    const globalPath = await this.resolveFromGlobal(moduleName);
+    if (globalPath) {
+      this.resolvedModules.set(cacheKey, globalPath);
+      return globalPath;
+    }
+
+    this.resolvedModules.set(cacheKey, null);
+    return null;
+  }
+
+  /**
+   * Clear all caches
+   */
+  clearCache() {
+    this.projectRootCache.clear();
+    this.manifestCache.clear();
+    this.resolvedModules.clear();
+  }
+}
+
+/**
+ * Create a package context for Node.js environment
+ */
+export async function createNodePackageContext() {
+  // Dynamic import for Node.js fs module
+  let fs, path;
+
+  try {
+    fs = await import('fs');
+    path = await import('path');
+  } catch (e) {
+    // Not in Node.js environment
+    return new PackageContext();
+  }
+
+  return new PackageContext({
+    fileExists: async (p) => {
+      try {
+        await fs.promises.access(p);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    readFile: async (p) => {
+      try {
+        return await fs.promises.readFile(p, 'utf8');
+      } catch {
+        return null;
+      }
+    },
+    listDir: async (p) => {
+      try {
+        return await fs.promises.readdir(p);
+      } catch {
+        return [];
+      }
+    },
+  });
+}
+
+/**
+ * Create a package context for web/Riva environment
+ */
+export function createWebPackageContext(options = {}) {
+  // virtualFS should be a Map or object with file paths as keys
+  const virtualFS = options.virtualFS || new Map();
+  const fetchPackage = options.fetchPackage || (() => null);
+
+  return new PackageContext({
+    fileExists: async (p) => {
+      if (virtualFS instanceof Map) {
+        return virtualFS.has(p);
+      }
+      return p in virtualFS;
+    },
+    readFile: async (p) => {
+      if (virtualFS instanceof Map) {
+        return virtualFS.get(p) || null;
+      }
+      return virtualFS[p] || null;
+    },
+    listDir: async (p) => {
+      const prefix = p.endsWith('/') ? p : p + '/';
+      const files = [];
+
+      const entries = virtualFS instanceof Map
+        ? Array.from(virtualFS.keys())
+        : Object.keys(virtualFS);
+
+      for (const entry of entries) {
+        if (entry.startsWith(prefix)) {
+          const rest = entry.substring(prefix.length);
+          const nextSep = rest.indexOf('/');
+          const name = nextSep >= 0 ? rest.substring(0, nextSep) : rest;
+          if (name && !files.includes(name)) {
+            files.push(name);
+          }
+        }
+      }
+
+      return files;
+    },
+  });
+}
+
+export default {
+  PackageContext,
+  createNodePackageContext,
+  createWebPackageContext,
+  getStoneHome,
+  normalizePath,
+  joinPath,
+};

package/packages/resolver.js

@@ -0,0 +1,310 @@
+/**
+ * Stone Package Dependency Resolver
+ *
+ * Resolves package dependencies with version constraints.
+ * Builds dependency graph and finds compatible versions.
+ */
+
+import { parseRange, satisfies, maxSatisfying, parseVersion } from './semver.js';
+
+/**
+ * Resolution error
+ */
+export class ResolutionError extends Error {
+  constructor(message, pkg = null, details = null) {
+    super(message);
+    this.name = 'ResolutionError';
+    this.package = pkg;
+    this.details = details;
+  }
+}
+
+/**
+ * Dependency graph node
+ */
+class DependencyNode {
+  constructor(name) {
+    this.name = name;
+    this.constraints = []; // Array of { range, source } where source is the dependent package
+    this.resolvedVersion = null;
+    this.dependencies = new Map(); // name -> DependencyNode
+    this.source = null; // URL source for fetching
+  }
+
+  addConstraint(range, source, packageSource = null) {
+    this.constraints.push({ range, source });
+    if (packageSource && !this.source) {
+      this.source = packageSource;
+    }
+  }
+}
+
+/**
+ * Dependency Resolver
+ */
+export class DependencyResolver {
+  constructor(options = {}) {
+    // Function to fetch available versions for a package
+    // Should return: { versions: string[], source?: string }
+    this.fetchVersions = options.fetchVersions || null;
+
+    // Cache of available versions per package
+    this.versionCache = new Map();
+
+    // The resolved dependency graph
+    this.graph = new Map();
+  }
+
+  /**
+   * Resolve dependencies starting from a root manifest
+   * @param {object} manifest - The root package manifest (parsed package.son)
+   * @returns {Map<string, ResolvedPackage>} Map of package name to resolved info
+   */
+  async resolve(manifest) {
+    // Clear previous state
+    this.graph.clear();
+
+    // Build the dependency graph
+    await this.buildGraph(manifest);
+
+    // Resolve versions for each package
+    const resolved = await this.resolveVersions();
+
+    return resolved;
+  }
+
+  /**
+   * Build the dependency graph from a manifest
+   */
+  async buildGraph(manifest, source = '<root>') {
+    const deps = this.normalizeDependencies(manifest.dependencies || {});
+
+    for (const [name, spec] of Object.entries(deps)) {
+      await this.addDependency(name, spec.version, source, spec.source);
+    }
+  }
+
+  /**
+   * Add a dependency to the graph
+   */
+  async addDependency(name, versionRange, source, packageSource = null) {
+    // Get or create node
+    let node = this.graph.get(name);
+    if (!node) {
+      node = new DependencyNode(name);
+      this.graph.set(name, node);
+    }
+
+    // Add constraint
+    const range = parseRange(versionRange);
+    node.addConstraint(range, source, packageSource);
+
+    // If we have a version fetcher, get the package's dependencies too
+    if (this.fetchVersions && !node.resolvedVersion) {
+      try {
+        const pkgInfo = await this.getPackageInfo(name, packageSource);
+        if (pkgInfo && pkgInfo.dependencies) {
+          // Add transitive dependencies
+          const transDeps = this.normalizeDependencies(pkgInfo.dependencies);
+          for (const [depName, depSpec] of Object.entries(transDeps)) {
+            await this.addDependency(depName, depSpec.version, name, depSpec.source);
+          }
+        }
+      } catch (e) {
+        // Package info not available, continue without transitive deps
+      }
+    }
+  }
+
+  /**
+   * Normalize dependencies to { version, source? } format
+   */
+  normalizeDependencies(deps) {
+    const result = {};
+    for (const [name, spec] of Object.entries(deps)) {
+      if (typeof spec === 'string') {
+        result[name] = { version: spec };
+      } else {
+        result[name] = { version: spec.version, source: spec.source };
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Get package info (versions, dependencies) from cache or fetcher
+   */
+  async getPackageInfo(name, source = null) {
+    // Check cache
+    if (this.versionCache.has(name)) {
+      return this.versionCache.get(name);
+    }
+
+    // Fetch if we have a fetcher
+    if (this.fetchVersions) {
+      try {
+        const info = await this.fetchVersions(name, source);
+        this.versionCache.set(name, info);
+        return info;
+      } catch (e) {
+        throw new ResolutionError(`Failed to fetch versions for ${name}: ${e.message}`, name);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Resolve versions for all packages in the graph
+   */
+  async resolveVersions() {
+    const resolved = new Map();
+
+    for (const [name, node] of this.graph) {
+      const version = await this.resolvePackageVersion(name, node);
+
+      resolved.set(name, {
+        name,
+        version,
+        source: node.source,
+        constraints: node.constraints.map(c => ({
+          range: c.range.toString(),
+          source: c.source,
+        })),
+      });
+    }
+
+    return resolved;
+  }
+
+  /**
+   * Resolve a single package's version
+   */
+  async resolvePackageVersion(name, node) {
+    // Get available versions
+    const pkgInfo = await this.getPackageInfo(name, node.source);
+    const availableVersions = pkgInfo?.versions || [];
+
+    if (availableVersions.length === 0) {
+      // No versions available - check if constraints can be satisfied with any version
+      // For offline/local development, we might not have version info
+      throw new ResolutionError(
+        `No versions available for package: ${name}`,
+        name,
+        { constraints: node.constraints.map(c => ({ range: c.range.toString(), source: c.source })) }
+      );
+    }
+
+    // Find versions that satisfy ALL constraints
+    const satisfyingVersions = availableVersions.filter(v => {
+      return node.constraints.every(c => satisfies(v, c.range));
+    });
+
+    if (satisfyingVersions.length === 0) {
+      // No version satisfies all constraints - report conflict
+      const constraintDetails = node.constraints.map(c => ({
+        range: c.range.toString(),
+        source: c.source,
+        satisfying: availableVersions.filter(v => satisfies(v, c.range)),
+      }));
+
+      throw new ResolutionError(
+        `Cannot resolve ${name}: no version satisfies all constraints`,
+        name,
+        {
+          available: availableVersions,
+          constraints: constraintDetails,
+        }
+      );
+    }
+
+    // Return the highest satisfying version
+    return maxSatisfying(satisfyingVersions, '*');
+  }
+}
+
+/**
+ * Simple resolver for when all versions are known upfront
+ */
+export class SimpleResolver {
+  /**
+   * Resolve dependencies with known available versions
+   * @param {object} dependencies - Dependencies to resolve { name: versionRange }
+   * @param {object} availableVersions - Available versions { name: [versions] }
+   * @returns {object} Resolved versions { name: version }
+   */
+  static resolve(dependencies, availableVersions) {
+    const resolved = {};
+    const errors = [];
+
+    for (const [name, versionRange] of Object.entries(dependencies)) {
+      const range = typeof versionRange === 'string' ? versionRange : versionRange.version;
+      const available = availableVersions[name] || [];
+
+      if (available.length === 0) {
+        errors.push(`No versions available for: ${name}`);
+        continue;
+      }
+
+      const matching = maxSatisfying(available, range);
+      if (!matching) {
+        errors.push(`No version of ${name} satisfies ${range}. Available: ${available.join(', ')}`);
+        continue;
+      }
+
+      resolved[name] = matching;
+    }
+
+    if (errors.length > 0) {
+      throw new ResolutionError(
+        `Resolution failed:\n${errors.join('\n')}`,
+        null,
+        { errors }
+      );
+    }
+
+    return resolved;
+  }
+}
+
+/**
+ * Check if a set of dependencies can be resolved together
+ * @param {object} dependencies - Map of package name to constraints
+ * @param {object} availableVersions - Map of package name to available versions
+ * @returns {object} { valid: boolean, conflicts?: [...] }
+ */
+export function checkCompatibility(dependencies, availableVersions) {
+  const conflicts = [];
+
+  for (const [name, constraints] of Object.entries(dependencies)) {
+    const available = availableVersions[name] || [];
+
+    // Find versions that satisfy all constraints for this package
+    const constraintList = Array.isArray(constraints) ? constraints : [constraints];
+    const ranges = constraintList.map(c => parseRange(typeof c === 'string' ? c : c.range));
+
+    const satisfying = available.filter(v => {
+      return ranges.every(r => r.test(parseVersion(v)));
+    });
+
+    if (satisfying.length === 0) {
+      conflicts.push({
+        package: name,
+        constraints: constraintList,
+        available,
+      });
+    }
+  }
+
+  return {
+    valid: conflicts.length === 0,
+    conflicts,
+  };
+}
+
+export default {
+  DependencyResolver,
+  SimpleResolver,
+  ResolutionError,
+  checkCompatibility,
+};