xypriss 9.0.13 → 9.1.1

package/tools/memory-cli/main.go

@@ -0,0 +1,401 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+// MemoryInfo represents system memory information
+type MemoryInfo struct {
+	Platform        string  `json:"platform"`
+	TotalMemory     uint64  `json:"totalMemory"`     // Total system memory in bytes
+	AvailableMemory uint64  `json:"availableMemory"` // Available memory for applications
+	FreeMemory      uint64  `json:"freeMemory"`      // free memory
+	UsedMemory      uint64  `json:"usedMemory"`      // Used memory
+	UsagePercentage float64 `json:"usagePercentage"` // Memory usage percentage
+	BuffersMemory   uint64  `json:"buffersMemory"`   // Buffers (Linux/Unix)
+	CachedMemory    uint64  `json:"cachedMemory"`    // Cached memory (Linux/Unix)
+	SwapTotal       uint64  `json:"swapTotal"`       // Total swap space
+	SwapUsed        uint64  `json:"swapUsed"`        // Used swap space
+	SwapFree        uint64  `json:"swapFree"`        // Free swap space
+}
+
+func main() {
+	if len(os.Args) > 1 && os.Args[1] == "--help" {
+		printHelp()
+		return
+	}
+
+	memInfo, err := getMemoryInfo()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error getting memory info: %v\n", err)
+		os.Exit(1)
+	}
+
+	output, err := json.Marshal(memInfo)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error marshaling JSON: %v\n", err)
+		os.Exit(1)
+	} 
+
+	fmt.Println(string(output))
+}
+
+func printHelp() {
+	fmt.Println("XyPriss Memory Info CLI")
+	fmt.Println("Usage: memory-cli [--help]")
+	fmt.Println("")
+	fmt.Println("Returns system memory information in JSON format:")
+	fmt.Println("- totalMemory: Total system memory in bytes")
+	fmt.Println("- availableMemory: Memory available for applications")
+	fmt.Println("- freeMemory: Truly free memory")
+	fmt.Println("- usedMemory: Currently used memory")
+	fmt.Println("- usagePercentage: Memory usage percentage")
+	fmt.Println("- buffersMemory: Buffer memory (Linux/Unix)")
+	fmt.Println("- cachedMemory: Cached memory (Linux/Unix)")
+	fmt.Println("- swapTotal/swapUsed/swapFree: Swap space information")
+}
+
+func getMemoryInfo() (*MemoryInfo, error) {
+	switch runtime.GOOS {
+	case "linux":
+		return getLinuxMemoryInfo()
+	case "darwin":
+		return getDarwinMemoryInfo()
+	case "windows":
+		return getWindowsMemoryInfo()
+	default:
+		return getGenericMemoryInfo()
+	}
+}
+
+// getGenericMemoryInfo provides basic memory info using Go's runtime
+func getGenericMemoryInfo() (*MemoryInfo, error) {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+
+	// This is very basic and not accurate for system memory
+	// but provides a fallback for unsupported platforms
+	return &MemoryInfo{
+		Platform:        runtime.GOOS,
+		TotalMemory:     m.Sys,
+		AvailableMemory: m.Sys - m.Alloc,
+		FreeMemory:      m.Sys - m.Alloc,
+		UsedMemory:      m.Alloc,
+		UsagePercentage: float64(m.Alloc) / float64(m.Sys) * 100,
+		BuffersMemory:   0,
+		CachedMemory:    0,
+		SwapTotal:       0,
+		SwapUsed:        0,
+		SwapFree:        0,
+	}, nil
+}
+
+// parseMemInfoLine parses a line from /proc/meminfo
+func parseMemInfoLine(line string) (string, uint64, error) {
+	parts := strings.Fields(line)
+	if len(parts) < 2 {
+		return "", 0, fmt.Errorf("invalid meminfo line: %s", line)
+	}
+
+	key := strings.TrimSuffix(parts[0], ":")
+	valueStr := parts[1]
+	
+	value, err := strconv.ParseUint(valueStr, 10, 64)
+	if err != nil {
+		return "", 0, err
+	}
+
+	// Convert from kB to bytes if unit is specified
+	if len(parts) >= 3 && parts[2] == "kB" {
+		value *= 1024
+	}
+
+	return key, value, nil
+}
+
+// bytesToMB converts bytes to megabytes for easier reading
+func bytesToMB(bytes uint64) float64 {
+	return float64(bytes) / 1024 / 1024
+}
+
+// calculateUsagePercentage calculates memory usage percentage
+func calculateUsagePercentage(used, total uint64) float64 {
+	if total == 0 {
+		return 0
+	}
+	return float64(used) / float64(total) * 100
+}
+
+// getLinuxMemoryInfo gets memory info on Linux using /proc/meminfo
+func getLinuxMemoryInfo() (*MemoryInfo, error) {
+	data, err := os.ReadFile("/proc/meminfo")
+	if err != nil {
+		return nil, fmt.Errorf("failed to read /proc/meminfo: %v", err)
+	}
+
+	memInfo := &MemoryInfo{Platform: "linux"}
+	lines := strings.Split(string(data), "\n")
+
+	for _, line := range lines {
+		if line == "" {
+			continue
+		}
+
+		key, value, err := parseMemInfoLine(line)
+		if err != nil {
+			continue // Skip invalid lines
+		}
+
+		switch key {
+		case "MemTotal":
+			memInfo.TotalMemory = value
+		case "MemAvailable":
+			memInfo.AvailableMemory = value
+		case "MemFree":
+			memInfo.FreeMemory = value
+		case "Buffers":
+			memInfo.BuffersMemory = value
+		case "Cached":
+			memInfo.CachedMemory = value
+		case "SwapTotal":
+			memInfo.SwapTotal = value
+		case "SwapFree":
+			memInfo.SwapFree = value
+		}
+	}
+
+	// Calculate derived values
+	memInfo.SwapUsed = memInfo.SwapTotal - memInfo.SwapFree
+	memInfo.UsedMemory = memInfo.TotalMemory - memInfo.AvailableMemory
+	memInfo.UsagePercentage = calculateUsagePercentage(memInfo.UsedMemory, memInfo.TotalMemory)
+
+	// If MemAvailable is not available, estimate it
+	if memInfo.AvailableMemory == 0 {
+		memInfo.AvailableMemory = memInfo.FreeMemory + memInfo.BuffersMemory + memInfo.CachedMemory
+	}
+
+	return memInfo, nil
+}
+
+// getDarwinMemoryInfo gets memory info on macOS using vm_stat and sysctl
+func getDarwinMemoryInfo() (*MemoryInfo, error) {
+	memInfo := &MemoryInfo{Platform: "darwin"}
+
+	// Get total memory using sysctl
+	totalCmd := exec.Command("sysctl", "-n", "hw.memsize")
+	totalOutput, err := totalCmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get total memory: %v", err)
+	}
+ 
+	totalMemory, err := strconv.ParseUint(strings.TrimSpace(string(totalOutput)), 10, 64)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse total memory: %v", err)
+	}
+	memInfo.TotalMemory = totalMemory
+
+	// Get memory statistics using vm_stat
+	vmStatCmd := exec.Command("vm_stat")
+	vmStatOutput, err := vmStatCmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get vm_stat: %v", err)
+	}
+
+	// Parse vm_stat output
+	lines := strings.Split(string(vmStatOutput), "\n")
+	var pageSize uint64 = 4096 // Default page size
+	var freePages, inactivePages, speculativePages uint64
+
+	for _, line := range lines {
+		if strings.Contains(line, "page size of") {
+			// Extract page size
+			parts := strings.Fields(line)
+			for i, part := range parts {
+				if part == "of" && i+1 < len(parts) {
+					if size, err := strconv.ParseUint(parts[i+1], 10, 64); err == nil {
+						pageSize = size
+					}
+					break
+				}
+			}
+		} else if strings.Contains(line, "Pages free:") {
+			freePages = parseVmStatValue(line)
+		} else if strings.Contains(line, "Pages inactive:") {
+			inactivePages = parseVmStatValue(line)
+		} else if strings.Contains(line, "Pages speculative:") {
+			speculativePages = parseVmStatValue(line)
+		}
+	}
+
+	// Calculate memory values
+	memInfo.FreeMemory = freePages * pageSize
+	memInfo.AvailableMemory = (freePages + inactivePages + speculativePages) * pageSize
+	memInfo.UsedMemory = memInfo.TotalMemory - memInfo.AvailableMemory
+	memInfo.UsagePercentage = calculateUsagePercentage(memInfo.UsedMemory, memInfo.TotalMemory)
+
+	// Get swap info using sysctl
+	swapUsageCmd := exec.Command("sysctl", "-n", "vm.swapusage")
+	if swapOutput, err := swapUsageCmd.Output(); err == nil {
+		parseSwapUsage(string(swapOutput), memInfo)
+	}
+
+	return memInfo, nil
+}
+
+// parseVmStatValue extracts numeric value from vm_stat line
+func parseVmStatValue(line string) uint64 {
+	parts := strings.Fields(line)
+	if len(parts) >= 2 {
+		valueStr := strings.TrimSuffix(parts[len(parts)-1], ".")
+		if value, err := strconv.ParseUint(valueStr, 10, 64); err == nil {
+			return value
+		}
+	}
+	return 0
+}
+
+// parseSwapUsage parses macOS swap usage output
+func parseSwapUsage(output string, memInfo *MemoryInfo) {
+	// Example: "total = 2048.00M  used = 1024.00M  free = 1024.00M  (encrypted)"
+	parts := strings.Fields(output)
+	for i, part := range parts {
+		if part == "total" && i+2 < len(parts) {
+			if total := parseMemoryValue(parts[i+2]); total > 0 {
+				memInfo.SwapTotal = total
+			}
+		} else if part == "used" && i+2 < len(parts) {
+			if used := parseMemoryValue(parts[i+2]); used > 0 {
+				memInfo.SwapUsed = used
+			}
+		} else if part == "free" && i+2 < len(parts) {
+			if free := parseMemoryValue(parts[i+2]); free > 0 {
+				memInfo.SwapFree = free
+			}
+		}
+	}
+}
+
+// parseMemoryValue parses memory values like "1024.00M" or "2.00G"
+func parseMemoryValue(value string) uint64 {
+	value = strings.TrimSpace(value)
+	if len(value) == 0 {
+		return 0
+	}
+
+	unit := value[len(value)-1:]
+	numStr := value[:len(value)-1]
+
+	num, err := strconv.ParseFloat(numStr, 64)
+	if err != nil {
+		return 0
+	}
+
+	switch unit {
+	case "K":
+		return uint64(num * 1024)
+	case "M":
+		return uint64(num * 1024 * 1024)
+	case "G":
+		return uint64(num * 1024 * 1024 * 1024)
+	default:
+		// Assume bytes if no unit
+		return uint64(num)
+	}
+}
+
+// getWindowsMemoryInfo gets memory info on Windows using wmic
+func getWindowsMemoryInfo() (*MemoryInfo, error) {
+	memInfo := &MemoryInfo{Platform: "windows"}
+
+	// Get total physical memory
+	totalCmd := exec.Command("wmic", "computersystem", "get", "TotalPhysicalMemory", "/value")
+	totalOutput, err := totalCmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get total memory: %v", err)
+	}
+
+	for _, line := range strings.Split(string(totalOutput), "\n") {
+		if strings.Contains(line, "TotalPhysicalMemory=") {
+			valueStr := strings.TrimSpace(strings.Split(line, "=")[1])
+			if total, err := strconv.ParseUint(valueStr, 10, 64); err == nil {
+				memInfo.TotalMemory = total
+			}
+			break
+		}
+	}
+
+	// Get available memory
+	availCmd := exec.Command("wmic", "OS", "get", "FreePhysicalMemory", "/value")
+	availOutput, err := availCmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get available memory: %v", err)
+	}
+
+	for _, line := range strings.Split(string(availOutput), "\n") {
+		if strings.Contains(line, "FreePhysicalMemory=") {
+			valueStr := strings.TrimSpace(strings.Split(line, "=")[1])
+			if free, err := strconv.ParseUint(valueStr, 10, 64); err == nil {
+				memInfo.FreeMemory = free * 1024 // Convert from KB to bytes
+				memInfo.AvailableMemory = memInfo.FreeMemory
+			}
+			break
+		}
+	}
+
+	// Get more accurate available memory using Performance Counters
+	perfCmd := exec.Command("typeperf", "\\Memory\\Available Bytes", "-sc", "1")
+	if perfOutput, err := perfCmd.Output(); err == nil {
+		lines := strings.Split(string(perfOutput), "\n")
+		for _, line := range lines {
+			if strings.Contains(line, "Available Bytes") {
+				parts := strings.Split(line, ",")
+				if len(parts) >= 2 {
+					valueStr := strings.Trim(strings.TrimSpace(parts[1]), "\"")
+					if avail, err := strconv.ParseFloat(valueStr, 64); err == nil {
+						memInfo.AvailableMemory = uint64(avail)
+					}
+				}
+				break
+			}
+		}
+	}
+
+	// Calculate derived values
+	memInfo.UsedMemory = memInfo.TotalMemory - memInfo.AvailableMemory
+	memInfo.UsagePercentage = calculateUsagePercentage(memInfo.UsedMemory, memInfo.TotalMemory)
+
+	// Get swap/page file info
+	swapCmd := exec.Command("wmic", "pagefile", "get", "Size,Usage", "/format:csv")
+	if swapOutput, err := swapCmd.Output(); err == nil {
+		parseWindowsSwap(string(swapOutput), memInfo)
+	}
+
+	return memInfo, nil
+}
+
+// parseWindowsSwap parses Windows page file information
+func parseWindowsSwap(output string, memInfo *MemoryInfo) {
+	lines := strings.Split(output, "\n")
+	for _, line := range lines {
+		if line == "" || strings.Contains(line, "Node,Size,Usage") {
+			continue
+		}
+
+		parts := strings.Split(line, ",")
+		if len(parts) >= 3 {
+			if size, err := strconv.ParseUint(strings.TrimSpace(parts[1]), 10, 64); err == nil {
+				memInfo.SwapTotal += size * 1024 * 1024 // Convert MB to bytes
+			}
+			if usage, err := strconv.ParseUint(strings.TrimSpace(parts[2]), 10, 64); err == nil {
+				memInfo.SwapUsed += usage * 1024 * 1024 // Convert MB to bytes
+			}
+		}
+	}
+	memInfo.SwapFree = memInfo.SwapTotal - memInfo.SwapUsed
+}

