@mandors/cli 0.0.1

package/npm/lib/config.js

@@ -0,0 +1,153 @@
+/**
+ * @fileoverview Mandor configuration management
+ * @description Reads and writes Mandor configuration using .mandorrc.json
+ * @version 0.0.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+/** @type {string} Default config filename */
+const CONFIG_FILENAME = '.mandorrc.json';
+
+/**
+ * Configuration management class for Mandor projects
+ * @class
+ * @version 0.0.1
+ * @example
+ * const config = new MandorConfig('/path/to/project');
+ * const defaultPriority = config.get('priority.default', 'P3');
+ * config.set('theme', 'dark');
+ */
+class MandorConfig {
+  /**
+   * Creates a new MandorConfig instance
+   * @constructor
+   * @param {string} projectRoot - Root directory of the project
+   * @example
+   * const config = new MandorConfig('/my/project');
+   */
+  constructor(projectRoot) {
+    /** @type {string} Path to config file */
+    this.configPath = path.join(projectRoot, CONFIG_FILENAME);
+    /** @type {string} Project root directory */
+    this.projectRoot = projectRoot;
+  }
+
+  /**
+   * Gets a configuration value
+   * @param {string} key - Configuration key (supports dot notation, e.g., 'priority.default')
+   * @param {*} [defaultValue] - Default value if key not found
+   * @returns {*} The configuration value or default
+   * @example
+   * const priority = config.get('priority.default', 'P3');
+   * const strict = config.get('strictMode', false);
+   */
+  get(key, defaultValue = undefined) {
+    if (!fs.existsSync(this.configPath)) return defaultValue;
+    const config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+
+    // Support dot notation for nested keys
+    const keys = key.split('.');
+    let value = config;
+    for (const k of keys) {
+      if (value && typeof value === 'object' && k in value) {
+        value = value[k];
+      } else {
+        return defaultValue;
+      }
+    }
+    return value !== undefined ? value : defaultValue;
+  }
+
+  /**
+   * Sets a configuration value
+   * @param {string} key - Configuration key (supports dot notation)
+   * @param {*} value - Value to set
+   * @returns {void}
+   * @example
+   * config.set('priority.default', 'P2');
+   * config.set('theme', 'dark');
+   */
+  set(key, value) {
+    const config = fs.existsSync(this.configPath)
+      ? JSON.parse(fs.readFileSync(this.configPath, 'utf-8'))
+      : {};
+
+    // Support dot notation for nested keys
+   .split('.');
+    const keys = key let current = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const k = keys[i];
+      if (!current[k] || typeof current[k] !== 'object') {
+        current[k] = {};
+      }
+      current = current[k];
+    }
+    current[keys[keys.length - 1]] = value;
+
+    fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+  }
+
+  /**
+   * Deletes a configuration key
+   * @param {string} key - Configuration key to delete
+   * @returns {boolean} True if key was deleted
+   * @example
+   * config.delete('theme');
+   */
+  delete(key) {
+    if (!fs.existsSync(this.configPath)) return false;
+    const config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+
+    const keys = key.split('.');
+    let current = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!current[keys[i]]) return false;
+      current = current[keys[i]];
+    }
+
+    if (current[keys[keys.length - 1]] !== undefined) {
+      delete current[keys[keys.length - 1]];
+      fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Checks if a configuration key exists
+   * @param {string} key - Configuration key to check
+   * @returns {boolean} True if key exists
+   * @example
+   * if (config.has('theme')) { console.log('Theme is set'); }
+   */
+  has(key) {
+    return this.get(key) !== undefined;
+  }
+
+  /**
+   * Gets all configuration as an object
+   * @returns {Object} Full configuration object
+   * @example
+   * const allConfig = config.getAll();
+   */
+  getAll() {
+    if (!fs.existsSync(this.configPath)) return {};
+    return JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+  }
+
+  /**
+   * Clears all configuration
+   * @returns {void}
+   * @example
+   * config.clear();
+   */
+  clear() {
+    if (fs.existsSync(this.configPath)) {
+      fs.unlinkSync(this.configPath);
+    }
+  }
+}
+
+module.exports = MandorConfig;

package/npm/lib/download.js

