kiroo 0.3.4 → 0.7.4

package/README.md

@@ -16,48 +16,60 @@
 
 ---
 
-## 📖 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.
 
 ---
 
-## ✨ Core Capabilities
+## 📊 Insights & Performance Dashboard (`kiroo stats`)
 
-### 🔴 **Auto-Recording**
-Every request made through Kiroo is automatically saved. No more manual exports from Postman.
-```bash
-kiroo post {{baseUrl}}/users -d "name=Yash email=yash@example.com"
-```
+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.
+
+---
 
-### 🔄 **Replay Engine**
-Re-run any past interaction instantly and see if the backend behavior has changed.
+## 🔌 Instant cURL Import (`kiroo import`)
+
+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 Testing**
+Capture a **Snapshot** of your entire API state and compare versions to detect breaking changes instantly.
 ```bash
-kiroo replay <interaction-id>
+kiroo snapshot save v1-stable
+# ... make changes ...
+kiroo snapshot compare v1-stable current
 ```
 
-### 🌍 **Smart Environments & Variables**
-Stop copy-pasting tokens. Chain requests together dynamically.
+### 🌍 **Variable Chaining**
+Chain requests like a pro. Save a token from one response and inject it into the next.
 ```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 /login --save jwt=data.token
+kiroo get /users -H "Authorization: Bearer {{jwt}}"
 ```
 
-### 📸 **Snapshot System & Diff Engine**
-Capture the "Status Quo" of your API and detect **Breaking Changes** during refactors.
+### ⌨️ **Shorthand JSON Parser**
+Forget escaping quotes. Type JSON like a human.
 ```bash
-# Before refactor
-kiroo snapshot save v1-stable
-
-# After refactor
-kiroo snapshot compare v1-stable current
+kiroo post /api/user -d "name=Yash email=yash@kiroo.io role=admin"
 ```
 
 ---
@@ -66,53 +78,172 @@ 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 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 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 +254,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

@@ -6,18 +6,20 @@ import { executeRequest } from '../src/executor.js';
 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 { 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';
 
 const program = new Command();
 
 program
   .name('kiroo')
   .description('Git for API interactions. Record, replay, snapshot, and diff your APIs.')
-  .version('0.3.4');
+  .version('0.7.4');
 
 // Init command
 program
@@ -26,6 +28,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 +99,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 +115,20 @@ program
     await replayInteraction(id);
   });
 
+// 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')
@@ -129,6 +198,14 @@ snapshot
     await compareSnapshots(tag1, tag2);
   });
 
+// Graph command
+program
+  .command('graph')
+  .description('Show visual dependency graph of API interactions')
+  .action(async () => {
+    await showGraph();
+  });
+
 // Import command
 program
   .command('import')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiroo",
