stone-lang 0.1.0

package/packages/browserCache.js

@@ -0,0 +1,359 @@
+/**
+ * Stone Browser Package Cache
+ *
+ * Manages package caching in the browser using IndexedDB.
+ * Packages are cached until logout.
+ */
+
+const DB_NAME = 'stone-packages';
+const DB_VERSION = 1;
+const STORE_NAME = 'packages';
+
+/**
+ * Open the IndexedDB database
+ */
+function openDatabase() {
+  return new Promise((resolve, reject) => {
+    if (typeof indexedDB === 'undefined') {
+      reject(new Error('IndexedDB not available'));
+      return;
+    }
+
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => resolve(request.result);
+
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, { keyPath: 'key' });
+        store.createIndex('name', 'name', { unique: false });
+        store.createIndex('version', 'version', { unique: false });
+        store.createIndex('timestamp', 'timestamp', { unique: false });
+      }
+    };
+  });
+}
+
+/**
+ * Browser Package Cache
+ */
+export class BrowserPackageCache {
+  constructor() {
+    this.db = null;
+    this.memoryCache = new Map(); // In-memory fallback
+  }
+
+  /**
+   * Initialize the cache
+   */
+  async init() {
+    try {
+      this.db = await openDatabase();
+    } catch (e) {
+      // Fall back to memory cache
+      console.warn('IndexedDB not available, using memory cache');
+      this.db = null;
+    }
+  }
+
+  /**
+   * Generate cache key for a package
+   */
+  getKey(name, version) {
+    return `${name}@${version}`;
+  }
+
+  /**
+   * Check if a package is cached
+   */
+  async has(name, version) {
+    const key = this.getKey(name, version);
+
+    if (!this.db) {
+      return this.memoryCache.has(key);
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, 'readonly');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.get(key);
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result !== undefined);
+    });
+  }
+
+  /**
+   * Get a cached package
+   */
+  async get(name, version) {
+    const key = this.getKey(name, version);
+
+    if (!this.db) {
+      return this.memoryCache.get(key) || null;
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, 'readonly');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.get(key);
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result || null);
+    });
+  }
+
+  /**
+   * Cache a package
+   */
+  async set(name, version, data) {
+    const key = this.getKey(name, version);
+
+    const entry = {
+      key,
+      name,
+      version,
+      data,
+      timestamp: Date.now(),
+    };
+
+    if (!this.db) {
+      this.memoryCache.set(key, entry);
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, 'readwrite');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.put(entry);
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+
+  /**
+   * Remove a package from cache
+   */
+  async delete(name, version) {
+    const key = this.getKey(name, version);
+
+    if (!this.db) {
+      this.memoryCache.delete(key);
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, 'readwrite');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.delete(key);
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+
+  /**
+   * Clear all cached packages
+   */
+  async clear() {
+    if (!this.db) {
+      this.memoryCache.clear();
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, 'readwrite');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.clear();
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+
+  /**
+   * List all cached packages
+   */
+  async list() {
+    if (!this.db) {
+      return Array.from(this.memoryCache.values()).map(e => ({
+        name: e.name,
+        version: e.version,
+        timestamp: e.timestamp,
+      }));
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(STORE_NAME, 'readonly');
+      const store = tx.objectStore(STORE_NAME);
+      const request = store.getAll();
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        const entries = request.result || [];
+        resolve(entries.map(e => ({
+          name: e.name,
+          version: e.version,
+          timestamp: e.timestamp,
+        })));
+      };
+    });
+  }
+
+  /**
+   * Get cache size in bytes (approximate)
+   */
+  async getSize() {
+    const packages = await this.list();
+    let size = 0;
+
+    for (const pkg of packages) {
+      const entry = await this.get(pkg.name, pkg.version);
+      if (entry && entry.data) {
+        size += JSON.stringify(entry.data).length;
+      }
+    }
+
+    return size;
+  }
+}
+
+/**
+ * Web Package Manager
+ *
+ * Manages package resolution and caching for web/Riva environment.
+ */
+export class WebPackageManager {
+  constructor(options = {}) {
+    this.cache = new BrowserPackageCache();
+    this.fetcher = options.fetcher || null;
+
+    // User's global dependencies (from user account)
+    this.globalDeps = options.globalDeps || {};
+
+    // Virtual file system for resolved packages
+    this.virtualFS = new Map();
+  }
+
+  /**
+   * Initialize the package manager
+   */
+  async init() {
+    await this.cache.init();
+  }
+
+  /**
+   * Resolve and load all dependencies for a workspace
+   */
+  async loadDependencies(workspaceDeps = {}) {
+    // Merge global and workspace dependencies
+    const allDeps = { ...this.globalDeps, ...workspaceDeps };
+
+    const loaded = [];
+    const errors = [];
+
+    for (const [name, spec] of Object.entries(allDeps)) {
+      try {
+        await this.loadPackage(name, spec);
+        loaded.push(name);
+      } catch (e) {
+        errors.push({ name, error: e.message });
+      }
+    }
+
+    return { loaded, errors };
+  }
+
+  /**
+   * Load a single package
+   */
+  async loadPackage(name, spec) {
+    const version = typeof spec === 'string' ? spec : spec.version;
+    const source = typeof spec === 'object' ? spec.source : null;
+
+    // Check cache first
+    const cached = await this.cache.get(name, version);
+    if (cached) {
+      this.addToVirtualFS(name, cached.data);
+      return cached.data;
+    }
+
+    // Fetch package
+    if (!this.fetcher) {
+      throw new Error(`No fetcher configured for package: ${name}`);
+    }
+
+    const pkgData = await this.fetcher.fetchPackage(name, version, source);
+
+    // Cache it
+    await this.cache.set(name, version, pkgData);
+
+    // Add to virtual FS
+    this.addToVirtualFS(name, pkgData);
+
+    return pkgData;
+  }
+
+  /**
+   * Add package to virtual file system
+   */
+  addToVirtualFS(name, pkgData) {
+    const basePath = `stone_modules/${name}`;
+
+    if (pkgData.files) {
+      for (const [filename, content] of pkgData.files) {
+        this.virtualFS.set(`${basePath}/${filename}`, content);
+      }
+    }
+
+    if (pkgData.manifest) {
+      this.virtualFS.set(`${basePath}/package.son`, JSON.stringify(pkgData.manifest));
+    }
+  }
+
+  /**
+   * Get a file from virtual FS
+   */
+  getFile(path) {
+    return this.virtualFS.get(path) || null;
+  }
+
+  /**
+   * Check if file exists in virtual FS
+   */
+  hasFile(path) {
+    return this.virtualFS.has(path);
+  }
+
+  /**
+   * Clear cache (call on logout)
+   */
+  async clearCache() {
+    await this.cache.clear();
+    this.virtualFS.clear();
+  }
+
+  /**
+   * Set global dependencies (from user account)
+   */
+  setGlobalDeps(deps) {
+    this.globalDeps = deps || {};
+  }
+}
+
+/**
+ * Create a web package manager
+ */
+export function createWebPackageManager(options = {}) {
+  return new WebPackageManager(options);
+}
+
+export default {
+  BrowserPackageCache,
+  WebPackageManager,
+  createWebPackageManager,
+};

