kiroo 0.7.4 → 0.9.0

package/src/init.js

@@ -1,48 +1,80 @@
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { writeFileSync, existsSync } from 'fs';
-import { ensureKirooDir } from './storage.js';
-
-export async function initProject() {
-  console.log('');
-  console.log(chalk.cyan.bold('  🚀 Welcome to Kiroo'));
-  console.log(chalk.gray('  Git for API interactions\n'));
-  
-  if (existsSync('.kiroo')) {
-    console.log(chalk.yellow('  ⚠️  Kiroo is already initialized in this directory.\n'));
-    return;
-  }
-  
-  const answers = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'projectName',
-      message: 'Project name:',
-      default: 'my-api-project',
-    },
-    {
-      type: 'input',
-      name: 'baseUrl',
-      message: 'Base URL (optional):',
-      default: '',
-    },
-  ]);
-  
-  ensureKirooDir();
-  
-  const config = {
-    projectName: answers.projectName,
-    baseUrl: answers.baseUrl,
-    createdAt: new Date().toISOString(),
-  };
-  
-  writeFileSync('.kiroo/config.json', JSON.stringify(config, null, 2));
-  
-  console.log('');
-  console.log(chalk.green('  ✅ Kiroo initialized successfully!'));
-  console.log('');
-  console.log(chalk.gray('  Next steps:'));
-  console.log(chalk.white('    kiroo POST https://api.example.com/login email=test@test.com'));
-  console.log(chalk.white('    kiroo list'));
-  console.log(chalk.white('    kiroo snapshot save initial\n'));
-}
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync } from 'fs';
+import { ensureKirooDir, loadEnv, saveEnv } from './storage.js';
+import { saveKirooConfig } from './config.js';
+
+export async function initProject() {
+  console.log('');
+  console.log(chalk.cyan.bold('  🚀 Welcome to Kiroo'));
+  console.log(chalk.gray('  Git for API interactions\n'));
+  
+  if (existsSync('.kiroo')) {
+    console.log(chalk.yellow('  ⚠️  Kiroo is already initialized in this directory.\n'));
+    return;
+  }
+  
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: 'my-api-project',
+    },
+    {
+      type: 'input',
+      name: 'baseUrl',
+      message: 'Base URL (optional):',
+      default: '',
+    },
+    {
+      type: 'password',
+      name: 'groqApiKey',
+      message: 'Groq API Key (optional, hidden):',
+      default: '',
+      mask: '*',
+    },
+    {
+      type: 'password',
+      name: 'lingoApiKey',
+      message: 'Lingo.dev API Key (optional, hidden):',
+      default: '',
+      mask: '*',
+    },
+  ]);
+  
+  ensureKirooDir();
+  
+  const config = {
+    projectName: answers.projectName,
+    baseUrl: answers.baseUrl,
+    createdAt: new Date().toISOString(),
+  };
+  
+  saveKirooConfig(config);
+
+  const envData = loadEnv();
+  const current = envData.current || 'default';
+  if (!envData.environments[current]) {
+    envData.environments[current] = {};
+  }
+
+  if (answers.baseUrl) {
+    envData.environments[current].baseUrl = answers.baseUrl;
+  }
+  if (answers.groqApiKey) {
+    envData.environments[current].GROQ_API_KEY = answers.groqApiKey;
+  }
+  if (answers.lingoApiKey) {
+    envData.environments[current].LINGODOTDEV_API_KEY = answers.lingoApiKey;
+  }
+  saveEnv(envData);
+  
+  console.log('');
+  console.log(chalk.green('  ✅ Kiroo initialized successfully!'));
+  console.log('');
+  console.log(chalk.gray('  Next steps:'));
+  console.log(chalk.white('    kiroo POST https://api.example.com/login email=test@test.com'));
+  console.log(chalk.white('    kiroo list'));
+  console.log(chalk.white('    kiroo snapshot save initial\n'));
+}

package/src/lingo.js

