kiroo 0.4.0 → 0.8.0

package/README.md

@@ -16,48 +16,75 @@
 
 ---
 
-## 📖 Introduction
+## 📖 What is Kiroo?
 
-Kiroo treats your API requests and responses as **first-class versionable artifacts**. 
+Kiroo is **Version Control for API Interactions**. It treats your requests and responses as first-class, versionable artifacts that live right alongside your code in your Git repository.
 
-Ever had a production bug that worked fine on your machine? Ever refactored a backend only to find out you broke a critical field 3 days later? Kiroo solves this by letting you **store API interactions in your repository**.
+Stop copy-pasting JSON into Postman. Stop losing your API history. Start versioning it. 🚀
 
-Every interaction is a structured, reproducibility-focused JSON file that lives in your `.kiroo/` directory.
+---
+
+## 🕸️ Visual Dependency Graph (`kiroo graph`)
+
+Kiroo doesn't just record requests; it understands the **relationships** between them. 
+- **Auto-Tracking**: Kiroo tracks variables created via `--save` and consumed via `{{key}}`.
+- **Insight**: Instantly see how data flows from your `/login` to your `/profile` and beyond.
+
+---
+
+## 📊 Insights & Performance Dashboard (`kiroo stats`)
+
+Monitor your API's health directly from your terminal.
+- **Success Rates**: Real-time 2xx/4xx/5xx distribution.
+- **Performance**: Average response times across all interactions.
+- **Bottlenecks**: Automatically identifies your top 5 slowest endpoints.
 
 ---
 
-## ✨ Core Capabilities
+## 🔌 Instant cURL Import (`kiroo import`)
 
-### 🔴 **Auto-Recording**
-Every request made through Kiroo is automatically saved. No more manual exports from Postman.
+Coming from a browser? Don't type a single header.
+- **Copy-Paste Magic**: Just `Copy as cURL` from Chrome/Firefox and run `kiroo import`.
+- **Clean Parsing**: Automatically handles multi-line commands, quotes, and complex flags.
+
+---
+
+## ✨ Features that WOW
+
+### 🟢 **Git-Native Diffing & Translating**
+Capture a **Snapshot** of your entire API state and compare versions.
+- **Deep Structural Diffs**: Recursively tracks nested schema changes and silent datatype overrides.
+- **Lingo.dev Translation**: Instantly localize breaking change alerts natively in your terminal.
 ```bash
-kiroo post {{baseUrl}}/users -d "name=Yash email=yash@example.com"
+kiroo snapshot save v1-stable
+kiroo --lang hi snapshot compare v1-stable current
 ```
 
-### 🔄 **Replay Engine**
-Re-run any past interaction instantly and see if the backend behavior has changed.
+### 🌍 **Variable Chaining**
+Chain requests like a pro. Save a token from one response and inject it into the next.
 ```bash
-kiroo replay <interaction-id>
+kiroo post /login --save jwt=data.token
+kiroo get /users -H "Authorization: Bearer {{jwt}}"
 ```
 
-### 🌍 **Smart Environments & Variables**
-Stop copy-pasting tokens. Chain requests together dynamically.
+### ⌨️ **Shorthand JSON Parser**
+Forget escaping quotes. Type JSON like a human.
 ```bash
-# Save a token from login
-kiroo post /login --save token=data.accessToken
-
-# Use it in the next request
-kiroo get /profile -H "Authorization: Bearer {{token}}"
+kiroo post /api/user -d "name=Yash email=yash@kiroo.io role=admin"
 ```
 
-### 📸 **Snapshot System & Diff Engine**
-Capture the "Status Quo" of your API and detect **Breaking Changes** during refactors.
+---
+
+### 🧪 **Zero-Code Testing Framework**
+Turn your terminal into an automated test runner. Validate responses on the fly without writing a single line of JS.
 ```bash
-# Before refactor
-kiroo snapshot save v1-stable
+kiroo check /api/login -m POST -d "user=yash pass=123" --status 200 --has token
+```
 
-# After refactor
-kiroo snapshot compare v1-stable current
+### 🚀 **Local Load Benchmarking**
+Stress test endpoints instantly. Simulates massive concurrency and environment-variable-injected workloads to locate latency limits.
+```bash
+kiroo bench /api/reports -n 1000 -c 50 -v
 ```
 
 ---
@@ -66,53 +93,192 @@ kiroo snapshot compare v1-stable current
 
 ### 1. Installation
 ```bash
-# Clone the repo
-git clone https://github.com/yash-pouranik/kiroo.git
-cd kiroo
-
-# Install and link
-npm install
-npm link
+npm install -g kiroo
 ```
 
-### 2. Initialize
+### 2. Initialization
 ```bash
 kiroo init
 ```
 
-### 3. Basic Request
+### 3. Record Your First Request
 ```bash
-kiroo env set baseUrl http://localhost:3000
-kiroo get {{baseUrl}}/health
+kiroo get https://api.github.com/users/yash-pouranik
 ```
 
 ---
 
