kiroo 0.8.0 → 0.9.5

package/src/config.js

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { stableJSONStringify } from './deterministic.js';
+
+const KIROO_DIR = '.kiroo';
+const CONFIG_FILE = join(KIROO_DIR, 'config.json');
+
+const DEFAULT_CONFIG_TEMPLATE = {
+  projectName: 'my-api-project',
+  baseUrl: '',
+  settings: {
+    determinism: {
+      sortKeys: true
+    },
+    redaction: {
+      enabled: true,
+      redactedValue: '<REDACTED>'
+    },
+    analysis: {
+      failOnSeverity: 'none',
+      provider: 'groq',
+      modelPriority: [
+        'qwen/qwen3-32b',
+        'moonshotai/kimi-k2-instruct-0905',
+        'openai/gpt-oss-20b'
+      ],
+      maxCompletionTokens: 900
+    },
+    export: {
+      defaultFormat: 'postman'
+    },
+    ci: {
+      failOnSeverity: 'high'
+    }
+  }
+};
+
+function cloneDefaultConfig() {
+  return JSON.parse(JSON.stringify(DEFAULT_CONFIG_TEMPLATE));
+}
+
+function mergeWithDefaults(defaultObj, currentObj) {
+  if (Array.isArray(defaultObj)) {
+    if (Array.isArray(currentObj)) return currentObj;
+    return [...defaultObj];
+  }
+
+  if (defaultObj && typeof defaultObj === 'object') {
+    const merged = {};
+    const source = currentObj && typeof currentObj === 'object' ? currentObj : {};
+    const keys = new Set([...Object.keys(defaultObj), ...Object.keys(source)]);
+
+    for (const key of keys) {
+      if (key in defaultObj) {
+        merged[key] = mergeWithDefaults(defaultObj[key], source[key]);
+      } else {
+        merged[key] = source[key];
+      }
+    }
+    return merged;
+  }
+
+  return currentObj !== undefined ? currentObj : defaultObj;
+}
+
+function ensureConfigFile() {
+  if (!existsSync(KIROO_DIR)) {
+    mkdirSync(KIROO_DIR);
+  }
+
+  if (!existsSync(CONFIG_FILE)) {
+    const initialConfig = {
+      ...cloneDefaultConfig(),
+      createdAt: new Date().toISOString()
+    };
+    writeFileSync(CONFIG_FILE, stableJSONStringify(initialConfig));
+  }
+}
+
+export function loadKirooConfig() {
+  ensureConfigFile();
+
+  const raw = readFileSync(CONFIG_FILE, 'utf8');
+  const parsed = JSON.parse(raw);
+  const defaults = cloneDefaultConfig();
+  const normalized = mergeWithDefaults(defaults, parsed);
+
+  if (!normalized.createdAt) {
+    normalized.createdAt = new Date().toISOString();
+  }
+
+  const normalizedRaw = stableJSONStringify(normalized);
+  if (normalizedRaw !== raw) {
+    writeFileSync(CONFIG_FILE, normalizedRaw);
+  }
+
+  return normalized;
+}
+
+export function saveKirooConfig(partialConfig = {}) {
+  const current = loadKirooConfig();
+  const merged = mergeWithDefaults(current, partialConfig);
+  writeFileSync(CONFIG_FILE, stableJSONStringify(merged));
+  return merged;
+}
+
+export function getDefaultKirooConfig() {
+  return cloneDefaultConfig();
+}

package/src/deterministic.js

@@ -0,0 +1,22 @@
+function sortObjectKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortObjectKeysDeep(item));
+  }
+
+  if (value && typeof value === 'object') {
+    const sorted = {};
+    const keys = Object.keys(value).sort((a, b) => a.localeCompare(b));
+    for (const key of keys) {
+      sorted[key] = sortObjectKeysDeep(value[key]);
+    }
+    return sorted;
+  }
+
+  return value;
+}
+
+export function stableJSONStringify(value, space = 2) {
+  return JSON.stringify(sortObjectKeysDeep(value), null, space);
+}
+
+export { sortObjectKeysDeep };

package/src/env.js

@@ -1,6 +1,33 @@
 import chalk from 'chalk';
 import Table from 'cli-table3';
 import { loadEnv, saveEnv } from './storage.js';
+import { isSensitiveKey } from './sanitizer.js';
+
+function maskEnvValue(key, value) {
+  if (!isSensitiveKey(key)) {
+    return String(value);
+  }
+
+  const raw = String(value || '');
+  if (raw.length <= 4) {
+    return '<REDACTED>';
+  }
+  return `${raw.slice(0, 2)}***${raw.slice(-2)}`;
+}
+
+export function getCurrentEnvVars() {
+  const env = loadEnv();
+  if (!env.environments[env.current]) {
+    env.environments[env.current] = {};
+    saveEnv(env);
+  }
+  return env.environments[env.current];
+}
+
+export function getEnvVar(key) {
+  const vars = getCurrentEnvVars();
+  return vars[key];
+}
 
 export function listEnv() {
   const env = loadEnv();
@@ -19,8 +46,8 @@ export function listEnv() {
       colWidths: [20, 40]
     });
     
-    Object.entries(currentVars).forEach(([k, v]) => {
-      table.push([chalk.white(k), chalk.gray(String(v))]);
+    Object.entries(currentVars).sort(([a], [b]) => a.localeCompare(b)).forEach(([k, v]) => {
+      table.push([chalk.white(k), chalk.gray(maskEnvValue(k, v))]);
     });
     console.log(table.toString());
   } else {
@@ -49,7 +76,8 @@ export function setVar(key, value) {
   const env = loadEnv();
   env.environments[env.current][key] = value;
   saveEnv(env);
-  console.log(chalk.green(`  ✅ Set ${key}=${value} in`), chalk.white(env.current));
+  const printValue = isSensitiveKey(key) ? '<REDACTED>' : value;
+  console.log(chalk.green(`  ✅ Set ${key}=${printValue} in`), chalk.white(env.current));
 }
 
 export function deleteVar(key) {

package/src/executor.js

@@ -177,7 +177,7 @@ export async function executeRequest(method, url, options = {}) {
     spinner.succeed(chalk.green(`${response.status} ${response.statusText}`) + chalk.gray(` (${duration}ms)`));
 
     // Format and display response
-    console.log(formatResponse(response));
+    console.log(await formatResponse(response, options.lang));
 
     // Handle --save option
     if (options.save) {
@@ -230,6 +230,23 @@ export async function executeRequest(method, url, options = {}) {
       console.error(chalk.red('\n  ✗ Error:'), error.message, '\n');
     }
     
+    // Save failed interaction
+    await saveInteraction({
+      method,
+      url,
+      headers,
+      body,
+      response: {
+        status: 0,
+        statusText: error.code || 'FAILED',
+        headers: {},
+        data: { error: error.message, code: error.code }
+      },
+      duration,
+      saves: [],
+      uses: Array.from(usedKeys)
+    });
+
     process.exit(1);
   }
 }