-  "version": "0.3.4",
+  "version": "0.7.4",
   "description": "Git for API interactions. Record, replay, snapshot, and diff your APIs.",
   "type": "module",
   "bin": {

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/executor.js

@@ -4,16 +4,20 @@ import ora from 'ora';
 import { saveInteraction, loadEnv, saveEnv } from './storage.js';
 import { formatResponse } from './formatter.js';
 
-function applyEnvReplacements(data, envVars) {
+export function applyEnvReplacements(data, envVars, usedKeys = null) {
   if (typeof data === 'string') {
     return data.replace(/\{\{(.+?)\}\}/g, (match, key) => {
-      return envVars[key] !== undefined ? envVars[key] : match;
+      if (envVars[key] !== undefined) {
+        if (usedKeys) usedKeys.add(key);
+        return envVars[key];
+      }
+      return match;
     });
   }
   if (typeof data === 'object' && data !== null) {
     const newData = Array.isArray(data) ? [] : {};
     for (const key in data) {
-      newData[key] = applyEnvReplacements(data[key], envVars);
+      newData[key] = applyEnvReplacements(data[key], envVars, usedKeys);
     }
     return newData;
   }
@@ -52,8 +56,11 @@ export async function executeRequest(method, url, options = {}) {
   const env = loadEnv();
   const currentEnvVars = env.environments[env.current] || {};
 
+  const usedKeys = new Set();
+  const savedKeys = [];
+
   // Apply replacements to URL
-  url = applyEnvReplacements(url, currentEnvVars);
+  url = applyEnvReplacements(url, currentEnvVars, usedKeys);
 
   // Auto-BaseURL logic
   if (currentEnvVars.baseUrl) {
@@ -82,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)
@@ -103,7 +116,7 @@ export async function executeRequest(method, url, options = {}) {
     options.header.forEach(h => {
       const [key, ...valueParts] = h.split(':');
       const headerValue = valueParts.join(':').trim();
-      headers[key.trim()] = applyEnvReplacements(headerValue, currentEnvVars);
+      headers[key.trim()] = applyEnvReplacements(headerValue, currentEnvVars, usedKeys);
     });
   }
 
@@ -112,7 +125,7 @@ export async function executeRequest(method, url, options = {}) {
   if (options.data) {
     let rawData = options.data;
     // Apply replacements to raw data string before parsing
-    rawData = applyEnvReplacements(rawData, currentEnvVars);
+    rawData = applyEnvReplacements(rawData, currentEnvVars, usedKeys);
 
     try {
       body = JSON.parse(rawData);
@@ -175,6 +188,7 @@ export async function executeRequest(method, url, options = {}) {
           const val = getDeep(response, responsePath);
           if (val !== undefined) {
             env.environments[env.current][envKey] = val;
+            savedKeys.push(envKey);
             console.log(chalk.cyan(`  ✨ Saved to env:`), chalk.white(`${envKey}=${val}`));
           } else {
             console.log(chalk.yellow(`  ⚠️  Could not find path '${responsePath}' in response`));
@@ -197,10 +211,13 @@ export async function executeRequest(method, url, options = {}) {
         data: response.data,
       },
       duration,
+      saves: savedKeys,
+      uses: Array.from(usedKeys)
     });
 
     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/graph.js

@@ -0,0 +1,75 @@
+import chalk from 'chalk';
+import { getAllInteractions } from './storage.js';
+
+export async function showGraph() {
+  const interactions = getAllInteractions().reverse(); // Chronological order
+
+  if (interactions.length === 0) {
+    console.log(chalk.yellow('\n  No interactions recorded yet.'));
+    console.log(chalk.gray('  Run some requests to see the dependency graph!\n'));
+    return;
+  }
+
+  // 1. Map: Variable -> Provider Interaction (Method + Path)
+  const variableProviders = {};
+  
+  // 2. Interaction nodes with their connections
+  const nodes = [];
+
+  const getPath = (urlStr) => {
+    try {
+      const urlObj = new URL(urlStr);
+      return urlObj.pathname;
+    } catch (e) {
+      return urlStr.startsWith('http') ? urlStr : (urlStr.startsWith('/') ? urlStr : '/' + urlStr);
+    }
+  };
+
+  interactions.forEach(int => {
+    const path = getPath(int.request.url);
+    const method = int.request.method;
+    const saves = int.metadata.saves || [];
+    const uses = int.metadata.uses || [];
+
+    // Track which variables this interaction provides
+    saves.forEach(v => {
+      variableProviders[v] = { method, path };
+    });
+
+    nodes.push({ method, path, saves, uses });
+  });
+
+  console.log(chalk.cyan('\n  🕸️  API Dependency Graph:'));
+  console.log(chalk.gray('  (Shows how data flows between endpoints)\n'));
+
+  // Simple visualization
+  const seenPaths = new Set();
+  
+  nodes.forEach((node, idx) => {
+    const nodeLabel = `${chalk.white(node.method)} ${chalk.gray(node.path)}`;
+    
+    // Find dependencies based on 'uses'
+    const dependencies = node.uses.map(v => {
+      const provider = variableProviders[v];
+      return provider ? `[${v}] from ${provider.method} ${provider.path}` : null;
+    }).filter(Boolean);
+
+    // Render the node
+    if (dependencies.length > 0) {
+      console.log(`  ${chalk.blue('⬇')} ${nodeLabel}`);
+      dependencies.forEach((dep, depIdx) => {
+        const branchToken = depIdx === dependencies.length - 1 ? '└─' : '├─';
+        console.log(`     ${chalk.gray(branchToken)} ${chalk.yellow('uses')} ${dep}`);
+      });
+    } else {
+      console.log(`  ${chalk.green('○')} ${nodeLabel}`);
+    }
+
+    if (node.saves.length > 0) {
+      const saveToken = node.uses.length > 0 ? '     │' : '     ';
+      console.log(`${saveToken}  ${chalk.magenta('↳')} ${chalk.gray('saves')} ${chalk.white(node.saves.join(', '))}`);
+    }
+    
+    console.log('');
+  });
+}

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

@@ -59,15 +59,27 @@ export async function compareSnapshots(tag1, tag2) {
     const results = [];
     let breakingChanges = 0;
     
-    // Simplistic comparison: match by URL and Method
+    // Helper to get path from URL string
+    const getPath = (urlStr) => {
+      try {
+        const urlObj = new URL(urlStr);
+        return urlObj.pathname;
+      } catch (e) {
+        // If it's already a path or invalid full URL, return as is
+        return urlStr.startsWith('http') ? urlStr : (urlStr.startsWith('/') ? urlStr : '/' + urlStr);
+      }
+    };
+
+    // Domain-agnostic comparison: match by Path and Method
     s2.interactions.forEach(int2 => {
-      const int1 = s1.interactions.find(i => i.url === int2.url && i.method === int2.method);
+      const path2 = getPath(int2.url);
+      const int1 = s1.interactions.find(i => getPath(i.url) === path2 && i.method === int2.method);
       
       if (!int1) {
         results.push({
           type: 'NEW',
           method: int2.method,
-          url: int2.url,
+          url: path2,
           msg: chalk.blue('New interaction added')
         });
         return;
@@ -97,7 +109,7 @@ export async function compareSnapshots(tag1, tag2) {
         results.push({
           type: 'CHANGE',
           method: int2.method,
-          url: int2.url,
+          url: path2,
           msg: diffs.join('\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) {
@@ -39,6 +44,8 @@ export async function saveInteraction(interaction) {
     response: interaction.response,
     metadata: {
       duration_ms: interaction.duration,
+      saves: interaction.saves || [], // Variables saved from this response
+      uses: interaction.uses || [],   // Variables used in this request
     },
   };