stone-lang 0.1.0

package/packages/lockfile.js

@@ -0,0 +1,271 @@
+/**
+ * Stone Package Lock File Handler
+ *
+ * Handles reading and writing package.lock.son files.
+ * Ensures reproducible builds with locked versions.
+ */
+
+import { parseSON, stringifySON } from '../frontend/parsing/sonParser.js';
+import { parseVersion, valid as validVersion } from './semver.js';
+
+/**
+ * Lock file version - increment when format changes
+ */
+const LOCK_VERSION = 1;
+
+/**
+ * Lock file error
+ */
+export class LockFileError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'LockFileError';
+  }
+}
+
+/**
+ * Locked package entry
+ */
+export class LockedPackage {
+  constructor(data = {}) {
+    this.name = data.name || '';
+    this.version = data.version || '';
+    this.source = data.source || null;
+    this.integrity = data.integrity || null;
+    this.dependencies = data.dependencies || {};
+  }
+
+  toObject() {
+    const obj = {
+      version: this.version,
+    };
+
+    if (this.source) {
+      obj.source = this.source;
+    }
+    if (this.integrity) {
+      obj.integrity = this.integrity;
+    }
+    if (Object.keys(this.dependencies).length > 0) {
+      obj.dependencies = this.dependencies;
+    }
+
+    return obj;
+  }
+}
+
+/**
+ * Lock file representation
+ */
+export class LockFile {
+  constructor() {
+    this.lockVersion = LOCK_VERSION;
+    this.packages = new Map(); // name -> LockedPackage
+  }
+
+  /**
+   * Add or update a locked package
+   */
+  setPackage(name, version, source = null, integrity = null, dependencies = {}) {
+    this.packages.set(name, new LockedPackage({
+      name,
+      version,
+      source,
+      integrity,
+      dependencies,
+    }));
+  }
+
+  /**
+   * Get a locked package
+   */
+  getPackage(name) {
+    return this.packages.get(name) || null;
+  }
+
+  /**
+   * Check if a package is locked
+   */
+  hasPackage(name) {
+    return this.packages.has(name);
+  }
+
+  /**
+   * Get the locked version of a package
+   */
+  getVersion(name) {
+    const pkg = this.packages.get(name);
+    return pkg ? pkg.version : null;
+  }
+
+  /**
+   * Remove a locked package
+   */
+  removePackage(name) {
+    this.packages.delete(name);
+  }
+
+  /**
+   * Clear all locked packages
+   */
+  clear() {
+    this.packages.clear();
+  }
+
+  /**
+   * Get all package names
+   */
+  getPackageNames() {
+    return Array.from(this.packages.keys());
+  }
+
+  /**
+   * Validate the lock file
+   */
+  validate() {
+    for (const [name, pkg] of this.packages) {
+      if (!pkg.version) {
+        throw new LockFileError(`Missing version for package: ${name}`);
+      }
+      if (!validVersion(pkg.version)) {
+        throw new LockFileError(`Invalid version for ${name}: ${pkg.version}`);
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Convert to plain object for serialization
+   */
+  toObject() {
+    const packages = {};
+
+    for (const [name, pkg] of this.packages) {
+      packages[name] = pkg.toObject();
+    }
+
+    return {
+      lockVersion: this.lockVersion,
+      packages,
+    };
+  }
+
+  /**
+   * Convert to .son string
+   */
+  toString() {
+    return stringifySON(this.toObject());
+  }
+
+  /**
+   * Create from resolved dependencies
+   * @param {Map|object} resolved - Map of name to { version, source?, integrity? }
+   */
+  static fromResolved(resolved) {
+    const lockFile = new LockFile();
+
+    const entries = resolved instanceof Map
+      ? Array.from(resolved.entries())
+      : Object.entries(resolved);
+
+    for (const [name, info] of entries) {
+      lockFile.setPackage(
+        name,
+        info.version,
+        info.source || null,
+        info.integrity || null,
+        info.dependencies || {}
+      );
+    }
+
+    return lockFile;
+  }
+}
+
+/**
+ * Parse a package.lock.son file content
+ * @param {string} content - The file content
+ * @param {string} filename - Optional filename for error messages
+ * @returns {LockFile} Parsed lock file
+ */
+export function parseLockFile(content, filename = 'package.lock.son') {
+  let data;
+
+  try {
+    data = parseSON(content, filename);
+  } catch (e) {
+    throw new LockFileError(`Failed to parse lock file: ${e.message}`);
+  }
+
+  // Check version compatibility
+  if (data.lockVersion && data.lockVersion > LOCK_VERSION) {
+    throw new LockFileError(
+      `Lock file version ${data.lockVersion} is newer than supported version ${LOCK_VERSION}. ` +
+      'Please update your Stone installation.'
+    );
+  }
+
+  const lockFile = new LockFile();
+  lockFile.lockVersion = data.lockVersion || 1;
+
+  if (data.packages && typeof data.packages === 'object') {
+    for (const [name, pkgData] of Object.entries(data.packages)) {
+      lockFile.setPackage(
+        name,
+        pkgData.version,
+        pkgData.source,
+        pkgData.integrity,
+        pkgData.dependencies
+      );
+    }
+  }
+
+  lockFile.validate();
+  return lockFile;
+}
+
+/**
+ * Stringify a lock file to .son format
+ */
+export function stringifyLockFile(lockFile) {
+  if (lockFile instanceof LockFile) {
+    return lockFile.toString();
+  }
+  return stringifySON(lockFile);
+}
+
+/**
+ * Check if a lock file is up to date with a manifest
+ * @param {LockFile} lockFile - The lock file
+ * @param {object} manifest - The package manifest
+ * @returns {{upToDate: boolean, missing: string[], extra: string[], outdated: string[]}}
+ */
+export function checkLockFileStatus(lockFile, manifest) {
+  const deps = manifest.dependencies || {};
+  const locked = lockFile.getPackageNames();
+  const depNames = Object.keys(deps);
+
+  const missing = depNames.filter(name => !lockFile.hasPackage(name));
+  const extra = locked.filter(name => !deps[name]);
+
+  // Check if any locked versions are outside their range
+  // (This would require re-resolving, so we just flag any missing)
+  const outdated = []; // Would need to compare with constraints
+
+  return {
+    upToDate: missing.length === 0 && extra.length === 0,
+    missing,
+    extra,
+    outdated,
+  };
+}
+
+export default {
+  LockFile,
+  LockedPackage,
+  LockFileError,
+  parseLockFile,
+  stringifyLockFile,
+  checkLockFileStatus,
+  LOCK_VERSION,
+};

package/packages/manifest.js

@@ -0,0 +1,291 @@
+/**
+ * Stone Package Manifest Handler
+ *
+ * Reads, writes, and validates package.son files.
+ */
+
+import { parseSON, stringifySON, SONParseError } from '../frontend/parsing/sonParser.js';
+import { parseVersion, parseRange, valid as validVersion } from './semver.js';
+
+/**
+ * Manifest validation error
+ */
+export class ManifestError extends Error {
+  constructor(message, field = null) {
+    super(message);
+    this.name = 'ManifestError';
+    this.field = field;
+  }
+}
+
+/**
+ * Parsed package manifest
+ */
+export class PackageManifest {
+  constructor(data = {}) {
+    // Required fields
+    this.name = data.name || '';
+    this.version = data.version || '';
+
+    // Optional fields
+    this.entry = data.entry || 'main.stn';
+    this.description = data.description || '';
+    this.author = data.author || '';
+    this.license = data.license || '';
+    this.keywords = data.keywords || [];
+    this.repository = data.repository || '';
+
+    // Dependencies: { name: { version, source } }
+    this.dependencies = data.dependencies || {};
+
+    // Dev dependencies (not needed for runtime)
+    this.devDependencies = data.devDependencies || {};
+
+    // Raw data for any additional fields
+    this._raw = data;
+  }
+
+  /**
+   * Validate the manifest
+   * @throws {ManifestError} If validation fails
+   */
+  validate() {
+    // Required: name
+    if (!this.name) {
+      throw new ManifestError('Missing required field: name', 'name');
+    }
+    if (typeof this.name !== 'string') {
+      throw new ManifestError('name must be a string', 'name');
+    }
+    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(this.name)) {
+      throw new ManifestError(
+        'name must start with a letter and contain only letters, numbers, underscores, and hyphens',
+        'name'
+      );
+    }
+
+    // Required: version
+    if (!this.version) {
+      throw new ManifestError('Missing required field: version', 'version');
+    }
+    if (!validVersion(this.version)) {
+      throw new ManifestError(`Invalid version: ${this.version}`, 'version');
+    }
+
+    // Optional: entry
+    if (this.entry && typeof this.entry !== 'string') {
+      throw new ManifestError('entry must be a string', 'entry');
+    }
+
+    // Optional: keywords
+    if (this.keywords && !Array.isArray(this.keywords)) {
+      throw new ManifestError('keywords must be an array', 'keywords');
+    }
+
+    // Validate dependencies
+    this.validateDependencies(this.dependencies, 'dependencies');
+    this.validateDependencies(this.devDependencies, 'devDependencies');
+
+    return true;
+  }
+
+  /**
+   * Validate a dependencies object
+   */
+  validateDependencies(deps, field) {
+    if (!deps || typeof deps !== 'object') return;
+
+    for (const [name, spec] of Object.entries(deps)) {
+      // Validate dependency name
+      if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)) {
+        throw new ManifestError(
+          `Invalid dependency name: ${name}`,
+          `${field}.${name}`
+        );
+      }
+
+      // Spec can be a string (version only) or object (version + source)
+      if (typeof spec === 'string') {
+        // Validate version range
+        try {
+          parseRange(spec);
+        } catch (e) {
+          throw new ManifestError(
+            `Invalid version range for ${name}: ${spec}`,
+            `${field}.${name}`
+          );
+        }
+      } else if (typeof spec === 'object' && spec !== null) {
+        // Must have version
+        if (!spec.version) {
+          throw new ManifestError(
+            `Missing version for dependency: ${name}`,
+            `${field}.${name}.version`
+          );
+        }
+        try {
+          parseRange(spec.version);
+        } catch (e) {
+          throw new ManifestError(
+            `Invalid version range for ${name}: ${spec.version}`,
+            `${field}.${name}.version`
+          );
+        }
+
+        // Optional source
+        if (spec.source && typeof spec.source !== 'string') {
+          throw new ManifestError(
+            `source must be a string for dependency: ${name}`,
+            `${field}.${name}.source`
+          );
+        }
+      } else {
+        throw new ManifestError(
+          `Invalid dependency specification for: ${name}`,
+          `${field}.${name}`
+        );
+      }
+    }
+  }
+
+  /**
+   * Get normalized dependencies (always { version, source? })
+   */
+  getNormalizedDependencies() {
+    const result = {};
+
+    for (const [name, spec] of Object.entries(this.dependencies)) {
+      if (typeof spec === 'string') {
+        result[name] = { version: spec };
+      } else {
+        result[name] = { ...spec };
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Add a dependency
+   */
+  addDependency(name, version, source = null) {
+    if (source) {
+      this.dependencies[name] = { version, source };
+    } else {
+      this.dependencies[name] = version;
+    }
+  }
+
+  /**
+   * Remove a dependency
+   */
+  removeDependency(name) {
+    delete this.dependencies[name];
+  }
+
+  /**
+   * Check if a dependency exists
+   */
+  hasDependency(name) {
+    return name in this.dependencies;
+  }
+
+  /**
+   * Convert to plain object for serialization
+   */
+  toObject() {
+    const obj = {
+      name: this.name,
+      version: this.version,
+    };
+
+    if (this.entry && this.entry !== 'main.stn') {
+      obj.entry = this.entry;
+    }
+    if (this.description) {
+      obj.description = this.description;
+    }
+    if (this.author) {
+      obj.author = this.author;
+    }
+    if (this.license) {
+      obj.license = this.license;
+    }
+    if (this.keywords && this.keywords.length > 0) {
+      obj.keywords = this.keywords;
+    }
+    if (this.repository) {
+      obj.repository = this.repository;
+    }
+    if (Object.keys(this.dependencies).length > 0) {
+      obj.dependencies = this.dependencies;
+    }
+    if (Object.keys(this.devDependencies).length > 0) {
+      obj.devDependencies = this.devDependencies;
+    }
+
+    return obj;
+  }
+
+  /**
+   * Convert to .son string
+   */
+  toString() {
+    return stringifySON(this.toObject());
+  }
+}
+
+/**
+ * Parse a package.son file content
+ * @param {string} content - The file content
+ * @param {string} filename - Optional filename for error messages
+ * @returns {PackageManifest} Parsed manifest
+ */
+export function parseManifest(content, filename = 'package.son') {
+  let data;
+
+  try {
+    data = parseSON(content, filename);
+  } catch (e) {
+    if (e instanceof SONParseError) {
+      throw new ManifestError(`Failed to parse ${filename}: ${e.message}`);
+    }
+    throw e;
+  }
+
+  const manifest = new PackageManifest(data);
+  manifest.validate();
+
+  return manifest;
+}
+
+/**
+ * Create a new manifest with default values
+ */
+export function createManifest(name, version = '1.0.0') {
+  const manifest = new PackageManifest({
+    name,
+    version,
+    entry: 'main.stn',
+  });
+  manifest.validate();
+  return manifest;
+}
+
+/**
+ * Stringify a manifest to .son format
+ */
+export function stringifyManifest(manifest) {
+  if (manifest instanceof PackageManifest) {
+    return manifest.toString();
+  }
+  return stringifySON(manifest);
+}
+
+export default {
+  PackageManifest,
+  ManifestError,
+  parseManifest,
+  createManifest,
+  stringifyManifest,
+};