@mandors/cli 0.0.16 → 0.0.18

package/README.md

@@ -69,48 +69,86 @@ Mandor provides:
 
 ## Installation
 
-Choose one of the following methods:
+Mandor can be installed via curl, npm, or built from source.
 
-### Option 1: curl (Recommended)
+### Option 1: curl (Recommended for macOS/Linux)
+
+The fastest way to install Mandor on macOS or Linux:
 
 ```bash
-# Install latest stable version
+# Install latest stable version (to ~/.local/bin)
 curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh
 
-# Or install to custom directory
-curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --prefix ~/bin
+# Install to custom directory
+curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --prefix /usr/local/bin
 
-# Install latest prerelease
+# Install latest prerelease (beta versions)
 curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --prerelease
 
 # Install specific version
-curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --version v0.0.14
+curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --version v0.0.16
 ```
 
-Default install location: `$HOME/.local/bin/mandor`
+**Default install location:** `$HOME/.local/bin/mandor`
 
-Add to PATH if needed:
+**Add to PATH:**
 ```bash
-export PATH="$HOME/.local/bin:$PATH"
+# For bash
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc
+
+# For zsh
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc && source ~/.zshrc
 ```
 
-### Option 2: NPM
+**Verify installation:**
+```bash
+mandor --help
+```
+
+### Option 2: NPM (Cross-platform)
+
+Install via npm for macOS, Linux, or Windows:
 
 ```bash
 # Install globally
 npm install -g @mandor/cli
 
-# Or use npx without installing
+# Verify installation
+mandor --help
+```
+
+**Or use npx to run without installing:**
+```bash
 npx @mandor/cli init "My Project"
 ```
 
+**Programmatic usage:**
+```javascript
+const mandor = require('@mandor/cli');
+
+const cli = new mandor.Mandor({ json: true, cwd: '/project/path' });
+await cli.init('My Project');
+await cli.projectCreate('api', { name: 'API Service' });
+const tasks = await cli.taskList({ project: 'api', status: 'pending' });
+```
+
 ### Option 3: From Source
 
+Build from Go source code:
+
 ```bash
+# Clone repository
 git clone https://github.com/sanxzy/mandor.git
 cd mandor
+
+# Build binary
 go build -o build/mandor ./cmd/mandor
+
+# Install to system
 sudo mv build/mandor /usr/local/bin/
+
+# Verify
+mandor --help
 ```
 
 ### Platform Support
@@ -118,9 +156,35 @@ sudo mv build/mandor /usr/local/bin/
 | Method | macOS | Linux | Windows |
 |--------|-------|-------|---------|
 | curl | ✅ arm64, x64 | ✅ arm64, x64 | ❌ |
-| NPM | ✅ arm64, x64 | ✅ arm64, x64 | ✅ arm64, x64 |
+| npm | ✅ arm64, x64 | ✅ arm64, x64 | ✅ arm64, x64 |
 | Source | ✅ | ✅ | ✅ |
 
+### Troubleshooting
+
+**curl: command not found**
+Install curl: `brew install curl` (macOS) or `sudo apt install curl` (Linux)
+
+**mandor: command not found**
+Ensure the install directory is in your PATH (see above)
+
+**Permission denied**
+```bash
+# Fix permissions for ~/.local/bin
+chmod +x ~/.local/bin/mandor
+```
+
+**NPM permission errors**
+```bash
+# Use npx (no install)
+npx @mandor/cli init "My Project"
+
+# Or fix npm global permissions
+mkdir -p ~/.npm-global
+npm config set prefix '~/.npm-global'
+echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.bashrc
+source ~/.bashrc
+```
+
 ---
 
 ## Quick Start

package/npm/lib/install.js

@@ -1,17 +1,17 @@
 /**
  * @fileoverview Post-install hook for Mandor CLI
- * @description Handles binary extraction during npm install
- * @version 0.0.2
+ * @description Downloads binary from GitHub releases during npm install
+ * @version 0.0.4
  */
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
+const https = require('https');
 
 const REPO = 'sanxzy/mandor';
 const GITHUB_API = 'https://api.github.com';
