@veraxhq/verax 0.2.1 → 0.4.0

package/src/verax/scan-summary-writer.js

@@ -15,6 +15,7 @@ export function writeScanSummary(projectDir, url, projectType, learnTruth, obser
   let expectationsSummary = { total: 0, navigation: 0, networkActions: 0, stateActions: 0 };
   if (manifestPath && existsSync(manifestPath)) {
     try {
+  // @ts-expect-error - readFileSync with encoding returns string
       const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
       expectationsSummary = computeExpectationsSummary(manifest);
     } catch (error) {
@@ -34,6 +35,7 @@ export function writeScanSummary(projectDir, url, projectType, learnTruth, obser
     const decisionsPath = resolve(runDirOpt, 'decisions.json');
     if (existsSync(decisionsPath)) {
       try {
+  // @ts-expect-error - readFileSync with encoding returns string
         const decisions = JSON.parse(readFileSync(decisionsPath, 'utf-8'));
         const { DecisionRecorder } = require('./core/determinism-model.js');
         const recorder = DecisionRecorder.fromExport(decisions);

package/src/verax/shared/artifact-manager.js

@@ -14,14 +14,34 @@
 
 import { existsSync, mkdirSync, writeFileSync, appendFileSync } from 'fs';
 import { resolve } from 'path';
-import { randomBytes } from 'crypto';
+import { generateRunId as generateDeterministicRunId } from '../core/run-id.js';
+
+const ZERO_BUDGET = Object.freeze({
+  maxScanDurationMs: 0,
+  maxInteractionsPerPage: 0,
+  maxUniqueUrls: 0,
+  interactionTimeoutMs: 0,
+  navigationTimeoutMs: 0,
+});
 
 /**
  * Generate a unique run ID.
  * @returns {string} - 8-character hex ID
  */
-export function generateRunId() {
-  return randomBytes(4).toString('hex');
+export function generateRunId(seed = 'about:blank') {
+  let baseOrigin = 'about:blank';
+  try {
+    baseOrigin = new URL(seed).origin;
+  } catch {
+    baseOrigin = seed;
+  }
+  return generateDeterministicRunId({
+    url: seed,
+    safetyFlags: {},
+    baseOrigin,
+    scanBudget: ZERO_BUDGET,
+    manifestPath: null,
+  });
 }
 
 /**
@@ -30,8 +50,8 @@ export function generateRunId() {
  * @param {string} runId - Run identifier
  * @returns {Object} - Paths to each artifact location
  */
-export function initArtifactPaths(projectRoot, runId = null) {
-  const id = runId || generateRunId();
+export function initArtifactPaths(projectRoot, runId = null, seed = projectRoot) {
+  const id = runId || generateRunId(seed);
   const runDir = resolve(projectRoot, '.verax', 'runs', id);
 
   const paths = {

package/src/verax/shared/caching.js

@@ -50,6 +50,7 @@ export function computeCacheKey(projectRoot, tsconfigPath, sourceFiles = []) {
     }
   }
 
+  // @ts-expect-error - digest returns string
   return hash.digest('hex').substring(0, 16); // Use first 16 chars for brevity
 }
 

package/src/verax/shared/css-spinner-rules.js

@@ -0,0 +1,204 @@
+/**
+ * CSS SPINNER DETECTION RULES
+ * 
+ * Truth boundary for detecting CSS-only loading indicators (spinners)
+ * without semantic attributes (aria-busy, data-loading, role).
+ * 
+ * Hard rules encoded as constants and predicates. No prose, only code.
+ */
+
+/**
+ * Reason codes for CSS spinner detection decisions
+ */
+export const CSS_SPINNER_REASON_CODES = {
+  DETECTED_BORDER_SPINNER: 'UI_CSS_SPINNER_DETECTED_BORDER',
+  DETECTED_ROTATION_ANIMATION: 'UI_CSS_SPINNER_DETECTED_ROTATION',
+  DETECTED_PULSE_ANIMATION: 'UI_CSS_SPINNER_DETECTED_PULSE',
+  REJECTED_DECORATIVE: 'UI_CSS_SPINNER_REJECTED_DECORATIVE',
+  REJECTED_TOO_LARGE: 'UI_CSS_SPINNER_REJECTED_TOO_LARGE',
+  REJECTED_ALWAYS_PRESENT: 'UI_CSS_SPINNER_REJECTED_ALWAYS_PRESENT',
+  REJECTED_NO_CORROBORATION: 'UI_CSS_SPINNER_REJECTED_NO_CORROBORATION',
+  REJECTED_TIMING_WINDOW: 'UI_CSS_SPINNER_TIMED',
+  ACCEPTED_WITH_CORROBORATION: 'UI_CSS_SPINNER_ACCEPTED_WITH_CORROBORATION'
+};
+
+/**
+ * Maximum size for a spinner element (in pixels)
+ * Larger elements are likely decorative, not loading indicators
+ */
+export const MAX_SPINNER_SIZE = 100; // pixels (width or height)
+
+/**
+ * Minimum size for a spinner element (in pixels)
+ * Very small elements might be decorative dots
+ */
+export const MIN_SPINNER_SIZE = 8; // pixels
+
+/**
+ * Timing window for spinner appearance (milliseconds)
+ * Spinner must appear within this window after interaction to count as loading feedback
+ */
+export const SPINNER_TIMING_WINDOW_MS = 2000; // 2 seconds
+
+/**
+ * Check if an element has border-based spinner pattern
+ * Pattern: border + border-top (or border-left) with different color, creating circular spinner
+ * 
+ * @param {Object} computedStyle - Computed style object
+ * @returns {boolean}
+ */
+export function isBorderSpinnerPattern(computedStyle) {
+  if (!computedStyle) return false;
+  
+  const borderWidth = parseFloat(computedStyle.borderWidth) || 0;
+  const borderTopWidth = parseFloat(computedStyle.borderTopWidth) || 0;
+  const borderLeftWidth = parseFloat(computedStyle.borderLeftWidth) || 0;
+  
+  // Must have border
+  if (borderWidth < 2 && borderTopWidth < 2 && borderLeftWidth < 2) {
+    return false;
+  }
+  
+  // Check for different border colors (spinner pattern)
+  const borderColor = computedStyle.borderColor || '';
+  const borderTopColor = computedStyle.borderTopColor || '';
+  const borderLeftColor = computedStyle.borderLeftColor || '';
+  
+  // Border-top or border-left should have different color than main border
+  const hasDifferentTopColor = borderTopColor && borderColor && borderTopColor !== borderColor && borderTopColor !== 'rgba(0, 0, 0, 0)';
+  const hasDifferentLeftColor = borderLeftColor && borderColor && borderLeftColor !== borderColor && borderLeftColor !== 'rgba(0, 0, 0, 0)';
+  
+  // Check for circular shape (border-radius >= 50%)
+  const borderRadius = computedStyle.borderRadius || '';
+  const isCircular = borderRadius.includes('50%') || borderRadius.includes('999') || parseFloat(borderRadius) > 20;
+  
+  return (hasDifferentTopColor || hasDifferentLeftColor) && isCircular;
+}
+
+/**
+ * Check if an element has rotation animation
+ * Pattern: animation-name includes rotation, or transform: rotate() in keyframes
+ * 
+ * @param {Object} computedStyle - Computed style object
+ * @param {Object} element - DOM element
+ * @returns {boolean}
+ */
+export function isRotationAnimation(computedStyle, element) {
+  if (!computedStyle || !element) return false;
+  
+  const animationName = computedStyle.animationName || '';
+  const animation = computedStyle.animation || '';
+  
+  // Check animation name for spinner-related keywords (but don't rely only on names)
+  const spinnerKeywords = ['spin', 'rotate', 'loading', 'loader'];
+  const hasSpinnerKeyword = spinnerKeywords.some(keyword => 
+    animationName.toLowerCase().includes(keyword) || animation.toLowerCase().includes(keyword)
+  );
+  
+  // Check for transform: rotate() in computed style (indicates rotation)
+  const transform = computedStyle.transform || '';
+  const hasRotation = transform.includes('rotate');
+  
+  // Check for animation-duration (must be animated)
+  const animationDuration = computedStyle.animationDuration || '';
+  const isAnimated = animationDuration && animationDuration !== '0s' && !animationDuration.includes('none');
+  
+  // Must have rotation AND be animated
+  return (hasRotation || hasSpinnerKeyword) && isAnimated;
+}
+
+/**
+ * Check if an element has pulse animation (opacity or scale pulsing)
+ * Pattern: animation that changes opacity or scale repeatedly
+ * 
+ * @param {Object} computedStyle - Computed style object
+ * @returns {boolean}
+ */
+export function isPulseAnimation(computedStyle) {
+  if (!computedStyle) return false;
+  
+  const animationName = computedStyle.animationName || '';
+  const animation = computedStyle.animation || '';
+  
+  // Check for pulse-related keywords
+  const pulseKeywords = ['pulse', 'fade', 'loading'];
+  const hasPulseKeyword = pulseKeywords.some(keyword => 
+    animationName.toLowerCase().includes(keyword) || animation.toLowerCase().includes(keyword)
+  );
+  
+  // Check for animation-duration
+  const animationDuration = computedStyle.animationDuration || '';
+  const isAnimated = animationDuration && animationDuration !== '0s' && !animationDuration.includes('none');
+  
+  // Check for opacity animation (common in pulse patterns)
+  const opacity = parseFloat(computedStyle.opacity) || 1;
+  const hasOpacityVariation = opacity < 1; // Partially transparent suggests pulsing
+  
+  return hasPulseKeyword && isAnimated && hasOpacityVariation;
+}
+
+/**
+ * Check if element size is within spinner bounds
+ * 
+ * @param {number} width - Element width in pixels
+ * @param {number} height - Element height in pixels
+ * @returns {boolean}
+ */
+export function isSpinnerSize(width, height) {
+  const maxDim = Math.max(width, height);
+  const minDim = Math.min(width, height);
+  
+  // Must be within size bounds
+  if (maxDim > MAX_SPINNER_SIZE || minDim < MIN_SPINNER_SIZE) {
+    return false;
+  }
+  
+  // Should be roughly square (spinners are usually circular/square)
+  const aspectRatio = maxDim / (minDim || 1);
+  return aspectRatio <= 2.0; // Allow some rectangular tolerance
+}
+
+/**
+ * Check if spinner appeared within timing window
+ * 
+ * @param {number} appearanceTime - Time when spinner appeared (ms since epoch)
+ * @param {number} interactionTime - Time when interaction occurred (ms since epoch)
+ * @returns {boolean}
+ */
+export function isWithinTimingWindow(appearanceTime, interactionTime) {
+  if (!appearanceTime || !interactionTime) return false;
+  const timeDiff = appearanceTime - interactionTime;
+  return timeDiff >= 0 && timeDiff <= SPINNER_TIMING_WINDOW_MS;
+}
+
+/**
+ * Check if element is likely decorative (always present, large, not near interaction)
+ * 
+ * @param {Object} element - DOM element
+ * @param {Object} computedStyle - Computed style object
+ * @param {boolean} wasPresentBefore - Whether element existed before interaction
+ * @returns {boolean}
+ */
+export function isDecorativeElement(element, computedStyle, wasPresentBefore) {
+  if (!element || !computedStyle) return false;
+  
+  // If element was always present, likely decorative
+  if (wasPresentBefore) {
+    return true;
+  }
+  
+  // Check size
+  const width = element.offsetWidth || 0;
+  const height = element.offsetHeight || 0;
+  if (!isSpinnerSize(width, height)) {
+    return true;
+  }
+  
+  // Check if element is very large (likely decorative)
+  if (width > MAX_SPINNER_SIZE || height > MAX_SPINNER_SIZE) {
+    return true;
+  }
+  
+  return false;
+}
+

package/src/verax/shared/expectation-tracker.js

@@ -26,6 +26,7 @@ export function generateExpectationId(expectation, type) {
   
   // Generate stable 8-character hex hash
   const hash = createHash('sha256').update(hashInput).digest('hex');
+  // @ts-expect-error - digest returns string
   return hash.substring(0, 8);
 }
 

package/src/verax/shared/view-switch-rules.js

@@ -0,0 +1,208 @@
+/**
+ * TRUTH BOUNDARY: State-Driven Navigation / View Switch Detection Rules
+ * 
+ * Hard rules encoded as constants and predicates. No prose, only code.
+ */
+
+/**
+ * Detectable view switch function name patterns (strict allowlist)
+ * Only literal string/number arguments are accepted.
+ */
+export const VIEW_SWITCH_FUNCTION_PATTERNS = {
+  // React setState patterns
+  react: [
+    /^setView$/i,
+    /^setPage$/i,
+    /^setStep$/i,
+    /^setScreen$/i,
+    /^setTab$/i,
+    /^setModalOpen$/i,
+    /^setDrawerOpen$/i,
+    /^setPanelOpen$/i,
+    /^setActiveTab$/i,
+    /^setActiveView$/i,
+    /^setCurrentStep$/i,
+    /^setCurrentPage$/i,
+    /^setCurrentScreen$/i,
+    /^setCurrentView$/i,
+    /^setShowModal$/i,
+    /^setShowDrawer$/i,
+    /^setShowPanel$/i,
+    /^setIsModalOpen$/i,
+    /^setIsDrawerOpen$/i,
+    /^setIsPanelOpen$/i
+  ],
+  
+  // Redux dispatch action types
+  redux: [
+    /^NAVIGATE$/i,
+    /^SET_VIEW$/i,
+    /^SET_STEP$/i,
+    /^SET_PAGE$/i,
+    /^SET_SCREEN$/i,
+    /^SET_TAB$/i,
+    /^OPEN_MODAL$/i,
+    /^CLOSE_MODAL$/i,
+    /^OPEN_DRAWER$/i,
+    /^CLOSE_DRAWER$/i,
+    /^OPEN_PANEL$/i,
+    /^CLOSE_PANEL$/i,
+    /^SWITCH_VIEW$/i,
+    /^SWITCH_TAB$/i,
+    /^SWITCH_STEP$/i
+  ],
+  
+  // Generic function call patterns
+  generic: [
+    /^showModal$/i,
+    /^hideModal$/i,
+    /^openDrawer$/i,
+    /^closeDrawer$/i,
+    /^openPanel$/i,
+    /^closePanel$/i,
+    /^switchView$/i,
+    /^switchTab$/i,
+    /^switchStep$/i,
+    /^navigateTo$/i,
+    /^goToView$/i,
+    /^goToStep$/i,
+    /^goToPage$/i,
+    /^goToScreen$/i
+  ]
+};
+
+/**
+ * View switch kinds (categories)
+ */
+export const VIEW_SWITCH_KINDS = {
+  TAB: 'tab',
+  VIEW: 'view',
+  MODAL: 'modal',
+  DRAWER: 'drawer',
+  PANEL: 'panel',
+  STEP: 'step',
+  SCREEN: 'screen',
+  PAGE: 'page'
+};
+
+/**
+ * Reason codes for truth boundary decisions
+ */
+export const VIEW_SWITCH_REASON_CODES = {
+  DETECTABLE_LITERAL_ARG: 'DETECTABLE_LITERAL_ARG',
+  REJECTED_COMPLEX_EXPRESSION: 'REJECTED_COMPLEX_EXPRESSION',
+  REJECTED_DYNAMIC_VALUE: 'REJECTED_DYNAMIC_VALUE',
+  REJECTED_MEMBER_EXPRESSION: 'REJECTED_MEMBER_EXPRESSION',
+  REJECTED_FUNCTION_CALL: 'REJECTED_FUNCTION_CALL',
+  REJECTED_NOT_IN_ALLOWLIST: 'REJECTED_NOT_IN_ALLOWLIST',
+  ACCEPTED_STRING_LITERAL: 'ACCEPTED_STRING_LITERAL',
+  ACCEPTED_NUMBER_LITERAL: 'ACCEPTED_NUMBER_LITERAL'
+};
+
+/**
+ * Check if a function name matches view switch patterns
+ * @param {string} functionName - Function name to check
+ * @returns {Object|null} - { kind, pattern } or null
+ */
+export function isViewSwitchFunction(functionName) {
+  if (!functionName || typeof functionName !== 'string') return null;
+  
+  // Check React patterns
+  for (const pattern of VIEW_SWITCH_FUNCTION_PATTERNS.react) {
+    if (pattern.test(functionName)) {
+      const kind = inferViewSwitchKind(functionName);
+      return { kind, pattern: 'react', functionName };
+    }
+  }
+  
+  // Check Redux patterns
+  for (const pattern of VIEW_SWITCH_FUNCTION_PATTERNS.redux) {
+    if (pattern.test(functionName)) {
+      const kind = inferViewSwitchKind(functionName);
+      return { kind, pattern: 'redux', functionName };
+    }
+  }
+  
+  // Check generic patterns
+  for (const pattern of VIEW_SWITCH_FUNCTION_PATTERNS.generic) {
+    if (pattern.test(functionName)) {
+      const kind = inferViewSwitchKind(functionName);
+      return { kind, pattern: 'generic', functionName };
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Infer view switch kind from function name
+ * @param {string} functionName - Function name
+ * @returns {string} - View switch kind
+ */
+function inferViewSwitchKind(functionName) {
+  const lower = functionName.toLowerCase();
+  
+  if (lower.includes('tab')) return VIEW_SWITCH_KINDS.TAB;
+  if (lower.includes('modal')) return VIEW_SWITCH_KINDS.MODAL;
+  if (lower.includes('drawer')) return VIEW_SWITCH_KINDS.DRAWER;
+  if (lower.includes('panel')) return VIEW_SWITCH_KINDS.PANEL;
+  if (lower.includes('step')) return VIEW_SWITCH_KINDS.STEP;
+  if (lower.includes('screen')) return VIEW_SWITCH_KINDS.SCREEN;
+  if (lower.includes('page')) return VIEW_SWITCH_KINDS.PAGE;
+  if (lower.includes('view')) return VIEW_SWITCH_KINDS.VIEW;
+  
+  return VIEW_SWITCH_KINDS.VIEW; // Default
+}
+
+/**
+ * Check if an AST node is a detectable literal argument
+ * TRUTH BOUNDARY: Only StringLiteral and NumericLiteral are accepted
+ * @param {Object} node - AST node
+ * @returns {Object|null} - { value, reasonCode } or null
+ */
+export function isDetectableLiteralArg(node) {
+  if (!node) return null;
+  
+  // String literal: setView('settings')
+  if (node.type === 'StringLiteral') {
+    return {
+      value: node.value,
+      reasonCode: VIEW_SWITCH_REASON_CODES.ACCEPTED_STRING_LITERAL
+    };
+  }
+  
+  // Number literal: setStep(2)
+  if (node.type === 'NumericLiteral') {
+    return {
+      value: String(node.value),
+      reasonCode: VIEW_SWITCH_REASON_CODES.ACCEPTED_NUMBER_LITERAL
+    };
+  }
+  
+  // Template literal without interpolation: setView(`settings`)
+  if (node.type === 'TemplateLiteral' && node.expressions.length === 0) {
+    const value = node.quasis[0]?.value?.cooked;
+    if (value) {
+      return {
+        value,
+        reasonCode: VIEW_SWITCH_REASON_CODES.ACCEPTED_STRING_LITERAL
+      };
+    }
+  }
+  
+  // REJECTED: Complex expressions
+  if (node.type === 'CallExpression') {
+    return { reasonCode: VIEW_SWITCH_REASON_CODES.REJECTED_FUNCTION_CALL };
+  }
+  
+  if (node.type === 'MemberExpression') {
+    return { reasonCode: VIEW_SWITCH_REASON_CODES.REJECTED_MEMBER_EXPRESSION };
+  }
+  
+  if (node.type === 'Identifier') {
+    return { reasonCode: VIEW_SWITCH_REASON_CODES.REJECTED_DYNAMIC_VALUE };
+  }
+  
+  return { reasonCode: VIEW_SWITCH_REASON_CODES.REJECTED_COMPLEX_EXPRESSION };
+}
+

package/src/verax/shared/zip-artifacts.js

@@ -45,6 +45,7 @@ export async function createArtifactsZip(runDir, outputPath = null) {
     
     // Handle errors
     archive.on('error', (err) => {
+      output.destroy();
       reject(err);
     });
     
@@ -52,6 +53,11 @@ export async function createArtifactsZip(runDir, outputPath = null) {
       resolvePromise(outputPath);
     });
     
+    output.on('error', (err) => {
+      archive.destroy();
+      reject(err);
+    });
+    
     // Pipe archive data to file
     archive.pipe(output);
     

package/src/verax/shared/config-loader.js

@@ -1,169 +0,0 @@
-/**
- * Wave 7 — Config File Support
- * 
- * Loads and validates .verax/config.json configuration file.
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
-
-/**
- * Default config values
- */
-const DEFAULT_CONFIG = {
-  defaultUrl: 'http://localhost:3000',
-  projectRoot: '.',
-  outDir: '.verax/runs',
-  ciDefaults: {
-    json: true,
-    zip: true,
-    explain: false
-  },
-  safety: {
-    allowlistDomains: [],
-    denyKeywords: ['delete', 'remove', 'billing', 'payment']
-  }
-};
-
-/**
- * Validate config structure
- * @param {Object} config - Config object to validate
- * @returns {Object} { valid: boolean, errors: string[] }
- */
-export function validateConfig(config) {
-  const errors = [];
-  
-  if (typeof config !== 'object' || config === null) {
-    errors.push('Config must be an object');
-    return { valid: false, errors };
-  }
-  
-  // Validate defaultUrl
-  if (config.defaultUrl !== undefined) {
-    if (typeof config.defaultUrl !== 'string' || config.defaultUrl.trim() === '') {
-      errors.push('defaultUrl must be a non-empty string');
-    } else {
-      try {
-        new URL(config.defaultUrl);
-      } catch (e) {
-        errors.push(`defaultUrl is not a valid URL: ${config.defaultUrl}`);
-      }
-    }
-  }
-  
-  // Validate projectRoot
-  if (config.projectRoot !== undefined && typeof config.projectRoot !== 'string') {
-    errors.push('projectRoot must be a string');
-  }
-  
-  // Validate outDir
-  if (config.outDir !== undefined && typeof config.outDir !== 'string') {
-    errors.push('outDir must be a string');
-  }
-  
-  // Validate ciDefaults
-  if (config.ciDefaults !== undefined) {
-    if (typeof config.ciDefaults !== 'object' || config.ciDefaults === null) {
-      errors.push('ciDefaults must be an object');
-    } else {
-      if (config.ciDefaults.json !== undefined && typeof config.ciDefaults.json !== 'boolean') {
-        errors.push('ciDefaults.json must be a boolean');
-      }
-      if (config.ciDefaults.zip !== undefined && typeof config.ciDefaults.zip !== 'boolean') {
-        errors.push('ciDefaults.zip must be a boolean');
-      }
-      if (config.ciDefaults.explain !== undefined && typeof config.ciDefaults.explain !== 'boolean') {
-        errors.push('ciDefaults.explain must be a boolean');
-      }
-    }
-  }
-  
-  // Validate safety
-  if (config.safety !== undefined) {
-    if (typeof config.safety !== 'object' || config.safety === null) {
-      errors.push('safety must be an object');
-    } else {
-      if (config.safety.allowlistDomains !== undefined) {
-        if (!Array.isArray(config.safety.allowlistDomains)) {
-          errors.push('safety.allowlistDomains must be an array');
-        } else {
-          for (const domain of config.safety.allowlistDomains) {
-            if (typeof domain !== 'string') {
-              errors.push('safety.allowlistDomains must contain only strings');
-              break;
-            }
-          }
-        }
-      }
-      if (config.safety.denyKeywords !== undefined) {
-        if (!Array.isArray(config.safety.denyKeywords)) {
-          errors.push('safety.denyKeywords must be an array');
-        } else {
-          for (const keyword of config.safety.denyKeywords) {
-            if (typeof keyword !== 'string') {
-              errors.push('safety.denyKeywords must contain only strings');
-              break;
-            }
-          }
-        }
-      }
-    }
-  }
-  
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-
-/**
- * Load config file from project directory
- * @param {string} projectRoot - Project root directory
- * @returns {Object|null} Config object or null if not found
- * @throws {Error} If config file exists but is invalid
- */
-export function loadConfig(projectRoot) {
-  const configPath = resolve(projectRoot, '.verax', 'config.json');
-  
-  if (!existsSync(configPath)) {
-    return null;
-  }
-  
-  try {
-    const content = readFileSync(configPath, 'utf-8');
-    const config = JSON.parse(content);
-    
-    const validation = validateConfig(config);
-    if (!validation.valid) {
-      throw new Error(`Invalid config file: ${validation.errors.join(', ')}`);
-    }
-    
-    // Merge with defaults
-    return {
-      ...DEFAULT_CONFIG,
-      ...config,
-      ciDefaults: {
-        ...DEFAULT_CONFIG.ciDefaults,
-        ...(config.ciDefaults || {})
-      },
-      safety: {
-        ...DEFAULT_CONFIG.safety,
-        ...(config.safety || {})
-      }
-    };
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      throw new Error(`Config file is not valid JSON: ${error.message}`);
-    }
-    throw error;
-  }
-}
-
-/**
- * Get default config (for init)
- * @returns {Object} Default config object
- */
-export function getDefaultConfig() {
-  return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
-}
-