package/tools/xfpm-go/LICENSE

@@ -0,0 +1,13 @@
+NEHONIX Open Source License (Nehonix OSL (NOSL)) v1.0
+
+Copyright (c) 2025 NEHONIX - www.nehonix.com
+
+This License governs the use, modification, and distribution of software provided by NEHONIX under its open source projects. NEHONIX is committed to fostering collaborative innovation while strictly protecting its intellectual property rights. Violation of any term of this License will result in immediate termination of all granted rights and may subject the violator to legal action.
+
+The full version of this license is available at: https://dll.nehonix.com/licenses/NOSL
+
+> **DISCLAIMER OF WARRANTY**  
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+> **LIMITATION OF LIABILITY**  
+> IN NO EVENT SHALL NEHONIX BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ARISING FROM THE USE OR INABILITY TO USE THE SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

package/tools/xfpm-go/README.md

@@ -0,0 +1,82 @@
+# XFPM — XyPriss Fast Package Manager
+
+**XFPM** is a high-performance, cross-platform CLI tool built for the XyPriss ecosystem. Written in Go, it delivers fast dependency resolution, strict package isolation through a virtual store, and a clean terminal interface designed for professional workflows.
+
+---
+
+## Features
+
+- **Performance** — Optimized resolution engine based on a neural dependency graph, written entirely in Go.
+- **Strict Isolation** — Content-addressable storage (CAS) and a virtual store architecture prevent dependency leakage between projects.
+- **Cross-Platform** — Native binaries available for Windows, Linux, and macOS (amd64 and arm64).
+- **Clean Output** — Structured, minimal terminal feedback with no visual noise.
+- **Auto-Update** — Built-in update engine keeps the CLI current without manual intervention.
+- **Single Binary** — No runtime dependencies. One binary, fully self-contained.
+
+---
+
+## Installation
+
+XFPM is distributed through the official Nehonix unified installer.
+
+### Unix / macOS / WSL
+
+```bash
+curl -sL https://xypriss.nehonix.com/install.js | node
+```
+
+### Windows (PowerShell)
+
+```powershell
+Invoke-RestMethod -Uri "https://xypriss.nehonix.com/install.js" -UseBasicParsing | node
+```
+
+---
+
+## Usage
+
+### Initialize a project
+
+```bash
+xfpm init
+```
+
+### Install dependencies
+
+```bash
+xfpm install           # Install from package.json
+xfpm add axios         # Add a specific package
+xfpm add -D vitest     # Add to devDependencies
+```
+
+### Update packages
+
+```bash
+xfpm update            # Update all packages
+xfpm update axios      # Update a specific package
+```
+
+### Remove a package
+
+```bash
+xfpm rm <package>
+```
+
+---
+
+## Architecture
+
+XFPM resolves dependencies by building a **Neural Dependency Graph** of your project.
+
+1. **CAS (Content Addressable Storage)** — Every file is hashed and stored once, eliminating duplicates across the system.
+2. **Virtual Store** — Dependencies are stored in a hidden directory (`node_modules/.xpm/virtual_store`) by exact version and symlinked into the project's `node_modules`.
+3. **Targeted Resolution** — Only the modified portions of the dependency graph are recalculated during updates, minimizing overhead.
+
+---
+
+## License
+
+Copyright 2025 Nehonix. All rights reserved.  
+Licensed under the **Nehonix OSL (NOSL)**.
+
+Powered by Nehonix and the XyPriss Engine.