package/packages/fetcher.js

@@ -0,0 +1,236 @@
+/**
+ * Stone Package Fetcher
+ *
+ * Fetches packages from HTTP sources and installs them locally.
+ * Handles downloading, extracting, and verification.
+ */
+
+import { parseSON } from '../frontend/parsing/sonParser.js';
+
+/**
+ * Fetch error
+ */
+export class FetchError extends Error {
+  constructor(message, url = null, statusCode = null) {
+    super(message);
+    this.name = 'FetchError';
+    this.url = url;
+    this.statusCode = statusCode;
+  }
+}
+
+/**
+ * Package Fetcher - Abstract base for different environments
+ */
+export class PackageFetcher {
+  constructor(options = {}) {
+    // Base URL for package registry (if any)
+    this.registryUrl = options.registryUrl || null;
+
+    // Cache of fetched package info
+    this.cache = new Map();
+  }
+
+  /**
+   * Fetch package versions list from source
+   * @param {string} name - Package name
+   * @param {string} source - Source URL
+   * @returns {Promise<{versions: string[], source: string}>}
+   */
+  async fetchVersions(name, source) {
+    // Try to get versions.son from the source
+    const versionsUrl = this.resolveUrl(source || this.registryUrl, name, 'versions.son');
+
+    try {
+      const content = await this.fetchText(versionsUrl);
+      const data = parseSON(content, versionsUrl);
+
+      return {
+        versions: data.versions || [],
+        source: source || this.registryUrl,
+      };
+    } catch (e) {
+      // If versions.son doesn't exist, return empty
+      return { versions: [], source };
+    }
+  }
+
+  /**
+   * Fetch a specific package version
+   * @param {string} name - Package name
+   * @param {string} version - Version to fetch
+   * @param {string} source - Source URL
+   * @returns {Promise<{files: Map<string, string>, manifest: object}>}
+   */
+  async fetchPackage(name, version, source) {
+    const packageUrl = this.resolveUrl(source, name, version);
+
+    // Fetch the package manifest first
+    const manifestUrl = `${packageUrl}/package.son`;
+    const manifestContent = await this.fetchText(manifestUrl);
+    const manifest = parseSON(manifestContent, manifestUrl);
+
+    // Fetch the file list
+    const filesUrl = `${packageUrl}/files.son`;
+    let fileList = [];
+
+    try {
+      const filesContent = await this.fetchText(filesUrl);
+      const filesData = parseSON(filesContent, filesUrl);
+      fileList = filesData.files || [];
+    } catch (e) {
+      // No files.son, try common files
+      fileList = ['main.stn'];
+    }
+
+    // Fetch each file
+    const files = new Map();
+    for (const file of fileList) {
+      const fileUrl = `${packageUrl}/${file}`;
+      try {
+        const content = await this.fetchText(fileUrl);
+        files.set(file, content);
+      } catch (e) {
+        // Skip missing files
+      }
+    }
+
+    return { files, manifest };
+  }
+
+  /**
+   * Resolve a URL for a package resource
+   */
+  resolveUrl(base, name, resource) {
+    if (!base) {
+      throw new FetchError(`No source URL specified for package: ${name}`);
+    }
+
+    // Ensure base doesn't end with /
+    base = base.replace(/\/+$/, '');
+
+    return `${base}/${name}/${resource}`;
+  }
+
+  /**
+   * Fetch text content from a URL (to be implemented by subclasses)
+   */
+  async fetchText(url) {
+    throw new Error('fetchText must be implemented by subclass');
+  }
+
+  /**
+   * Compute integrity hash for content
+   */
+  async computeHash(content) {
+    // Use SubtleCrypto if available (browser/modern Node)
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(content);
+      const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      return 'sha256-' + hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+
+    // Fallback: no hashing
+    return null;
+  }
+
+  /**
+   * Verify integrity hash
+   */
+  async verifyIntegrity(content, expectedHash) {
+    if (!expectedHash) return true;
+
+    const actualHash = await this.computeHash(content);
+    if (!actualHash) return true; // Can't verify, skip
+
+    return actualHash === expectedHash;
+  }
+}
+
+/**
+ * Node.js Package Fetcher - Uses native fetch or http module
+ */
+export class NodePackageFetcher extends PackageFetcher {
+  async fetchText(url) {
+    // Use native fetch if available (Node 18+)
+    if (typeof fetch === 'function') {
+      const response = await fetch(url);
+
+      if (!response.ok) {
+        throw new FetchError(
+          `Failed to fetch ${url}: ${response.status} ${response.statusText}`,
+          url,
+          response.status
+        );
+      }
+
+      return await response.text();
+    }
+
+    // Fallback to Node's http/https modules
+    return new Promise((resolve, reject) => {
+      const protocol = url.startsWith('https') ? require('https') : require('http');
+
+      protocol.get(url, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          // Follow redirect
+          this.fetchText(res.headers.location).then(resolve).catch(reject);
+          return;
+        }
+
+        if (res.statusCode !== 200) {
+          reject(new FetchError(
+            `Failed to fetch ${url}: ${res.statusCode}`,
+            url,
+            res.statusCode
+          ));
+          return;
+        }
+
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => resolve(data));
+        res.on('error', reject);
+      }).on('error', reject);
+    });
+  }
+}
+
+/**
+ * Browser Package Fetcher - Uses fetch API
+ */
+export class BrowserPackageFetcher extends PackageFetcher {
+  async fetchText(url) {
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new FetchError(
+        `Failed to fetch ${url}: ${response.status} ${response.statusText}`,
+        url,
+        response.status
+      );
+    }
+
+    return await response.text();
+  }
+}
+
+/**
+ * Create the appropriate fetcher for the current environment
+ */
+export function createFetcher(options = {}) {
+  if (typeof window !== 'undefined') {
+    return new BrowserPackageFetcher(options);
+  }
+  return new NodePackageFetcher(options);
+}
+
+export default {
+  PackageFetcher,
+  NodePackageFetcher,
+  BrowserPackageFetcher,
+  FetchError,
+  createFetcher,
+};

