mantle-forge 1.0.0

package/PUBLISH_INSTRUCTIONS.md

@@ -0,0 +1,57 @@
+# Publishing MantlePush CLI to npm
+
+## Publishing Steps
+
+1. **Verify npm authentication:**
+   ```bash
+   npm whoami
+   ```
+   If not logged in:
+   ```bash
+   npm login
+   # Or create account: npm adduser
+   ```
+
+2. **Check package name availability:**
+   ```bash
+   npm view @marshalz/git-mantle-agent
+   ```
+   Should return 404 (not found) - package name is available!
+
+3. **Prepare for publishing:**
+   ```bash
+   cd git-agent-cli
+   npm version patch  # Increment version (e.g., 1.0.2 → 1.0.3)
+   npm publish
+   ```
+
+4. **Post-publishing installation:**
+   Users can now install the MantlePush CLI globally:
+   ```bash
+   npm install -g @marshalz/git-mantle-agent
+   ```
+
+## Package Details
+
+- **Package name**: `@marshalz/git-mantle-agent` (npm registry identifier)
+- **Command name**: `git-mantle-agent` (accessed via Git alias)
+- **Versioning**: Follow semantic versioning (major.minor.patch)
+- **Dependencies**: All required packages must be listed in `package.json`
+
+## User Setup Instructions
+
+After installing from npm, users configure the Git alias:
+```bash
+git config --global alias.mantle-agent '!git-mantle-agent'
+```
+
+Alternatively, users can invoke the CLI directly:
+```bash
+git-mantle-agent stats
+git-mantle-agent compare main aggressive
+git-mantle-agent logs
+```
+
+## Mantle Network Integration
+
+This CLI package is designed specifically for Mantle Sepolia testnet deployments. All agent contracts are deployed to Mantle's Layer 2 infrastructure, providing fast and cost-effective AI agent execution.

package/README.md

