cell/scripts/shop.cm

// Module shop system for managing dependencies and mods

var toml = use('toml')
var json = use('json')
var fd = use('fd')
var http = use('http')
var miniz = use('miniz')
var time = use('time')
var js = use('js')
var qop
var core_qop

// a locator is what is used to import a module, like prosperon/sprite
// in prosperon/sprite, sprite is the module, and prosperon is the package (usually, an alias)
// a canonical package name relates prosperon to its source, like gitea.pockle.world/john/prosperon

var Shop = {}

var SCOPE_LOCAL = 0
var SCOPE_PACKAGE = 1
var SCOPE_CORE = 2

var MOD_EXT = '.cm'
var ACTOR_EXT = '.ce'

var os 
var use_cache
Shop.set_os = function(o)
{
  os = o
  qop = os.load_internal('js_qop_use')
  core_qop = os.core_qop
  use_cache = os.use_cache
}

var config = null

var shop_path = '.cell/cell.toml'

var open_dl = {}

function get_import_package(name) {
  var parts = name.split('/')
  if (parts.length > 1)
    return parts[0]

  return null
}

function get_import_name(path)
{
  var parts = path.split('/')
  if (parts.length < 2) return null
  return parts.slice(1).join('/')
}

// given a path, get a full package import
// ie, 'prosperon/sprite' would return 'gitea.pockle.world/john/prosperon/sprite'
// if prosperon were a dependency
function get_package_from_path(path, ctx)
{
  var pkg = get_import_package(path)
  var locator = get_import_name(path)
  if (!pkg) return null

  var pck = get_normalized_module(pkg, ctx)
  return pck + "/" + locator
}

function get_normalized_package(path, ctx)
{
  var pkg = get_import_package(path)
  if (!pkg) return null
  return get_normalized_module(pkg, ctx)
}

// taking the package into account, find the canonical name
function get_normalized_module(mod, ctx) {
  var deps = Shop.load_config(ctx);
  return deps.dependencies[mod]
}

function get_import_dl(name) {
  var pkg = get_import_package(name)
  if (!pkg) return null
  if (open_dl[pkg]) return open_dl[pkg]
  var dlpath = `.cell/modules/${pkg}/${pkg}${dylib_ext}`
  var dl = os.dylib_open(dlpath)
  if (dl) {
    open_dl[pkg] = dl
    return dl
  }
  return null
}

Shop.get_c_symbol = function get_c_symbol(name) {
  var dl = get_import_dl(name)
  var symname = `js_${name.replace('/', '_')}_use`

  if (dl)
    return os.dylib_symbol(dl, symname)
  else
    return os.load_internal(symname)
}

function slurpwrite(path, content) {
  var f = fd.open(path)
  fd.write(f, content)
  fd.close(f)
}

function ensure_dir(path) {
  if (fd.stat(path).isDirectory) return true
  
  var parts = path.split('/')
  var current = ''
  for (var i = 0; i < parts.length; i++) {
    if (parts[i] == '') continue
    current += parts[i] + '/'
    if (!fd.stat(current).isDirectory) {
      fd.mkdir(current)
    }
  }
  return true
}

// Load cell.toml configuration
// module given in canonical format (e.g., "gitea.pockle.world/john/prosperon")
// If module is null, loads the root cell.toml
// If module is provided, loads module/cell.toml
Shop.load_config = function(module) {
  var content
  if (!module) {
    if (!fd.is_file(shop_path))
      return null
    
    content = fd.slurp(shop_path)
  } else {
    var module_path = `.cell/modules/${module}/cell.toml`
    if (!fd.stat(module_path).isFile)
      return null
    
    content = fd.slurp(module_path)
  }

  if (!content.length) return {}
  return toml.decode(text(content))
}

// Save cell.toml configuration
Shop.save_config = function(config) {
  slurpwrite(shop_path, toml.encode(config));
}

function lock_path(pkg)
{
  if (pkg)
    return `.cell/modules/${pkg}/.cell/lock.toml`
  else
    return '.cell/lock.toml'
}

// Load lock.toml configuration
Shop.load_lock = function(pkg) {
  var path = lock_path(pkg)
  
  if (!fd.is_file(path))
    return null
  
  var content = text(fd.slurp(lock_path))
  return toml.decode(content)
}

