@mandors/cli 0.0.18 → 0.0.20

package/npm/bin/mandor

@@ -1,32 +1,15 @@
 #!/usr/bin/env node
 
-/**
- * @fileoverview Mandor CLI Node.js wrapper script
- * @description Resolves the Mandor binary path and spawns the CLI with provided arguments
- * @version 0.0.1
- */
-
-const { resolve } = require('../lib/resolve');
 const { spawn } = require('child_process');
 const path = require('path');
+const os = require('os');
 
-/**
- * Main entry point for the Mandor CLI wrapper
- * @async
- * @returns {Promise<void>} Resolves when the CLI process exits
- * @throws {Error} If binary resolution fails
- * @example
- * // Run: mandor task list --project api
- * await main();
- */
-async function main() {
-  const binaryPath = await resolve();
-  const args = process.argv.slice(2);
-  const proc = spawn(binaryPath, args, {
-    stdio: 'inherit',
-    cwd: process.cwd()
-  });
-  proc.on('exit', process.exit);
-}
+const INSTALL_DIR = path.join(os.homedir(), '.local', 'bin');
+const binaryPath = path.join(INSTALL_DIR, process.platform === 'win32' ? 'mandor.exe' : 'mandor');
 
-main().catch(console.error);
+const args = process.argv.slice(2);
+const proc = spawn(binaryPath, args, {
+  stdio: 'inherit',
+  cwd: process.cwd()
+});
+proc.on('exit', process.exit);

package/npm/lib/index.js

@@ -1,138 +1,21 @@
 /**
  * @fileoverview Mandor CLI npm package entry point
- * @description Main export for programmatic usage and CLI access
- * @version 0.0.1
+ * @description Main export for CLI access
+ * @version 0.0.2
  */
 
-const Mandor = require('./api');
-const MandorConfig = require('./config');
-const { resolve, listCachedBinaries, clearCache } = require('./resolve');
-const { downloadBinary, getCurrentPlatform } = require('./download');
 const { install } = require('./install');
+const MandorConfig = require('./config');
 
-/**
- * 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'
+  version: '0.0.2'
 };
 
-// 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);
-    });
+if (require.main === module || process.env.npm_lifecycle_event === 'postinstall') {
+  install().catch(error => {
+    console.error('Failed to install Mandor:', error.message);
+    process.exit(1);
+  });
 }

package/npm/lib/install.js

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Post-install hook for Mandor CLI
- * @description Downloads binary from GitHub releases during npm install
- * @version 0.0.4
+ * @description Downloads and extracts binary from GitHub releases
+ * @version 0.0.5
  */
 
 const fs = require('fs');
@@ -11,8 +11,7 @@ const { execSync } = require('child_process');
 const https = require('https');
 
 const REPO = 'sanxzy/mandor';