-## 🛠️ Advanced Workflows
-
-### Nested Data Support
-Kiroo's shorthand parser understands nested objects and arrays:
-```bash
-kiroo put /products/1 -d "reviews[0].stars=5 metadata.isFeatured=true"
-```
-
-### Managing Environments
-```bash
-kiroo env use prod
-kiroo env list
-```
+## 📚 Full Command Documentation
+
+### `kiroo init`
+Initialize Kiroo in your current project.
+- **Description**: Creates the `.kiroo/` directory structure and a default `env.json`.
+- **Prerequisites**: None. Run once per project.
+- **Example**:
+  ```bash
+  kiroo init
+  ```
+
+### `kiroo get/post/put/delete <url>`
+Execute and record an API interaction.
+- **Description**: Performs an HTTP request, displays the response, and saves it to history.
+- **Prerequisites**: Access to the URL (or a `baseUrl` set in the environment).
+- **Arguments**:
+  - `url`: The endpoint (Absolute URL or relative path if `baseUrl` exists).
+- **Options**:
+  - `-H, --header <key:value>`: Add custom headers.
+  - `-d, --data <data>`: Request body (JSON or shorthand `key=val`).
+  - `-s, --save <key=path>`: Save response data to environment variables.
+- **Example**:
+  ```bash
+  kiroo post /api/auth/login -d "email=user@test.com password=123" --save token=data.token
+  ```
+
+### `kiroo list`
+View your interaction history.
+- **Description**: Displays a paginated list of all recorded requests.
+- **Arguments**: None.
+- **Options**:
+  - `-n, --limit <number>`: How many records to show (Default: 10).
+  - `-o, --offset <number>`: How many records to skip (Default: 0).
+- **Example**:
+  ```bash
+  kiroo list -n 20
+  ```
+
+### `kiroo replay <id>`
+Re-run a specific interaction.
+- **Description**: Fetches the original request from history and executes it again.
+- **Arguments**:
+  - `id`: The timestamp ID of the interaction (found via `kiroo list`).
+- **Example**:
+  ```bash
+  kiroo replay 2026-03-10T14-30-05-123Z
+  ```
+
+### `kiroo edit <id>`
+Quick Refinement. Edit an interaction on the fly and replay it.
+- **Description**: Opens the stored interaction JSON in your default system editor (VS Code, Nano, Vim, etc.). Edit the headers, body, or URL, save, and close. Kiroo immediately replays the updated request.
+- **Arguments**:
+  - `id`: The timestamp ID of the interaction.
+- **Example**:
+  ```bash
+  kiroo edit 2026-03-10T14-30-05-123Z
+  ```
+
+### `kiroo check <url>`
+Zero-Code Testing engine.
+- **Description**: Executes a request and runs assertions on the response. Exits with code 1 on failure.
+- **Prerequisites**: Access to the URL.
+- **Arguments**:
+  - `url`: The endpoint.
+- **Options**:
+  - `-m, --method <method>`: HTTP method (GET, POST, etc. Default: GET).
+  - `-H, --header <key:value>`: Add custom headers.
+  - `-d, --data <data>`: Request body.
+  - `--status <numbers>`: Expected HTTP status code.
+  - `--has <fields>`: Comma-separated list of expected fields in JSON.
+  - `--match <key=val>`: Exact value matching for JSON fields.
+- **Example**:
+  ```bash
+  # Check if login is successful
+  kiroo check /api/login -m POST -d "user=yash pass=123" --status 200 --has token
+  ```
+
+### `kiroo bench <url>`
+Local load testing and benchmarking.
+- **Description**: Sends multiple concurrent HTTP requests to measure endpoint performance (Latency, RPS, Error Rate).
+- **Prerequisites**: Access to the URL.
+- **Arguments**:
+  - `url`: The endpoint (supports Auto-BaseURL).
+- **Options**:
+  - `-m, --method <method>`: HTTP method (GET, POST, etc. Default: GET).
+  - `-n, --number <number>`: Total requests to send (Default: 10).
+  - `-c, --concurrent <number>`: Concurrent workers (Default: 1).
+  - `-v, --verbose`: Show the HTTP status, response time, and truncated response body for every individual request instead of a single progress spinner.
+  - `-H, --header <key:value>`: Add custom headers.
+  - `-d, --data <data>`: Request body.
+- **Example**:
+  ```bash
+  # Send 100 requests in batches of 10
+  kiroo bench /api/projects -n 100 -c 10
+  ```
+
+### `kiroo graph`
+Visualize API dependencies.
+- **Description**: Generates a tree view showing how data flows between endpoints via saved/used variables.
+- **Prerequisites**: Recorded interactions that use `--save` and `{{variable}}`.
+- **Example**:
+  ```bash
+  kiroo graph
+  ```
+
+### `kiroo stats`
+Analytics dashboard.
+- **Description**: Shows performance metrics, success rates, and identify slow endpoints.
+- **Example**:
+  ```bash
+  kiroo stats
+  ```
+
+### `kiroo import`
+Import from cURL.
+- **Description**: Converts a cURL command into a Kiroo interaction. Opens an interactive editor if no argument is provided.
+- **Arguments**:
+  - `curl`: (Optional) The raw cURL string in quotes.
+- **Example**:
+  ```bash
+  kiroo import "curl https://api.exa.com -H 'Auth: 123'"
+  ```
+
+### `kiroo snapshot` 
+Snapshot management.
+- **Commands**:
+  - `save <tag>`: Save current history as a versioned state.
+  - `list`: List all saved snapshots.
+  - `compare <tag1> <tag2>`: Detect breaking changes between two states.
+- **Example**:
+  ```bash
+  kiroo snapshot compare v1.stable current
+  ```
+
+### `kiroo export`
+Team Compatibility. Export to Postman.
+- **Description**: Converts all stored Kiroo interactions and responses into a standard Postman Collection v2.1.0 format (`.json`) for seamless GUI import.
+- **Options**:
+  - `-o, --out <filename>`: The output filename (Default: `kiroo-collection.json`).
+- **Example**:
+  ```bash
+  kiroo export --out my_api_collection.json
+  ```
+
+### `kiroo env`
+Environment & Variable management.
+- **Commands**:
+  - `list`: View all environments and their variables.
+  - `use <name>`: Switch active environment (e.g., `prod`, `local`).
+  - `set <key> <value>`: Set a variable in the active environment.
+  - `rm <key>`: Remove a variable.
+- **Example**:
+  ```bash
+  kiroo env set baseUrl https://api.myapp.com
+  ```
+
+### `kiroo clear`
+Wipe history.
+- **Description**: Deletes all recorded interactions to start fresh.
+- **Options**:
+  - `-f, --force`: Clear without a confirmation prompt.
+- **Example**:
+  ```bash
+  kiroo clear --force
+  ```
 
 ---
 
-## 🎯 Comparison
+## 🤝 Contributing
 