package/packages/index.js

@@ -0,0 +1,130 @@
+/**
+ * Stone Package System
+ *
+ * Main entry point for the Stone package management system.
+ * Exports all package-related functionality.
+ */
+
+// SON Parser
+export { parseSON, stringifySON, SONParseError } from '../frontend/parsing/sonParser.js';
+
+// Semver
+export {
+  SemVer,
+  SemVerError,
+  VersionRange,
+  parseVersion,
+  parseRange,
+  satisfies,
+  compare,
+  gt,
+  gte,
+  lt,
+  lte,
+  eq,
+  sort,
+  rsort,
+  maxSatisfying,
+  minSatisfying,
+  valid,
+  coerce,
+} from './semver.js';
+
+// Package Manifest
+export {
+  PackageManifest,
+  ManifestError,
+  parseManifest,
+  createManifest,
+  stringifyManifest,
+} from './manifest.js';
+
+// Dependency Resolver
+export {
+  DependencyResolver,
+  SimpleResolver,
+  ResolutionError,
+  checkCompatibility,
+} from './resolver.js';
+
+// Package Fetcher
+export {
+  PackageFetcher,
+  NodePackageFetcher,
+  BrowserPackageFetcher,
+  FetchError,
+  createFetcher,
+} from './fetcher.js';
+
+// Lock File
+export {
+  LockFile,
+  LockedPackage,
+  LockFileError,
+  parseLockFile,
+  stringifyLockFile,
+  checkLockFileStatus,
+} from './lockfile.js';
+
+// Package Resolution
+export {
+  PackageContext,
+  createNodePackageContext,
+  createWebPackageContext,
+  getStoneHome,
+} from './packageResolver.js';
+
+// Browser Cache (web only)
+export {
+  BrowserPackageCache,
+  WebPackageManager,
+  createWebPackageManager,
+} from './browserCache.js';
+
+/**
+ * Create a package manager instance with all components wired together
+ */
+export function createPackageManager(options = {}) {
+  const fetcher = options.fetcher || (typeof window !== 'undefined'
+    ? new (require('./fetcher.js').BrowserPackageFetcher)(options)
+    : new (require('./fetcher.js').NodePackageFetcher)(options));
+
+  const resolver = new (require('./resolver.js').DependencyResolver)({
+    fetchVersions: (name, source) => fetcher.fetchVersions(name, source),
+    ...options,
+  });
+
+  return {
+    fetcher,
+    resolver,
+
+    /**
+     * Resolve dependencies from a manifest
+     */
+    async resolve(manifest) {
+      return resolver.resolve(manifest);
+    },
+
+    /**
+     * Fetch and install a package
+     */
+    async fetchPackage(name, version, source) {
+      return fetcher.fetchPackage(name, version, source);
+    },
+
+    /**
+     * Parse a package.son file
+     */
+    parseManifest: require('./manifest.js').parseManifest,
+
+    /**
+     * Parse a lock file
+     */
+    parseLockFile: require('./lockfile.js').parseLockFile,
+  };
+}
+
+export default {
+  // Re-export everything for convenient default import
+  createPackageManager,
+};