@@ -0,0 +1,32 @@
+import { LingoDotDevEngine } from "lingo.dev/sdk";
+import chalk from "chalk";
+import { getEnvVar } from "./env.js";
+
+function getLingoEngine() {
+  const apiKey = getEnvVar('LINGODOTDEV_API_KEY') || getEnvVar('LINGO_API_KEY');
+
+  if (!apiKey) {
+    console.log(chalk.yellow(`\n  ⚠️  Lingo API key not found in .kiroo/env.json.`));
+    console.log(chalk.gray(`  Run 'kiroo env set LINGODOTDEV_API_KEY <your_key>' or re-run 'kiroo init'.\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/proxy.js

@@ -0,0 +1,120 @@
+import http from 'http';
+import httpProxy from 'http-proxy';
+import chalk from 'chalk';
+import { URL } from 'url';
+import stream from 'stream';
+import { saveInteraction } from './storage.js';
+
+export async function runProxy(targetHost, options = {}) {
+  const port = parseInt(options.port, 10) || 8080;
+
+  if (isNaN(port) || port <= 0 || port > 65535) {
+    console.error(chalk.red('\n  ✗ Invalid port provided.'), options.port);
+    console.log(chalk.gray('  Port must be a number between 1 and 65535.\n'));
+    process.exit(1);
+  }
+
+  // Validate target URL
+  try {
+    new URL(targetHost);
+  } catch (err) {
+    console.error(chalk.red('\n  ✗ Invalid target URL provided.'), targetHost);
+    console.log(chalk.gray('  Example: kiroo proxy --target http://localhost:3000\n'));
+    process.exit(1);
+  }
+
+  const proxy = httpProxy.createProxyServer({
+    target: targetHost,
+    changeOrigin: true,
+    secure: false,
+  });
+
+  // Handle Proxy Errors
+  proxy.on('error', (err, req, res) => {
+    let errorMsg = err.message;
+    if (err.code === 'ECONNREFUSED') {
+      errorMsg = `Connection Refused. Is your backend server running on ${targetHost}?`;
+    } else if (err.code === 'ENOTFOUND') {
+      errorMsg = `Target host not found: ${targetHost}`;
+    }
+
+    console.error(chalk.red(`\n  ✗ Proxy error for ${req.method} ${req.url}`));
+    console.error(chalk.yellow(`    Error: ${errorMsg} (${err.code || 'UNKNOWN'})\n`));
+
+    if (!res.headersSent && res.writeHead) {
+      res.writeHead(502, { 'Content-Type': 'application/json' });
+    }
+    if (res.end) {
+      res.end(JSON.stringify({ error: 'Proxy Error', message: errorMsg, code: err.code }));
+    }
+  });
+
+  // Intercept Response to save interaction
+  proxy.on('proxyRes', (proxyRes, req, res) => {
+    let responseBody = '';
+    proxyRes.on('data', (chunk) => {
+      responseBody += chunk.toString('utf8');
+    });
+
+    proxyRes.on('end', () => {
+      const duration = Date.now() - req.kirooStartTime;
+      const fullUrl = new URL(req.url, targetHost).toString();
+      
+      let parsedReqBody = req.kirooBodyData;
+      if (req.kirooBodyData) {
+         try { parsedReqBody = JSON.parse(req.kirooBodyData); } catch (e) { }
+      }
+
+      let parsedResBody = responseBody;
+      if (responseBody) {
+         try { parsedResBody = JSON.parse(responseBody); } catch (e) { }
+      }
+
+      // Only save if it's not a CORS preflight with no content
+      if (req.method !== 'OPTIONS' || proxyRes.statusCode !== 204) {
+          saveInteraction({
+            method: req.method,
+            url: fullUrl,
+            headers: req.headers,
+            body: parsedReqBody || undefined,
+            response: {
+              status: proxyRes.statusCode,
+              headers: proxyRes.headers,
+              body: parsedResBody || undefined
+            },
+            duration: duration
+          });
+          
+          const statusColor = proxyRes.statusCode >= 400 ? chalk.red : chalk.green;
+          console.log(`  ${statusColor(req.method)} ${chalk.dim(fullUrl)} ${statusColor(proxyRes.statusCode)} - ${duration}ms`);
+      }
+    });
+  });
+
+  const server = http.createServer((req, res) => {
+    req.kirooStartTime = Date.now();
+    let bodyChunks = [];
+
+    req.on('data', (chunk) => {
+      bodyChunks.push(chunk);
+    });
+
+    req.on('end', () => {
+      const bodyBuffer = Buffer.concat(bodyChunks);
+      req.kirooBodyData = bodyBuffer.toString('utf8');
+      
+      // We must re-stream the body because the original req stream is exhausted
+      const bufferStream = new stream.PassThrough();
+      bufferStream.end(bodyBuffer);
+      
+      proxy.web(req, res, { buffer: bufferStream });
+    });
+  });
+
+  server.listen(port, () => {
+    console.log(chalk.cyan(`\n  📡 Kiroo Proxy Started`));
+    console.log(chalk.white(`  Listening on : http://localhost:${port}`));
+    console.log(chalk.white(`  Forwarding to: ${targetHost}`));
+    console.log(chalk.gray(`\n  (Press Ctrl+C to stop recording)\n`));
+  });
+}

package/src/replay.js

@@ -11,7 +11,7 @@ export async function listInteractions(options) {
   
   // Apply Filters
   if (options.date) {
-    interactions = interactions.filter(int => int.id.startsWith(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()));
@@ -42,12 +42,13 @@ export async function listInteractions(options) {
       ? chalk.red 
       : chalk.yellow;
     
+    const url = int.request.url || 'N/A';
     table.push([
       chalk.white(int.id),
-      chalk.white(int.request.method),
-      chalk.gray(int.request.url.substring(0, 42) + (int.request.url.length > 42 ? '...' : '')),
+      chalk.white(int.request.method || '???'),
+      chalk.gray(url.substring(0, 42) + (url.length > 42 ? '...' : '')),
       statusColor(int.response.status),
-      chalk.gray(int.metadata.duration_ms + 'ms'),
+      chalk.gray((int.metadata.duration_ms || 0) + 'ms'),
     ]);
   });
   

package/src/sanitizer.js

@@ -0,0 +1,100 @@
+const REDACTED = '<REDACTED>';
+
+const SENSITIVE_KEY_PATTERN =
+  /authorization|cookie|set-cookie|token|secret|password|passwd|pwd|api[-_]?key|x-api-key|client[-_]?secret|session|jwt|access[-_]?token|refresh[-_]?token/i;
+
+function redactSensitiveString(value, redactedValue = REDACTED) {
+  if (typeof value !== 'string') {
+    return redactedValue;
+  }
+
+  if (/^bearer\s+/i.test(value)) {
+    return `Bearer ${redactedValue}`;
+  }
+
+  if (/^basic\s+/i.test(value)) {
+    return `Basic ${redactedValue}`;
+  }
+
+  return redactedValue;
+}
+
+export function isSensitiveKey(key, sensitiveKeyPattern = SENSITIVE_KEY_PATTERN) {
+  return sensitiveKeyPattern.test(String(key || ''));
+}
+
+export function redactSensitiveInUrl(urlValue, options = {}) {
+  const redactedValue = options.redactedValue || REDACTED;
+  const sensitiveKeyPattern = options.sensitiveKeyPattern || SENSITIVE_KEY_PATTERN;
+
+  if (typeof urlValue !== 'string' || !urlValue.includes('?')) {
+    return urlValue;
+  }
+
+  const sanitizeParams = (url) => {
+    for (const key of Array.from(url.searchParams.keys())) {
+      if (isSensitiveKey(key, sensitiveKeyPattern)) {
+        url.searchParams.set(key, redactedValue);
+      }
+    }
+    return url.toString();
+  };
+
+  try {
+    return sanitizeParams(new URL(urlValue));
+  } catch {
+    try {
+      const parsed = new URL(urlValue, 'http://kiroo.local');
+      sanitizeParams(parsed);
+      return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+    } catch {
+      return urlValue;
+    }
+  }
+}
+
+function sanitizeValue(value, currentKey = '', options = {}) {
+  const redactedValue = options.redactedValue || REDACTED;
+  const sensitiveKeyPattern = options.sensitiveKeyPattern || SENSITIVE_KEY_PATTERN;
+
+  if (isSensitiveKey(currentKey, sensitiveKeyPattern)) {
+    return redactSensitiveString(value, redactedValue);
+  }
+
+  if (typeof value === 'string') {
+    if (currentKey.toLowerCase() === 'url') {
+      return redactSensitiveInUrl(value, options);
+    }
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeValue(item, currentKey, options));
+  }
+
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+      out[key] = sanitizeValue(nestedValue, key, options);
+    }
+    return out;
+  }
+
+  return value;
+}
+
+export function sanitizeInteractionRecord(record, options = {}) {
+  const mergedOptions = {
+    enabled: options.enabled !== false,
+    redactedValue: options.redactedValue || REDACTED,
+    sensitiveKeyPattern: options.sensitiveKeyPattern || SENSITIVE_KEY_PATTERN
+  };
+
+  if (!mergedOptions.enabled) {
+    return record;
+  }
+
+  return sanitizeValue(record, '', mergedOptions);
+}
+
+export { REDACTED };

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,14 +50,17 @@ 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 = [];
+    const resultMap = new Map();
     let breakingChanges = 0;
     
     // Helper to get path from URL string