-const GITHUB_API = 'https://api.github.com';
-const CACHE_DIR = path.join(os.homedir(), '.mandor', 'bin');
+const INSTALL_DIR = path.join(os.homedir(), '.local', 'bin');
 
 function getPlatform() {
   const platform = os.platform();
@@ -27,8 +26,8 @@ function getPlatform() {
 
 async function getLatestVersion(prerelease = false) {
   const url = prerelease
-    ? `${GITHUB_API}/repos/${REPO}/releases`
-    : `${GITHUB_API}/repos/${REPO}/releases/latest`;
+    ? `https://api.github.com/repos/${REPO}/releases`
+    : `https://api.github.com/repos/${REPO}/releases/latest`;
 
   return new Promise((resolve, reject) => {
     https.get(url, { headers: { 'User-Agent': 'Mandor-CLI' } }, (res) => {
@@ -37,8 +36,17 @@ async function getLatestVersion(prerelease = false) {
       res.on('end', () => {
         try {
           const parsed = JSON.parse(data);
-          const tagName = Array.isArray(parsed) ? parsed[0].tag_name : parsed.tag_name;
-          resolve(tagName.replace(/^v/, ''));
+          let tagName = null;
+          if (parsed && parsed.tag_name) {
+            tagName = parsed.tag_name;
+          } else if (Array.isArray(parsed) && parsed.length > 0 && parsed[0].tag_name) {
+            tagName = parsed[0].tag_name;
+          }
+          if (tagName) {
+            resolve(tagName.replace(/^v/, ''));
+          } else {
+            reject(new Error('No release found'));
+          }
         } catch (e) {
           reject(e);
         }
@@ -70,7 +78,7 @@ async function install(options = {}) {
   const version = options.version || 'latest';
   const prerelease = options.prerelease || false;
   const osArch = `${platform}-${arch}`;
-  const assetName = `${osArch}.tar.gz`;
+  const binaryName = platform === 'win32' ? 'mandor.exe' : 'mandor';
 
   console.log('Mandor Installer');
   console.log('================');
@@ -85,37 +93,38 @@ async function install(options = {}) {
   console.log(`Version: ${installVersion}`);
   console.log('');
 
-  const cachePath = path.join(CACHE_DIR, installVersion, osArch);
-  const binaryPath = path.join(cachePath, platform === 'win32' ? 'mandor.exe' : 'mandor');
+  const binaryPath = path.join(INSTALL_DIR, binaryName);
 
   if (fs.existsSync(binaryPath)) {
-    console.log(`Using cached binary: ${binaryPath}`);
+    console.log(`Already installed: ${binaryPath}`);
     return binaryPath;
   }
 
   console.log('Downloading from GitHub releases...');
-  const downloadUrl = `https://github.com/${REPO}/releases/download/v${installVersion}/${assetName}`;
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mandor-install-'));
-  const tarball = path.join(tempDir, assetName);
+  const downloadUrl = `https://github.com/${REPO}/releases/download/v${installVersion}/${osArch}.tar.gz`;
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mandor-'));
+  const tarball = path.join(tempDir, `${osArch}.tar.gz`);
 
   await downloadFile(downloadUrl, tarball);
 
-  if (!fs.existsSync(cachePath)) {
-    fs.mkdirSync(cachePath, { recursive: true });
-  }
+  fs.mkdirSync(INSTALL_DIR, { recursive: true });
+  execSync(`tar -xzf "${tarball}" -C "${tempDir}"`, { stdio: 'inherit' });
 
-  execSync(`tar -xzf "${tarball}" -C "${cachePath}"`, { stdio: 'inherit' });
+  const extractedBinary = path.join(tempDir, binaryName);
+  fs.copyFileSync(extractedBinary, binaryPath);
   fs.chmodSync(binaryPath, '755');
 
   fs.rmSync(tempDir, { recursive: true });
 
   console.log(`Installed: ${binaryPath}`);
+  console.log('');
+  console.log('Add to PATH:');
+  console.log(`  export PATH="${INSTALL_DIR}:$PATH"`);
   return binaryPath;
 }
 
 if (require.main === module || process.env.npm_lifecycle_event === 'postinstall') {
-  const prerelease = process.argv.includes('--prerelease') || process.argv.includes('-p');
-  install({ prerelease }).catch(error => {
+  install().catch(error => {
     console.error('Failed to install Mandor:', error.message);
     process.exit(1);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandors/cli",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "Event-based task manager CLI for AI agent workflows",
   "main": "npm/lib/index.js",
   "bin": {

package/npm/lib/api.js

@@ -1,216 +0,0 @@
-/**
- * @fileoverview Mandor CLI programmatic API
- * @description Node.js API for interacting with Mandor from JavaScript/TypeScript code
- * @version 0.0.1
- */
-
-const { spawn } = require('child_process');
-
-/**
- * @typedef {Object} MandorOptions
- * @property {string} [cwd] - Working directory (default: process.cwd())
- * @property {boolean} [json] - Use JSON output format (default: false)
- */
-
-/**
- * @typedef {Object} ProjectCreateOptions
- * @property {string} [name] - Project display name
- * @property {string} [goal] - Project goal description
- */
-
-/**
- * @typedef {Object} TaskListOptions
- * @property {string} [project] - Filter by project ID
- * @property {string} [feature] - Filter by feature ID
- * @property {string} [status] - Filter by status (pending, ready, in_progress, done, blocked, cancelled)
- * @property {string} [priority] - Filter by priority (P0-P5)
- */
-
-/**
- * Mandor CLI wrapper class for programmatic access
- * @class
- * @version 0.0.1
- * @example
- * const mandor = new Mandor({ cwd: '/path/to/project', json: true });
- * const tasks = await mandor.taskList({ project: 'api', status: 'pending' });
- */
-class Mandor {
-  /**
-   * Creates a new Mandor instance
-   * @constructor
-   * @param {MandorOptions} [options] - Configuration options
-   * @example
-   * const mandor = new Mandor({ cwd: '/my/project', json: true });
-   */
-  constructor(options = {}) {
-    /** @type {string} Working directory */
-    this.cwd = options.cwd || process.cwd();
-    /** @type {boolean} Use JSON output */
-    this.json = options.json || false;
-  }
-
-  /**
-   * Initializes a new Mandor workspace
-   * @async
-   * @param {string} name - Workspace name
-   * @returns {Promise<number>} Exit code from the CLI
-   * @throws {Error} If initialization fails
-   * @example
-   * await mandor.init('My AI Project');
-   */
-  async init(name) {
-    return this._run('init', [name]);
-  }
-
-  /**
-   * Creates a new project
-   * @async
-   * @param {string} id - Project identifier (lowercase, hyphens only)
-   * @param {ProjectCreateOptions} [options] - Project options
-   * @returns {Promise<number>} Exit code from the CLI
-   * @example
-   * await mandor.projectCreate('api', {
-   *   name: 'API Service',
-   *   goal: 'Implement REST API with user management'
-   * });
-   */
-  async projectCreate(id, options = {}) {
-    const args = ['project', 'create', id];
-    if (options.name) args.push('--name', options.name);
-    if (options.goal) args.push('--goal', options.goal);
-    return this._run(...args);
-  }
-
-  /**
-   * Lists tasks with optional filters
-   * @async
-   * @param {TaskListOptions} [options] - Filter options
-   * @returns {Promise<Object[]|number>} Task list (JSON) or exit code
-   * @example
-   * const tasks = await mandor.taskList({
-   *   project: 'api',
-   *   status: 'pending',
-   *   json: true
-   * });
-   */
-  async taskList(options = {}) {
-    const args = ['task', 'list'];
-    if (options.project) args.push('--project', options.project);
-    if (options.feature) args.push('--feature', options.feature);
-    if (options.status) args.push('--status', options.status);
-    if (options.priority) args.push('--priority', options.priority);
-    if (options.json) args.push('--json');
-    return this._run(...args);
-  }
-
-  /**
-   * Gets detailed information about a task
-   * @async
-   * @param {string} taskId - Task identifier
-   * @returns {Promise<Object|number>} Task details (JSON) or exit code
-   * @example
-   * const task = await mandor.taskDetail('api-feature-abc-task-xyz789', { json: true });
-   */
-  async taskDetail(taskId) {
-    return this._run('task', 'detail', taskId);
-  }
-
-  /**
-   * Updates a task's status or metadata
-   * @async
-   * @param {string} taskId - Task identifier
-   * @param {Object} updates - Fields to update
-   * @returns {Promise<number>} Exit code from the CLI
-   * @example
-   * await mandor.taskUpdate('api-feature-abc-task-xyz789', {
-   *   status: 'in_progress'
-   * });
-   */
-  async taskUpdate(taskId, updates = {}) {
-    const args = ['task', 'update', taskId];
-    if (updates.status) args.push('--status', updates.status);
-    if (updates.name) args.push('--name', updates.name);
-    if (updates.priority) args.push('--priority', updates.priority);
-    return this._run(...args);
-  }
-
-  /**
-   * Lists features with optional filters
-   * @async
-   * @param {Object} [options] - Filter options
-   * @returns {Promise<Object[]|number>} Feature list (JSON) or exit code
-   * @example
-   * const features = await mandor.featureList({ project: 'api', json: true });
-   */
-  async featureList(options = {}) {
-    const args = ['feature', 'list'];
-    if (options.project) args.push('--project', options.project);
-    if (options.status) args.push('--status', options.status);
-    if (options.json) args.push('--json');
-    return this._run(...args);
-  }
-
-  /**
-   * Lists issues with optional filters
-   * @async
-   * @param {Object} [options] - Filter options
-   * @returns {Promise<Object[]|number>} Issue list (JSON) or exit code
-   * @example
-   * const issues = await mandor.issueList({ project: 'api', type: 'bug', json: true });
-   */
-  async issueList(options = {}) {
-    const args = ['issue', 'list'];
-    if (options.project) args.push('--project', options.project);
-    if (options.type) args.push('--type', options.type);
-    if (options.status) args.push('--status', options.status);
-    if (options.json) args.push('--json');
-    return this._run(...args);
-  }
-
-  /**
-   * Gets workspace status and statistics
-   * @async
-   * @param {Object} [options] - Options
-   * @returns {Promise<Object|number>} Status (JSON) or exit code
-   * @example
-   * const status = await mandor.status({ json: true });
-   */
-  async status(options = {}) {
-    const args = ['status'];
-    if (options.json) args.push('--json');
-    return this._run(...args);
-  }
-
-  /**
-   * Internal method to run mandor CLI commands
-   * @private
-   * @async
-   * @param {...string} args - Command arguments
-   * @returns {Promise<Object|number>} Result based on json option
-   * @throws {Error} If process fails
-   */
-  _run(...args) {
-    return new Promise((resolve, reject) => {
-      const proc = spawn('mandor', args, {
-        cwd: this.cwd,
-        stdio: this.json ? 'pipe' : 'inherit'
-      });
-
-      if (this.json) {
-        let data = '';
-        proc.stdout.on('data', chunk => data += chunk);
-        proc.on('close', (code) => {
-          try {
-            resolve(JSON.parse(data));
-          } catch {
-            resolve(data);
-          }
-        });
-      } else {
-        proc.on('close', resolve);
-      }
-    });
-  }
-}
-
-module.exports = Mandor;

package/npm/lib/download.js

@@ -1,83 +0,0 @@
-/**
- * @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/resolve.js

@@ -1,159 +0,0 @@
-/**
- * @fileoverview Version resolution module for Mandor CLI
- * @description Resolves the correct binary path based on version and platform
- * @version 0.0.2
- */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const { downloadBinary, getCurrentPlatform } = require('./download');
-
-const REPO = 'sanxzy/mandor';
-const GITHUB_API = 'https://api.github.com';
-const DEFAULT_VERSION = 'latest';
-
-function getCachedBinary(version, platform, arch) {
-  const osArch = `${platform}-${arch}`;
-  const binaryName = platform === 'win32' ? 'mandor.exe' : 'mandor';
-  const binaryPath = path.join(os.homedir(), '.mandor', 'bin', version, osArch, binaryName);
-
-  if (fs.existsSync(binaryPath)) {
-    return binaryPath;
-  }
-  return null;
-}
-
-async function getLatestVersion(prerelease = false) {
-  const url = prerelease
-    ? `${GITHUB_API}/repos/${REPO}/releases`
-    : `${GITHUB_API}/repos/${REPO}/releases/latest`;
-
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch releases: ${response.statusText}`);
-  }
-  const data = await response.json();
-  const tagName = Array.isArray(data) ? data[0].tag_name : data.tag_name;
-  return tagName.replace(/^v/, '');
-}
-
-function cacheBinary(binaryPath, version, platform, arch) {
-  const osArch = `${platform}-${arch}`;
-  const cacheDir = path.join(os.homedir(), '.mandor', 'bin', version, osArch);
-  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');
-}
-
-async function resolve(options = {}) {
-  const version = options.version || DEFAULT_VERSION;
-  const { platform, arch } = getCurrentPlatform();
-  const prerelease = options.prerelease || false;
-
-  let resolveVersion = version;
-  if (version === 'latest') {
-    resolveVersion = await getLatestVersion(prerelease);
-  }
-
-  const cachedPath = getCachedBinary(resolveVersion, platform, arch);
-  if (cachedPath && !options.forceDownload) {
-    return cachedPath;
-  }
-
-  const osArch = `${platform}-${arch}`;
-  const downloadUrl = `https://github.com/${REPO}/releases/download/v${resolveVersion}/${osArch}.tar.gz`;
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mandor-download-'));
-  const tarball = path.join(tempDir, `${osArch}.tar.gz`);
-
-  console.log(`Downloading Mandor ${resolveVersion}...`);
-
-  const response = await fetch(downloadUrl);
-  if (!response.ok) {
-    fs.rmSync(tempDir, { recursive: true });
-    throw new Error(`Download failed: ${response.statusText}`);
-  }
-
-  const file = fs.createWriteStream(tarball);
-  await new Promise((resolve, reject) => {
-    response.body.pipe(file);
-    file.on('finish', resolve);
-    file.on('error', reject);
-  });
-
-  const binaryName = platform === 'win32' ? 'mandor.exe' : 'mandor';
-  const cacheDir = path.join(os.homedir(), '.mandor', 'bin', resolveVersion, osArch);
-  fs.mkdirSync(cacheDir, { recursive: true });
-
-  const { execSync } = require('child_process');
-  execSync(`tar -xzf "${tarball}" -C "${cacheDir}"`, { stdio: 'pipe' });
-  fs.chmodSync(path.join(cacheDir, binaryName), '755');
-
-  fs.rmSync(tempDir, { recursive: true });
-
-  return path.join(cacheDir, binaryName);
-}
-
-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 versionPath = path.join(cacheDir, entry);
-    if (fs.statSync(versionPath).isDirectory()) {
-      const subEntries = fs.readdirSync(versionPath);
-      for (const subEntry of subEntries) {
-        const subPath = path.join(versionPath, subEntry);
-        if (fs.statSync(subPath).isDirectory()) {
-          const parts = subEntry.split('-');
-          const arch = parts.pop();
-          const platform = parts.join('-');
-          versions.push({ version: entry, platform, arch, path: subPath });
-        }
-      }
-    }
-  }
-
-  return versions;
-}
-
-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,
-  getLatestVersion
-};