stone-lang 0.1.0

package/cli/commands/package.js

@@ -0,0 +1,713 @@
+/**
+ * Package commands - Manage Stone packages
+ *
+ * Usage:
+ *   stone install                              Install dependencies from package.son
+ *   stone install <pkg> --source <url>         Add and install from URL
+ *   stone install <pkg> --source <path>        Add and install from local directory
+ *   stone install -g <pkg>                     Install package globally
+ *   stone remove <pkg>                         Remove a dependency
+ *   stone update                               Update all dependencies
+ *   stone update <pkg>                         Update specific package
+ *   stone list                                 List installed packages
+ *   stone init                                 Create new package.son
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { parseManifest, createManifest, stringifyManifest } from '../../packages/manifest.js';
+import { parseLockFile, LockFile, stringifyLockFile } from '../../packages/lockfile.js';
+import { DependencyResolver } from '../../packages/resolver.js';
+import { createFetcher } from '../../packages/fetcher.js';
+import { parseRange, maxSatisfying } from '../../packages/semver.js';
+
+/**
+ * Check if a source is a URL or a local path
+ */
+function isUrl(source) {
+  return source.startsWith('http://') || source.startsWith('https://');
+}
+
+/**
+ * Check if a source is a local path
+ */
+function isLocalPath(source) {
+  // Absolute paths or relative paths starting with . or /
+  return !isUrl(source) && (
+    path.isAbsolute(source) ||
+    source.startsWith('./') ||
+    source.startsWith('../') ||
+    source.startsWith('.\\') ||
+    source.startsWith('..\\') ||
+    // Windows drive letters
+    /^[a-zA-Z]:/.test(source)
+  );
+}
+
+/**
+ * Find project root by walking up to find package.son
+ */
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+
+  while (currentDir) {
+    const manifestPath = path.join(currentDir, 'package.son');
+    if (fs.existsSync(manifestPath)) {
+      return currentDir;
+    }
+
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir) break; // Hit root
+    currentDir = parent;
+  }
+
+  return null;
+}
+
+/**
+ * Get Stone home directory
+ */
+function getStoneHome() {
+  if (process.env.STONE_HOME) {
+    return process.env.STONE_HOME;
+  }
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (home) {
+    return path.join(home, '.stone');
+  }
+  return null;
+}
+
+/**
+ * Initialize a new package.son
+ */
+export async function initCommand(options = {}) {
+  const { json = false, force = false } = options;
+  const cwd = process.cwd();
+  const manifestPath = path.join(cwd, 'package.son');
+
+  if (fs.existsSync(manifestPath) && !force) {
+    if (json) {
+      console.log(JSON.stringify({ error: 'package.son already exists. Use --force to overwrite.' }));
+    } else {
+      console.error('package.son already exists. Use --force to overwrite.');
+    }
+    process.exit(1);
+  }
+
+  // Get project name from directory
+  const projectName = path.basename(cwd).toLowerCase().replace(/[^a-z0-9_-]/g, '-');
+
+  const manifest = createManifest(projectName, '1.0.0');
+  const content = stringifyManifest(manifest);
+
+  fs.writeFileSync(manifestPath, content);
+
+  if (json) {
+    console.log(JSON.stringify({ success: true, file: manifestPath }));
+  } else {
+    console.log(`Created package.son`);
+  }
+}
+
+/**
+ * Install dependencies
+ */
+export async function installCommand(pkg = null, options = {}) {
+  const { json = false, global: isGlobal = false, source = null, save = true } = options;
+
+  // Determine target directory
+  let targetDir;
+  let manifestPath;
+
+  if (isGlobal) {
+    targetDir = getStoneHome();
+    if (!targetDir) {
+      const msg = 'Could not determine Stone home directory';
+      if (json) {
+        console.log(JSON.stringify({ error: msg }));
+      } else {
+        console.error(msg);
+      }
+      process.exit(1);
+    }
+    manifestPath = path.join(targetDir, 'package.son');
+
+    // Create global dirs if needed
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    const globalModules = path.join(targetDir, 'stone_modules');
+    if (!fs.existsSync(globalModules)) {
+      fs.mkdirSync(globalModules, { recursive: true });
+    }
+
+    // Create global package.son if needed
+    if (!fs.existsSync(manifestPath)) {
+      const manifest = createManifest('global', '0.0.0');
+      fs.writeFileSync(manifestPath, stringifyManifest(manifest));
+    }
+  } else {
+    targetDir = findProjectRoot();
+    if (!targetDir) {
+      const msg = 'No package.son found. Run `stone init` first.';
+      if (json) {
+        console.log(JSON.stringify({ error: msg }));
+      } else {
+        console.error(msg);
+      }
+      process.exit(1);
+    }
+    manifestPath = path.join(targetDir, 'package.son');
+  }
+
+  // Read manifest
+  const manifestContent = fs.readFileSync(manifestPath, 'utf8');
+  const manifest = parseManifest(manifestContent, manifestPath);
+
+  if (pkg) {
+    // Install specific package
+    await installPackage(pkg, source, manifest, manifestPath, targetDir, options);
+  } else {
+    // Install all dependencies from manifest
+    await installAllDependencies(manifest, targetDir, options);
+  }
+}
+
+/**
+ * Install a package from a local directory
+ */
+async function installFromLocalPath(pkg, sourcePath, manifest, manifestPath, targetDir, options) {
+  const { json = false, save = true } = options;
+
+  // Resolve the source path
+  const resolvedSource = path.resolve(sourcePath);
+
+  if (!fs.existsSync(resolvedSource)) {
+    throw new Error(`Source directory not found: ${resolvedSource}`);
+  }
+
+  const stat = fs.statSync(resolvedSource);
+  if (!stat.isDirectory()) {
+    throw new Error(`Source is not a directory: ${resolvedSource}`);
+  }
+
+  // Read the source package.son if it exists
+  const sourceManifestPath = path.join(resolvedSource, 'package.son');
+  let pkgManifest = null;
+  let version = '*';
+
+  if (fs.existsSync(sourceManifestPath)) {
+    try {
+      const content = fs.readFileSync(sourceManifestPath, 'utf8');
+      pkgManifest = parseManifest(content, sourceManifestPath);
+      version = pkgManifest.version || '*';
+    } catch (e) {
+      // Ignore manifest parse errors, proceed without version info
+    }
+  }
+
+  // Install to stone_modules
+  const modulesDir = path.join(targetDir, 'stone_modules', pkg);
+
+  // Remove existing if present
+  if (fs.existsSync(modulesDir)) {
+    fs.rmSync(modulesDir, { recursive: true, force: true });
+  }
+
+  // Copy all files from source to target
+  copyDirectorySync(resolvedSource, modulesDir);
+
+  // Update project manifest
+  if (save) {
+    // Store the absolute path as source for local packages
+    manifest.addDependency(pkg, version === '*' ? '*' : `^${version}`, resolvedSource);
+    fs.writeFileSync(manifestPath, stringifyManifest(manifest));
+  }
+
+  return { version };
+}
+
+/**
+ * Recursively copy a directory
+ */
+function copyDirectorySync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectorySync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Install a specific package
+ */
+async function installPackage(pkg, source, manifest, manifestPath, targetDir, options) {
+  const { json = false, save = true } = options;
+
+  if (!source) {
+    const msg = `Source required. Use: stone install ${pkg} --source <url-or-path>`;
+    if (json) {
+      console.log(JSON.stringify({ error: msg }));
+    } else {
+      console.error(msg);
+    }
+    process.exit(1);
+  }
+
+  // Check if source is a local path or URL
+  if (isLocalPath(source)) {
+    // Install from local directory
+    if (!json) {
+      console.log(`Installing ${pkg} from local path ${source}...`);
+    }
+
+    try {
+      const result = await installFromLocalPath(pkg, source, manifest, manifestPath, targetDir, options);
+
+      if (json) {
+        console.log(JSON.stringify({ success: true, package: pkg, version: result.version, source: 'local' }));
+      } else {
+        console.log(`  Installed ${pkg}@${result.version} (from local)`);
+      }
+    } catch (err) {
+      if (json) {
+        console.log(JSON.stringify({ error: err.message }));
+      } else {
+        console.error(`Failed to install ${pkg}: ${err.message}`);
+      }
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Install from URL
+  if (!json) {
+    console.log(`Installing ${pkg} from ${source}...`);
+  }
+
+  const fetcher = createFetcher();
+
+  try {
+    // Fetch available versions
+    const versionInfo = await fetcher.fetchVersions(pkg, source);
+
+    if (!versionInfo.versions || versionInfo.versions.length === 0) {
+      // No versions.son - try fetching latest directly
+      if (!json) {
+        console.log(`  Fetching package...`);
+      }
+
+      const pkgData = await fetcher.fetchPackage(pkg, 'latest', source);
+
+      // Install to stone_modules
+      const modulesDir = path.join(targetDir, 'stone_modules', pkg);
+      fs.mkdirSync(modulesDir, { recursive: true });
+
+      // Write files
+      for (const [filename, content] of pkgData.files) {
+        const filePath = path.join(modulesDir, filename);
+        const fileDir = path.dirname(filePath);
+        if (!fs.existsSync(fileDir)) {
+          fs.mkdirSync(fileDir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, content);
+      }
+
+      // Write package.son if available
+      if (pkgData.manifest) {
+        fs.writeFileSync(
+          path.join(modulesDir, 'package.son'),
+          JSON.stringify(pkgData.manifest, null, 2) // TODO: use stringifySON
+        );
+      }
+
+      // Update project manifest
+      if (save) {
+        manifest.addDependency(pkg, pkgData.manifest?.version || '*', source);
+        fs.writeFileSync(manifestPath, stringifyManifest(manifest));
+      }
+
+      if (json) {
+        console.log(JSON.stringify({ success: true, package: pkg, version: pkgData.manifest?.version }));
+      } else {
+        console.log(`  Installed ${pkg}@${pkgData.manifest?.version || 'latest'}`);
+      }
+    } else {
+      // Pick highest version
+      const version = versionInfo.versions[versionInfo.versions.length - 1];
+
+      if (!json) {
+        console.log(`  Found version ${version}`);
+      }
+
+      const pkgData = await fetcher.fetchPackage(pkg, version, source);
+
+      // Install to stone_modules
+      const modulesDir = path.join(targetDir, 'stone_modules', pkg);
+      fs.mkdirSync(modulesDir, { recursive: true });
+
+      for (const [filename, content] of pkgData.files) {
+        const filePath = path.join(modulesDir, filename);
+        const fileDir = path.dirname(filePath);
+        if (!fs.existsSync(fileDir)) {
+          fs.mkdirSync(fileDir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, content);
+      }
+
+      // Update project manifest
+      if (save) {
+        manifest.addDependency(pkg, `^${version}`, source);
+        fs.writeFileSync(manifestPath, stringifyManifest(manifest));
+      }
+
+      if (json) {
+        console.log(JSON.stringify({ success: true, package: pkg, version }));
+      } else {
+        console.log(`  Installed ${pkg}@${version}`);
+      }
+    }
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ error: err.message }));
+    } else {
+      console.error(`Failed to install ${pkg}: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Install all dependencies from manifest
+ */
+async function installAllDependencies(manifest, targetDir, options) {
+  const { json = false } = options;
+
+  const deps = manifest.getNormalizedDependencies();
+  const depNames = Object.keys(deps);
+
+  if (depNames.length === 0) {
+    if (json) {
+      console.log(JSON.stringify({ success: true, installed: 0 }));
+    } else {
+      console.log('No dependencies to install.');
+    }
+    return;
+  }
+
+  if (!json) {
+    console.log(`Installing ${depNames.length} dependencies...`);
+  }
+
+  const fetcher = createFetcher();
+  const installed = [];
+  const errors = [];
+
+  for (const name of depNames) {
+    const spec = deps[name];
+
+    try {
+      if (!json) {
+        console.log(`  ${name}...`);
+      }
+
+      // Check if source is a local path
+      if (spec.source && isLocalPath(spec.source)) {
+        // Install from local directory
+        const resolvedSource = path.resolve(spec.source);
+
+        if (!fs.existsSync(resolvedSource)) {
+          throw new Error(`Source directory not found: ${resolvedSource}`);
+        }
+
+        // Read the source package.son if it exists
+        const sourceManifestPath = path.join(resolvedSource, 'package.son');
+        let version = spec.version || '*';
+
+        if (fs.existsSync(sourceManifestPath)) {
+          try {
+            const content = fs.readFileSync(sourceManifestPath, 'utf8');
+            const pkgManifest = parseManifest(content, sourceManifestPath);
+            version = pkgManifest.version || version;
+          } catch (e) {
+            // Ignore manifest parse errors
+          }
+        }
+
+        // Install to stone_modules
+        const modulesDir = path.join(targetDir, 'stone_modules', name);
+
+        // Remove existing if present
+        if (fs.existsSync(modulesDir)) {
+          fs.rmSync(modulesDir, { recursive: true, force: true });
+        }
+
+        // Copy all files
+        copyDirectorySync(resolvedSource, modulesDir);
+
+        installed.push({ name, version });
+
+        if (!json) {
+          console.log(`    ✓ ${name}@${version} (local)`);
+        }
+      } else {
+        // Install from URL
+        const versionInfo = await fetcher.fetchVersions(name, spec.source);
+
+        let version;
+        if (versionInfo.versions && versionInfo.versions.length > 0) {
+          version = maxSatisfying(versionInfo.versions, spec.version);
+          if (!version) {
+            throw new Error(`No version satisfies ${spec.version}`);
+          }
+        } else {
+          version = 'latest';
+        }
+
+        const pkgData = await fetcher.fetchPackage(name, version, spec.source);
+
+        // Install to stone_modules
+        const modulesDir = path.join(targetDir, 'stone_modules', name);
+        fs.mkdirSync(modulesDir, { recursive: true });
+
+        for (const [filename, content] of pkgData.files) {
+          const filePath = path.join(modulesDir, filename);
+          const fileDir = path.dirname(filePath);
+          if (!fs.existsSync(fileDir)) {
+            fs.mkdirSync(fileDir, { recursive: true });
+          }
+          fs.writeFileSync(filePath, content);
+        }
+
+        installed.push({ name, version: pkgData.manifest?.version || version });
+
+        if (!json) {
+          console.log(`    ✓ ${name}@${pkgData.manifest?.version || version}`);
+        }
+      }
+    } catch (err) {
+      errors.push({ name, error: err.message });
+      if (!json) {
+        console.error(`    ✗ ${name}: ${err.message}`);
+      }
+    }
+  }
+
+  // Write lock file
+  const lockFile = new LockFile();
+  for (const { name, version } of installed) {
+    const spec = deps[name];
+    lockFile.setPackage(name, version, spec.source);
+  }
+  const lockPath = path.join(targetDir, 'package.lock.son');
+  fs.writeFileSync(lockPath, stringifyLockFile(lockFile));
+
+  if (json) {
+    console.log(JSON.stringify({
+      success: errors.length === 0,
+      installed: installed.length,
+      errors: errors.length > 0 ? errors : undefined,
+    }));
+  } else {
+    console.log(`\nInstalled ${installed.length}/${depNames.length} packages.`);
+    if (errors.length > 0) {
+      console.log(`${errors.length} errors occurred.`);
+    }
+  }
+
+  if (errors.length > 0) {
+    process.exit(1);
+  }
+}
+
+/**
+ * Remove a package
+ */
+export async function removeCommand(pkg, options = {}) {
+  const { json = false, global: isGlobal = false } = options;
+
+  let targetDir;
+  let manifestPath;
+
+  if (isGlobal) {
+    targetDir = getStoneHome();
+    if (!targetDir) {
+      const msg = 'Could not determine Stone home directory';
+      if (json) console.log(JSON.stringify({ error: msg }));
+      else console.error(msg);
+      process.exit(1);
+    }
+    manifestPath = path.join(targetDir, 'package.son');
+  } else {
+    targetDir = findProjectRoot();
+    if (!targetDir) {
+      const msg = 'No package.son found.';
+      if (json) console.log(JSON.stringify({ error: msg }));
+      else console.error(msg);
+      process.exit(1);
+    }
+    manifestPath = path.join(targetDir, 'package.son');
+  }
+
+  // Read manifest
+  const manifestContent = fs.readFileSync(manifestPath, 'utf8');
+  const manifest = parseManifest(manifestContent, manifestPath);
+
+  if (!manifest.hasDependency(pkg)) {
+    const msg = `Package ${pkg} is not a dependency`;
+    if (json) console.log(JSON.stringify({ error: msg }));
+    else console.error(msg);
+    process.exit(1);
+  }
+
+  // Remove from manifest
+  manifest.removeDependency(pkg);
+  fs.writeFileSync(manifestPath, stringifyManifest(manifest));
+
+  // Remove from stone_modules
+  const moduleDir = path.join(targetDir, 'stone_modules', pkg);
+  if (fs.existsSync(moduleDir)) {
+    fs.rmSync(moduleDir, { recursive: true, force: true });
+  }
+
+  if (json) {
+    console.log(JSON.stringify({ success: true, removed: pkg }));
+  } else {
+    console.log(`Removed ${pkg}`);
+  }
+}
+
+/**
+ * Update dependencies
+ */
+export async function updateCommand(pkg = null, options = {}) {
+  const { json = false } = options;
+
+  const targetDir = findProjectRoot();
+  if (!targetDir) {
+    const msg = 'No package.son found.';
+    if (json) console.log(JSON.stringify({ error: msg }));
+    else console.error(msg);
+    process.exit(1);
+  }
+
+  // For now, just re-install
+  // TODO: Implement proper update logic with version bumping
+  if (!json) {
+    console.log('Updating dependencies...');
+  }
+
+  const manifestPath = path.join(targetDir, 'package.son');
+  const manifestContent = fs.readFileSync(manifestPath, 'utf8');
+  const manifest = parseManifest(manifestContent, manifestPath);
+
+  await installAllDependencies(manifest, targetDir, options);
+}
+
+/**
+ * List installed packages
+ */
+export async function listCommand(options = {}) {
+  const { json = false, global: isGlobal = false } = options;
+
+  let targetDir;
+  let manifestPath;
+
+  if (isGlobal) {
+    targetDir = getStoneHome();
+    if (!targetDir) {
+      const msg = 'Could not determine Stone home directory';
+      if (json) console.log(JSON.stringify({ error: msg }));
+      else console.error(msg);
+      process.exit(1);
+    }
+    manifestPath = path.join(targetDir, 'package.son');
+  } else {
+    targetDir = findProjectRoot();
+    if (!targetDir) {
+      const msg = 'No package.son found.';
+      if (json) console.log(JSON.stringify({ error: msg }));
+      else console.error(msg);
+      process.exit(1);
+    }
+    manifestPath = path.join(targetDir, 'package.son');
+  }
+
+  if (!fs.existsSync(manifestPath)) {
+    if (json) {
+      console.log(JSON.stringify({ packages: [] }));
+    } else {
+      console.log('No packages installed.');
+    }
+    return;
+  }
+
+  const manifestContent = fs.readFileSync(manifestPath, 'utf8');
+  const manifest = parseManifest(manifestContent, manifestPath);
+
+  const deps = manifest.getNormalizedDependencies();
+  const packages = [];
+
+  // Check what's actually installed
+  const modulesDir = path.join(targetDir, 'stone_modules');
+  for (const [name, spec] of Object.entries(deps)) {
+    const pkgDir = path.join(modulesDir, name);
+    const installed = fs.existsSync(pkgDir);
+
+    let installedVersion = null;
+    if (installed) {
+      const pkgManifest = path.join(pkgDir, 'package.son');
+      if (fs.existsSync(pkgManifest)) {
+        try {
+          const content = fs.readFileSync(pkgManifest, 'utf8');
+          const pkg = parseManifest(content, pkgManifest);
+          installedVersion = pkg.version;
+        } catch (e) {
+          // Ignore parse errors
+        }
+      }
+    }
+
+    packages.push({
+      name,
+      wanted: spec.version,
+      installed: installedVersion,
+      source: spec.source,
+    });
+  }
+
+  if (json) {
+    console.log(JSON.stringify({ packages }));
+  } else {
+    if (packages.length === 0) {
+      console.log('No packages.');
+    } else {
+      console.log(`${isGlobal ? 'Global' : 'Project'} packages:\n`);
+      for (const pkg of packages) {
+        const status = pkg.installed ? `@${pkg.installed}` : '(not installed)';
+        console.log(`  ${pkg.name}${status}`);
+        if (pkg.source) {
+          console.log(`    source: ${pkg.source}`);
+        }
+      }
+    }
+  }
+}
+
+export default {
+  initCommand,
+  installCommand,
+  removeCommand,
+  updateCommand,
+  listCommand,
+};