@@ -70,65 +74,183 @@ export async function compareSnapshots(tag1, tag2) {
       }
     };
 
+    const compareByMethodAndPath = (a, b) => {
+      const pathA = getPath(a.url || '');
+      const pathB = getPath(b.url || '');
+      const methodA = String(a.method || '').toUpperCase();
+      const methodB = String(b.method || '').toUpperCase();
+      if (methodA !== methodB) return methodA.localeCompare(methodB);
+      return pathA.localeCompare(pathB);
+    };
+
+    const s1Interactions = [...s1.interactions].sort(compareByMethodAndPath);
+    const s2Interactions = [...s2.interactions].sort(compareByMethodAndPath);
+    const consumedS1Indexes = new Set();
+
+    const isBreakingStatusChange = (beforeStatus, afterStatus) => {
+      const before2xx = beforeStatus >= 200 && beforeStatus < 300;
+      const after3xx = afterStatus >= 300 && afterStatus < 400;
+      const after4xx5xx = afterStatus >= 400;
+
+      if (before2xx && afterStatus === 304) return false;
+      if (before2xx && after3xx) return false;
+      if (before2xx && after4xx5xx) return true;
+      return beforeStatus !== afterStatus;
+    };
+
+    const addResult = (type, method, url, msg) => {
+      const cleanMethod = String(method || '').toUpperCase();
+      const key = `${type}|${cleanMethod}|${url}`;
+      if (!resultMap.has(key)) {
+        resultMap.set(key, { type, method: cleanMethod, url, messages: [], occurrences: 0 });
+      }
+      const row = resultMap.get(key);
+      row.occurrences += 1;
+      if (msg && !row.messages.includes(msg)) {
+        row.messages.push(msg);
+      }
+    };
+
     // Domain-agnostic comparison: match by Path and Method