// Save lock.toml configuration
Shop.save_lock = function(pkg, lock) {
  var path = lock_path(pkg)
  slurpwrite(path, toml.encode(lock));
}

// Initialize .cell directory structure
Shop.init = function() {
  if (!fd.is_directory('.cell')) {
    fd.mkdir('.cell')
  }
  
  if (!fd.is_directory('.cell/modules')) {
    fd.mkdir('.cell/modules')
  }
  
  if (!fd.is_directory('.cell/build')) {
    fd.mkdir('.cell/build')
  }
  
  if (!fd.is_file('.cell/lock.toml')) {
    slurpwrite('.cell/lock.toml', '# Lock file for module integrity\n');
  }
  
  return true
}

// Parse module locator (e.g., "https://git.world/jj/mod@v0.6.3")
Shop.parse_locator = function(locator) {
  var protocol = null
  var path = locator
  var version = null
  
  // Extract method (e.g., "https")
  if (locator.includes('://')) {
    var methodParts = locator.split('://')
    protocol = methodParts[0]
    path = methodParts[1]
  }
  
  // Extract version if present
  if (path.includes('@')) {
    var versionParts = path.split('@')
    path = versionParts[0]
    version = versionParts[1]
  }
  
  // Extract name (last part of path)
  var name = path.split('/').pop()
  
  return {
    protocol,
    path,
    name,
    version
  }
}

// Convert module locator to download URL
Shop.get_download_url = function(locator) {
  var parsed = Shop.parse_locator(locator)
  if (!parsed) return null
  
  // Handle different git hosting patterns
  if (locator.startsWith('https://')) {
    // Remove https:// prefix for parsing
    var cleanLocator = locator.substring(8)
    var hostAndPath = cleanLocator.split('@')[0]
    
    // Gitea pattern: gitea.pockle.world/user/repo@branch
    if (hostAndPath.includes('gitea.')) {
      return 'https://' + hostAndPath + '/archive/' + parsed.version + '.zip'
    }
    
    // GitHub pattern: github.com/user/repo@tag
    if (hostAndPath.includes('github.com')) {
      return 'https://' + hostAndPath + '/archive/refs/tags/' + parsed.version + '.zip'
    }
    
    // GitLab pattern: gitlab.com/user/repo@tag
    if (hostAndPath.includes('gitlab.')) {
      return 'https://' + hostAndPath + '/-/archive/' + parsed.version + '/' + parsed.name + '-' + parsed.version + '.zip'
    }
  } else {
      // Implicit https
      var hostAndPath = parsed.path
       // Gitea pattern: gitea.pockle.world/user/repo@branch
      if (hostAndPath.includes('gitea.')) {
        return 'https://' + hostAndPath + '/archive/' + parsed.version + '.zip'
      }
      
      // GitHub pattern: github.com/user/repo@tag
      if (hostAndPath.includes('github.com')) {
        return 'https://' + hostAndPath + '/archive/refs/tags/' + parsed.version + '.zip'
      }
  }
  
  // Fallback to original locator if no pattern matches
  return locator
}

// Add a dependency
Shop.add_dependency = function(alias, locator) {
  var config = Shop.load_config()
  if (!config)
    throw new Error("No cell.toml found");
  
  if (!config.dependencies)
    config.dependencies = {}

  if (config.dependencies[alias] == locator)
    throw new Error("Dependency '" + alias + "' already exists with the same version");
  
  config.dependencies[alias] = locator
  Shop.save_config(config)
  return true
}

// Remove a dependency
Shop.remove_dependency = function(alias) {
  var config = Shop.load_config()
  if (!config) {
    log.error("No cell.toml found")
    return false
  }
  
  if (!config.dependencies || !config.dependencies[alias]) {
    return false
  }
  
  delete config.dependencies[alias]
  Shop.save_config(config)
  return true
}

