kiroo 0.8.0 → 0.9.5

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

@@ -60,7 +60,7 @@ export async function compareSnapshots(tag1, tag2, 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
@@ -74,27 +74,66 @@ export async function compareSnapshots(tag1, tag2, lang) {
       }
     };
 
+    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++;
+        if (isBreakingStatusChange(int1.response.status, int2.response.status)) {
+          breakingChanges++;
+        }
       }
       
       // Helper for deep structural comparison
@@ -154,15 +193,19 @@ export async function compareSnapshots(tag1, tag2, lang) {
         }
       }      
       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) {
       let finalMsg = 'No differences detected. Your API is stable!';
       if (lang) finalMsg = await translateText(finalMsg, lang);
@@ -170,8 +213,18 @@ export async function compareSnapshots(tag1, tag2, lang) {
     } else {
       console.log('');
       
-      for (const res of results) {
-        let printMsg = 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, '');
@@ -179,7 +232,11 @@ export async function compareSnapshots(tag1, tag2, lang) {
            printMsg = chalk.yellow('[Translated] ') + translatedMsg;
         }
 
-        const symbol = res.type === 'NEW' ? chalk.blue('+') : chalk.yellow('⚠️');
+        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}`);
       }

package/src/stats.js

@@ -1,8 +1,10 @@
 import chalk from 'chalk';
 import Table from 'cli-table3';
 import { getAllInteractions } from './storage.js';
+import { translateText } from './lingo.js';
 
-export function showStats() {
+export async function showStats(options = {}) {
+  const lang = options.lang;
   const interactions = getAllInteractions();
 
   if (interactions.length === 0) {
@@ -11,7 +13,9 @@ export function showStats() {
     return;
   }
 
-  console.log(chalk.cyan.bold('\n  📊 Kiroo Analytics Dashboard\n'));
+  let title = '📊 Kiroo Analytics Dashboard';
+  if (lang) title = await translateText(title, lang);
+  console.log(chalk.cyan.bold(`\n  ${title}\n`));
 
   // 1. General Metrics
   const total = interactions.length;
@@ -26,7 +30,9 @@ export function showStats() {
     { [chalk.white('Avg. Duration')]: chalk.white(avgDuration + 'ms') }
   );
 
-  console.log(chalk.white.bold('  ● General Performance'));
+  let generalHeader = '● General Performance';
+  if (lang) generalHeader = await translateText(generalHeader, lang);
+  console.log(chalk.white.bold(`  ${generalHeader}`));
   console.log(generalTable.toString());
 
   // 2. Method Distribution
@@ -45,7 +51,9 @@ export function showStats() {
     methodTable.push([chalk.white(method), chalk.white(count), chalk.gray(percentage)]);
   });
 
-  console.log(chalk.white.bold('\n  ● Request Distribution'));
+  let distHeader = '● Request Distribution';
+  if (lang) distHeader = await translateText(distHeader, lang);
+  console.log(chalk.white.bold(`\n  ${distHeader}`));
   console.log(methodTable.toString());
 
   // 3. Slowest Endpoints
@@ -67,7 +75,9 @@ export function showStats() {
     ]);
   });
 
-  console.log(chalk.white.bold('\n  ● Top 5 Slowest Endpoints (Bottlenecks)'));
+  let slowHeader = '● Top 5 Slowest Endpoints (Bottlenecks)';
+  if (lang) slowHeader = await translateText(slowHeader, lang);
+  console.log(chalk.white.bold(`\n  ${slowHeader}`));
   console.log(slowTable.toString());
   console.log('');
 }

package/src/storage.js

@@ -1,142 +1,223 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'fs';
-import { join } from 'path';
-
-const KIROO_DIR = '.kiroo';
-const INTERACTIONS_DIR = join(KIROO_DIR, 'interactions');
-const SNAPSHOTS_DIR = join(KIROO_DIR, 'snapshots');
-const ENV_FILE = join(KIROO_DIR, 'env.json');
-
-export function ensureKirooDir() {
-  if (!existsSync(KIROO_DIR)) {
-    mkdirSync(KIROO_DIR);
-  }
-  if (!existsSync(INTERACTIONS_DIR)) {
-    mkdirSync(INTERACTIONS_DIR);
-  }
-  if (!existsSync(SNAPSHOTS_DIR)) {
-    mkdirSync(SNAPSHOTS_DIR);
-  }
-  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) {
-  ensureKirooDir();
-  
-  const timestamp = new Date().toISOString();
-  const id = timestamp.replace(/[:.]/g, '-');
-  
-  const interactionData = {
-    id,
-    timestamp,
-    request: {
-      method: interaction.method,
-      url: interaction.url,
-      headers: interaction.headers,
-      body: interaction.body,
-    },
-    response: interaction.response,
-    metadata: {
-      duration_ms: interaction.duration,
-      saves: interaction.saves || [], // Variables saved from this response
-      uses: interaction.uses || [],   // Variables used in this request
-    },
-  };
-
-  const filename = `${id}.json`;
-  const filepath = join(INTERACTIONS_DIR, filename);
-  
-  writeFileSync(filepath, JSON.stringify(interactionData, null, 2));
-  
-  return id;
-}
-
-export function loadInteraction(id) {
-  const filepath = join(INTERACTIONS_DIR, `${id}.json`);
-  
-  if (!existsSync(filepath)) {
-    throw new Error(`Interaction not found: ${id}`);
-  }
-  
-  const data = readFileSync(filepath, 'utf8');
-  return JSON.parse(data);
-}
-
-export function getAllInteractions() {
-  ensureKirooDir();
-  
-  if (!existsSync(INTERACTIONS_DIR)) {
-    return [];
-  }
-  
-  const files = readdirSync(INTERACTIONS_DIR)
-    .filter(f => f.endsWith('.json'))
-    .sort()
-    .reverse(); // Most recent first
-  
-  return files.map(f => {
-    const filepath = join(INTERACTIONS_DIR, f);
-    const data = readFileSync(filepath, 'utf8');
-    return JSON.parse(data);
-  });
-}
-
-export function saveSnapshotData(tag, data) {
-  ensureKirooDir();
-  
-  const filename = `${tag}.json`;
-  const filepath = join(SNAPSHOTS_DIR, filename);
-  
-  writeFileSync(filepath, JSON.stringify(data, null, 2));
-}
-
-export function loadSnapshotData(tag) {
-  const filepath = join(SNAPSHOTS_DIR, `${tag}.json`);
-  
-  if (!existsSync(filepath)) {
-    throw new Error(`Snapshot not found: ${tag}`);
-  }
-  
-  const data = readFileSync(filepath, 'utf8');
-  return JSON.parse(data);
-}
-
-export function getAllSnapshots() {
-  ensureKirooDir();
-  
-  if (!existsSync(SNAPSHOTS_DIR)) {
-    return [];
-  }
-  
-  return readdirSync(SNAPSHOTS_DIR)
-    .filter(f => f.endsWith('.json'))
-    .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');
-  return JSON.parse(data);
-}
-
-export function saveEnv(data) {
-  ensureKirooDir();
-  writeFileSync(ENV_FILE, JSON.stringify(data, null, 2));
-}
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { sanitizeInteractionRecord } from './sanitizer.js';
+import { loadKirooConfig } from './config.js';
+import { stableJSONStringify } from './deterministic.js';
+
+const KIROO_DIR = '.kiroo';
+const INTERACTIONS_DIR = join(KIROO_DIR, 'interactions');
+const SNAPSHOTS_DIR = join(KIROO_DIR, 'snapshots');
+const ENV_FILE = join(KIROO_DIR, 'env.json');
+
+function getPersistenceSettings() {
+  const config = loadKirooConfig();
+  const redaction = config.settings?.redaction || {};
+  const determinism = config.settings?.determinism || {};
+
+  return {
+    redactEnabled: redaction.enabled !== false,
+    redactedValue: redaction.redactedValue || '<REDACTED>',
+    sortKeys: determinism.sortKeys !== false
+  };
+}
+
+function stringifyForPersistence(value, sortKeysEnabled) {
+  if (sortKeysEnabled) {
+    return stableJSONStringify(value, 2);
+  }
+  return JSON.stringify(value, null, 2);
+}
+
+export function ensureKirooDir() {
+  if (!existsSync(KIROO_DIR)) {
+    mkdirSync(KIROO_DIR);
+  }
+  if (!existsSync(INTERACTIONS_DIR)) {
+    mkdirSync(INTERACTIONS_DIR);
+  }
+  if (!existsSync(SNAPSHOTS_DIR)) {
+    mkdirSync(SNAPSHOTS_DIR);
+  }
+  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) {
+  ensureKirooDir();
+  const settings = getPersistenceSettings();
+  
+  const timestamp = new Date().toISOString();
+  const id = timestamp.replace(/[:.]/g, '-');
+  
+  const interactionData = {
+    id,
+    timestamp,
+    request: {
+      method: interaction.method,
+      url: interaction.url,
+      headers: interaction.headers,
+      body: interaction.body,
+    },
+    response: interaction.response,
+    metadata: {
+      duration_ms: interaction.duration,
+      saves: interaction.saves || [], // Variables saved from this response
+      uses: interaction.uses || [],   // Variables used in this request
+    },
+  };
+
+  const sanitizedInteractionData = sanitizeInteractionRecord(interactionData, {
+    enabled: settings.redactEnabled,
+    redactedValue: settings.redactedValue
+  });
+
+  const filename = `${id}.json`;
+  const filepath = join(INTERACTIONS_DIR, filename);
+  
+  writeFileSync(filepath, stringifyForPersistence(sanitizedInteractionData, settings.sortKeys));
+  
+  return id;
+}
+
+export function loadInteraction(id) {
+  const filepath = join(INTERACTIONS_DIR, `${id}.json`);
+  
+  if (!existsSync(filepath)) {
+    throw new Error(`Interaction not found: ${id}`);
+  }
+  
+  const data = readFileSync(filepath, 'utf8');
+  return JSON.parse(data);
+}
+
+export function getAllInteractions() {
+  ensureKirooDir();
+  
+  if (!existsSync(INTERACTIONS_DIR)) {
+    return [];
+  }
+  
+  const files = readdirSync(INTERACTIONS_DIR)
+    .filter(f => f.endsWith('.json'))
+    .sort()
+    .reverse(); // Most recent first
+  
+  return files.map(f => {
+    const filepath = join(INTERACTIONS_DIR, f);
+    const data = readFileSync(filepath, 'utf8');
+    return JSON.parse(data);
+  });
+}
+
+export function saveSnapshotData(tag, data) {
+  ensureKirooDir();
+  const settings = getPersistenceSettings();
+  
+  const filename = `${tag}.json`;
+  const filepath = join(SNAPSHOTS_DIR, filename);
+  const sanitizedSnapshot = sanitizeInteractionRecord(data, {
+    enabled: settings.redactEnabled,
+    redactedValue: settings.redactedValue
+  });
+  
+  writeFileSync(filepath, stringifyForPersistence(sanitizedSnapshot, settings.sortKeys));
+}
+
+export function loadSnapshotData(tag) {
+  const filepath = join(SNAPSHOTS_DIR, `${tag}.json`);
+  
+  if (!existsSync(filepath)) {
+    throw new Error(`Snapshot not found: ${tag}`);
+  }
+  
+  const data = readFileSync(filepath, 'utf8');
+  return JSON.parse(data);
+}
+
+export function getAllSnapshots() {
+  ensureKirooDir();
+  
+  if (!existsSync(SNAPSHOTS_DIR)) {
+    return [];
+  }
+  
+  return readdirSync(SNAPSHOTS_DIR)
+    .filter(f => f.endsWith('.json'))
+    .sort((a, b) => a.localeCompare(b))
+    .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 });
+    });
+  }
+}
+
+function scrubDirectory(directoryPath, { dryRun = false } = {}) {
+  const settings = getPersistenceSettings();
+
+  if (!existsSync(directoryPath)) {
+    return { scanned: 0, updated: 0 };
+  }
+
+  const files = readdirSync(directoryPath).filter((f) => f.endsWith('.json'));
+  let updated = 0;
+
+  for (const fileName of files) {
+    const filePath = join(directoryPath, fileName);
+    const originalRaw = readFileSync(filePath, 'utf8');
+    const originalData = JSON.parse(originalRaw);
+    const sanitizedData = sanitizeInteractionRecord(originalData, {
+      enabled: settings.redactEnabled,
+      redactedValue: settings.redactedValue
+    });
+    const sanitizedRaw = stringifyForPersistence(sanitizedData, settings.sortKeys);
+
+    if (originalRaw !== sanitizedRaw) {
+      updated += 1;
+      if (!dryRun) {
+        writeFileSync(filePath, sanitizedRaw);
+      }
+    }
+  }
+
+  return { scanned: files.length, updated };
+}
+
+export function scrubStoredData(options = {}) {
+  ensureKirooDir();
+  const { dryRun = false } = options;
+
+  const interactions = scrubDirectory(INTERACTIONS_DIR, { dryRun });
+  const snapshots = scrubDirectory(SNAPSHOTS_DIR, { dryRun });
+
+  return {
+    interactions,
+    snapshots,
+    totalUpdated: interactions.updated + snapshots.updated,
+    dryRun,
+  };
+}
+
+export function loadEnv() {
+  ensureKirooDir();
+  const data = readFileSync(ENV_FILE, 'utf8');
+  return JSON.parse(data);
+}
+
+export function saveEnv(data) {
+  ensureKirooDir();
+  const settings = getPersistenceSettings();
+  writeFileSync(ENV_FILE, stringifyForPersistence(data, settings.sortKeys));
+}