@mandors/cli 0.0.19 → 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

@@ -36,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);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandors/cli",
-  "version": "0.0.19",
+  "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,60 +0,0 @@
-/**
- * @fileoverview Version resolution module for Mandor CLI
- * @description Resolves the binary path for the CLI
- * @version 0.0.3
- */
-
-const path = require('path');
-const os = require('os');
-const https = require('https');
-
-const REPO = 'sanxzy/mandor';
-const DEFAULT_VERSION = 'latest';
-const INSTALL_DIR = path.join(os.homedir(), '.local', 'bin');
-
-function getPlatform() {
-  const platform = os.platform();
-  const arch = os.arch();
-  const platformMap = { darwin: 'darwin', linux: 'linux', win32: 'win32' };
-  const archMap = { x64: 'x64', arm64: 'arm64', amd64: 'x64', aarch64: 'arm64' };
-  return {
-    platform: platformMap[platform] || platform,
-    arch: archMap[arch] || arch
-  };
-}
-
-async function getLatestVersion(prerelease = false) {
-  const url = prerelease
-    ? `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) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      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/, ''));
-        } catch (e) {
-          reject(e);
-        }
-      });
-    }).on('error', reject);
-  });
-}
-
-function getBinaryPath(version = DEFAULT_VERSION) {
-  const { platform, arch } = getPlatform();
-  const binaryName = platform === 'win32' ? 'mandor.exe' : 'mandor';
-  return path.join(INSTALL_DIR, binaryName);
-}
-
-module.exports = {
-  getPlatform,
-  getLatestVersion,
-  getBinaryPath,
-  DEFAULT_VERSION,
-  INSTALL_DIR
-};