@@ -0,0 +1,170 @@
+# MantleForge CLI
+
+**Deploy AI Agents on Mantle with Git** - Professional command-line interface for the MantleForge deployment platform.
+
+MantleForge transforms AI agent deployment into a seamless Git-native workflow. Deploy autonomous agents to Mantle Sepolia testnet with a single `git push`. Each branch becomes a unique smart contract, enabling true parallel A/B testing of trading strategies.
+
+## Installation
+
+### Quick Install (For Users)
+
+**Option 1: Install from npm (Recommended)**
+```bash
+npm install -g mantle-forge
+
+# Start using MantleForge CLI
+mantle-forge stats
+mantle-forge compare main aggressive
+```
+
+**Option 2: Install from source (Development)**
+```bash
+git clone https://github.com/xaviersharwin10/somnia-git-agent.git
+cd somnia-git-agent/git-agent-cli
+npm install -g .
+
+# Set up Git alias
+```
+
+### Development
+```bash
+npm link
+```
+
+## CLI Commands
+
+* `mantle-forge init` - Configure MantleForge deployment pipeline for your repository
+* `mantle-forge secrets set <KEY=VALUE>` - Store encrypted secrets for the current branch (e.g., `GROQ_API_KEY=sk-...`)
+* `mantle-forge secrets check` - Verify which secrets are configured for your agent
+* `mantle-forge stats` - Display real-time performance metrics from your Mantle agent
+* `mantle-forge logs` - Stream the latest 50 log entries from your agent process
+* `mantle-forge compare <branch1> <branch2>` - Side-by-side comparison of two agent strategies
+* `mantle-forge restart` - Restart the agent for the current branch
+
+You can use `mantle-forge` directly as shown above.
+
+## Key Features
+
+- 🚀 **One-Command Setup**: Interactive initialization that configures everything automatically
+- 🔐 **Enterprise-Grade Security**: AES-256 encrypted secret storage, one set per Git branch
+- 📊 **Live Performance Tracking**: Real-time metrics from agents executing on Mantle Sepolia
+- 🔄 **Parallel Strategy Testing**: Compare multiple trading strategies running simultaneously
+- ⛓️ **Native Mantle Integration**: Built specifically for Mantle's Layer 2 infrastructure
+- 🎨 **Developer-Friendly UX**: Color-coded terminal output with clear, actionable feedback
+- ⚡ **Lightweight & Fast**: Minimal dependencies, instant command execution
+
+## Mantle Sepolia Integration
+
+MantleForge leverages Mantle's high-performance Layer 2 infrastructure to deploy and manage AI agents:
+
+- **Smart Contract Deployment**: Each Git branch deploys as a unique `Agent.sol` contract on Mantle Sepolia
+- **On-Chain Identity**: Every agent has a permanent contract address on Mantle blockchain
+- **DEX Integration**: Agents execute real trades on Mantle-compatible decentralized exchanges
+- **Factory Pattern**: Centralized `AgentFactory` contract manages all agent deployments
+- **Blockchain-Backed Registry**: Agent addresses persist on-chain, surviving backend failures
+
+## Usage
+
+### Initialize Repository for Mantle Deployment
+
+```bash
+mantle-forge init
+```
+
+The initialization process:
+- Creates `.gitagent.json` configuration file in your repository root
+- Prompts for GitHub repository URL (used for webhook auto-configuration)
+- Provides step-by-step instructions for connecting to MantleForge backend
+- Guides you through secret management and first deployment workflow
+
+### Configure Agent Secrets
+
+```bash
+mantle-forge secrets set GROQ_API_KEY=sk-your-key-here
+mantle-forge secrets set AGENT_PRIVATE_KEY=0x...
+mantle-forge secrets set AI_PROMPT="You are an aggressive trader"
+```
+
+**Security Features:**
+- Secrets are encrypted using AES-256 before storage
+- Each Git branch maintains its own isolated secret set
+- Secrets are automatically injected as environment variables when agents deploy to Mantle
+- Never stored in plaintext - all encryption handled by MantleForge backend
+
+### Monitor Agent Performance
+
+```bash
+mantle-forge stats    # View comprehensive performance metrics
+mantle-forge logs     # Stream real-time agent decision logs
+```
+
+The `stats` command displays:
+- Total trading decisions made
+- BUY vs HOLD signal breakdown
+- Number of executed trades
+- Success rate percentage
+- Price statistics (average, min, max)
+- Activity timeline (first/last decision timestamps)
+
+### Compare Trading Strategies
+
+Run parallel A/B tests by comparing different Git branches deployed as separate Mantle contracts:
+```bash
+mantle-forge compare main aggressive
+```
+
+**Comparison Metrics:**
+- Decision volume (total decisions per strategy)
+- Signal distribution (BUY vs HOLD ratios)
+- Trade execution counts
+- Win rate percentages
+- Average trading prices
+- Performance winner analysis
+
+Perfect for testing different AI prompts, trading thresholds, or risk parameters across multiple Mantle agent contracts simultaneously.
+
+## Configuration
+
+The CLI creates a `.mantlepush.json` file in your repository root:
+
+```json
+{
+  "repo_url": "https://github.com/username/repo.git"
+}
+```
+
+## Development
+
+To test the CLI locally:
+
+```bash
+npm link
+mantle-forge --help
+```
+
+## About MantleForge
+
+MantleForge is a Git-native deployment platform built specifically for Mantle Network. It brings the simplicity of Vercel-style deployments to blockchain AI agents, making Mantle the easiest network to deploy autonomous agents on.
+
+**Key Benefits:**
+- ⚡ **30-second deployments** - From `git push` to live on-chain agent
+- 🔄 **Branch-based A/B testing** - Test multiple strategies simultaneously
+- 🔒 **Enterprise security** - Encrypted secrets, on-chain identity
+- 📊 **Real-time monitoring** - CLI and web dashboard for agent metrics
+
+**Repository**: https://github.com/xaviersharwin10/somnia-git-agent  
+**Live Dashboard**: https://mantle-git-agent.onrender.com/dashboard  
+**Mantle Explorer**: https://sepolia.mantlescan.xyz
+
+## Requirements
+
+- **Node.js** 16+ (for CLI tool)
+- **Git** repository (for version control)
+- **MantleForge Backend** (deployed at https://mantle-git-agent.onrender.com or self-hosted)
+- **Mantle Sepolia Testnet** access (for contract deployment)
+
+
+
+
+
+

package/index.js

@@ -0,0 +1,580 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const axios = require('axios');
+const shell = require('shelljs');
+const { createPromptModule } = require('inquirer');
+const prompt = createPromptModule();
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+
+const program = new Command();
+program.name('mantle-forge');
+program.version('1.0.0');
+
+// --- Configuration ---
+// MantleForge backend API endpoint
+// For local development, use http://localhost:3005
+// For production deployments, use your deployed backend URL
+const API_BASE_URL = 'https://mantle-git-agent.onrender.com'; // Production MantleForge backend
+const CONFIG_FILE = '.mantlepush.json';
+
+// --- Helper Functions ---
+
+// Reads the .mantlepush.json file (or migrates from .gitagent.json)
+function getConfig() {
+  // Check for new config file first
+  if (fs.existsSync(CONFIG_FILE)) {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  }
+  
+  // Check for old config file and migrate
+  const oldConfigFile = '.gitagent.json';
+  if (fs.existsSync(oldConfigFile)) {
+    console.log(chalk.yellow(`Migrating from ${oldConfigFile} to ${CONFIG_FILE}...`));
+    const oldConfig = JSON.parse(fs.readFileSync(oldConfigFile, 'utf8'));
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(oldConfig, null, 2));
+    console.log(chalk.green(`✅ Migrated to ${CONFIG_FILE}`));
+    return oldConfig;
+  }
+  
+  // No config file found
+  console.error(chalk.red(`Error: This repository is not configured for MantleForge. Missing ${CONFIG_FILE}.`));
+  console.log(chalk.yellow('Run `mantle-forge init` to initialize MantleForge in this repository.'));
+    process.exit(1);
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  return config;
+}
+
+// Gets the current git branch
+function getCurrentBranch() {
+  const branch = shell.exec('git rev-parse --abbrev-ref HEAD', { silent: true }).stdout.trim();
+  if (!branch) {
+    console.error(chalk.red('Error: Could not determine git branch.'));
+    process.exit(1);
+  }
+  return branch;
+}
+
+// Calculate branch_hash (same as backend)
+const { ethers } = require('ethers');
+
+function calculateBranchHash(repo_url, branch_name) {
+  return ethers.id(repo_url + "/" + branch_name);
+}
+
+// Helper function to fetch stats for a specific branch
+async function getStats(repo_url, branch_name) {
+  try {
+    const branch_hash = calculateBranchHash(repo_url, branch_name);
+    const url = `${API_BASE_URL}/api/stats/${branch_hash}`;
+    const { data } = await axios.get(url);
+    return { ...data, branch_name, repo_url };
+  } catch (err) {
+    const errorMsg = err.response?.data?.error || err.message;
+    if (err.response?.status === 404) {
+      console.error(chalk.red(`Agent not found for branch "${branch_name}"`));
+      console.log(chalk.yellow(`  → Make sure you've pushed this branch: ${chalk.cyan(`git push origin ${branch_name}`)}`));
+      console.log(chalk.yellow(`  → The backend webhook will deploy it automatically`));
+    } else {
+      console.error(chalk.red(`Error fetching stats for ${branch_name}: ${errorMsg}`));
+    }
+    return null;
+  }
+}
+
+// --- CLI Commands ---
+
+/**
+ * 1. INIT
+ * Initializes the project by creating .mantlepush.json
+ */
+program
+  .command('init')
+  .description('Initialize MantleForge deployment pipeline for this repository')
+  .action(async () => {
+    // Check for both old and new config file names
+    const oldConfigFile = '.gitagent.json';
+    const hasOldConfig = fs.existsSync(oldConfigFile);
+    const hasNewConfig = fs.existsSync(CONFIG_FILE);
+    
+    if (hasNewConfig) {
+      const existingConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      console.log(chalk.yellow(`This project is already initialized.`));
+      console.log(chalk.cyan(`Current repository: ${existingConfig.repo_url}`));
+      console.log(chalk.yellow(`\nTo reinitialize with a different repository, delete ${CONFIG_FILE} first.`));
+      return;
+    }
+    
+    // Migrate from old config file if it exists, but still prompt to confirm/change
+    if (hasOldConfig) {
+      const oldConfig = JSON.parse(fs.readFileSync(oldConfigFile, 'utf8'));
+      console.log(chalk.yellow(`Found old config file (${oldConfigFile}).`));
+      console.log(chalk.cyan(`Current repository: ${oldConfig.repo_url}`));
+      console.log(chalk.yellow(`\nDo you want to keep this repository or change it?`));
+      
+      const answers = await prompt([
+        {
+          type: 'input',
+          name: 'repo_url',
+          message: 'What is your GitHub repository URL (e.g., https://github.com/user/repo.git)?',
+          default: oldConfig.repo_url || shell.exec('git remote get-url origin', { silent: true }).stdout.trim(),
+        }
+      ]);
+
+      if (!answers.repo_url) {
+        console.error(chalk.red('Error: Repository URL is required.'));
+        return;
+      }
+
+      const config = { repo_url: answers.repo_url };
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+      
+      // Remove old config file after successful migration
+      if (fs.existsSync(oldConfigFile)) {
+        fs.unlinkSync(oldConfigFile);
+      }
+      
+      console.log(chalk.green(`✅ ${CONFIG_FILE} created.`));
+      if (answers.repo_url !== oldConfig.repo_url) {
+        console.log(chalk.green(`✅ Repository URL updated from old config.`));
+      } else {
+        console.log(chalk.green(`✅ Migrated from ${oldConfigFile} to ${CONFIG_FILE}`));
+      }
+      
+      // Continue with next steps (same as new initialization)
+      console.log('');
+      console.log(chalk.bold('📋 Next Steps:'));
+      console.log('');
+      
+      const repoUrl = answers.repo_url;
+      const oauthUrl = `https://mantle-git-agent.onrender.com/auth/github?repo_url=${encodeURIComponent(repoUrl)}`;
+      
+      console.log(chalk.cyan('🚀 Option A: Automatic Webhook Configuration (Recommended)'));
+      console.log(`   Visit: ${chalk.underline(oauthUrl)}`);
+      console.log(`   Authorize GitHub to automatically set up deployment webhooks`);
+      console.log('');
+      
+      console.log(chalk.yellow('⚙️  Option B: Manual Webhook Configuration'));
+      console.log(`   Navigate to: GitHub → ${answers.repo_url.split('/').slice(-2).join('/')} → Settings → Webhooks`);
+      console.log(`   Webhook URL: ${chalk.cyan('https://mantle-git-agent.onrender.com/webhook/github/push')}`);
+      console.log(`   Content type: ${chalk.cyan('application/json')}`);
+      console.log(`   Events: ${chalk.cyan('Just the push event')}`);
+      console.log('');
+      
+      console.log(chalk.bold('🔐 Configure Agent Secrets:'));
+      console.log(`   ${chalk.cyan('mantle-forge secrets set GROQ_API_KEY=your-key-here')}`);
+      console.log(`   ${chalk.cyan('mantle-forge secrets set AGENT_PRIVATE_KEY=0x...')}`);
+      console.log(`   These secrets are encrypted and securely stored for each branch`);
+      console.log('');
+      
+      console.log(chalk.bold('🚀 Deploy to Mantle Sepolia:'));
+      console.log(`   ${chalk.cyan('git push origin main')}`);
+      console.log(`   Each push automatically deploys a new smart contract on Mantle Sepolia testnet`);
+      console.log(`   Your agent will be live on-chain within 30 seconds!`);
+      console.log('');
+      
+      console.log(chalk.bold('📊 Monitor Your Agents:'));
+      console.log(`   ${chalk.cyan('mantle-forge stats')} - View real-time performance metrics`);
+      console.log(`   ${chalk.cyan('mantle-forge logs')} - Stream live agent decision logs`);
+      console.log(`   Web Dashboard: ${chalk.underline('https://mantle-git-agent.onrender.com/dashboard')}`);
+      
+      return;
+    }
+
+    const answers = await prompt([
+      {
+        type: 'input',
+        name: 'repo_url',
+        message: 'What is your GitHub repository URL (e.g., https://github.com/user/repo.git)?',
+        default: shell.exec('git remote get-url origin', { silent: true }).stdout.trim(),
+      }
+    ]);
+
+    if (!answers.repo_url) {
+      console.error(chalk.red('Error: Repository URL is required.'));
+      return;
+    }
+
+    const config = { repo_url: answers.repo_url };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+
+    console.log(chalk.green(`✅ ${CONFIG_FILE} created.`));
+    console.log('');
+    console.log(chalk.bold('📋 Next Steps:'));
+    console.log('');
+    
+    // Show OAuth URL for automatic setup
+    const repoUrl = answers.repo_url;
+    const oauthUrl = `https://mantle-git-agent.onrender.com/auth/github?repo_url=${encodeURIComponent(repoUrl)}`;
+    
+    console.log(chalk.cyan('🚀 Option A: Automatic Webhook Configuration (Recommended)'));
+    console.log(`   Visit: ${chalk.underline(oauthUrl)}`);
+    console.log(`   Authorize GitHub to automatically set up deployment webhooks`);
+    console.log('');
+    
+    console.log(chalk.yellow('⚙️  Option B: Manual Webhook Configuration'));
+    console.log(`   Navigate to: GitHub → ${answers.repo_url.split('/').slice(-2).join('/')} → Settings → Webhooks`);
+    console.log(`   Webhook URL: ${chalk.cyan('https://mantle-git-agent.onrender.com/webhook/github/push')}`);
+    console.log(`   Content type: ${chalk.cyan('application/json')}`);
+    console.log(`   Events: ${chalk.cyan('Just the push event')}`);
+    console.log('');
+    
+    console.log(chalk.bold('🔐 Configure Agent Secrets:'));
+    console.log(`   ${chalk.cyan('mantle-forge secrets set GROQ_API_KEY=your-key-here')}`);
+    console.log(`   ${chalk.cyan('mantle-forge secrets set AGENT_PRIVATE_KEY=0x...')}`);
+    console.log(`   These secrets are encrypted and securely stored for each branch`);
+    console.log('');
+    
+    console.log(chalk.bold('🚀 Deploy to Mantle Sepolia:'));
+    console.log(`   ${chalk.cyan('git push origin main')}`);
+    console.log(`   Each push automatically deploys a new smart contract on Mantle Sepolia testnet`);
+    console.log(`   Your agent will be live on-chain within 30 seconds!`);
+    console.log('');
+    
+    console.log(chalk.bold('📊 Monitor Your Agents:'));
+    console.log(`   ${chalk.cyan('mantle-forge stats')} - View real-time performance metrics`);
+    console.log(`   ${chalk.cyan('mantle-forge logs')} - Stream live agent decision logs`);
+    console.log(`   Web Dashboard: ${chalk.underline('https://mantle-git-agent.onrender.com/dashboard')}`);
+  });
+
+/**
+ * 2. SECRETS - Create a command group for secrets
+ */
+const secretsCommand = program
+  .command('secrets')
+  .description('Manage secrets for the current branch');
+
+// SECRETS SET - Set a secret
+secretsCommand
+  .command('set <KEY_VALUE>')
+  .description('Set a secret for the current branch (e.g., KEY=VALUE)')
+  .action(async (keyValue) => {
+    // Handle the case where commander might parse this incorrectly
+    const fullCommand = process.argv.slice(2).join(' ');
+    const match = fullCommand.match(/secrets set (.+)/);
+    
+    if (!match) {
+      console.error(chalk.red('Error: Invalid format. Use KEY=VALUE'));
+      return;
+    }
+    
+    const keyValueStr = match[1];
+    const [key, ...valueParts] = keyValueStr.split('=');
+    const value = valueParts.join('=');
+
+    if (!key || !value) {
+      console.error(chalk.red('Error: Invalid format. Use KEY=VALUE'));
+      return;
+    }
+
+    const config = getConfig();
+    const branch_name = getCurrentBranch();
+
+    try {
+      console.log(chalk.cyan(`Setting secret ${key} for branch ${branch_name}...`));
+      await axios.post(`${API_BASE_URL}/api/secrets`, {
+        repo_url: config.repo_url,
+        branch_name: branch_name,
+        key: key,
+        value: value,
+      });
+      console.log(chalk.green(`✅ Secret ${key} set.`));
+    } catch (err) {
+      console.error(chalk.red(`Error setting secret: ${err.response?.data?.error || err.message}`));
+    }
+  });
+
+// SECRETS CHECK - Check which secrets are set
+secretsCommand
+  .command('check')
+  .description('Check which required secrets are set for the current branch')
+  .action(async () => {
+    const config = getConfig();
+    const branch_name = getCurrentBranch();
+    const branch_hash = calculateBranchHash(config.repo_url, branch_name);
+
+    try {
+      console.log(chalk.cyan(`🔍 Checking secrets for branch: ${chalk.bold(branch_name)}...`));
+      const { data } = await axios.get(`${API_BASE_URL}/api/secrets/check/${branch_hash}`);
+      
+      console.log(chalk.bold(`\n--- Secrets Status for ${branch_name} ---`));
+      
+      // Required secrets
+      console.log(chalk.bold('\n📋 Required Secrets:'));
+      data.secrets.required.forEach(secret => {
+        const status = secret.set ? chalk.green('✅ Set') : chalk.red('❌ Missing');
+        console.log(`  ${status} ${chalk.bold(secret.key)}`);
+      });
+      
+      // Optional secrets
+      if (data.secrets.optional.length > 0) {
+        console.log(chalk.bold('\n⚙️  Optional Secrets:'));
+        data.secrets.optional.forEach(secret => {
+          const status = secret.set ? chalk.cyan('✓ Set') : chalk.gray('○ Not set');
+          console.log(`  ${status} ${secret.key}`);
+        });
+      }
+      
+      // Overall status
+      console.log(chalk.bold('\n📊 Status:'));
+      if (data.all_required_set) {
+        console.log(chalk.green(`  ✅ All required secrets are set! Agent is ready to run.`));
+      } else {
+        console.log(chalk.red(`  ❌ Missing required secrets: ${chalk.bold(data.missing.join(', '))}`));
+        console.log(chalk.yellow(`\n💡 Set missing secrets with:`));
+        data.missing.forEach(key => {
+          console.log(chalk.cyan(`     mantle-forge secrets set ${key}=<your-value>`));
+        });
+      }
+      
+    } catch (err) {
+      if (err.response?.status === 404) {
+        console.error(chalk.red(`Agent not found for branch "${branch_name}"`));
+        console.log(chalk.yellow(`  → Make sure you've pushed this branch: ${chalk.cyan(`git push origin ${branch_name}`)}`));
+      } else {
+        console.error(chalk.red(`Error checking secrets: ${err.response?.data?.error || err.message}`));
+      }
+    }
+  });
+
+/**
+ * 4. STATS
+ * Gets stats for the current branch
+ */
+program
+  .command('stats')
+  .description('View real-time performance metrics for your Mantle agent')
+  .action(async () => {
+    const config = getConfig();
+    const branch_name = getCurrentBranch();
+
+    console.log(chalk.cyan(`📊 Fetching stats for ${branch_name}...`));
+    const result = await getStats(config.repo_url, branch_name);
+
+    if (!result) {
+      console.log(chalk.yellow(`\n⚠️  Could not fetch stats for "${branch_name}"`));
+      console.log(chalk.yellow(`   The agent may not be deployed yet, or there was an error.`));
+      return;
+    }
+
+    if (result && result.stats) {
+      const s = result.stats;
+      const totalDecisions = s.total_decisions || 0;
+      
+      console.log(chalk.bold(`\n--- Mantle Agent Performance: ${branch_name} ---`));
+      console.log(chalk.green(`  Total Decisions:  ${totalDecisions}`));
+      console.log(chalk.cyan(`  BUY Signals:     ${s.buy_count || 0}`));
+      console.log(chalk.yellow(`  HOLD Signals:    ${s.hold_count || 0}`));
+      console.log(chalk.magenta(`  Trades Executed: ${s.trades_executed || 0}`));
+      
+      if (totalDecisions === 0) {
+      console.log(chalk.yellow(`\n⚠️  No trading decisions recorded yet.`));
+      console.log(chalk.yellow(`   → Check agent status: ${chalk.cyan('mantle-forge logs')}`));
+      console.log(chalk.yellow(`   → Verify the agent process is running on MantleForge backend`));
+        return;
+      }
+      
+      if (s.avg_price) {
+        console.log(`\n  Price Statistics:`);
+        console.log(`    Average: $${parseFloat(s.avg_price).toFixed(4)}`);
+        console.log(`    Min:     $${parseFloat(s.min_price).toFixed(4)}`);
+        console.log(`    Max:     $${parseFloat(s.max_price).toFixed(4)}`);
+      }
+      
+      if (s.first_decision && s.last_decision) {
+        console.log(`\n  Activity:`);
+        console.log(`    First Decision: ${s.first_decision}`);
+        console.log(`    Last Decision:  ${s.last_decision}`);
+      }
+      
+      if (s.trades_executed > 0 && totalDecisions > 0) {
+        const successRate = ((s.trades_executed / totalDecisions) * 100).toFixed(1);
+        console.log(chalk.green(`\n  Success Rate: ${successRate}%`));
+      }
+    } else {
+      console.log(chalk.yellow('No performance metrics available yet. The agent needs to make trading decisions first.'));
+    }
+  });
+
+/**
+ * 5. LOGS
+ * Gets logs for the current branch
+ */
+program
+  .command('logs')
+  .description('Stream real-time logs from your Mantle agent process')
+  .action(async () => {
+    const config = getConfig();
+    const branch_name = getCurrentBranch();
+
+    try {
+      console.log(chalk.cyan(`Fetching logs for ${branch_name}...`));
+      const url = `${API_BASE_URL}/api/logs/${encodeURIComponent(config.repo_url)}/${encodeURIComponent(branch_name)}`;
+      const { data } = await axios.get(url);
+
+      console.log(chalk.bold(`--- Recent Agent Logs: ${branch_name} (Last 50 entries) ---`));
+      if (data.logs && data.logs.length > 0) {
+        data.logs.forEach(line => console.log(line));
+      } else {
+        console.log(chalk.yellow('No logs found.'));
+      }
+    } catch (err) {
+      console.error(chalk.red(`Error fetching logs: ${err.response?.data?.error || err.message}`));
+    }
+  });
+
+/**
+ * 6. RESTART
+ * Restarts the agent for the current branch
+ */
+program
+  .command('restart')
+  .description('Restart the Mantle agent for the current branch')
+  .action(async () => {
+    const config = getConfig();
+    const branch_name = getCurrentBranch();
+    const branch_hash = calculateBranchHash(config.repo_url, branch_name);
+
+    try {
+      console.log(chalk.cyan(`🔄 Restarting agent for branch: ${chalk.bold(branch_name)}...`));
+      const url = `${API_BASE_URL}/api/agents/branch/${branch_hash}/restart`;
+      const { data } = await axios.post(url);
+
+      if (data.success) {
+        console.log(chalk.green(`✅ Agent restarted successfully!`));
+        console.log(chalk.gray(`   Branch: ${data.agent?.branch_name || branch_name}`));
+        console.log(chalk.gray(`   Repository: ${data.agent?.repo_url || config.repo_url}`));
+        console.log(chalk.cyan(`\n💡 The agent will reload with the latest code and secrets.`));
+      } else {
+        console.log(chalk.yellow(`⚠️  Restart response: ${JSON.stringify(data)}`));
+      }
+    } catch (err) {
+      const errorMsg = err.response?.data?.error || err.message;
+      if (err.response?.status === 404) {
+        console.error(chalk.red(`Agent not found for branch "${branch_name}"`));
+        console.log(chalk.yellow(`  → Make sure you've pushed this branch: ${chalk.cyan(`git push origin ${branch_name}`)}`));
+        console.log(chalk.yellow(`  → The backend webhook will deploy it automatically`));
+      } else {
+        console.error(chalk.red(`Error restarting agent: ${errorMsg}`));
+      }
+    }
+  });
+
+/**
+ * 7. COMPARE
+ * Compares two branches side-by-side
+ */
+program
+  .command('compare <branch1> <branch2>')
+  .description('Compare performance metrics between two agent strategies on Mantle')
+  .action(async (branch1, branch2) => {
+    const config = getConfig();
+
+    console.log(chalk.cyan(`📊 Comparing Mantle agent strategies: ${chalk.bold(branch1)} vs ${chalk.bold(branch2)}...`));
+
+    const [result1, result2] = await Promise.all([
+      getStats(config.repo_url, branch1),
+      getStats(config.repo_url, branch2)
+    ]);
+
+    if (!result1 || !result2) {
+      console.error(chalk.red('Could not fetch stats for comparison.'));
+      if (!result1) {
+        console.log(chalk.yellow(`  ${branch1}: Agent not found or error occurred`));
+        console.log(chalk.yellow(`    → Make sure you've pushed: ${chalk.cyan(`git push origin ${branch1}`)}`));
+      }
+      if (!result2) {
+        console.log(chalk.yellow(`  ${branch2}: Agent not found or error occurred`));
+        console.log(chalk.yellow(`    → Make sure you've pushed: ${chalk.cyan(`git push origin ${branch2}`)}`));
+      }
+      return;
+    }
+
+    if (!result1.stats || !result2.stats) {
+      console.log(chalk.yellow('\n⚠️  One or both agents have no metrics yet.'));
+      if (!result1.stats) console.log(chalk.yellow(`  ${branch1}: Waiting for first decision...`));
+      if (!result2.stats) console.log(chalk.yellow(`  ${branch2}: Waiting for first decision...`));
+      return;
+    }
+
+    const s1 = result1.stats;
+    const s2 = result2.stats;
+
+    // Helper function to strip ANSI codes for width calculation
+    const stripAnsi = (str) => str.replace(/\u001b\[[0-9;]*m/g, '');
+    
+    // Helper function to pad string accounting for ANSI codes
+    const padWithAnsi = (str, width) => {
+      const visibleLength = stripAnsi(str).length;
+      const padding = Math.max(0, width - visibleLength);
+      return str + ' '.repeat(padding);
+    };
+
+    console.log(chalk.bold('\n╔═════════════════════╦═══════════════════════════╦════════════════════════════╗'));
+    const titleText = '  Mantle Agent Strategy Comparison';
+    const titlePadding = 78 - titleText.length; // 77 total width minus title and borders
+    console.log(chalk.bold(`║${titleText}${' '.repeat(titlePadding)}║`));
+    console.log(chalk.bold('╠═════════════════════╬═══════════════════════════╬════════════════════════════╣'));
+    
+    // Create comparison table
+    const metrics = [
+      { label: 'Total Decisions', v1: s1.total_decisions || 0, v2: s2.total_decisions || 0, format: (v) => v.toString() },
+      { label: 'BUY Signals', v1: s1.buy_count || 0, v2: s2.buy_count || 0, format: (v) => chalk.cyan(v.toString()) },
+      { label: 'HOLD Signals', v1: s1.hold_count || 0, v2: s2.hold_count || 0, format: (v) => chalk.yellow(v.toString()) },
+      { label: 'Trades Executed', v1: s1.trades_executed || 0, v2: s2.trades_executed || 0, format: (v) => chalk.magenta(v.toString()) },
+      { label: 'Avg Price', v1: s1.avg_price || 0, v2: s2.avg_price || 0, format: (v) => `$${parseFloat(v).toFixed(4)}` },
+      { label: 'Success Rate', 
+        v1: s1.total_decisions ? ((s1.trades_executed / s1.total_decisions) * 100).toFixed(1) : '0.0', 
+        v2: s2.total_decisions ? ((s2.trades_executed / s2.total_decisions) * 100).toFixed(1) : '0.0',
+        format: (v) => chalk.green(`${v}%`)
+      },
+    ];
+
+    // Header row
+    const headerMetric = padWithAnsi('Metric', 19);
+    const header1 = padWithAnsi(chalk.bold(branch1), 27);
+    const header2 = padWithAnsi(chalk.bold(branch2), 27);
+    console.log(`║ ${headerMetric}║ ${header1}║ ${header2}║`);
+    console.log(chalk.bold('╠═════════════════════╬═══════════════════════════╬═══════════════════════════╣'));
+    
+    // Data rows
+    metrics.forEach((m, idx) => {
+      const label = padWithAnsi(m.label, 19);
+      const v1Str = padWithAnsi(m.format(m.v1), 27);
+      const v2Str = padWithAnsi(m.format(m.v2), 27);
+      console.log(`║ ${label}║ ${v1Str}║ ${v2Str}║`);
+    });
+    
+    console.log(chalk.bold('╚═════════════════════╩═══════════════════════════╩════════════════════════════╝'));
+
+    // Determine winner
+    console.log('\n' + chalk.bold('🏆 Performance Analysis:'));
+    if ((s1.trades_executed || 0) > (s2.trades_executed || 0)) {
+      console.log(chalk.green(`  ${branch1} has executed more trades`));
+    } else if ((s2.trades_executed || 0) > (s1.trades_executed || 0)) {
+      console.log(chalk.green(`  ${branch2} has executed more trades`));
+    } else {
+      console.log(chalk.yellow(`  Both strategies show similar trade execution patterns`));
+    }
+
+    if (s1.total_decisions && s2.total_decisions) {
+      const rate1 = (s1.trades_executed / s1.total_decisions) * 100;
+      const rate2 = (s2.trades_executed / s2.total_decisions) * 100;
+      if (rate1 > rate2) {
+        console.log(chalk.green(`  ${branch1} has better success rate (${rate1.toFixed(1)}% vs ${rate2.toFixed(1)}%)`));
+      } else if (rate2 > rate1) {
+        console.log(chalk.green(`  ${branch2} has better success rate (${rate2.toFixed(1)}% vs ${rate1.toFixed(1)}%)`));
+      }
+    }
+  });
+
+// --- Parse and Run ---
+program.parse(process.argv);
+
+
+
+
+
+

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "mantle-forge",
+  "version": "1.0.0",
+  "description": "CLI tool for deploying and managing AI agents on Mantle Sepolia via Git workflows",
+  "main": "index.js",
+  "readme": "README.md",
+  "bin": {
+    "mantle-forge": "./index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xaviersharwin10/somnia-git-agent.git",
+    "directory": "git-agent-cli"
+  },
+  "keywords": [
+    "git",
+    "agent",
+    "cli",
+    "ai",
+    "trading",
+    "blockchain",
+    "mantle",
+    "web3",
+    "defi",
+    "autonomous-agents"
+  ],
+  "author": "marshal.25ec@licet.ac.in",
+  "license": "MIT",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "axios": "^1.13.1",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.2",
+    "ethers": "^6.15.0",
+    "inquirer": "^12.10.0",
+    "shelljs": "^0.10.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}