kiroo 0.7.4 → 0.8.0

package/README.md

@@ -51,12 +51,13 @@ Coming from a browser? Don't type a single header.
 
 ## ✨ Features that WOW
 
-### 🟢 **Git-Native Testing**
-Capture a **Snapshot** of your entire API state and compare versions to detect breaking changes instantly.
+### 🟢 **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 snapshot save v1-stable
-# ... make changes ...
-kiroo snapshot compare v1-stable current
+kiroo --lang hi snapshot compare v1-stable current
 ```
 
 ### 🌍 **Variable Chaining**
@@ -74,6 +75,20 @@ kiroo post /api/user -d "name=Yash email=yash@kiroo.io role=admin"
 
 ---
 
+### 🧪 **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
+kiroo check /api/login -m POST -d "user=yash pass=123" --status 200 --has token
+```
+
+### 🚀 **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
+```
+
+---
+
 ## 🚀 Quick Start
 
 ### 1. Installation
@@ -141,6 +156,16 @@ Re-run a specific interaction.
   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.
@@ -217,6 +242,16 @@ Snapshot management.
   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**:

package/bin/kiroo.js

@@ -13,13 +13,16 @@ 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.7.4');
+  .version('0.8.0')
+  .option('--lang <language>', 'Translate output to specified language (e.g., hi, es, fr)');
 
 // Init command
 program
@@ -115,6 +118,23 @@ 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>')
@@ -195,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.7.4",
+  "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/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/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/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`));
       }
     }