kiroo 0.2.0 → 0.3.4

package/bin/kiroo.js

@@ -8,14 +8,16 @@ import { saveSnapshot, compareSnapshots, listSnapshots } from '../src/snapshot.j
 import { setEnv, setVar, deleteVar, listEnv } from '../src/env.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.3.4');
 
 // 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,29 @@ snapshot
     await compareSnapshots(tag1, tag2);
   });
 
+// 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 +163,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.3.4",
   "description": "Git for API interactions. Record, replay, snapshot, and diff your APIs.",
   "type": "module",
   "bin": {

package/src/executor.js

@@ -55,6 +55,48 @@ export async function executeRequest(method, url, options = {}) {
   // Apply replacements to URL
   url = applyEnvReplacements(url, currentEnvVars);
 
+  // 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 = {};
   if (options.header) {

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/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';
@@ -112,6 +112,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');