package/tools/xfpm-go/build.sh

@@ -0,0 +1,91 @@
+#!/bin/bash
+# ***************************************************************************
+# * XFPM (XyPriss Fast Package Manager)
+# * Cross-Platform Build Architecture
+# * @license Nehonix OSL (NOSL)
+# ***************************************************************************
+
+# Colors for premium terminal output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+MAGENTA='\033[0;35m'
+YELLOW='\033[1;33m'
+BOLD='\033[1m'
+DIM='\033[2m'
+NC='\033[0m'
+
+# Configuration
+DIST_DIR="dist"
+BINARY_NAME="xfpm"
+ENTRY_POINT="./cmd/xfpm"
+# Extract version from Go source
+VERSION=$(grep "BinVersion =" internal/utils/lib_version.go | cut -d'"' -f2)
+
+echo -e "\n${BLUE}${BOLD} 🚀 XFPM BUILD ENGINE ${NC} ${DIM}v${VERSION}${NC}"
+echo -e "${DIM} ──────────────────────────────────────────────────${NC}\n"
+
+# Check for compress flag
+COMPRESS=false
+if [[ "$*" == *"--compress"* ]]; then
+    COMPRESS=true
+    if ! command -v upx >/dev/null 2>&1; then
+        echo -e " ${YELLOW}⚠️  UPX not found. Compression will be skipped.${NC}"
+        COMPRESS=false
+    fi
+fi
+
+# Multi-platform targets
+# format: "os/arch"
+TARGETS=(
+    "linux/amd64"
+    "linux/arm64"
+    "darwin/amd64"
+    "darwin/arm64"
+    "windows/amd64"
+    "windows/arm64"
+)
+
+# Initialization
+rm -rf "$DIST_DIR"
+mkdir -p "$DIST_DIR"
+
+# Build Loop
+for TARGET in "${TARGETS[@]}"; do
+    IFS="/" read -r OS ARCH <<< "$TARGET"
+    
+    # Filename logic
+    OUTPUT="${BINARY_NAME}-${OS}-${ARCH}"
+    if [ "$OS" == "windows" ]; then
+        OUTPUT="${OUTPUT}.exe"
+    fi
+
+    # Display progress
+    printf "  ${CYAN}%-20s${NC} ${DIM}»${NC} " "Creating ${OS}/${ARCH}"
+    
+    # Build command
+    # -s: Omit the symbol table and debug information
+    # -w: Omit the DWARF symbol table
+    if GOOS=$OS GOARCH=$ARCH go build -ldflags="-s -w" -o "${DIST_DIR}/${OUTPUT}" "$ENTRY_POINT"; then
+        echo -e "${GREEN}✓ DONE${NC}"
+        
+        # Compression phase
+        if [ "$COMPRESS" = true ]; then
+            printf "  ${MAGENTA}%-20s${NC} ${DIM}»${NC} " "UPX Compressing"
+            if upx --best "${DIST_DIR}/${OUTPUT}" > /dev/null 2>&1; then
+                echo -e "${MAGENTA}✨ OPTIMIZED${NC}"
+            else
+                echo -e "${YELLOW}⨯ SKIPPED${NC}"
+            fi
+        fi
+    else
+        echo -e "${NC}❌ FAILED${NC}"
+        exit 1
+    fi
+done
+
+echo -e "\n${GREEN}${BOLD} ✅ BUILD PIPELINE COMPLETE ${NC}"
+echo -e "${DIM} Artifacts stored in: ./${DIST_DIR}${NC}\n"
+
+ls -lh "$DIST_DIR" | grep "$BINARY_NAME" | awk '{print "  " $5 "\t" $9}'
+echo ""