// Get the API URL for checking remote git commits
Shop.get_api_url = function(locator) {
  var parsed = Shop.parse_locator(locator)
  if (!parsed) return null
  
  var hostAndPath = parsed.path
  if (locator.startsWith('https://')) {
    hostAndPath = locator.substring(8).split('@')[0]
  }
  
  var parts = hostAndPath.split('/')
  
  // Gitea pattern: gitea.pockle.world/user/repo@branch
  if (hostAndPath.includes('gitea.')) {
    var host = parts[0]
    var user = parts[1]
    var repo = parts[2]
    return 'https://' + host + '/api/v1/repos/' + user + '/' + repo + '/branches/' + parsed.version
  }
  
  // GitHub pattern: github.com/user/repo@tag or @branch
  if (hostAndPath.includes('github.com')) {
    var user = parts[1]
    var repo = parts[2]
    // Try branch first, then tag
    return 'https://api.github.com/repos/' + user + '/' + repo + '/branches/' + parsed.version
  }
  
  // GitLab pattern: gitlab.com/user/repo@tag
  if (hostAndPath.includes('gitlab.')) {
    var user = parts[1]
    var repo = parts[2]
    var projectId = encodeURIComponent(user + '/' + repo)
    return 'https://' + parts[0] + '/api/v4/projects/' + projectId + '/repository/branches/' + parsed.version
  }
  
  // Fallback - return null if no API pattern matches
  return null
}

// Extract commit hash from API response
Shop.extract_commit_hash = function(locator, response) {
  if (!response) return null
  
  var data
  try {
    data = json.decode(response)
  } catch (e) {
    log.console("Failed to parse API response: " + e)
    return null
  }
  
  // Handle different git hosting response formats
  if (locator.includes('gitea.')) {
    // Gitea: response.commit.id
    return data.commit && data.commit.id
  } else if (locator.includes('github.com')) {
    // GitHub: response.commit.sha
    return data.commit && data.commit.sha
  } else if (locator.includes('gitlab.')) {
    // GitLab: response.commit.id
    return data.commit && data.commit.id
  }
  
  return null
}

// Get the module directory for a given alias
Shop.get_module_dir = function(alias) {
  var config = Shop.load_config()
  if (!config || !config.dependencies || !config.dependencies[alias]) {
    return null
  }
  
  // Check if replaced
  if (config.replace && config.replace[alias]) {
    return config.replace[alias]
  }

  var locator = config.dependencies[alias]
  var parsed = Shop.parse_locator(locator)
  if (!parsed) return null
  
  return '.cell/modules/' + parsed.path
}

// Install a dependency
Shop.install = function(alias) {
  var config = Shop.load_config()
  if (!config || !config.dependencies || !config.dependencies[alias]) {
    log.error("Dependency not found in config: " + alias)
    return false
  }

  var locator = config.dependencies[alias]
  var parsed = Shop.parse_locator(locator)
  var target_dir = '.cell/modules/' + parsed.path
  
  log.console("Installing " + alias + " (" + locator + ")...")
  
  // 1. Get Commit Hash
  var api_url = Shop.get_api_url(locator)
  var commit_hash = null
  if (api_url) {
    try {
      log.console("Fetching info from " + api_url)
      var resp = http.fetch(api_url)
      var resp_text = text(resp)
      commit_hash = Shop.extract_commit_hash(locator, resp_text)
      log.console("Resolved commit: " + commit_hash)
    } catch (e) {
      log.console("Warning: Failed to fetch API info: " + e)
    }
  }

  // 2. Download Zip
  var download_url = Shop.get_download_url(locator)
  if (!download_url) {
    log.error("Could not determine download URL for " + locator)
    return false
  }
  
  log.console("Downloading from " + download_url)
  var zip_blob
  try {
    zip_blob = http.fetch(download_url)
  } catch (e) {
    log.error("Download failed: " + e)
    return false
  }
  
  // 3. Unpack
  log.console("Unpacking to " + target_dir)
  ensure_dir(target_dir)
  
  var zip = miniz.read(zip_blob)
  if (!zip) {
    log.error("Failed to read zip archive")
    return false
  }
  
  var count = zip.count()
  for (var i = 0; i < count; i++) {
    if (zip.is_directory(i)) continue
    
    var filename = zip.get_filename(i)
    // Strip top-level directory
    var parts = filename.split('/')
    if (parts.length > 1) {
      parts.shift() // Remove root folder
      var rel_path = parts.join('/')
      
      var full_path = target_dir + '/' + rel_path
      var dir_path = full_path.substring(0, full_path.lastIndexOf('/'))
      ensure_dir(dir_path)
      
      var content = zip.slurp(filename)
      slurpwrite(full_path, content)
    }
  }
  
  // 4. Update Lock
  if (commit_hash) {
    var lock = Shop.load_lock()
    lock[alias] = {
      locator: locator,
      commit: commit_hash,
      updated: time.number()
    }
    Shop.save_lock(lock)
  }
  
  log.console("Installed " + alias)
  return true
}