-    s2.interactions.forEach(int2 => {
+    s2Interactions.forEach(int2 => {
       const path2 = getPath(int2.url);
-      const int1 = s1.interactions.find(i => getPath(i.url) === path2 && i.method === int2.method);
+      const candidates = s1Interactions
+        .map((item, index) => ({ item, index }))
+        .filter(({ item, index }) => !consumedS1Indexes.has(index) && getPath(item.url) === path2 && item.method === int2.method);
+      const match = candidates.find(({ item }) => item.id && int2.id && item.id === int2.id) || candidates[0];
+      const int1 = match?.item;
       
       if (!int1) {
-        results.push({
-          type: 'NEW',
-          method: int2.method,
-          url: path2,
-          msg: chalk.blue('New interaction added')
-        });
+        addResult('NEW', int2.method, path2, 'New interaction added');
         return;
       }
+      consumedS1Indexes.add(match.index);
       
       const diffs = [];
       
       // Compare status
       if (int1.response.status !== int2.response.status) {
         diffs.push(`Status: ${chalk.gray(int1.response.status)} → ${chalk.red(int2.response.status)}`);
-        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);
-        
-        const removed = keys1.filter(k => !keys2.includes(k));
-        if (removed.length > 0) {
-          diffs.push(`Fields removed: ${chalk.red(removed.join(', '))}`);
+        if (isBreakingStatusChange(int1.response.status, int2.response.status)) {
           breakingChanges++;
         }
       }
       
+      // Helper for deep structural comparison
+      const deepCompare = (val1, val2, path = '') => {
+        const changes = [];
+        
+        // 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',
-          method: int2.method,
-          url: path2,
-          msg: diffs.join('\n    ')
-        });
+        addResult('CHANGE', int2.method, path2, diffs.join('\n    '));
       }
     });
 
+    s1Interactions.forEach((int1, index) => {
+      if (consumedS1Indexes.has(index)) return;
+      const path1 = getPath(int1.url);
+      addResult('REMOVED', int1.method, path1, 'Interaction removed in target snapshot');
+      breakingChanges++;
+    });
+
+    const results = [...resultMap.values()];
+
     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 => {
-        const symbol = res.type === 'NEW' ? chalk.blue('+') : chalk.yellow('⚠️');
-        console.log(`  ${symbol} ${chalk.white(res.method)} ${chalk.gray(res.url)}`);
-        console.log(`    ${res.msg}`);
+      
+      const sortedResults = [...results].sort((a, b) => {
+        const methodA = String(a.method || '').toUpperCase();
+        const methodB = String(b.method || '').toUpperCase();
+        if (methodA !== methodB) return methodA.localeCompare(methodB);
+        return String(a.url || '').localeCompare(String(b.url || ''));
       });
+
+      for (const res of sortedResults) {
+        let printMsg = res.messages.join('\n    ');
+        if (res.occurrences > 1 && (res.type === 'NEW' || res.type === 'REMOVED')) {
+          printMsg += `\n    (${res.occurrences} occurrences)`;
+        }
+        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('+')
+          : res.type === 'REMOVED'
+          ? chalk.red('-')
+          : chalk.yellow('⚠️');
+        console.log(`  ${symbol} ${chalk.white(res.method)} ${chalk.gray(res.url)}`);
+        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`));
       }
     }