-| Feature | Postman / Insomnia | Bruno | **Kiroo** |
-| :--- | :---: | :---: | :---: |
-| **CLI-First** | ❌ | ⚠️ | ✅ |
-| **Git-Native** | ❌ | ✅ | ✅ |
-| **Auto-Recording** | ❌ | ❌ | ✅ |
-| **Built-in Replay** | ❌ | ❌ | ✅ |
-| **Variable Chaining** | ⚠️ | ⚠️ | ✅ |
+Kiroo is an open-source project and we love contributions! Check out our [Contribution Guidelines](CONTRIBUTING.md).
 
 ---
 
@@ -123,5 +289,5 @@ Distributed under the MIT License. See `LICENSE` for more information.
 ---
 
 <div align="center">
-  Built with ❤️ for Developers by <a href="https://github.com/yash-pouranik">Yash Pouranik</a>
+  Built with ❤️ for Developers
 </div>

package/bin/kiroo.js

@@ -7,17 +7,22 @@ import { listInteractions, replayInteraction } from '../src/replay.js';
 import { saveSnapshot, compareSnapshots, listSnapshots } from '../src/snapshot.js';
 import { setEnv, setVar, deleteVar, listEnv } from '../src/env.js';
 import { showGraph } from '../src/graph.js';
+import { validateResponse, showCheckResult } from '../src/checker.js';
 import { initProject } from '../src/init.js';
 import { showStats } from '../src/stats.js';
 import { handleImport } from '../src/import.js';
 import { clearAllInteractions } from '../src/storage.js';
+import { runBenchmark } from '../src/bench.js';
+import { editInteraction } from '../src/edit.js';
+import { exportToPostman } from '../src/export.js';
 
 const program = new Command();
 
 program
   .name('kiroo')
   .description('Git for API interactions. Record, replay, snapshot, and diff your APIs.')
-  .version('0.4.0');
+  .version('0.8.0')
+  .option('--lang <language>', 'Translate output to specified language (e.g., hi, es, fr)');
 
 // Init command
 program
@@ -26,6 +31,56 @@ program
   .action(async () => {
     await initProject();
   });
+
+// Check command (Zero-Code Testing)
+program
+  .command('check <url>')
+  .description('Execute a request and validate the response against rules')
+  .option('-m, --method <method>', 'HTTP method (GET, POST, etc.)', 'GET')
+  .option('-H, --header <header...>', 'Add custom headers')
+  .option('-d, --data <data>', 'Request body (JSON or shorthand)')
+  .option('--status <code...>', 'Expected HTTP status code')
+  .option('--has <fields...>', 'Comma-separated list of expected fields in JSON response')
+  .option('--match <matches...>', 'Expected field values (e.g., status=active)')
+  .action(async (url, options) => {
+    // Execute request
+    const response = await executeRequest(options.method || 'GET', url, {
+      header: options.header,
+      data: options.data,
+    });
+
+    if (!response) {
+      console.error(chalk.red('\n  ✗ No response received to validate.'));
+      process.exit(1);
+    }
+
+    // Parse matches: ["key1=val1", "key2=val2"] -> { key1: val1, key2: val2 }
+    const matchObj = {};
+    if (options.match) {
+      options.match.forEach(m => {
+        const [k, ...v] = m.split('=');
+        if (k) matchObj[k] = v.join('=');
+      });
+    }
+
+    // Parse has: ["id,name"] or ["id", "name"] -> ["id", "name"]
+    const hasFields = options.has ? options.has.flatMap(h => h.split(',')).map(f => f.trim()) : [];
+
+    // Construct rules
+    const rules = {
+      status: Array.isArray(options.status) ? options.status[0] : options.status,
+      has: hasFields,
+      match: matchObj
+    };
+
+    // Validate
+    const validation = validateResponse(response, rules);
+    showCheckResult(validation);
+
+    if (!validation.passed) {
+      process.exit(1);
+    }
+  });
   // sk_live_p7BWJjsYlKmauBOjiEeiLRuu4DokkBWsgYne_E6osTo
 
 // HTTP methods as commands
@@ -47,7 +102,10 @@ program
   .command('list')
   .description('List all stored interactions')
   .option('-n, --limit <number>', 'Number of interactions to show', '10')
-  .option('-o, --offset <number>', 'Number of interactions to skip', '0')
+  .option('-o, --offset <number>', 'Offset for pagination', '0')
+  .option('--date <date>', 'Filter by date (YYYY-MM-DD)')
+  .option('--url <url>', 'Filter by URL path')
+  .option('--status <status>', 'Filter by HTTP status')
   .action(async (options) => {
     await listInteractions(options);
   });
@@ -60,6 +118,37 @@ program
     await replayInteraction(id);
   });
 
+// Edit interaction
+program
+  .command('edit <id>')
+  .description('Edit an interaction in your text editor and quickly replay it')
+  .action(async (id) => {
+    await editInteraction(id);
+  });
+
+// Export interactions
+program
+  .command('export')
+  .description('Export all stored interactions to a Postman Collection')
+  .option('-o, --out <filename>', 'Output JSON filename', 'kiroo-collection.json')
+  .action((options) => {
+    exportToPostman(options.out);
+  });
+
+// Bench command (Load Testing)
+program
+  .command('bench <url>')
+  .description('Run a basic load test against an endpoint')
+  .option('-m, --method <method>', 'HTTP method (GET, POST, etc.)', 'GET')
+  .option('-n, --number <number>', 'Number of total requests to send', '10')
+  .option('-c, --concurrent <number>', 'Number of concurrent requests', '1')
+  .option('-H, --header <header...>', 'Add custom headers')
+  .option('-v, --verbose', 'Show detailed output for every request')
+  .option('-d, --data <data>', 'Request body')
+  .action(async (url, options) => {
+    await runBenchmark(url, options);
+  });
+
 // Clear command
 program
   .command('clear')