-const BUNDLE_DIR = path.join(__dirname, '..', 'binaries');
 const CACHE_DIR = path.join(os.homedir(), '.mandor', 'bin');
 
 function getPlatform() {
@@ -30,13 +30,39 @@ async function getLatestVersion(prerelease = false) {
     ? `${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/, '');
+  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 downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https.get(url, (res) => {
+      if (res.statusCode === 302 || res.statusCode === 301) {
+        return downloadFile(res.headers.location, dest).then(resolve).catch(reject);
+      }
+      res.pipe(file);
+      file.on('finish', () => {
+        file.close(resolve);
+      });
+    }).on('error', (err) => {
+      fs.unlink(dest, () => {});
+      reject(err);
+    });
+  });
 }
 
 async function install(options = {}) {
@@ -60,45 +86,19 @@ async function install(options = {}) {
   console.log('');
 
   const cachePath = path.join(CACHE_DIR, installVersion, osArch);
-  const binaryPath = path.join(cachePath, 'mandor');
-
-  if (platform === 'win32') {
-    binaryPath = binaryPath + '.exe';
-  }
+  const binaryPath = path.join(cachePath, platform === 'win32' ? 'mandor.exe' : 'mandor');
 
   if (fs.existsSync(binaryPath)) {
     console.log(`Using cached binary: ${binaryPath}`);
     return binaryPath;
   }
 
-  const bundledPath = path.join(BUNDLE_DIR, assetName);
-  if (fs.existsSync(bundledPath)) {
-    console.log(`Using bundled binary: ${bundledPath}`);
-    if (!fs.existsSync(cachePath)) {
-      fs.mkdirSync(cachePath, { recursive: true });
-    }
-    execSync(`tar -xzf "${bundledPath}" -C "${cachePath}"`, { stdio: 'inherit' });
-    fs.chmodSync(binaryPath, '755');
-    console.log(`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 response = await fetch(downloadUrl);
-  if (!response.ok) {
-    throw new Error(`Download failed: ${response.statusText} (${downloadUrl})`);
-  }
-
-  const file = fs.createWriteStream(tarball);
-  await new Promise((resolve, reject) => {
-    response.body.pipe(file);
-    file.on('finish', resolve);
-    file.on('error', reject);
-  });
+  await downloadFile(downloadUrl, tarball);
 
   if (!fs.existsSync(cachePath)) {
     fs.mkdirSync(cachePath, { recursive: true });
@@ -114,7 +114,8 @@ async function install(options = {}) {
 }
 
 if (require.main === module || process.env.npm_lifecycle_event === 'postinstall') {
-  install().catch(error => {
+  const prerelease = process.argv.includes('--prerelease') || process.argv.includes('-p');
+  install({ prerelease }).catch(error => {
     console.error('Failed to install Mandor:', error.message);
     process.exit(1);
   });

package/npm/scripts/build.js

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Cross-platform build script for Mandor binaries
  * @description Compiles Go binaries for all supported platforms and creates distribution archives
- * @version 0.0.1
+ * @version 0.0.2
  */
 
 const { execSync } = require('child_process');
@@ -9,13 +9,11 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-/**
- * @typedef {Object} PlatformConfig
- * @property {string} os - Operating system (darwin, linux, win32)
- * @property {string} arch - Architecture (x64, arm64)
- */
+const ROOT_DIR = path.join(__dirname, '..', '..');
+const BINARIES_DIR = path.join(ROOT_DIR, 'binaries');
+const NPM_DIR = path.join(ROOT_DIR, 'npm');
+const NPM_BINARIES_DIR = path.join(NPM_DIR, 'binaries');
 
-/** @type {PlatformConfig[]} All supported platform configurations */
 const PLATFORMS = [
   { os: 'darwin', arch: 'x64' },
   { os: 'darwin', arch: 'arm64' },
@@ -25,118 +23,105 @@ const PLATFORMS = [
   { os: 'win32', arch: 'arm64' }
 ];
 
-/**
- * Builds the Mandor binary for a specific platform
- * @param {PlatformConfig} platform - Platform configuration
- * @param {string} sourceDir - Source directory containing Go code
- * @returns {string|null} Path to the compiled binary, or null if unsupported
- * @example
- * const binaryPath = buildForPlatform({ os: 'darwin', arch: 'arm64' }, './cmd/mandor');
- */
-function buildForPlatform(platform, sourceDir) {
+function buildForPlatform(platform) {
   const { os, arch } = platform;
-  const outputDir = path.join(__dirname, '..', 'binaries', `${os}-${arch}`);
-  const outputPath = path.join(outputDir, os === 'win32' ? 'mandor.exe' : 'mandor');
+  const outputDir = path.join(BINARIES_DIR, `${os}-${arch}`);
+  const binaryName = os === 'win32' ? 'mandor.exe' : 'mandor';
+  const outputPath = path.join(outputDir, binaryName);
 
   fs.mkdirSync(outputDir, { recursive: true });
 
   console.log(`Building for ${os}-${arch}...`);
 
   try {
-    execSync(`GOOS=${os} GOARCH=${arch} go build -o "${outputPath}" ${sourceDir}`, {
+    execSync(`GOOS=${os} GOARCH=${arch} go build -o "${outputPath}" ./cmd/mandor`, {
       stdio: 'pipe',
       shell: process.platform === 'win32'
     });
     return outputPath;
   } catch (error) {
-    // Check stderr for unsupported pair message
     const stderr = error.stderr ? error.stderr.toString() : '';
     if (stderr.includes('unsupported GOOS/GOARCH pair')) {
-      console.log(`  ⊘ Not supported on this system`);
+      console.log(`  Not supported on this system`);
       return null;
     }
-    console.error(`  ✗ Build failed:`, error.message);
+    console.error(`  Build failed:`, error.message);
     throw error;
   }
 }
 
-/**
- * Creates a distribution archive for a platform
- * @param {PlatformConfig} platform - Platform configuration
- * @returns {string|null} Path to the archive file, or null if binary doesn't exist
- * @example
- * const archivePath = createArchive({ os: 'linux', arch: 'x64' });
- */
 function createArchive(platform) {
   const { os, arch } = platform;
-  const sourceDir = path.join(__dirname, '..', 'binaries', `${os}-${arch}`);
+  const sourceDir = path.join(BINARIES_DIR, `${os}-${arch}`);
+  const binaryName = os === 'win32' ? 'mandor.exe' : 'mandor';
 
-  // Check if binary exists
-  const binaryExists = fs.existsSync(path.join(sourceDir, os === 'win32' ? 'mandor.exe' : 'mandor'));
-  if (!binaryExists) {
+  if (!fs.existsSync(path.join(sourceDir, binaryName))) {
     return null;
   }
 
-  const archivePath = path.join(__dirname, '..', 'binaries', `${os}-${arch}.tar.gz`);
+  const archivePath = path.join(BINARIES_DIR, `${os}-${arch}.tar.gz`);
+
+  try {
+    execSync(`tar -czf "${archivePath}" -C "${sourceDir}" .`, {
+      stdio: 'pipe',
+      shell: true
+    });
+    return archivePath;
+  } catch (error) {
+    console.error(`  Failed to create archive:`, error.message);
+    return null;
+  }
+}
 
-  console.log(`Creating archive for ${os}-${arch}...`);
+function copyToNpm() {
+  fs.mkdirSync(NPM_BINARIES_DIR, { recursive: true });
 
-  execSync(`tar -czf "${archivePath}" -C "${sourceDir}" .`, {
-    stdio: 'inherit',
-    shell: true
-  });
+  for (const platform of PLATFORMS) {
+    const { os, arch } = platform;
+    const archivePath = path.join(BINARIES_DIR, `${os}-${arch}.tar.gz`);
+    const destPath = path.join(NPM_BINARIES_DIR, `${os}-${arch}.tar.gz`);
 
-  return archivePath;
+    if (fs.existsSync(archivePath)) {
+      fs.cpSync(archivePath, destPath);
+      console.log(`Copied ${os}-${arch}.tar.gz to npm/`);
+    }
+  }
 }
 
-/**
- * Main build function - attempts to build all platforms
- * @returns {Object[]} Build results for each successfully built platform
- * @example
- * const results = mainBuild();
- * console.log(`Built ${results.length} platforms`);
- */
-function mainBuild() {
-  const sourceDir = path.join(__dirname, '..', '..', 'cmd', 'mandor');
-  const results = [];
-  const unsupported = [];
+function cleanBuildDirs() {
+  if (fs.existsSync(BINARIES_DIR)) {
+    for (const entry of fs.readdirSync(BINARIES_DIR)) {
+      if (entry.endsWith('.tar.gz')) {
+        fs.unlinkSync(path.join(BINARIES_DIR, entry));
+      }
+    }
+  }
+}
 
+function mainBuild() {
   console.log(`Running on: ${os.platform()}/${os.arch()}`);
   console.log('Building cross-platform binaries...\n');
 
-  // Build all platforms
+  cleanBuildDirs();
+  fs.mkdirSync(NPM_BINARIES_DIR, { recursive: true });
+
+  const results = [];
+  const unsupported = [];
+
   for (const platform of PLATFORMS) {
-    const binaryPath = buildForPlatform(platform, sourceDir);
+    const binaryPath = buildForPlatform(platform);
     if (binaryPath) {
-      results.push({
-        platform: platform.os,
-        arch: platform.arch,
-        binaryPath,
-        status: 'built'
-      });
-      console.log(`  ✓ Built successfully\n`);
+      results.push({ platform: platform.os, arch: platform.arch, binaryPath, status: 'built' });
+      console.log(`  Built successfully\n`);
     } else {
-      unsupported.push({
-        platform: platform.os,
-        arch: platform.arch,
-        status: 'unsupported'
-      });
+      unsupported.push({ platform: platform.os, arch: platform.arch, status: 'unsupported' });
     }
   }
 
-  // Create archives for successfully built platforms
-  const archiveResults = [];
   for (const platform of PLATFORMS) {
     const archivePath = createArchive(platform);
     if (archivePath) {
       const stats = fs.statSync(archivePath);
-      archiveResults.push({
-        platform: platform.os,
-        arch: platform.arch,
-        archivePath,
-        archiveSize: stats.size
-      });
-
       const existing = results.find(r => r.platform === platform.os && r.arch === platform.arch);
       if (existing) {
         existing.archivePath = archivePath;
@@ -145,10 +130,12 @@ function mainBuild() {
     }
   }
 
-  // Summary
+  console.log('Copying archives to npm/binaries/ for npm package...');
+  copyToNpm();
+
   console.log('─'.repeat(50));
   console.log(`Build complete!`);
-  console.log(`  Built: ${archiveResults.length} platforms`);
+  console.log(`  Built: ${results.length} platforms`);
   console.log(`  Unsupported: ${unsupported.length} platforms`);
 
   if (unsupported.length > 0) {
@@ -158,10 +145,12 @@ function mainBuild() {
     });
   }
 
-  return archiveResults;
+  console.log(`\nArchives location: ${BINARIES_DIR}/`);
+  console.log(`NPM package binaries: ${NPM_BINARIES_DIR}/`);
+
+  return results;
 }
 
-// Run if executed directly
 if (require.main === module) {
   const results = mainBuild();
   if (results.length > 0) {
@@ -170,14 +159,7 @@ if (require.main === module) {
       Platform: `${r.platform}/${r.arch}`,
       'Archive Size': `${(r.archiveSize / 1024).toFixed(1)} KB`
     })));
-
-    console.log('Archives location: npm/binaries/');
   }
 }
 
-module.exports = {
-  PLATFORMS,
-  buildForPlatform,
-  createArchive,
-  mainBuild
-};
+module.exports = { PLATFORMS, buildForPlatform, createArchive, mainBuild, copyToNpm };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandors/cli",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Event-based task manager CLI for AI agent workflows",
   "main": "npm/lib/index.js",
   "bin": {
@@ -19,9 +19,7 @@
     "node": ">=16.0.0"
   },
   "scripts": {
-    "postinstall": "node npm/lib/install.js",
-    "prepublishOnly": "npm run build",
-    "preversion": "npm run build",
+    "postinstall": "node npm/lib/install.js --prerelease",
     "build": "node npm/scripts/build.js",
     "build:darwin:x64": "GOOS=darwin GOARCH=x64 go build -o binaries/darwin-x64/mandor ./cmd/mandor",
     "build:darwin:arm64": "GOOS=darwin GOARCH=arm64 go build -o binaries/darwin-arm64/mandor ./cmd/mandor",