soso-ppm 2.4.8

package/.github/workflows/npm-publish.yaml

@@ -0,0 +1,24 @@
+name: Publish to npm
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          registry-url: https://registry.npmjs.org/
+
+      - run: npm install
+
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NitoGX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# Soso
+A powerfull package manager!
+## What is "Soso"?
+Soso is a powerfull package manager written in javascript using Node.js.
+To install, publish, update packages, you'll need the pre-requesites below
+## Pre-requesites
+- Node.js (https://nodejs.org)
+- Git (https://git-scm.com/)
+## How to install?
+First, clone the repo:
+```bash
+git clone --branch master --single-branch https://github.com/Nitogx/soso-ppm.git
+```
+Then, inside the repo folder, install the required packages:
+```bash
+npm i
+```
+And lastly, link it:
+```console
+npm link
+```
+### How to use it?
+In a new terminal run:
+```bash
+soso -h 
+# Or 
+soso --help
+```
+And you'll have a detailled guide about all commands!
+
+### Official Packages
+[Hugging Face API for Soso PPM](https://github.com/Nitogx/huggingface-inference-wrapper/tree/master)
+[Clark AI for Soso PPM](https://github.com/Nitogx/clarky/tree/master)

package/bin/soso.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+'use strict';
+
+const { install } = require('../lib/commands/install');
+const { publish } = require('../lib/commands/publish');
+const { update } = require('../lib/commands/update');
+const { info } = require('../lib/commands/info');
+const { clean } = require('../lib/commands/clean');
+const { printHelp, printVersion } = require('../lib/utils/help');
+const { enableDebug } = require('../lib/utils/logger');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+// Check for flags
+const debug = args.includes('--debug') || args.includes('-d');
+if (debug) {
+  enableDebug();
+}
+
+async function main() {
+  try {
+    switch (command) {
+      case 'install':
+      case 'i':
+        await install(args.slice(1));
+        break;
+      
+      case 'publish':
+        await publish(args.slice(1));
+        break;
+      
+      case 'update':
+        await update(args.slice(1));
+        break;
+      
+      case 'info':
+        await info(args.slice(1));
+        break;
+      
+      case 'cache':
+        if (args[1] === 'clean') {
+          await clean(args.slice(2));
+        } else {
+          console.error('Unknown cache command. Use: soso cache clean');
+          process.exit(1);
+        }
+        break;
+      
+      case 'version':
+      case '-v':
+      case '--version':
+        printVersion();
+        break;
+      
+      case 'help':
+      case '-h':
+      case '--help':
+      case undefined:
+        printHelp();
+        break;
+      
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.error('Run "soso help" for usage information.');
+        process.exit(1);
+    }
+  } catch (error) {
+    if (debug) {
+      console.error(error);
+    } else {
+      console.error(`Error: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/lib/cache.js

@@ -0,0 +1,196 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { getCacheDir, ensureDir } = require('./config');
+const { debug } = require('./utils/logger');
+
+/**
+ * Cache manager for package storage
+ */
+class CacheManager {
+  constructor() {
+    this.cacheDir = getCacheDir();
+    ensureDir(this.cacheDir);
+  }
+
+  /**
+   * Generate cache key for package
+   */
+  getCacheKey(name, version) {
+    const key = `${name}@${version}`;
+    return crypto.createHash('sha256').update(key).digest('hex');
+  }
+
+  /**
+   * Get cache path for package
+   */
+  getCachePath(name, version) {
+    const key = this.getCacheKey(name, version);
+    return path.join(this.cacheDir, key, 'package');
+  }
+
+  /**
+   * Check if package is cached
+   */
+  has(name, version) {
+    const cachePath = this.getCachePath(name, version);
+    const packageJsonPath = path.join(cachePath, 'package.json');
+    return fs.existsSync(packageJsonPath);
+  }
+
+  /**
+   * Get cached package path
+   */
+  get(name, version) {
+    if (!this.has(name, version)) {
+      return null;
+    }
+    return this.getCachePath(name, version);
+  }
+
+  /**
+   * Add package to cache
+   * @param {string} name - Package name
+   * @param {string} version - Package version
+   * @param {string} sourcePath - Path to package files
+   * @returns {string} Cache path
+   */
+  add(name, version, sourcePath) {
+    const cachePath = this.getCachePath(name, version);
+    
+    debug(`Caching ${name}@${version} to ${cachePath}`);
+    
+    ensureDir(cachePath);
+    
+    // Copy all files from source to cache
+    this.copyRecursive(sourcePath, cachePath);
+    
+    return cachePath;
+  }
+
+  /**
+   * Copy directory recursively
+   */
+  copyRecursive(src, dest) {
+    ensureDir(dest);
+    
+    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()) {
+        this.copyRecursive(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Calculate integrity hash for package
+   */
+  calculateIntegrity(packagePath) {
+    const hash = crypto.createHash('sha256');
+    this.hashDirectory(packagePath, hash);
+    return 'sha256-' + hash.digest('base64');
+  }
+
+  /**
+   * Hash directory contents recursively
+   */
+  hashDirectory(dir, hash) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+      .sort((a, b) => a.name.localeCompare(b.name));
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      
+      // Skip node_modules
+      if (entry.name === 'node_modules') {
+        continue;
+      }
+      
+      hash.update(entry.name);
+      
+      if (entry.isDirectory()) {
+        this.hashDirectory(fullPath, hash);
+      } else {
+        const content = fs.readFileSync(fullPath);
+        hash.update(content);
+      }
+    }
+  }
+
+  /**
+   * Clear entire cache
+   */
+  clear() {
+    debug(`Clearing cache at ${this.cacheDir}`);
+    
+    if (fs.existsSync(this.cacheDir)) {
+      this.removeRecursive(this.cacheDir);
+      ensureDir(this.cacheDir);
+    }
+  }
+
+  /**
+   * Remove directory recursively
+   */
+  removeRecursive(dir) {
+    if (!fs.existsSync(dir)) {
+      return;
+    }
+    
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      
+      if (entry.isDirectory()) {
+        this.removeRecursive(fullPath);
+      } else {
+        fs.unlinkSync(fullPath);
+      }
+    }
+    
+    fs.rmdirSync(dir);
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const entries = fs.readdirSync(this.cacheDir);
+    return {
+      packages: entries.length,
+      size: this.getDirectorySize(this.cacheDir)
+    };
+  }
+
+  /**
+   * Calculate directory size
+   */
+  getDirectorySize(dir) {
+    let size = 0;
+    
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      
+      if (entry.isDirectory()) {
+        size += this.getDirectorySize(fullPath);
+      } else {
+        size += fs.statSync(fullPath).size;
+      }
+    }
+    
+    return size;
+  }
+}
+
+module.exports = { CacheManager };

package/lib/commands/clean.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { CacheManager } = require('../cache');
+const { success, info } = require('../utils/logger');
+
+/**
+ * Clean package cache
+ */
+async function clean(args) {
+  const cache = new CacheManager();
+  
+  info('Clearing package cache...');
+  
+  const stats = cache.getStats();
+  const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+  
+  cache.clear();
+  
+  success(`Cleared cache (${stats.packages} packages, ${sizeMB} MB)`);
+}
+
+module.exports = { clean };

package/lib/commands/info.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const chalk = require('chalk');
+const { loadRegistry } = require('../config');
+const { error } = require('../utils/logger');
+
+/**
+ * Show package information
+ */
+async function info(args) {
+  if (args.length === 0 || args[0].startsWith('-')) {
+    throw new Error('Package name required. Usage: soso info <package>');
+  }
+
+  const packageName = args[0];
+  const registry = loadRegistry();
+
+  const packageData = registry.packages[packageName];
+  
+  if (!packageData) {
+    error(`Package not found: ${packageName}`);
+    console.log('\nAvailable packages:');
+    const packages = Object.keys(registry.packages).sort();
+    if (packages.length === 0) {
+      console.log('  (none)');
+    } else {
+      packages.forEach(name => console.log(`  ${name}`));
+    }
+    process.exit(1);
+  }
+
+  // Display package information
+  console.log();
+  console.log(chalk.bold.cyan(packageData.name));
+  console.log();
+
+  const versions = Object.keys(packageData.versions).sort((a, b) => {
+    const semver = require('semver');
+    return semver.rcompare(a, b);
+  });
+
+  console.log(chalk.bold('Versions:'));
+  for (const version of versions) {
+    const versionData = packageData.versions[version];
+    const isLatest = version === versions[0];
+    const tag = isLatest ? chalk.green(' (latest)') : '';
+    
+    console.log(`  ${chalk.yellow(version)}${tag}`);
+    console.log(`    ${chalk.gray('Git:')} ${versionData.gitUrl}#${versionData.tag}`);
+    
+    if (versionData.publishedAt) {
+      const date = new Date(versionData.publishedAt).toLocaleString();
+      console.log(`    ${chalk.gray('Published:')} ${date}`);
+    }
+    
+    if (versionData.dependencies && Object.keys(versionData.dependencies).length > 0) {
+      console.log(`    ${chalk.gray('Dependencies:')}`);
+      for (const [depName, depRange] of Object.entries(versionData.dependencies)) {
+        console.log(`      ${depName}: ${depRange}`);
+      }
+    }
+    
+    console.log();
+  }
+}
+
+module.exports = { info };

package/lib/commands/install.js

@@ -0,0 +1,220 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { loadRegistry, ensureDir } = require('../config');
+const { Resolver } = require('../resolver');
+const { CacheManager } = require('../cache');
+const { Lockfile } = require('../lockfile');
+const { success, error, info, debug } = require('../utils/logger');
+const git = require('../utils/git');
+const os = require('os');
+
+/**
+ * Install dependencies
+ */
+async function install(args) {
+  const cwd = process.cwd();
+  const packageJsonPath = path.join(cwd, 'package.json');
+
+  // Load package.json
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error('No package.json found in current directory');
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  
+  // Determine what to install
+  let specificPackage = null;
+  if (args.length > 0 && !args[0].startsWith('-')) {
+    specificPackage = args[0];
+  }
+
+  if (specificPackage) {
+    info(`Installing ${specificPackage}...`);
+    // Add to dependencies if not present
+    if (!packageJson.dependencies) {
+      packageJson.dependencies = {};
+    }
+    if (!packageJson.dependencies[specificPackage]) {
+      packageJson.dependencies[specificPackage] = '*';
+      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+    }
+  } else {
+    info('Installing dependencies...');
+  }
+
+  const dependencies = packageJson.dependencies || {};
+
+  if (Object.keys(dependencies).length === 0) {
+    success('No dependencies to install');
+    return;
+  }
+
+  // Load registry and initialize components
+  const registry = loadRegistry();
+  const cache = new CacheManager();
+  const lockfile = new Lockfile(cwd);
+
+  // Resolve dependencies
+  info('Resolving dependency tree...');
+  const resolver = new Resolver(registry);
+  const resolved = await resolver.resolve(dependencies);
+
+  debug(`Resolved ${Object.keys(resolved).length} packages`);
+
+  // Prepare node_modules
+  const nodeModulesPath = path.join(cwd, 'node_modules');
+  ensureDir(nodeModulesPath);
+
+  // Install packages
+  const installed = {};
+  
+  for (const [name, version] of Object.entries(resolved)) {
+    await installPackage(name, version, nodeModulesPath, cache, registry, installed);
+  }
+
+  // Write lockfile
+  lockfile.write(installed);
+
+  success(`Installed ${Object.keys(installed).length} packages`);
+}
+
+/**
+ * Install a single package
+ */
+async function installPackage(name, version, nodeModulesPath, cache, registry, installed) {
+  info(`Installing ${name}@${version}...`);
+
+  // Check cache first
+  let sourcePath = cache.get(name, version);
+  
+  if (sourcePath) {
+    debug(`Using cached ${name}@${version}`);
+  } else {
+    // Fetch from registry
+    sourcePath = await fetchPackage(name, version, registry, cache);
+  }
+
+  // Install to node_modules
+  const targetPath = getPackageInstallPath(name, nodeModulesPath);
+  ensureDir(path.dirname(targetPath));
+  
+  // Copy from cache to node_modules
+  copyDirectory(sourcePath, targetPath);
+
+  // Calculate integrity
+  const integrity = cache.calculateIntegrity(sourcePath);
+
+  // Get package info from registry
+  const packageData = registry.packages[name];
+  const versionData = packageData.versions[version];
+
+  // Track installed package
+  installed[name] = {
+    version,
+    resolved: versionData.gitUrl,
+    integrity,
+    dependencies: versionData.dependencies || {}
+  };
+
+  debug(`Installed ${name}@${version} to ${targetPath}`);
+}
+
+/**
+ * Fetch package from registry
+ */
+async function fetchPackage(name, version, registry, cache) {
+  const packageData = registry.packages[name];
+  if (!packageData) {
+    throw new Error(`Package not found in registry: ${name}`);
+  }
+
+  const versionData = packageData.versions[version];
+  if (!versionData) {
+    throw new Error(`Version ${version} not found for ${name}`);
+  }
+
+  const gitUrl = versionData.gitUrl;
+  const tag = `v${version}`;
+
+  debug(`Fetching ${name}@${version} from ${gitUrl}`);
+
+  // Create temporary directory for cloning
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'soso-'));
+  
+  try {
+    // Shallow clone at specific tag
+    await git.clone(gitUrl, tempDir, { shallow: true, branch: tag });
+
+    // Add to cache
+    const cachePath = cache.add(name, version, tempDir);
+
+    return cachePath;
+  } finally {
+    // Clean up temp directory
+    removeDirectory(tempDir);
+  }
+}
+
+/**
+ * Get installation path for package
+ */
+function getPackageInstallPath(name, nodeModulesPath) {
+  if (name.startsWith('@')) {
+    // Scoped package: @scope/name -> node_modules/@scope/name
+    const parts = name.split('/');
+    return path.join(nodeModulesPath, parts[0], parts[1]);
+  }
+  return path.join(nodeModulesPath, name);
+}
+
+/**
+ * Copy directory recursively
+ */
+function copyDirectory(src, dest) {
+  ensureDir(dest);
+  
+  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);
+    
+    // Skip .git directory
+    if (entry.name === '.git') {
+      continue;
+    }
+    
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Remove directory recursively
+ */
+function removeDirectory(dir) {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+  
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    
+    if (entry.isDirectory()) {
+      removeDirectory(fullPath);
+    } else {
+      fs.unlinkSync(fullPath);
+    }
+  }
+  
+  fs.rmdirSync(dir);
+}
+
+module.exports = { install };