kiroo 0.2.0 → 0.4.0

package/bin/kiroo.js

@@ -6,16 +6,18 @@ 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 { initProject } from '../src/init.js';
-// import { showStats } from '../src/stats.js';
+import { showStats } from '../src/stats.js';
+import { handleImport } from '../src/import.js';
+import { clearAllInteractions } from '../src/storage.js';
 
 const program = new Command();
 
 program
   .name('kiroo')
   .description('Git for API interactions. Record, replay, snapshot, and diff your APIs.')
-  .version('0.2.0');
+  .version('0.4.0');
 
 // Init command
 program
@@ -58,6 +60,28 @@ program
     await replayInteraction(id);
   });
 
+// Clear command
+program
+  .command('clear')
+  .description('Clear all stored interaction history')
+  .option('-f, --force', 'Force clear without confirmation')
+  .action(async (options) => {
+    if (!options.force) {
+      const inquirer = (await import('inquirer')).default;
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: chalk.red('Are you sure you want to clear all history?'),
+          default: false
+        }
+      ]);
+      if (!confirm) return;
+    }
+    clearAllInteractions();
+    console.log(chalk.green('\n  ✨ History cleared successfully.\n'));
+  });
+
 // Environment commands
 const env = program.command('env').description('Environment management');
 
@@ -105,6 +129,37 @@ 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')
+  .description('Import a request from a cURL command (opens editor if no command is provided)')
+  .allowUnknownOption()
+  .action(async (_, command) => {
+    if (command.args.length > 0) {
+      // Pass tokens directly to handleImport
+      await handleImport(command.args);
+    } else {
+      const inquirer = (await import('inquirer')).default;
+      const response = await inquirer.prompt([
+        {
+          type: 'editor',
+          name: 'curl',
+          message: 'Paste your cURL command here (opens your default editor):',
+          validate: (input) => input.trim().length > 0 || 'Please enter a cURL command'
+        }
+      ]);
+      await handleImport(response.curl);
+    }
+  });
+
 // Graph command
 /*
 program
@@ -116,14 +171,12 @@ program
 */
 
 // Stats command
-/*
 program
   .command('stats')
   .description('Show usage statistics')
   .action(async () => {
     await showStats();
   });
-*/
 
 // Error handling
 program.exitOverride();

package/package.json

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

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) {
+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,53 @@ 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) {
+    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;
+      // Extract the part after the drive letter and potential Git Bash root
+      // We look for common markers or just the first segment that looks like a path
+      // Most reliable for Git Bash: The user's path is at the end.
+      // We'll try to find the /api, /v1, etc., or just fallback to the full path after the first few segments
+      const segments = url.split(/[/\\]/);
+      const apiIdx = segments.findIndex(s => s === 'api' || s === 'v1' || s === 'v2');
+      if (apiIdx !== -1) {
+        pathPart = '/' + segments.slice(apiIdx).join('/');
+      } else {
+        // Fallback: If we can't find a marker, it's hard to guess safely,
+        // but we can try to strip the drive letter and first few segments
+        // In Git Bash, it's usually C:/Program Files/Git/api...
+        // Let's at least strip the drive letter root
+        pathPart = url.replace(/^[a-zA-Z]:/, '').replace(/\\/g, '/');
+        if (!pathPart.startsWith('/')) pathPart = '/' + pathPart;
+      }
+    }
+    // 3. No leading slash but doesn't look like a host (no dots, no protocol)
+    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;
+      url = normalizedBaseUrl + (pathPart.startsWith('/') ? pathPart : '/' + pathPart);
+    }
+  }
 
   // Parse headers
   const headers = {};
@@ -61,7 +110,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);
     });
   }
 