@@ -126,7 +215,8 @@ snapshot
   .command('compare <tag1> <tag2>')
   .description('Compare two snapshots')
   .action(async (tag1, tag2) => {
-    await compareSnapshots(tag1, tag2);
+    const opts = program.opts();
+    await compareSnapshots(tag1, tag2, opts.lang);
   });
 
 // Graph command

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiroo",
-  "version": "0.4.0",
+  "version": "0.8.0",
   "description": "Git for API interactions. Record, replay, snapshot, and diff your APIs.",
   "type": "module",
   "bin": {
@@ -41,8 +41,10 @@
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.3",
     "commander": "^12.0.0",
+    "dotenv": "^17.3.1",
     "inquirer": "^9.2.15",
     "js-yaml": "^4.1.0",
+    "lingo.dev": "^0.133.1",
     "ora": "^8.0.1"
   },
   "engines": {

package/src/bench.js

@@ -0,0 +1,229 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import axios from 'axios';
+import ora from 'ora';
+import { loadEnv } from './storage.js';
+import { applyEnvReplacements } from './executor.js';
+
+export async function runBenchmark(url, options) {
+  const envData = loadEnv();
+  const currentEnvVars = envData.environments[envData.current] || {};
+
+  url = applyEnvReplacements(url, currentEnvVars);
+
+  const method = (options.method || 'GET').toUpperCase();
+  const totalRequests = parseInt(options.number) || 10;
+  const concurrency = parseInt(options.concurrent) || 1;
+  const headersObj = {};
+
+  if (options.header) {
+    options.header.forEach(h => {
+      const parts = h.split(':');
+      if (parts.length >= 2) {
+        let val = parts.slice(1).join(':').trim();
+        val = applyEnvReplacements(val, currentEnvVars);
+        headersObj[parts[0].trim()] = val;
+      }
+    });
+  }
+
+  // Auto-BaseURL logic (Synced from executor.js)
+  let targetUrl = url;
+  if (!url.startsWith('http://') && !url.startsWith('https://')) {
+    if (currentEnvVars.baseUrl) {
+      let isRelative = false;
+      let pathPart = url;
+
+      // 1. Direct relative path
+      if (url.startsWith('/')) {
+        isRelative = true;
+      } 
+      // 2. Windows Git Bash conversion: Detect "C:/..." style paths with no protocol
+      else if (process.platform === 'win32' && /^[a-zA-Z]:[/\\]/.test(url) && !url.includes('://')) {
+        isRelative = true;
+        const segments = url.split(/[/\\]/);
+        const apiIdx = segments.findIndex(s => s === 'api' || s === 'v1' || s === 'v2');
+        if (apiIdx !== -1) {
+          pathPart = '/' + segments.slice(apiIdx).join('/');
+        } else {
+          pathPart = url.replace(/^[a-zA-Z]:/, '').replace(/\\/g, '/');
+          if (!pathPart.startsWith('/')) pathPart = '/' + pathPart;
+          
+          // Hard fix for Git Bash root expansion "C:/Program Files/Git/" -> "/"
+          const lowerPath = pathPart.toLowerCase();
+          if (lowerPath === '/program files/git/' || lowerPath === '/program files/git') {
+             pathPart = '/';
+          }
+        }
+      }
+      // 3. No leading slash but doesn't look like a host
+      else if (!url.includes('://') && !url.includes('.') && !url.includes(':') && !url.startsWith('localhost')) {
+        isRelative = true;
+        pathPart = '/' + url;
+      }
+
+      if (isRelative) {
+        const baseUrl = currentEnvVars.baseUrl;
+        const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+        targetUrl = normalizedBaseUrl + (pathPart.startsWith('/') ? pathPart : '/' + pathPart);
+      }
+    } else {
+      console.log(chalk.red(`\n  ✗ Invalid URL and no baseUrl defined in environment '${envData.current}'\n`));
+      process.exit(1);
+    }
+  }
+
+  // Parse Body
+  let requestData = options.data;
+  if (options.data) {
+    requestData = applyEnvReplacements(options.data, currentEnvVars);
+  }
+
+  if (requestData && typeof requestData === 'string' && !requestData.trim().startsWith('{')) {
+    const pairs = requestData.split(' ');
+    requestData = {};
+    pairs.forEach(pair => {
+      const [key, value] = pair.split('=');
+      if (key && value !== undefined) {
+        requestData[key] = value;
+      }
+    });
+  } else if (requestData && typeof requestData === 'string') {
+    try {
+      requestData = JSON.parse(requestData);
+    } catch(e) {}
+  }
+
+  const isVerbose = options.verbose;
+  let spinner;
+  
+  if (!isVerbose) {
+    spinner = ora(`Benchmarking ${method} ${targetUrl} (Reqs: ${totalRequests}, Workers: ${concurrency})`).start();
+  } else {
+    console.log(chalk.cyan(`\n  Starting Benchmark: ${method} ${targetUrl} (Reqs: ${totalRequests}, Workers: ${concurrency})\n`));
+  }
+
+  const results = {
+    total: totalRequests,
+    success: 0,
+    failures: 0,
+    times: []
+  };
+
+  const startTime = Date.now();
+  let completedCount = 0;
+  let activeWorkers = 0;
+  
+  // Custom concurrency implementation
+  return new Promise((resolve) => {
+    const executeNext = async () => {
+      if (completedCount >= totalRequests) {
+        if (activeWorkers === 0) finalizeBenchmark();
+        return;
+      }
+
+      activeWorkers++;
+      const reqIndex = completedCount++;
+      const reqId = reqIndex + 1;
+      const reqStartTime = Date.now();
+
+      try {
+        const response = await axios({
+          method: method.toLowerCase(),
+          url: targetUrl,
+          headers: headersObj,
+          data: requestData,
+          validateStatus: () => true, // Don't throw on 4xx/5xx
+        });
+        
+        const duration = Date.now() - reqStartTime;
+        results.times.push(duration);
+        
+        let statusColor = response.status >= 400 ? chalk.red : chalk.green;
+        
+        if (response.status >= 200 && response.status < 400) {
+          results.success++;
+        } else {
+          results.failures++;
+        }
+
+        if (isVerbose) {
+           console.log(chalk.gray(`  [Req ${reqId}/${totalRequests}] `) + statusColor(`${response.status} ${response.statusText}`) + chalk.gray(` - ${duration}ms`));
+           
+           // Print snippet of data if available
+           if (response.data) {
+             let dataStr = typeof response.data === 'object' ? JSON.stringify(response.data) : String(response.data);
+             if (dataStr.length > 200) dataStr = dataStr.substring(0, 197) + '...';
+             console.log(chalk.gray(`  ↳ Data: `) + chalk.white(dataStr));
+           }
+        }
+      } catch (error) {
+        const duration = Date.now() - reqStartTime;
+        results.times.push(duration);
+        results.failures++;
+
+        if (isVerbose) {
+           console.log(chalk.gray(`  [Req ${reqId}/${totalRequests}] `) + chalk.red(`ERR: ${error.message}`) + chalk.gray(` - ${duration}ms`));
+        }
+      } finally {
+        activeWorkers--;
+        // Update spinner if not verbose
+        if (!isVerbose) {
+          const percent = Math.floor((completedCount / totalRequests) * 100);
+          spinner.text = `Benchmarking... ${percent}% [${completedCount}/${totalRequests}]`;
+        }
+        
+        executeNext();
+      }
+    };
+
+    const finalizeBenchmark = () => {
+      const totalTime = Date.now() - startTime;
+      if (!isVerbose) spinner.stop();
+      
+      const rps = ((results.total / totalTime) * 1000).toFixed(2);
+      
+      // Calculate min, max, avg
+      let min = 0, max = 0, avg = 0;
+      if (results.times.length > 0) {
+        min = Math.min(...results.times);
+        max = Math.max(...results.times);
+        avg = Math.round(results.times.reduce((a, b) => a + b, 0) / results.times.length);
+      }
+
+      console.log('\n  ' + chalk.blue.bold('🚀 Benchmark Results'));
+      console.log('  ' + chalk.gray(`${method} ${targetUrl}\n`));
+
+      const statsTable = new Table({
+        colWidths: [20, 15]
+      });
+
+      statsTable.push(
+        [chalk.white('Total Requests'), chalk.cyan(results.total)],
+        [chalk.white('Concurrency'), chalk.cyan(concurrency)],
+        [chalk.white('Success Rate'), results.failures === 0 ? chalk.green('100%') : chalk.yellow(`${((results.success/results.total)*100).toFixed(1)}%`)],
+        [chalk.white('Requests/sec'), chalk.magenta(rps)],
+        [chalk.gray('---'), chalk.gray('---')],
+        [chalk.white('Fastest (Min)'), chalk.green(`${min}ms`)],
+        [chalk.white('Slowest (Max)'), chalk.red(`${max}ms`)],
+        [chalk.white('Average'), chalk.blue(`${avg}ms`)]
+      );
+
+      console.log(statsTable.toString());
+      
+      if (results.failures > 0) {
+        console.log(chalk.red(`\n  ⚠️  ${results.failures} requests failed (HTTP 4xx/5xx or Network Error).\n`));
+      } else {
+        console.log(chalk.green(`\n  ✅ All requests completed successfully.\n`));
+      }
+      
+      resolve();
+    };
+
+    // Bootstrap workers
+    const initialWorkers = Math.min(concurrency, totalRequests);
+    for (let i = 0; i < initialWorkers; i++) {
+      executeNext();
+    }
+  });
+}

package/src/checker.js

@@ -0,0 +1,99 @@
+import chalk from 'chalk';
+
+/**
+ * Validates a response against a set of rules
+ * @param {Object} response - The Axios response object
+ * @param {Object} rules - Rules like { status, has: [], match: { key: value } }
+ * @returns {Object} { passed: boolean, results: [] }
+ */
+export function validateResponse(response, rules) {
+  const results = [];
+  let allPassed = true;
+
+  // 1. Status Check
+  if (rules.status) {
+    const expected = parseInt(rules.status);
+    const actual = response.status;
+    const passed = expected === actual;
+    results.push({
+      label: 'Status Code',
+      expected,
+      actual,
+      passed
+    });
+    if (!passed) allPassed = false;
+  }
+
+  // 2. Body Presence Check (has keys)
+  if (rules.has && rules.has.length > 0) {
+    const body = response.data || {};
+    rules.has.forEach(key => {
+      let actual = getDeep(body, key);
+      let passed = actual !== undefined;
+      
+      // Smart Array Handling: 
+      // If root is an Array and user checks for 'data' (or any key) that's missing,
+      // we check if the array itself belongs to the "presence" check.
+      if (!passed && Array.isArray(body)) {
+        // If the user is checking for existence on a root array, 
+        // we'll pass if the array is not empty.
+        passed = body.length > 0;
+        actual = passed ? `Array(${body.length})` : 'Empty Array';
+      }
+
+      results.push({
+        label: `Field Presence [${key}]`,
+        expected: 'Exists',
+        actual: passed ? (actual === undefined ? 'Found' : actual) : 'Missing',
+        passed
+      });
+      if (!passed) allPassed = false;
+    });
+  }
+
+  // 3. Value Match Check
+  if (rules.match && Object.keys(rules.match).length > 0) {
+    const body = response.data || {};
+    for (const [key, expected] of Object.entries(rules.match)) {
+      const actual = getDeep(body, key);
+      const passed = String(actual) === String(expected);
+      results.push({
+        label: `Value Match [${key}]`,
+        expected,
+        actual: actual !== undefined ? actual : 'undefined',
+        passed
+      });
+      if (!passed) allPassed = false;
+    }
+  }
+
+  return { passed: allPassed, results };
+}
+
+function getDeep(obj, path) {
+  if (!obj) return undefined;
+  const keys = path.split(/[.[\]]+/).filter(Boolean);
+  return keys.reduce((acc, key) => acc && acc[key], obj);
+}
+
+export function showCheckResult(validation) {
+  console.log(chalk.cyan('\n  🧪 Test Results:'));
+  
+  validation.results.forEach(res => {
+    const icon = res.passed ? chalk.green('✓') : chalk.red('✗');
+    const color = res.passed ? chalk.white : chalk.red;
+    
+    console.log(`  ${icon} ${res.label}`);
+    if (!res.passed) {
+      console.log(chalk.gray(`     Expected: ${res.expected}`));
+      console.log(chalk.gray(`     Actual:   ${res.actual}`));
+    }
+  });
+
+  if (validation.passed) {
+    console.log(chalk.green.bold('\n  ✨ ALL TESTS PASSED! \n'));
+  } else {
+    console.log(chalk.red.bold('\n  ❌ SOME TESTS FAILED \n'));
+    process.exit(1);
+  }
+}

package/src/edit.js

@@ -0,0 +1,85 @@
+import { readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import { loadInteraction } from './storage.js';
+import { replayInteraction } from './replay.js';
+
+export async function editInteraction(id) {
+  try {
+    const interaction = loadInteraction(id);
+    if (!interaction) {
+      console.log(chalk.red(`\n  ✗ Interaction not found: ${id}\n`));
+      return;
+    }
+
+    // Step 2: Generate temporary editable JSON
+    const tmpFileName = `.kiroo/tmp_edit_${id}.json`;
+    const editableData = {
+      method: interaction.request.method,
+      url: interaction.request.url,
+      headers: interaction.request.headers || {},
+      data: interaction.request.body || null
+    };
+
+    writeFileSync(tmpFileName, JSON.stringify(editableData, null, 2));
+
+    // Step 3: Launch Editor
+    const editor = process.env.EDITOR || 'code'; // Fallbacks: code, nano, vim, notepad...
+    
+    console.log(chalk.cyan(`\n  📝 Opening interaction in your editor (${editor})...`));
+    console.log(chalk.gray(`  Save and close the file to automatically replay the request.`));
+    
+    try {
+      // In windows, 'code -w' waits for VS Code to close. 
+      // If notepad, just 'notepad' blocks until closed.
+      // If using fallback, we try standard blocking call.
+      const launchCmd = editor === 'code' ? 'code -w' : editor;
+      execSync(`${launchCmd} ${tmpFileName}`, { stdio: 'inherit' });
+    } catch (e) {
+      console.log(chalk.red(`\n  ✗ Failed to open editor '${editor}'.`));
+      console.log(chalk.gray(`  Please specify a valid editor via EDITOR environment variable (e.g. EDITOR=nano kiroo edit).`));
+      try { unlinkSync(tmpFileName); } catch(err){}
+      return;
+    }
+
+    // Step 4: Editor closed, read updated data
+    let updatedDataStr;
+    try {
+      updatedDataStr = readFileSync(tmpFileName, 'utf-8');
+    } catch (e) {
+      console.log(chalk.red('\n  ✗ Could not read the edited file. Editing cancelled.\n'));
+      return;
+    }
+
+    let updatedData;
+    try {
+      updatedData = JSON.parse(updatedDataStr);
+    } catch (e) {
+      console.log(chalk.red('\n  ✗ Invalid JSON syntax in edited file. Editing cancelled.\n'));
+      try { unlinkSync(tmpFileName); } catch(err){}
+      return;
+    }
+
+    // Step 5: Merge and Rewrite
+    interaction.request.method = updatedData.method;
+    interaction.request.url = updatedData.url;
+    interaction.request.headers = updatedData.headers;
+    interaction.request.body = updatedData.data;
+    
+    // Save it over the original file
+    const originalPath = join('.kiroo', 'interactions', `${id}.json`);
+    writeFileSync(originalPath, JSON.stringify(interaction, null, 2));
+    
+    // Cleanup tmp file
+    try { unlinkSync(tmpFileName); } catch(err){}
+
+    console.log(chalk.green(`\n  ✅ Interaction updated. Replaying now...\n`));
+
+    // Step 6: Trigger replay
+    await replayInteraction(id);
+
+  } catch (error) {
+    console.error(chalk.red(`\n  ✗ Edit Failed: ${error.message}\n`));
+  }
+}

package/src/executor.js

@@ -4,7 +4,7 @@ import ora from 'ora';
 import { saveInteraction, loadEnv, saveEnv } from './storage.js';
 import { formatResponse } from './formatter.js';
 
-function applyEnvReplacements(data, envVars, usedKeys = null) {
+export function applyEnvReplacements(data, envVars, usedKeys = null) {
   if (typeof data === 'string') {
     return data.replace(/\{\{(.+?)\}\}/g, (match, key) => {
       if (envVars[key] !== undefined) {
@@ -89,6 +89,12 @@ export async function executeRequest(method, url, options = {}) {
         // Let's at least strip the drive letter root
         pathPart = url.replace(/^[a-zA-Z]:/, '').replace(/\\/g, '/');
         if (!pathPart.startsWith('/')) pathPart = '/' + pathPart;
+        
+        // Hard fix for Git Bash root expansion "C:/Program Files/Git/" -> "/"
+        const lowerPath = pathPart.toLowerCase();
+        if (lowerPath === '/program files/git/' || lowerPath === '/program files/git') {
+             pathPart = '/';
+        }
       }
     }
     // 3. No leading slash but doesn't look like a host (no dots, no protocol)
@@ -211,6 +217,7 @@ export async function executeRequest(method, url, options = {}) {
 
     console.log(chalk.gray('\n  💾 Interaction saved:'), chalk.white(interactionId));
 
+    return response;
   } catch (error) {
     const duration = Date.now() - startTime;
     spinner.fail(chalk.red('Request failed'));

package/src/export.js

@@ -0,0 +1,93 @@
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { getAllInteractions } from './storage.js';
+
+export function exportToPostman(outFileName) {
+  try {
+    const interactions = getAllInteractions();
+
+    if (interactions.length === 0) {
+      console.log(chalk.yellow('\n  ⚠️ No interactions found to export.'));
+      console.log(chalk.gray('  Run some requests first before exporting.\n'));
+      return;
+    }
+
+    const postmanCollection = {
+      info: {
+        name: `Kiroo Export - ${new Date().toISOString().split('T')[0]}`,
+        schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+      },
+      item: interactions.map(int => {
+        // Map Headers
+        const headerList = Object.entries(int.request.headers || {}).map(([key, value]) => ({
+          key,
+          value: value.toString(),
+          type: "text"
+        }));
+
+        // Format body
+        let rawBody = '';
+        if (int.request.body) {
+          rawBody = typeof int.request.body === 'object' 
+            ? JSON.stringify(int.request.body, null, 2) 
+            : int.request.body.toString();
+        }
+
+        // Response Body
+        let resBodyStr = '';
+        if (int.response.body) {
+            resBodyStr = typeof int.response.body === 'object'
+            ? JSON.stringify(int.response.body, null, 2)
+            : int.response.body.toString();
+        }
+
+        return {
+          name: `[${int.request.method}] ${int.request.url}`,
+          request: {
+            method: int.request.method.toUpperCase(),
+            header: headerList,
+            url: {
+              raw: int.request.url
+            },
+            ...(rawBody ? {
+              body: {
+                mode: "raw",
+                raw: rawBody,
+                options: {
+                  raw: { language: "json" }
+                }
+              }
+            } : {})
+          },
+          response: [
+            {
+              name: "Saved Example from Kiroo",
+              originalRequest: {
+                method: int.request.method.toUpperCase(),
+                header: headerList,
+                url: { raw: int.request.url }
+              },
+              status: "Saved Response",
+              code: int.response.status,
+              _postman_previewlanguage: "json",
+              header: [],
+              cookie: [],
+              body: resBodyStr
+            }
+          ]
+        };
+      })
+    };
+
+    const outputPath = join(process.cwd(), outFileName);
+    writeFileSync(outputPath, JSON.stringify(postmanCollection, null, 2));
+
+    console.log(chalk.green(`\n  ✅ Collection exported successfully!`));
+    console.log(chalk.gray(`  Saved to: ${outputPath}`));
+    console.log(chalk.magenta(`  You can now import this file directly into Postman/Insomnia.\n`));
+
+  } catch (error) {
+    console.error(chalk.red('\n  ✗ Export failed:'), error.message, '\n');
+  }
+}

package/src/lingo.js

@@ -0,0 +1,36 @@
+import { LingoDotDevEngine } from "lingo.dev/sdk";
+import chalk from "chalk";
+import { loadEnv } from "./storage.js";
+
+function getLingoEngine() {
+  const envData = loadEnv();
+  const currentEnvVars = envData.environments[envData.current] || {};
+  
+  // Prioritize process.env, fallback to kiroo environments
+  const apiKey = currentEnvVars.LINGODOTDEV_API_KEY;
+
+  if (!apiKey) {
+    console.log(chalk.yellow(`\n  ⚠️  LINGODOTDEV_API_KEY not found.`));
+    console.log(chalk.gray(`run 'kiroo env set LINGODOTDEV_API_KEY <your_key>'\n`));
+    return null;
+  }
+
+  return new LingoDotDevEngine({ apiKey });
+}
+
+export async function translateText(text, targetLang) {
+  const engine = getLingoEngine();
+  if (!engine) return text;
+
+  try {
+    const result = await engine.localizeText(text, {
+      sourceLocale: 'en',
+      targetLocale: targetLang,
+      fast: true 
+    });
+    return result;
+  } catch (error) {
+    console.log(chalk.red(`\n  ⚠️  Translation failed: ${error.message}`));
+    return text; 
+  }
+}

package/src/replay.js

@@ -5,13 +5,26 @@ import { getAllInteractions, loadInteraction } from './storage.js';
 import { formatResponse } from './formatter.js';
 
 export async function listInteractions(options) {
-  const interactions = getAllInteractions();
+  let interactions = getAllInteractions();
   const limit = parseInt(options.limit) || 10;
   const offset = parseInt(options.offset) || 0;
   
+  // Apply Filters
+  if (options.date) {
+    interactions = interactions.filter(int => int.id.startsWith(options.date));
+  }
+  if (options.url) {
+    interactions = interactions.filter(int => int.request.url.toLowerCase().includes(options.url.toLowerCase()));
+  }
+  if (options.status) {
+    interactions = interactions.filter(int => String(int.response.status) === String(options.status));
+  }
+
   if (interactions.length === 0) {
-    console.log(chalk.yellow('\n  No interactions found.'));
-    console.log(chalk.gray('  Run a request first: '), chalk.white('kiroo POST https://api.example.com/endpoint\n'));
+    console.log(chalk.yellow('\n  No matching interactions found.'));
+    if (!options.date && !options.url && !options.status) {
+      console.log(chalk.gray('  Run a request first: '), chalk.white('kiroo POST https://api.example.com/endpoint\n'));
+    }
     return;
   }
   

package/src/snapshot.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import Table from 'cli-table3';
 import { getAllInteractions, saveSnapshotData, getAllSnapshots, loadSnapshotData } from './storage.js';
+import { translateText } from './lingo.js';
 
 export async function saveSnapshot(tag) {
   const interactions = getAllInteractions();
@@ -49,12 +50,15 @@ export async function listSnapshots() {
   console.log('');
 }
 
-export async function compareSnapshots(tag1, tag2) {
+export async function compareSnapshots(tag1, tag2, lang) {
   try {
     const s1 = loadSnapshotData(tag1);
     const s2 = loadSnapshotData(tag2);
     
     console.log(chalk.cyan(`\n  🔍 Comparing Snapshots:`), chalk.white(tag1), chalk.gray('vs'), chalk.white(tag2));
+    if (lang) {
+      console.log(chalk.magenta(`  🌍 Translating output to: ${chalk.white(lang.toUpperCase())} using Lingo.dev...`));
+    }
     
     const results = [];
     let breakingChanges = 0;
@@ -93,18 +97,62 @@ export async function compareSnapshots(tag1, tag2) {
         breakingChanges++;
       }
       
-      // Deep field comparison (very basic for MVP)
-      if (typeof int1.response.body === 'object' && typeof int2.response.body === 'object' && int1.response.body !== null && int2.response.body !== null) {
-        const keys1 = Object.keys(int1.response.body);
-        const keys2 = Object.keys(int2.response.body);
+      // Helper for deep structural comparison
+      const deepCompare = (val1, val2, path = '') => {
+        const changes = [];
         
-        const removed = keys1.filter(k => !keys2.includes(k));
-        if (removed.length > 0) {
-          diffs.push(`Fields removed: ${chalk.red(removed.join(', '))}`);
-          breakingChanges++;
+        // Handle nulls
+        if (val1 === null && val2 !== null) return [{ path, msg: `type changed from null to ${typeof val2}`, breaking: false }];
+        if (val1 !== null && val2 === null) return [{ path, msg: `type changed from ${typeof val1} to null`, breaking: false }];
+        if (val1 === null && val2 === null) return changes;
+
+        const type1 = Array.isArray(val1) ? 'array' : typeof val1;
+        const type2 = Array.isArray(val2) ? 'array' : typeof val2;
+
+        if (type1 !== type2) {
+          changes.push({ path, msg: `type changed from ${chalk.yellow(type1)} to ${chalk.yellow(type2)}`, breaking: true });
+          return changes;
         }
-      }
-      
+
+        if (type1 === 'object') {
+          const keys1 = Object.keys(val1);
+          const keys2 = Object.keys(val2);
+
+          // Check for removed keys (Breaking)
+          for (const k of keys1) {
+            const currentPath = path ? `${path}.${k}` : k;
+            if (!keys2.includes(k)) {
+              changes.push({ path: currentPath, msg: `was ${chalk.red('removed')}`, breaking: true });
+            } else {
+              changes.push(...deepCompare(val1[k], val2[k], currentPath));
+            }
+          }
+
+          // Check for added keys (Non-breaking)
+          for (const k of keys2) {
+            const currentPath = path ? `${path}.${k}` : k;
+            if (!keys1.includes(k)) {
+              changes.push({ path: currentPath, msg: `was ${chalk.green('added')}`, breaking: false });
+            }
+          }
+        } else if (type1 === 'array') {
+          // Array structure validation (check first item schema only if exists)
+          if (val1.length > 0 && val2.length > 0) {
+            const itemPath = path ? `${path}[0]` : '[0]';
+            changes.push(...deepCompare(val1[0], val2[0], itemPath));
+          }
+        }
+        
+        return changes;
+      };
+
+      if (int1.response.body !== undefined && int2.response.body !== undefined) {
+        const structuralChanges = deepCompare(int1.response.body, int2.response.body);
+        for (const change of structuralChanges) {
+           diffs.push(`${chalk.cyan(change.path || 'root')} ${change.msg}`);
+           if (change.breaking) breakingChanges++;
+        }
+      }      
       if (diffs.length > 0) {
         results.push({
           type: 'CHANGE',
@@ -116,19 +164,36 @@ export async function compareSnapshots(tag1, tag2) {
     });
 
     if (results.length === 0) {
-      console.log(chalk.green('\n  ✅ No differences detected. Your API is stable!\n'));
+      let finalMsg = 'No differences detected. Your API is stable!';
+      if (lang) finalMsg = await translateText(finalMsg, lang);
+      console.log(chalk.green(`\n  ✅ ${finalMsg}\n`));
     } else {
       console.log('');
-      results.forEach(res => {
+      
+      for (const res of results) {
+        let printMsg = res.msg;
+        if (lang) {
+           // Basic translation hook for individual diff items (stripping ansi)
+           const cleanMsg = printMsg.replace(/\x1B\[[0-9;]*m/g, '');
+           const translatedMsg = await translateText(cleanMsg, lang);
+           printMsg = chalk.yellow('[Translated] ') + translatedMsg;
+        }
+
         const symbol = res.type === 'NEW' ? chalk.blue('+') : chalk.yellow('⚠️');
         console.log(`  ${symbol} ${chalk.white(res.method)} ${chalk.gray(res.url)}`);
-        console.log(`    ${res.msg}`);
-      });
+        console.log(`    ${printMsg}`);
+      }
       
+      let alertMsg = breakingChanges > 0 
+          ? `Detected ${breakingChanges} potential breaking changes!`
+          : `Non-breaking changes detected.`;
+          
+      if (lang) alertMsg = await translateText(alertMsg, lang);
+
       if (breakingChanges > 0) {
-        console.log(chalk.red(`\n  🚨 Detected ${breakingChanges} potential breaking changes!\n`));
+        console.log(chalk.red(`\n  🚨 ${alertMsg}\n`));
       } else {
-        console.log(chalk.blue('\n  ℹ️ Non-breaking changes detected.\n'));
+        console.log(chalk.blue(`\n  ℹ️ ${alertMsg}\n`));
       }
     }
 

package/src/storage.js

@@ -19,6 +19,11 @@ export function ensureKirooDir() {
   if (!existsSync(ENV_FILE)) {
     writeFileSync(ENV_FILE, JSON.stringify({ current: 'default', environments: { default: {} } }, null, 2));
   }
+  
+  const GITIGNORE_FILE = join(KIROO_DIR, '.gitignore');
+  if (!existsSync(GITIGNORE_FILE)) {
+    writeFileSync(GITIGNORE_FILE, 'env.json\n');
+  }
 }
 
 export async function saveInteraction(interaction) {