@@ -0,0 +1,83 @@
+/**
+ * @fileoverview Binary download module for Mandor CLI
+ * @description Handles downloading and caching Mandor binaries for the current platform
+ * @version 0.0.1
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/** @type {string} GitHub releases API URL */
+const RELEASES_URL = 'https://api.github.com/repos/sanxzy/mandor/releases';
+
+/**
+ * Downloads the Mandor binary for the specified platform and architecture
+ * @async
+ * @param {string} version - The Mandor version to download (e.g., '1.0.0', 'latest')
+ * @param {string} platform - Target platform (e.g., 'darwin', 'linux', 'win32')
+ * @param {string} arch - Target architecture (e.g., 'x64', 'arm64')
+ * @returns {Promise<string>} Path to the downloaded and executable binary
+ * @throws {Error} If download fails or platform is unsupported
+ * @example
+ * // Download Mandor v1.0.0 for macOS x64
+ * const binaryPath = await downloadBinary('1.0.0', 'darwin', 'x64');
+ * console.log(`Binary downloaded to: ${binaryPath}`);
+ */
+async function downloadBinary(version, platform, arch) {
+  const filename = `mandor-${platform}-${arch}`;
+  const url = `${RELEASES_URL}/download/${version}/${filename}`;
+  const dest = path.join(os.homedir(), '.mandor', 'bin', filename);
+
+  // Download and make executable
+  return new Promise((resolve, reject) => {
+    https.get(url, (response) => {
+      if (response.statusCode === 302) {
+        return downloadBinary(response.headers.location, platform, arch);
+      }
+      const file = fs.createWriteStream(dest);
+      response.pipe(file);
+      file.on('finish', () => {
+        fs.chmodSync(dest, '755');
+        resolve(dest);
+      });
+    }).on('error', reject);
+  });
+}
+
+/**
+ * Gets the platform identifier for the current system
+ * @returns {{platform: string, arch: string}} Platform and architecture info
+ * @example
+ * const { platform, arch } = getCurrentPlatform();
+ * console.log(`Running on ${platform}-${arch}`);
+ */
+function getCurrentPlatform() {
+  const platform = os.platform(); // 'darwin', 'linux', 'win32'
+  const arch = os.arch(); // 'x64', 'arm64'
+  return { platform, arch };
+}
+
+/**
+ * Checks if a binary already exists and is up-to-date
+ * @param {string} version - Expected version
+ * @param {string} platform - Target platform
+ * @param {string} arch - Target architecture
+ * @returns {Promise<boolean>} True if binary exists and is valid
+ * @example
+ * const exists = await binaryExists('1.0.0', 'darwin', 'x64');
+ * if (exists) { console.log('Binary cached'); }
+ */
+async function binaryExists(version, platform, arch) {
+  const filename = `mandor-${platform}-${arch}`;
+  const dest = path.join(os.homedir(), '.mandor', 'bin', filename);
+  return fs.existsSync(dest);
+}
+
+module.exports = {
+  downloadBinary,
+  getCurrentPlatform,
+  binaryExists,
+  RELEASES_URL
+};

package/npm/lib/index.js

@@ -0,0 +1,138 @@
+/**
+ * @fileoverview Mandor CLI npm package entry point
+ * @description Main export for programmatic usage and CLI access
+ * @version 0.0.1
+ */
+
+const Mandor = require('./api');
+const MandorConfig = require('./config');
+const { resolve, listCachedBinaries, clearCache } = require('./resolve');
+const { downloadBinary, getCurrentPlatform } = require('./download');
+const { install } = require('./install');
+
+/**
+ * Main export object containing all public APIs
+ * @namespace mandor
+ * @version 0.0.1
+ * @example
+ * const mandor = require('@mandor/cli');
+ *
+ * // CLI access via npx or npm script
+ * // $ npx mandor init "My Project"
+ *
+ * // Programmatic usage
+ * const cli = new mandor.Mandor({ json: true });
+ * await cli.init('My Project');
+ */
+module.exports = {
+  /**
+   * Mandor CLI wrapper class for programmatic access
+   * @type {typeof Mandor}
+   * @memberof mandor
+   * @example
+   * const mandor = require('@mandor/cli');
+   * const cli = new mandor.Mandor({ json: true });
+   */
+  Mandor,
+
+  /**
+   * Configuration management class
+   * @type {typeof MandorConfig}
+   * @memberof mandor
+   * @example
+   * const config = new mandor.MandorConfig('/path/to/project');
+   * const priority = config.get('priority.default', 'P3');
+   */
+  MandorConfig,
+
+  /**
+   * Resolves the Mandor binary path
+   * @function
+   * @param {Object} [options] - Resolution options
+   * @param {string} [options.version] - Version to use
+   * @returns {Promise<string>} Path to binary
+   * @memberof mandor
+   * @example
+   * const binaryPath = await mandor.resolve({ version: 'latest' });
+   */
+  resolve,
+
+  /**
+   * Lists all cached binary versions
+   * @function
+   * @returns {Object[]} Cached binary info
+   * @memberof mandor
+   * @example
+   * const cached = mandor.listCachedBinaries();
+   */
+  listCachedBinaries,
+
+  /**
+   * Clears all cached binaries
+   * @function
+   * @returns {number} Number of binaries removed
+   * @memberof mandor
+   * @example
+   * const removed = mandor.clearCache();
+   */
+  clearCache,
+
+  /**
+   * Downloads a Mandor binary
+   * @function
+   * @param {string} version - Version to download
+   * @param {string} [platform] - Target platform
+   * @param {string} [arch] - Target architecture
+   * @returns {Promise<string>} Path to downloaded binary
+   * @memberof mandor
+   * @example
+   * const binary = await mandor.downloadBinary('1.0.0', 'darwin', 'x64');
+   */
+  downloadBinary,
+
+  /**
+   * Gets current platform information
+   * @function
+   * @returns {{platform: string, arch: string}} Platform info
+   * @memberof mandor
+   * @example
+   * const { platform, arch } = mandor.getCurrentPlatform();
+   */
+  getCurrentPlatform,
+
+  /**
+   * Runs post-install setup
+   * @function
+   * @param {Object} [options] - Install options
+   * @returns {Promise<string>} Path to installed binary
+   * @memberof mandor
+   * @example
+   * await mandor.install({ version: 'latest' });
+   */
+  install,
+
+  // Version info
+  /** @type {string} Package version */
+  version: '0.0.1',
+
+  /** @type {string} Supported Mandor version range */
+  mandorVersionRange: '>=0.0.1'
+};
+
+// CLI entry point when bin/mandor is executed
+if (require.main === module) {
+  resolve()
+    .then(binaryPath => {
+      const { spawn } = require('child_process');
+      const args = process.argv.slice(2);
+      const proc = spawn(binaryPath, args, {
+        stdio: 'inherit',
+        cwd: process.cwd()
+      });
+      proc.on('exit', process.exit);
+    })
+    .catch(error => {
+      console.error('Failed to start Mandor:', error.message);
+      process.exit(1);
+    });
+}