// Verify dependencies
Shop.verify = function() {
  var config = Shop.load_config()
  if (!config || !config.dependencies) return true
  
  var all_ok = true
  for (var alias in config.dependencies) {
    var dir = Shop.get_module_dir(alias)
    if (!dir) {
        // Might be a replace that is invalid or something else
        continue
    }
    if (!fd.stat(dir).isDirectory) {
      log.error("Missing dependency: " + alias + " (expected at " + dir + ")")
      all_ok = false
    } else {
        // Check if empty?
    }
  }
  return all_ok
}

var open_dls = {}

function resolve_locator(path, ext, ctx)
{
  var local_path
  if (ctx) 
    local_path = `.cell/modules/${ctx}/${path}${ext}`
  else
    local_path = path + ext
    
  if (fd.is_file(local_path))
    return {path: local_path, scope: SCOPE_LOCAL, script: text(fd.slurp(local_path))};

  var mod_path = `.cell/modules/${get_package_from_path(path, ctx)}${ext}`

  if (fd.is_file(mod_path))
    return {path: mod_path, scope: SCOPE_PACKAGE, script: text(fd.slurp(mod_path))};

  var core = core_qop.read(path + ext)
  if (core)
    return {path, scope: SCOPE_CORE, script: text(core)};

  return null;
}

function resolve_c_symbol(path, package_ctx)
{
  var local_path = package_ctx ? package_ctx : 'local'
  var local = `js_${local_path}_${path.replace('/', '_')}_use`
  var local_dl_name = `.cell/build/${local_path}/cellmod.dylib`

  if (fd.is_file(local_dl_name)) {
    if (!open_dls[local_dl_name])
      open_dls[local_dl_name] = os.dylib_open(local_dl_name);
    
    if (open_dls[local_dl_name]) {
      var local_addr = os.dylib_symbol(open_dls[local_dl_name], local);
      if (local_addr) return {symbol: local_addr, scope: SCOPE_LOCAL};
    }
  }

  var static_local_addr = os.load_internal(`js_${local_path}_${path.replace('/', '_')}_use`);
  if (static_local_addr) return {symbol: static_local_addr, scope: SCOPE_LOCAL};

  var pkg = get_package_from_path(path, package_ctx)
  if (pkg) {
    var package_sym = `js_${pkg.replace('/', '_')}_use`
    var canon_pkg = get_normalized_package(path, package_ctx)
    var package_dl_name = `.cell/build/${canon_pkg}/cellmod.dylib`;
    
    if (canon_pkg && fd.is_file(package_dl_name)) {
      if (!open_dls[package_dl_name])
        open_dls[package_dl_name] = os.dylib_open(package_dl_name);
      
      if (open_dls[package_dl_name]) {
        var package_addr = os.dylib_symbol(open_dls[package_dl_name], package_sym);
        if (package_addr)
          return {symbol:package_addr, scope: SCOPE_PACKAGE, package: canon_pkg};
      }
    }
    
    var static_package_addr = os.load_internal(`js_${pkg.replace('/', '_')}_use`);
    if (static_package_addr)
      return {symbol:static_package_addr, scope: SCOPE_PACKAGE, package: canon_pkg};
  }

  var core_addr = os.load_internal(`js_${path.replace('/', '_')}_use`);
  if (core_addr)
    return {symbol:core_addr, scope: SCOPE_CORE};

  return null
}

function mod_scriptor(name, script)
{
  return `(function setup_${name}_module($_){${script}})`
}

function eval_mod(path, script, c_sym)
{
  var content = mod_scriptor(path, script)
  var fn = js.eval(path, content)
  return fn.call(c_sym)
}

// first looks in local
// then in dependencies
// then in core
// package_context: optional package context to resolve relative paths within
Shop.use = function(path, package_context) {
  var c_resolve = resolve_c_symbol(path, package_context) || {scope:999}
  var mod_resolve = resolve_locator(path, '.cm', package_context) || {scope:999}

  var min_scope = Math.min(c_resolve.scope, mod_resolve.scope)

  if (min_scope == 999) {
    throw new Error(`Module ${path} could not be found`)
  }

  var cache_key = `${text(min_scope)}::${path}`

  if (use_cache[cache_key])
    return use_cache[cache_key]

  if (c_resolve.scope < mod_resolve.scope)
    use_cache[cache_key] = c_resolve.symbol
  else if (mod_resolve.scope < c_resolve.scope)
    use_cache[cache_key] = eval_mod(mod_resolve.path, mod_resolve.script)
  else
    use_cache[cache_key] = eval_mod(mod_resolve.path, mod_resolve.script, c_resolve.symbol)

  return use_cache[cache_key]
}