@@ -70,7 +119,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);
@@ -133,6 +182,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`));
@@ -155,6 +205,8 @@ 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));

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

@@ -0,0 +1,113 @@
+import chalk from 'chalk';
+import { executeRequest } from './executor.js';
+
+export async function handleImport(input) {
+  try {
+    let tokens = [];
+    if (Array.isArray(input)) {
+      tokens = input;
+    } else {
+      tokens = stringToTokens(input);
+    }
+    
+    const parsed = parseCurlTokens(tokens);
+    
+    console.log(chalk.cyan('\n  📥 Parsed cURL Command:'));
+    console.log(chalk.gray(`  Method: `), chalk.white(parsed.method));
+    console.log(chalk.gray(`  URL:    `), chalk.white(parsed.url));
+    console.log(chalk.gray(`  Headers:`), chalk.white(Object.keys(parsed.headers).length));
+    if (parsed.body) {
+      console.log(chalk.gray(`  Body:   `), chalk.white('Present'));
+    }
+    console.log('');
+
+    // Convert parsed object to options format for executeRequest
+    const options = {
+      header: Object.entries(parsed.headers).map(([k, v]) => `${k}: ${v}`),
+      data: parsed.body
+    };
+
+    await executeRequest(parsed.method, parsed.url, options);
+    
+  } catch (error) {
+    console.error(chalk.red('\n  ✗ Import failed:'), error.message, '\n');
+  }
+}
+
+function stringToTokens(curlString) {
+  // Clean up shell artifacts (Windows ^, backslashes for line continuation)
+  let cleanStr = curlString.replace(/\^/g, '').replace(/\\\n/g, ' ').trim();
+  
+  const tokens = [];
+  let currentToken = '';
+  let inQuotes = false;
+  let quoteChar = '';
+
+  for (let i = 0; i < cleanStr.length; i++) {
+    const char = cleanStr[i];
+    if ((char === "'" || char === '"') && (i === 0 || cleanStr[i - 1] !== '\\')) {
+      if (inQuotes && char === quoteChar) {
+        inQuotes = false;
+        tokens.push(currentToken);
+        currentToken = '';
+        quoteChar = '';
+      } else if (!inQuotes) {
+        inQuotes = true;
+        quoteChar = char;
+      } else {
+        currentToken += char;
+      }
+    } else if (char === ' ' && !inQuotes) {
+      if (currentToken) {
+        tokens.push(currentToken);
+        currentToken = '';
+      }
+    } else {
+      currentToken += char;
+    }
+  }
+  if (currentToken) tokens.push(currentToken);
+  return tokens;
+}
+
+function parseCurlTokens(tokens) {
+  const result = {
+    method: 'GET',
+    url: '',
+    headers: {},
+    body: ''
+  };
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i].trim();
+    if (!token) continue;
+
+    if (token === '-X' || token === '--request') {
+      result.method = tokens[++i].toUpperCase();
+    } else if (token === '-H' || token === '--header') {
+      const headerStr = tokens[++i];
+      if (!headerStr) continue;
+      const colonIdx = headerStr.indexOf(':');
+      if (colonIdx !== -1) {
+        const key = headerStr.substring(0, colonIdx).trim();
+        const value = headerStr.substring(colonIdx + 1).trim();
+        result.headers[key] = value;
+      }
+    } else if (token === '-d' || token === '--data' || token === '--data-raw' || token === '--data-binary') {
+      result.body = tokens[++i];
+      if (result.method === 'GET') result.method = 'POST';
+    } else if (token.includes('://') || (token.startsWith('localhost') || token.startsWith('127.0.0.1'))) {
+      if (!result.url) result.url = token;
+    } else if (token === 'curl' || token.startsWith('-')) {
+      continue;
+    } else {
+      if (!result.url) result.url = token;
+    }
+  }
+
+  if (result.url) {
+    result.url = result.url.replace(/^["']|["']$/g, '');
+  }
+
+  return result;
+}

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

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { getAllInteractions } from './storage.js';
+
+export function showStats() {
+  const interactions = getAllInteractions();
+
+  if (interactions.length === 0) {
+    console.log(chalk.yellow('\n  No interactions found to analyze.'));
+    console.log(chalk.gray('  Run some requests first to see the magic! ✨\n'));
+    return;
+  }
+
+  console.log(chalk.cyan.bold('\n  📊 Kiroo Analytics Dashboard\n'));
+
+  // 1. General Metrics
+  const total = interactions.length;
+  const successes = interactions.filter(i => i.response.status >= 200 && i.response.status < 300).length;
+  const successRate = ((successes / total) * 100).toFixed(1);
+  const avgDuration = (interactions.reduce((acc, i) => acc + i.metadata.duration_ms, 0) / total).toFixed(0);
+
+  const generalTable = new Table();
+  generalTable.push(
+    { [chalk.white('Total Requests')]: chalk.cyan(total) },
+    { [chalk.white('Success Rate')]: successRate >= 80 ? chalk.green(successRate + '%') : chalk.yellow(successRate + '%') },
+    { [chalk.white('Avg. Duration')]: chalk.white(avgDuration + 'ms') }
+  );
+
+  console.log(chalk.white.bold('  ● General Performance'));
+  console.log(generalTable.toString());
+
+  // 2. Method Distribution
+  const methods = {};
+  interactions.forEach(i => {
+    methods[i.request.method] = (methods[i.request.method] || 0) + 1;
+  });
+
+  const methodTable = new Table({
+    head: ['Method', 'Count', 'Percentage'].map(h => chalk.cyan(h)),
+    colWidths: [15, 10, 15]
+  });
+
+  Object.entries(methods).forEach(([method, count]) => {
+    const percentage = ((count / total) * 100).toFixed(1) + '%';
+    methodTable.push([chalk.white(method), chalk.white(count), chalk.gray(percentage)]);
+  });
+
+  console.log(chalk.white.bold('\n  ● Request Distribution'));
+  console.log(methodTable.toString());
+
+  // 3. Slowest Endpoints
+  const slowTable = new Table({
+    head: ['URL', 'Status', 'Duration'].map(h => chalk.cyan(h)),
+    colWidths: [45, 10, 15]
+  });
+
+  const sortedBySlowest = [...interactions].sort((a, b) => b.metadata.duration_ms - a.metadata.duration_ms);
+  const topSlow = sortedBySlowest.slice(0, 5);
+
+  topSlow.forEach(i => {
+    const url = i.request.url.length > 42 ? i.request.url.substring(0, 39) + '...' : i.request.url;
+    const statusColor = i.response.status < 400 ? chalk.green : chalk.red;
+    slowTable.push([
+      chalk.gray(url),
+      statusColor(i.response.status),
+      chalk.red(i.metadata.duration_ms + 'ms')
+    ]);
+  });
+
+  console.log(chalk.white.bold('\n  ● Top 5 Slowest Endpoints (Bottlenecks)'));
+  console.log(slowTable.toString());
+  console.log('');
+}

package/src/storage.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'fs';
 import { join } from 'path';
 
 const KIROO_DIR = '.kiroo';
@@ -39,6 +39,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
     },
   };
 
@@ -112,6 +114,17 @@ export function getAllSnapshots() {
     .map(f => f.replace('.json', ''));
 }
 
+export function clearAllInteractions() {
+  ensureKirooDir();
+  if (existsSync(INTERACTIONS_DIR)) {
+    const files = readdirSync(INTERACTIONS_DIR);
+    files.forEach(f => {
+      const filepath = join(INTERACTIONS_DIR, f);
+      rmSync(filepath, { force: true });
+    });
+  }
+}
+
 export function loadEnv() {
   ensureKirooDir();
   const data = readFileSync(ENV_FILE, 'utf8');