feat: Implement initial CLI structure and install core dependencies.

Author: ProgrammerKR

README.md

@@ -114,8 +114,14 @@ main();
 ```
 
 ### 2. Run It
+Using the CLI:
 ```bash
-prox hello.prox
+prox run hello.prox
+```
+
+Or using the legacy direct execution:
+```bash
+./proxpl hello.prox
 ```
 
 ### 3. Build It (Coming Soon)
@@ -133,14 +139,25 @@ Your lucky number is: 42
 
 ## 📥 Installation
 
-### Option 1: Pre-built Binaries (Recommended)
+### Option 1: CLI via Node.js (Recommended for Developers)
+The ProXPL CLI provides an enhanced experience with watch mode and better logging.
+
+```bash
+cd src/cli
+npm install
+npm link
+```
+
+Now you can use the `prox` command globally.
+
+### Option 2: Pre-built Binaries
 No compilation required. Download the latest release for your OS:
 
-*   **Windows**: [Download `prox.exe`](https://github.com/ProgrammerKR/ProXPL/releases/latest)
-*   **Linux**: [Download `prox`](https://github.com/ProgrammerKR/ProXPL/releases/latest)
-*   **macOS**: [Download `prox-macos`](https://github.com/ProgrammerKR/ProXPL/releases/latest)
+*   **Windows**: [Download `proxpl.exe`](https://github.com/ProgrammerKR/ProXPL/releases/latest)
+*   **Linux**: [Download `proxpl`](https://github.com/ProgrammerKR/ProXPL/releases/latest)
+*   **macOS**: [Download `proxpl-macos`](https://github.com/ProgrammerKR/ProXPL/releases/latest)
 
-Add the executable to your system `PATH` to run it from anywhere.
+Add the executable to your system `PATH` to run it as `proxpl`.
 
 ### Option 2: Build from Source (CMake)
 Requirements: **GCC/Clang** (C99+), **CMake** 3.10+, **Git**.

examples/cli_test.prox

@@ -0,0 +1,13 @@
+// examples/cli_test.prox
+func main() {
+    print("CLI Test Script");
+    let x = 10;
+    let y = 20;
+    print("Sum: " + to_string(x + y));
+    
+    if (x < y) {
+        print("x is less than y");
+    }
+}
+
+main();

src/cli/README.md

@@ -0,0 +1,62 @@
+# ProXPL CLI
+
+Professional Command-Line Interface for the ProX Programming Language.
+
+## Features
+
+- **Run Script**: Execute `.prox` files with `prox run <file>`.
+- **REPL**: Interactive shell with `prox repl` or by running `prox` without arguments.
+- **Build**: Compile scripts to bytecode (currently a placeholder for future VM support).
+- **Watch Mode**: Automatically rerun scripts on change with `--watch`.
+- **Debug/Verbose**: Get detailed execution info with `--debug` and `--verbose`.
+- **Config**: Support for `.proxrc` or `prox.json` configuration files.
+
+## Installation
+
+```bash
+cd src/cli
+npm install
+npm link
+```
+
+## Usage
+
+### Running a script
+```bash
+prox run examples/hello.prox
+```
+
+### Watch mode
+```bash
+prox run main.prox --watch
+```
+
+### REPL
+```bash
+prox repl
+```
+
+### Help
+```bash
+prox --help
+```
+
+## Configuration
+
+You can create a `.proxrc` or `prox.json` in your project root to set default options:
+
+```json
+{
+  "debug": true,
+  "verbose": false
+}
+```
+
+## Development
+
+The CLI is built with Node.js and uses the `commander` package. It interacts with the C-based ProXPL core by spawning it as a child process.
+
+### Directory Structure
+- `index.js`: Main entry point.
+- `commands/`: Individual command implementations.
+- `utils/`: Helper utilities (logger, runner, config).

src/cli/commands/build.js

@@ -0,0 +1,28 @@
+import { runProXPL } from '../utils/runner.js';
+import { logger } from '../utils/logger.js';
+import path from 'path';
+import fs from 'fs-extra';
+
+export async function buildCommand(file, options) {
+    if (!file) {
+        logger.error('No file specified.', 'Usage: prox build <file>');
+        process.exit(1);
+    }
+
+    const filePath = path.resolve(file);
+
+    if (!await fs.pathExists(filePath)) {
+        logger.error(`File not found: ${file}`);
+        process.exit(1);
+    }
+
+    logger.info(`Compiling ${path.basename(file)}...`);
+
+    try {
+        // Current C implementation has a stub for build
+        await runProXPL(['build', filePath]);
+        logger.success('Build successful.');
+    } catch (err) {
+        process.exit(1);
+    }
+}

src/cli/commands/repl.js

@@ -0,0 +1,11 @@
+import { runProXPL } from '../utils/runner.js';
+import { logger } from '../utils/logger.js';
+
+export async function replCommand() {
+    logger.info('Starting ProXPL REPL...');
+    try {
+        await runProXPL([]);
+    } catch (err) {
+        process.exit(1);
+    }
+}

src/cli/commands/run.js

@@ -0,0 +1,54 @@
+import { runProXPL } from '../utils/runner.js';
+import { logger } from '../utils/logger.js';
+import chokidar from 'chokidar';
+import path from 'path';
+import fs from 'fs-extra';
+
+export async function runCommand(file, options) {
+    if (!file) {
+        logger.error('No file specified.', 'Usage: prox run <file>');
+        process.exit(1);
+    }
+
+    const filePath = path.resolve(file);
+
+    if (!await fs.pathExists(filePath)) {
+        logger.error(`File not found: ${file}`);
+        process.exit(1);
+    }
+
+    if (options.watch) {
+        logger.info(`Watching for changes in ${path.basename(file)}...`);
+
+        const watcher = chokidar.watch(filePath);
+
+        let isRunning = false;
+
+        const execute = async () => {
+            if (isRunning) return;
+            isRunning = true;
+
+            console.clear();
+            logger.info(`Rerunning ${path.basename(file)}...`);
+
+            try {
+                await runProXPL(['run', filePath]);
+                logger.success('Execution finished.');
+            } catch (err) {
+                // Error already logged by runner stdio:inherit
+            } finally {
+                isRunning = false;
+                logger.dim('\nWaiting for changes...');
+            }
+        };
+
+        watcher.on('change', execute);
+        execute(); // Initial run
+    } else {
+        try {
+            await runProXPL(['run', filePath]);
+        } catch (err) {
+            process.exit(1);
+        }
+    }
+}

src/cli/index.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { runCommand } from './commands/run.js';
+import { buildCommand } from './commands/build.js';
+import { replCommand } from './commands/repl.js';
+import { logger } from './utils/logger.js';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { loadConfig, mergeOptions } from './utils/config.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageJson = fs.readJsonSync(path.join(__dirname, 'package.json'));
+const config = await loadConfig();
+
+const program = new Command();
+
+program
+    .name('prox')
+    .description('ProXPL CLI - Professional Command-Line Interface for ProX Programming Language')
+    .version(packageJson.version, '-v, --version');
+
+program
+    .command('run')
+    .alias('r')
+    .description('Execute a .prox script')
+    .argument('<file>', 'Path to the .prox script')
+    .option('-w, --watch', 'Watch mode: automatically rerun on file changes')
+    .option('-d, --debug', 'Show detailed debug information')
+    .option('-v, --verbose', 'Show verbose execution info')
+    .action((file, options) => {
+        const merged = mergeOptions(options, config);
+        runCommand(file, merged);
+    });
+
+program
+    .command('build')
+    .alias('b')
+    .description('Compile a .prox script to bytecode')
+    .argument('<file>', 'Path to the .prox script')
+    .option('-o, --output <output>', 'Specified output file')
+    .action((file, options) => {
+        const merged = mergeOptions(options, config);
+        buildCommand(file, merged);
+    });
+
+program
+    .command('repl')
+    .description('Start interactive ProXPL shell')
+    .action(() => {
+        replCommand();
+    });
+
+// Handle unknown commands
+program.on('command:*', () => {
+    logger.error('Invalid command: ' + program.args.join(' '));
+    logger.info('See "prox --help" for available commands.');
+    process.exit(1);
+});
+
+// Default behavior: run repl if no args, or run file if first arg is a file
+if (process.argv.length === 2) {
+    replCommand();
+} else {
+    program.parse(process.argv);
+}