Shop.resolve_locator = resolve_locator

// Check for updates
Shop.update = function() {
  var config = Shop.load_config()
  if (!config || !config.dependencies) return
  
  var lock = Shop.load_lock()
  
  for (var alias in config.dependencies) {
    var locator = config.dependencies[alias]
    var api_url = Shop.get_api_url(locator)
    
    if (api_url) {
      try {
        var resp = http.fetch(api_url)
        var resp_text = text(resp)
        var remote_hash = Shop.extract_commit_hash(locator, resp_text)
        
        var local_hash = lock[alias] ? lock[alias].commit : null
        
        if (remote_hash && remote_hash != local_hash) {
          log.console("Update available for " + alias + ": " + local_hash + " -> " + remote_hash)
          Shop.install(alias)
        } else {
          log.console(alias + " is up to date.")
        }
      } catch (e) {
        log.error("Failed to check update for " + alias + ": " + e)
      }
    }
  }
}

// Compile a module
Shop.compile_module = function(alias) {
  var module_dir = Shop.get_module_dir(alias)
  if (!module_dir) {
    log.error("Module not found: " + alias)
    return false
  }
  
  log.console("Would compile module: " + alias + " from " + module_dir)
  return true
}

// Build all modules
Shop.build = function() {
  var config = Shop.load_config()
  if (!config || !config.dependencies) {
    return true
  }
  
  for (var alias in config.dependencies) {
    Shop.compile_module(alias)
  }
  
  return true
}

// Get all declared dependencies as a map of alias -> locator
Shop.get_dependencies = function() {
  var config = Shop.load_config()
  if (!config || !config.dependencies) {
    return {}
  }
  return config.dependencies
}

// Resolve a module path given a package context
// Returns { path, package_name } or null if not found
// Resolution order:
//   1. Local to the current package (if package_name is set)
//   2. Declared dependencies (by alias)
//   3. Core modules (handled by caller)
Shop.resolve_module = function(module_name, package_name, is_file_fn) {
  var config = Shop.load_config()
  var dependencies = (config && config.dependencies) || {}
  
  // If we're in a package context, check the package first
  if (package_name) {
    var pkg_path = '.cell/modules/' + package_name + '/' + module_name + '.cm'
    if (is_file_fn(pkg_path)) {
      return { path: pkg_path, package_name: package_name }
    }
  }
  
  // Check if module_name contains a slash (explicit package reference)
  if (module_name.includes('/')) {
    var parts = module_name.split('/')
    var pkg_alias = parts[0]
    var sub_module = parts.slice(1).join('/')
    
    // Check if it's a declared dependency
    if (dependencies[pkg_alias]) {
      // Need to resolve alias to canonical path
      var locator = dependencies[pkg_alias]
      var parsed = Shop.parse_locator(locator)
      var canonical_path = parsed.path
      
      var dep_path = '.cell/modules/' + canonical_path + '/' + sub_module + '.cm'
      if (is_file_fn(dep_path)) {
        return { path: dep_path, package_name: pkg_alias }
      }
    }
    
    // Check local path (relative to project root)
    var local_path = module_name + '.cm'
    if (is_file_fn(local_path)) {
      return { path: local_path, package_name: null }
    }
  } else {
    // Simple module name - check local first, then dependencies
    var local_path = module_name + '.cm'
    if (is_file_fn(local_path)) {
      return { path: local_path, package_name: null }
    }
    
    // Check each declared dependency for this module
    for (var alias in dependencies) {
      var locator = dependencies[alias]
      var parsed = Shop.parse_locator(locator)
      var canonical_path = parsed.path
      
      var dep_path = '.cell/modules/' + canonical_path + '/' + module_name + '.cm'
      if (is_file_fn(dep_path)) {
        return { path: dep_path, package_name: alias }
      }
    }
  }
  
  return null
}

return Shop