package/npm/lib/install.js

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Post-install hook for Mandor CLI
+ * @description Handles binary download and caching during npm install
+ * @version 0.0.1
+ */
+
+const { downloadBinary, getCurrentPlatform } = require('./download');
+const fs = require('fs');
+const path = require('path');
+
+/** @type {string} Cache directory for binaries */
+const CACHE_DIR = path.join(__dirname, '..', '.cache');
+
+/**
+ * Installs the Mandor binary for the current platform
+ * @async
+ * @param {Object} [options] - Installation options
+ * @param {string} [options.version] - Version to install (default: 'latest')
+ * @returns {Promise<string>} Path to the installed binary
+ * @throws {Error} If download fails
+ * @example
+ * // Called automatically by npm postinstall
+ * await install();
+ */
+async function install(options = {}) {
+  const version = options.version || 'latest';
+  const { platform, arch } = getCurrentPlatform();
+
+  console.log(`Installing Mandor ${version} for ${platform}-${arch}...`);
+
+  const binaryPath = await downloadBinary(version, platform, arch);
+  console.log(`✓ Mandor installed: ${binaryPath}`);
+
+  return binaryPath;
+}
+
+/**
+ * Cleans up old binary caches
+ * @returns {number} Number of files removed
+ * @example
+ * const removed = cleanupCache();
+ * console.log(`Removed ${removed} old binary files`);
+ */
+function cleanupCache() {
+  if (!fs.existsSync(CACHE_DIR)) return 0;
+
+  const files = fs.readdirSync(CACHE_DIR);
+  let removed = 0;
+
+  for (const file of files) {
+    const filePath = path.join(CACHE_DIR, file);
+    const stats = fs.statSync(filePath);
+
+    // Remove files older than 30 days
+    const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
+    if (stats.mtimeMs < thirtyDaysAgo) {
+      fs.unlinkSync(filePath);
+      removed++;
+    }
+  }
+
+  return removed;
+}
+
+/**
+ * Gets the installed binary version
+ * @returns {string|null} Version string or null if not installed
+ * @example
+ * const version = getInstalledVersion();
+ * if (version) { console.log(`Using Mandor ${version}`); }
+ */
+function getInstalledVersion() {
+  const versionPath = path.join(CACHE_DIR, 'version.txt');
+  if (fs.existsSync(versionPath)) {
+    return fs.readFileSync(versionPath, 'utf-8').trim();
+  }
+  return null;
+}
+
+// Run install on postinstall
+if (require.main === module || process.env.npm_lifecycle_event === 'postinstall') {
+  install().catch(error => {
+    console.error('Failed to install Mandor:', error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  install,
+  cleanupCache,
+  getInstalledVersion
+};

package/npm/lib/resolve.js

@@ -0,0 +1,148 @@
+/**
+ * @fileoverview Version resolution module for Mandor CLI
+ * @description Resolves the correct binary path based on version and platform
+ * @version 0.0.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { downloadBinary, getCurrentPlatform, binaryExists } = require('./download');
+
+/** @type {string} Default version to use */
+const DEFAULT_VERSION = 'latest';
+
+/**
+ * Resolves the binary path for the requested version
+ * @async
+ * @param {Object} [options] - Resolution options
+ * @param {string} [options.version] - Requested version (default: 'latest')
+ * @param {boolean} [options.forceDownload] - Force re-download even if cached
+ * @returns {Promise<string>} Path to the Mandor binary
+ * @throws {Error} If binary cannot be resolved or downloaded
+ * @example
+ * const binaryPath = await resolve({ version: '1.0.0' });
+ * console.log(`Using: ${binaryPath}`);
+ */
+async function resolve(options = {}) {
+  const version = options.version || DEFAULT_VERSION;
+  const { platform, arch } = getCurrentPlatform();
+
+  // Check cache first
+  const cachedPath = getCachedBinary(version, platform, arch);
+  if (cachedPath && !options.forceDownload) {
+    return cachedPath;
+  }
+
+  // Download if not cached
+  const binaryPath = await downloadBinary(version, platform, arch);
+  cacheBinary(binaryPath, version, platform, arch);
+
+  return binaryPath;
+}
+
+/**
+ * Gets the cached binary path for a specific version
+ * @param {string} version - Version to look for
+ * @param {string} platform - Target platform
+ * @param {string} arch - Target architecture
+ * @returns {string|null} Path to cached binary or null
+ * @example
+ * const cached = getCachedBinary('1.0.0', 'darwin', 'x64');
+ */
+function getCachedBinary(version, platform, arch) {
+  const cacheDir = path.join(os.homedir(), '.mandor', 'bin');
+  const binaryName = platform === 'win32' ? 'mandor.exe' : 'mandor';
+  const binaryPath = path.join(cacheDir, `${version}-${platform}-${arch}`, binaryName);
+
+  if (fs.existsSync(binaryPath)) {
+    return binaryPath;
+  }
+  return null;
+}
+
+/**
+ * Caches a binary for future use
+ * @param {string} binaryPath - Path to the binary
+ * @param {string} version - Version identifier
+ * @param {string} platform - Target platform
+ * @param {string} arch - Target architecture
+ * @returns {void}
+ * @example
+ * cacheBinary('/home/user/.mandor/bin/1.0.0-darwin-x64/mandor', '1.0.0', 'darwin', 'x64');
+ */
+function cacheBinary(binaryPath, version, platform, arch) {
+  const cacheDir = path.join(os.homedir(), '.mandor', 'bin', `${version}-${platform}-${arch}`);
+  fs.mkdirSync(cacheDir, { recursive: true });
+
+  const binaryName = platform === 'win32' ? 'mandor.exe' : 'mandor';
+  const destPath = path.join(cacheDir, binaryName);
+
+  fs.copyFileSync(binaryPath, destPath);
+  fs.chmodSync(destPath, '755');
+}
+
+/**
+ * Lists all cached binary versions
+ * @returns {Object[]} Array of cached binary info
+ * @example
+ * const cached = listCachedBinaries();
+ * cached.forEach(b => console.log(`${b.version} (${b.platform}-${b.arch})`));
+ */
+function listCachedBinaries() {
+  const cacheDir = path.join(os.homedir(), '.mandor', 'bin');
+
+  if (!fs.existsSync(cacheDir)) {
+    return [];
+  }
+
+  const versions = [];
+  const entries = fs.readdirSync(cacheDir);
+
+  for (const entry of entries) {
+    const entryPath = path.join(cacheDir, entry);
+    if (fs.statSync(entryPath).isDirectory()) {
+      const [version, platform, arch] = entry.split('-');
+      versions.push({ version, platform, arch, path: entryPath });
+    }
+  }
+
+  return versions;
+}
+
+/**
+ * Clears all cached binaries
+ * @returns {number} Number of binaries removed
+ * @example
+ * const removed = clearCache();
+ * console.log(`Cleared ${removed} cached binaries`);
+ */
+function clearCache() {
+  const cacheDir = path.join(os.homedir(), '.mandor', 'bin');
+
+  if (!fs.existsSync(cacheDir)) {
+    return 0;
+  }
+
+  const entries = fs.readdirSync(cacheDir);
+  let removed = 0;
+
+  for (const entry of entries) {
+    const entryPath = path.join(cacheDir, entry);
+    if (fs.statSync(entryPath).isDirectory()) {
+      fs.rmSync(entryPath, { recursive: true, force: true });
+      removed++;
+    }
+  }
+
+  return removed;
+}
+
+module.exports = {
+  resolve,
+  getCachedBinary,
+  cacheBinary,
+  listCachedBinaries,
+  clearCache,
+  DEFAULT_VERSION
+};