claude-flow 2.0.0-alpha.55 → 2.0.0-alpha.56

package/bin/claude-flow

@@ -1,7 +1,7 @@
 #!/bin/sh
 # Claude-Flow Smart Dispatcher - Detects and uses the best available runtime
 
-VERSION="2.0.0-alpha.55"
+VERSION="2.0.0-alpha.56"
 
 # Determine the correct path based on how the script is invoked
 if [ -L "$0" ]; then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "2.0.0-alpha.55",
+  "version": "2.0.0-alpha.56",
   "description": "Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)",
   "main": "cli.mjs",
   "bin": {
@@ -111,6 +111,7 @@
     "cli-table3": "^0.6.3",
     "commander": "^11.1.0",
     "cors": "^2.8.5",
+    "diskusage": "^1.1.3",
     "express": "^4.18.2",
     "figlet": "^1.8.1",
     "fs-extra": "^11.2.0",

package/src/cli/commands/hook-types.ts

@@ -26,25 +26,43 @@ export interface PreEditOptions extends BaseHookOptions {
   file: string;
   operation?: 'read' | 'write' | 'edit' | 'delete';
   validate?: boolean;
+  autoAssignAgents?: boolean;
+  'auto-assign-agents'?: boolean;
+  loadContext?: boolean;
+  'load-context'?: boolean;
 }
 
 export interface PostEditOptions extends BaseHookOptions {
   file: string;
   memoryKey?: string;
+  'memory-key'?: string;
   format?: boolean;
   analyze?: boolean;
+  updateMemory?: boolean;
+  'update-memory'?: boolean;
+  trainNeural?: boolean;
+  'train-neural'?: boolean;
 }
 
 export interface PreCommandOptions extends BaseHookOptions {
   command: string;
   validate?: boolean;
+  'validate-safety'?: boolean;
   sandbox?: boolean;
+  prepareResources?: boolean;
+  'prepare-resources'?: boolean;
 }
 
 export interface PostCommandOptions extends BaseHookOptions {
   command: string;
   exitCode?: number;
+  'exit-code'?: number;
   duration?: number;
+  trackMetrics?: boolean;
+  'track-metrics'?: boolean;
+  storeResults?: boolean;
+  'store-results'?: boolean;
+  output?: string;
 }
 
 export interface SessionStartOptions extends BaseHookOptions {
@@ -56,7 +74,11 @@ export interface SessionStartOptions extends BaseHookOptions {
 export interface SessionEndOptions extends BaseHookOptions {
   sessionId?: string;
   exportMetrics?: boolean;
+  'export-metrics'?: boolean;
   generateSummary?: boolean;
+  'generate-summary'?: boolean;
+  persistState?: boolean;
+  'persist-state'?: boolean;
   saveTo?: string;
 }
 

package/src/cli/help-text.js

@@ -3,14 +3,14 @@
  * Provides clear, actionable command documentation
  */
 
-export const VERSION = '2.0.0-alpha.55';
+export const VERSION = '2.0.0-alpha.56';
 
 export const MAIN_HELP = `
 🌊 Claude-Flow v${VERSION} - Enterprise-Grade AI Agent Orchestration Platform
 
 🎯 ENTERPRISE FEATURES: Complete ruv-swarm integration with 87 MCP tools, neural networking, and production-ready infrastructure
 🐝 NEW: Advanced Hive Mind System with Queen-led coordination, collective intelligence, and unlimited scaling
-⚡ ALPHA 55: Fixed configuration placement and process management issues
+⚡ ALPHA 56: Enhanced code quality - Fixed UI rendering, real metrics, CLI parsing, and portability
 
 USAGE:
   claude-flow <command> [options]

package/src/cli/node-compat.js

@@ -8,6 +8,7 @@ import { existsSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import process from 'process';
+import { spawn } from 'child_process';
 
 // Process arguments (remove first two: node executable and script path)
 export const args = process.argv.slice(2);
@@ -75,6 +76,53 @@ export const exit = (code = 0) => {
   process.exit(code);
 };
 
+export const execPath = () => process.execPath;
+
+// stdin/stdout/stderr support
+export const stdin = {
+  read: async (buffer) => {
+    return new Promise((resolve) => {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+      process.stdin.resume();
+      process.stdin.once('data', (data) => {
+        const bytes = Math.min(data.length, buffer.length);
+        for (let i = 0; i < bytes; i++) {
+          buffer[i] = data[i];
+        }
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        resolve(bytes);
+      });
+    });
+  }
+};
+
+export const stdout = {
+  write: async (data) => {
+    return new Promise((resolve, reject) => {
+      process.stdout.write(data, (err) => {
+        if (err) reject(err);
+        else resolve(data.length);
+      });
+    });
+  }
+};
+
+export const stderr = {
+  write: async (data) => {
+    return new Promise((resolve, reject) => {
+      process.stderr.write(data, (err) => {
+        if (err) reject(err);
+        else resolve(data.length);
+      });
+    });
+  }
+};
+
 // Deno.errors compatibility
 export const errors = {
   NotFound: class NotFound extends Error {
@@ -130,6 +178,74 @@ export const build = {
   target: `${process.arch}-${process.platform}`
 };
 
+// Environment variables support
+export const env = {
+  get: (key) => process.env[key],
+  set: (key, value) => { process.env[key] = value; },
+  toObject: () => ({ ...process.env })
+};
+
+// Deno.Command compatibility
+export class Command {
+  constructor(command, options = {}) {
+    this.command = command;
+    this.options = options;
+  }
+
+  async output() {
+    return new Promise((resolve, reject) => {
+      const child = spawn(this.command, this.options.args || [], {
+        cwd: this.options.cwd,
+        env: this.options.env,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      let stdout = [];
+      let stderr = [];
+
+      child.stdout.on('data', (data) => {
+        stdout.push(data);
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr.push(data);
+      });
+
+      child.on('close', (code) => {
+        resolve({
+          code,
+          success: code === 0,
+          stdout: Buffer.concat(stdout),
+          stderr: Buffer.concat(stderr)
+        });
+      });
+
+      child.on('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+
+  spawn() {
+    const child = spawn(this.command, this.options.args || [], {
+      cwd: this.options.cwd,
+      env: this.options.env,
+      stdio: this.options.stdio || 'inherit'
+    });
+
+    return {
+      status: new Promise((resolve) => {
+        child.on('close', (code) => {
+          resolve({ code, success: code === 0 });
+        });
+      }),
+      stdout: child.stdout,
+      stderr: child.stderr,
+      kill: (signal) => child.kill(signal)
+    };
+  }
+}
+
 // Export a Deno-like object for easier migration
 export const Deno = {
   args,
@@ -143,8 +259,14 @@ export const Deno = {
   pid,
   kill,
   exit,
+  execPath,
   errors,
-  build
+  build,
+  stdin,
+  stdout,
+  stderr,
+  env,
+  Command
 };
 
 export default Deno;

package/src/cli/simple-cli.js

@@ -18,7 +18,7 @@ import process from 'process';
 import readline from 'readline';
 import { getMainHelp, getCommandHelp } from './help-text.js';
 
-const VERSION = '2.0.0-alpha.55';
+const VERSION = '2.0.0-alpha.56';
 
 function printHelp() {
   console.log(getMainHelp());

package/src/cli/simple-commands/github.js

@@ -5,6 +5,61 @@
  */
 
 import { printSuccess, printError, printWarning } from '../utils.js';
+import { platform } from 'os';
+import { access, constants } from 'fs/promises';
+import { join } from 'path';
+
+/**
+ * Cross-platform check for executable availability
+ * @param {string} command - The command to check
+ * @returns {Promise<boolean>} - True if command is available
+ */
+async function checkCommandAvailable(command) {
+  const { execSync } = await import('child_process');
+  
+  if (platform() === 'win32') {
+    // Windows: Use 'where' command
+    try {
+      execSync(`where ${command}`, { stdio: 'ignore' });
+      return true;
+    } catch (e) {
+      return false;
+    }
+  } else {
+    // Unix-like systems: Check common paths and use 'command -v'
+    try {
+      execSync(`command -v ${command}`, { stdio: 'ignore', shell: true });
+      return true;
+    } catch (e) {
+      // Fallback: Check common installation paths
+      const commonPaths = [
+        '/usr/local/bin',
+        '/usr/bin',
+        '/opt/homebrew/bin',
+        join(process.env.HOME || '', '.local', 'bin'),
+        join(process.env.HOME || '', 'bin')
+      ];
+      
+      for (const dir of commonPaths) {
+        try {
+          await access(join(dir, command), constants.X_OK);
+          return true;
+        } catch (e) {
+          // Continue checking other paths
+        }
+      }
+      return false;
+    }
+  }
+}
+
+/**
+ * Check if Claude CLI is available
+ * @returns {Promise<boolean>} - True if Claude is available
+ */
+async function checkClaudeAvailable() {
+  return checkCommandAvailable('claude');
+}
 
 const GITHUB_MODES = {
   'gh-coordinator': {
@@ -149,9 +204,9 @@ export async function githubCommand(args, flags) {
     // Check if Claude is available
     const { execSync } = await import('child_process');
     
-    try {
-      execSync('which claude', { stdio: 'ignore' });
-    } catch (e) {
+    // Cross-platform check for Claude CLI
+    const isClaudeAvailable = await checkClaudeAvailable();
+    if (!isClaudeAvailable) {
       printWarning('⚠️  Claude CLI not found. GitHub automation requires Claude.');
       console.log('Install Claude: https://claude.ai/code');
       console.log('\nAlternatively, this would execute:');