package/tools/xfpm-go/cmd/xfpm/exec.go

@@ -0,0 +1,68 @@
+/***************************************************************************
+ * XFPM (XyPriss Fast Package Manager)
+ *
+ * @author Nehonix
+ * @license Nehonix OSL (NOSL)
+ *
+ * Copyright (c) 2025 Nehonix. All rights reserved.
+ *
+ * This License governs the use, modification, and distribution of software
+ * provided by NEHONIX under its open source projects.
+ * NEHONIX is committed to fostering collaborative innovation while strictly
+ * protecting its intellectual property rights.
+ * Violation of any term of this License will result in immediate termination of all granted rights
+ * and may subject the violator to legal action.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
+ * AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL NEHONIX BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES ARISING FROM THE USE OR INABILITY TO USE THE SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ *
+ ***************************************************************************** */
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/Nehonix-Team/xfpm-go/internal/utils"
+	"github.com/spf13/cobra"
+)
+
+var execCmd = &cobra.Command{
+	Use:   "exec [command]",
+	Short: "Execute a command from local node_modules/.bin",
+	Aliases: []string{"x"},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if len(args) == 0 {
+			return fmt.Errorf("no command specified")
+		}
+
+		binName := args[0]
+		binArgs := args[1:]
+
+		projectRoot, _ := os.Getwd()
+		binPath := filepath.Join(projectRoot, "node_modules", ".bin", binName)
+
+		if _, err := os.Stat(binPath); err == nil {
+			utils.Info("Executing: %s", binName)
+			return executeCommand(binPath, binArgs, projectRoot)
+		}
+
+		// Fallback: try to execute directly if it's in the system PATH
+		if _, err := exec.LookPath(binName); err == nil {
+			return executeCommand(binName, binArgs, projectRoot)
+		}
+
+		return fmt.Errorf("command '%s' not found", binName)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(execCmd)
+}