codex-genesis-harness 0.1.4 → 0.1.6

package/scripts/contract_integrity_gate.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+/**
+ * AST Contract-Code Integrity Gate
+ * Part of Genesis Codex Harness v0.1.8
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function printUsage() {
+  console.log('Usage:');
+  console.log('  node scripts/contract_integrity_gate.js --code <code-file-path> --contract <response-json-path>');
+  process.exit(1);
+}
+
+const args = process.argv.slice(2);
+const codeIndex = args.indexOf('--code');
+const contractIndex = args.indexOf('--contract');
+
+if (codeIndex === -1 || contractIndex === -1 || !args[codeIndex + 1] || !args[contractIndex + 1]) {
+  printUsage();
+}
+
+const codePath = path.resolve(process.cwd(), args[codeIndex + 1]);
+const contractPath = path.resolve(process.cwd(), args[contractIndex + 1]);
+
+if (!fs.existsSync(codePath)) {
+  console.error(`Error: Source code file does not exist at: ${codePath}`);
+  process.exit(1);
+}
+
+if (!fs.existsSync(contractPath)) {
+  console.error(`Error: Contract JSON file does not exist at: ${contractPath}`);
+  process.exit(1);
+}
+
+// 1. Parse Contract JSON Schema
+let contractSchema = {};
+try {
+  contractSchema = JSON.parse(fs.readFileSync(contractPath, 'utf8'));
+} catch (err) {
+  console.error(`[ERROR] Failed to parse JSON contract:`, err.message);
+  process.exit(1);
+}
+
+const properties = contractSchema.properties || {};
+const requiredFields = contractSchema.required || Object.keys(properties);
+
+// 2. Parse Source Code File (Static scan)
+const codeContent = fs.readFileSync(codePath, 'utf8');
+
+console.log(`[Integrity Gate] Auditing static code alignment:`);
+console.log(`  - Code file: ${path.basename(codePath)}`);
+console.log(`  - Contract: ${path.basename(contractPath)}`);
+
+let integrityFailed = false;
+const missingFields = [];
+
+// For each required field in the contract, verify its presence inside the code
+for (const field of requiredFields) {
+  // Use a simple, robust regex to match field names in common object/JSON structures
+  // Matches: "field", 'field', field:, field =
+  const fieldRegex = new RegExp(`['"]?${field}['"]?\\s*[:=]`, 'g');
+  
+  if (!fieldRegex.test(codeContent)) {
+    missingFields.push(field);
+    integrityFailed = true;
+  }
+}
+
+if (integrityFailed) {
+  console.error(`\n❌ [INTEGRITY FAILURE] [STATIC ALIGNMENT DRIFT]`);
+  console.error(`  The source code file is missing implementations/properties for the following required contract fields:`);
+  for (const field of missingFields) {
+    console.error(`  - Missing property: "${field}" (Expected type: "${properties[field]?.type || 'any'}")`);
+  }
+  console.error(`  Transition Blocked. Please align your source implementation with the API contracts.`);
+  process.exit(1);
+} else {
+  console.log(`\n✅ [INTEGRITY SUCCESS] Code matches all ${requiredFields.length} required fields from contract.`);
+  process.exit(0);
+}

package/scripts/healing_telemetry.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+/**
+ * Healing Telemetry & Lessons-Learned System
+ * Part of Genesis Codex Harness v0.1.8
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function printUsage() {
+  console.log('Usage:');
+  console.log('  node scripts/healing_telemetry.js --record --error "<error>" --file "<file>" --fix "<fix-desc>"');
+  console.log('  node scripts/healing_telemetry.js --recall --error "<error>"');
+  process.exit(1);
+}
+
+const args = process.argv.slice(2);
+const recordMode = args.includes('--record');
+const recallMode = args.includes('--recall');
+
+if (!recordMode && !recallMode) {
+  printUsage();
+}
+
+const LESSONS_PATH = path.resolve(process.cwd(), '.codebase/failures/lessons_learned.md');
+
+// Helper to sanitize text for markdown table/list compatibility
+const sanitize = (text) => text.replace(/[\n\r]/g, ' ').replace(/\|/g, '\\|').trim();
+
+// 1. Record Mode
+if (recordMode) {
+  const errorIndex = args.indexOf('--error');
+  const fileIndex = args.indexOf('--file');
+  const fixIndex = args.indexOf('--fix');
+
+  if (errorIndex === -1 || fileIndex === -1 || fixIndex === -1 || !args[errorIndex + 1] || !args[fileIndex + 1] || !args[fixIndex + 1]) {
+    printUsage();
+  }
+
+  const error = args[errorIndex + 1];
+  const file = args[fileIndex + 1];
+  const fix = args[fixIndex + 1];
+
+  console.log(`[Healing Telemetry] Recording lessons-learned telemetry entry...`);
+
+  // Ensure directories exist
+  fs.mkdirSync(path.dirname(LESSONS_PATH), { recursive: true });
+
+  let header = '';
+  if (!fs.existsSync(LESSONS_PATH)) {
+    header = `# Self-Healing Lessons Learned Database\n\nThis file persists recorded error-fix telemetry signatures to facilitate immediate 1-turn recovery.\n\n| Timestamp | Target File | Error Signature | Remedial Fix Applied |\n| :--- | :--- | :--- | :--- |\n`;
+  }
+
+  const timestamp = new Date().toISOString().replace('T', ' ').substring(0, 19);
+  const rowEntry = `| ${timestamp} | ${sanitize(file)} | ${sanitize(error)} | ${sanitize(fix)} |\n`;
+
+  fs.appendFileSync(LESSONS_PATH, header + rowEntry, 'utf8');
+  console.log(`✓ Telemetry successfully recorded inside lessons_learned.md`);
+  process.exit(0);
+}
+
+// 2. Recall Mode
+if (recallMode) {
+  const errorIndex = args.indexOf('--error');
+  if (errorIndex === -1 || !args[errorIndex + 1]) {
+    printUsage();
+  }
+
+  const queryError = args[errorIndex + 1].toLowerCase();
+  console.log(`[Healing Telemetry] Querying telemetry for: "${queryError}"`);
+
+  if (!fs.existsSync(LESSONS_PATH)) {
+    console.log('No telemetry lessons-learned database available yet. Proceeding with standard healing.');
+    process.exit(0);
+  }
+
+  const content = fs.readFileSync(LESSONS_PATH, 'utf8');
+  const lines = content.split('\n');
+
+  let matchFound = false;
+  let bestMatch = null;
+
+  for (const line of lines) {
+    if (!line.startsWith('|') || line.includes('Timestamp') || line.includes(':---')) continue;
+
+    const parts = line.split('|').map(p => p.trim());
+    if (parts.length >= 5) {
+      const errorSignature = parts[3].toLowerCase();
+      const refactoringFix = parts[4];
+
+      // Simple keyword intersection/substring search
+      if (queryError.includes(errorSignature) || errorSignature.includes(queryError)) {
+        bestMatch = {
+          file: parts[2],
+          signature: parts[3],
+          fix: refactoringFix
+        };
+        matchFound = true;
+        break; // Return first closest match
+      }
+    }
+  }
+
+  if (matchFound && bestMatch) {
+    console.log(`\n🎯 [RECALL MATCH FOUND] [1-TURN RECOVERY SUGGESTION]:`);
+    console.log(`  - Target file: ${bestMatch.file}`);
+    console.log(`  - Signature matched: "${bestMatch.signature}"`);
+    console.log(`  - Recommended Fix: ${bestMatch.fix}`);
+    
+    // Output key snippet directly for script parsing/AI intake
+    console.log(`\nSUGGESTED_FIX_START: ${bestMatch.fix} :SUGGESTED_FIX_END`);
+    process.exit(0);
+  } else {
+    console.log('No matching error-fix signature found. Defaulting to general code analysis.');
+    process.exit(0);
+  }
+}

package/scripts/install.sh

@@ -8,6 +8,7 @@ skill_names=(
   genesis-upgrade-design
   genesis-architecture
   genesis-planning
+  genesis-mvp-planning
   genesis-codebase-map
   genesis-design-spec
   genesis-api-contract
@@ -79,7 +80,9 @@ install_one() {
     local target_dir="$target_root/$skill_name"
 
     if [ -e "$target_dir" ]; then
-      backup_dir="${target_dir}.backup.$(date +%Y%m%d%H%M%S)"
+      local backup_parent="$(dirname "$target_root")/backups"
+      mkdir -p "$backup_parent"
+      backup_dir="${backup_parent}/${skill_name}.backup.$(date +%Y%m%d%H%M%S)"
       mv "$target_dir" "$backup_dir"
       echo "Existing skill backed up to: $backup_dir"
     fi

package/scripts/prompt_sentinel.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-emptive Prompt Sentinel
+ * Part of Genesis Codex Harness v0.1.7
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function printUsage() {
+  console.log('Usage:');
+  console.log('  node scripts/prompt_sentinel.js --check <file-or-log-path> [--threshold <tokens>]');
+  process.exit(1);
+}
+
+const args = process.argv.slice(2);
+if (args.length < 2 || args[0] !== '--check') {
+  printUsage();
+}
+
+const targetPath = path.resolve(process.cwd(), args[1]);
+let threshold = 20000; // Default safety threshold is 20k tokens
+
+const thresholdIndex = args.indexOf('--threshold');
+if (thresholdIndex !== -1 && args[thresholdIndex + 1]) {
+  threshold = parseInt(args[thresholdIndex + 1], 10);
+}
+
+if (!fs.existsSync(targetPath)) {
+  console.error(`Target file/log does not exist: ${targetPath}`);
+  process.exit(1);
+}
+
+const stats = fs.statSync(targetPath);
+const fileSizeChars = stats.size;
+const estimatedTokens = Math.ceil(fileSizeChars / 4);
+
+console.log(`[Prompt Sentinel] Evaluating token load for: ${path.basename(targetPath)}`);
+console.log(`  - File size: ${fileSizeChars} characters`);
+console.log(`  - Estimated token payload: ${estimatedTokens} tokens (Safety threshold: ${threshold})`);
+
+if (estimatedTokens > threshold) {
+  console.warn(`\n[WARNING] [PROMPT SENTINEL] Payload of ${estimatedTokens} tokens exceeds the safety threshold of ${threshold}!`);
+  console.warn(`[WARNING] Risk of context rot, model amnesia, and high API billing costs detected.`);
+  console.warn(`[ACTION] Automatically triggering context compaction and log optimization...\n`);
+
+  // Trigger compact-context script if it exists
+  const compactionScript = path.resolve(process.cwd(), 'scripts/compact-context.sh');
+  if (fs.existsSync(compactionScript)) {
+    try {
+      console.log(`Executing: ${compactionScript}`);
+      const output = execSync(`bash "${compactionScript}"`, { encoding: 'utf8' });
+      console.log(output);
+      console.log(`[Prompt Sentinel] Context compaction successfully executed. ✓`);
+    } catch (err) {
+      console.error(`[ERROR] Failed to execute context compaction:`, err.message);
+    }
+  } else {
+    console.warn(`[WARNING] Compaction script not found at ${compactionScript}. Skipping auto-compaction.`);
+  }
+
+  // Pre-emptively truncate the bloated log file to keep the window safe
+  try {
+    const fileContent = fs.readFileSync(targetPath, 'utf8');
+    // Keep only the first 500 lines and last 500 lines of the file, strip the rest
+    const lines = fileContent.split('\n');
+    if (lines.length > 1000) {
+      const truncatedContent = [
+        ...lines.slice(0, 500),
+        `\n... [PROMPT SENTINEL AUTO-TRUNCATION: Stript ${lines.length - 1000} lines of redundant log data to protect token bounds] ...\n`,
+        ...lines.slice(-500)
+      ].join('\n');
+      
+      fs.writeFileSync(targetPath, truncatedContent, 'utf8');
+      console.log(`[Prompt Sentinel] Bloated file truncated successfully to safeguard token bounds. ✓`);
+    }
+  } catch (err) {
+    console.error(`[ERROR] Failed to truncate target file:`, err.message);
+  }
+} else {
+  console.log(`✓ [Prompt Sentinel] Token payload is within safe boundaries. No action required.`);
+}

package/scripts/run-evals.sh

@@ -10,6 +10,7 @@ skill_names=(
   genesis-upgrade-design
   genesis-architecture
   genesis-planning
+  genesis-mvp-planning
   genesis-codebase-map
   genesis-design-spec
   genesis-api-contract

package/scripts/run-verify-loop.sh

@@ -54,6 +54,12 @@ if [ "$CURRENT_ITERATION" -gt "$MAX_ITERATIONS" ]; then
   exit 99
 fi
 
+# Recall prior lessons learned if there was a previous failure log
+if [ -f "$FAILURE_LOG" ]; then
+  echo "==> [HEALING TELEMETRY] Analyzing previous failure logs for matching recorded lessons..."
+  node "$(dirname "$0")/healing_telemetry.js" --recall --error "$(head -n 2 "$FAILURE_LOG" | tr '\n' ' ')" || true
+fi
+
 # Execute verification command
 set +e
 "$@" > "$FAILURE_LOG" 2>&1
@@ -62,6 +68,10 @@ set -e
 
 if [ $EXIT_CODE -eq 0 ]; then
   echo "==> [VERIFY LOOP] Pass! Verification completed successfully."
+  if [ "$CURRENT_ITERATION" -gt 1 ]; then
+    echo "==> [HEALING TELEMETRY] Capturing successful self-healing fix to telemetry database..."
+    node "$(dirname "$0")/healing_telemetry.js" --record --error "Verify command failure" --file "codebase" --fix "Resolved verify check regression at iteration $CURRENT_ITERATION" || true
+  fi
   rm -f "$LOOP_COUNT_FILE"
   rm -f "$FAILURE_LOG"
 else
@@ -73,3 +83,4 @@ else
 fi
 
 exit $EXIT_CODE
+

package/scripts/spec_visual_sync.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+/**
+ * Spec Visual Sync - Bi-directional AST Sync between Mermaid ERD and JSON Contracts
+ * Part of Genesis Codex Harness v0.1.7
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function printUsage() {
+  console.log('Usage:');
+  console.log('  node scripts/spec_visual_sync.js --from-erd    # Sync ERD diagram to API contracts');
+  console.log('  node scripts/spec_visual_sync.js --to-erd      # Sync API contracts to ERD diagram');
+  process.exit(1);
+}
+
+const args = process.argv.slice(2);
+if (args.length !== 1 || (args[0] !== '--from-erd' && args[0] !== '--to-erd')) {
+  printUsage();
+}
+
+const ERD_PATH = path.resolve(process.cwd(), '.planning/diagrams/database-erd.mmd');
+const CONTRACTS_DIR = path.resolve(process.cwd(), 'contracts/api');
+
+// 1. Sync from ERD to API Contracts
+function syncFromErd() {
+  if (!fs.existsSync(ERD_PATH)) {
+    console.error(`ERD file not found at: ${ERD_PATH}`);
+    process.exit(1);
+  }
+
+  const erdContent = fs.readFileSync(ERD_PATH, 'utf8');
+  console.log(`Parsing Mermaid ERD from: ${ERD_PATH}`);
+
+  // Regular expression to parse erDiagram blocks
+  // e.g. ENTITY { type name }
+  const entityRegex = /(\w+)\s*\{\s*([^}]+)\}/g;
+  let match;
+  let parsedEntities = 0;
+
+  while ((match = entityRegex.exec(erdContent)) !== null) {
+    const entityName = match[1].toLowerCase();
+    const fieldsBlock = match[2];
+
+    const properties = {};
+    const required = [];
+
+    // Parse individual fields
+    const fieldLines = fieldsBlock.split('\n');
+    for (let line of fieldLines) {
+      line = line.trim();
+      if (!line || line.startsWith('%%')) continue; // Skip comments/empty
+
+      // Format: <type> <name> "comment" or <type> <name>
+      const parts = line.split(/\s+/);
+      if (parts.length >= 2) {
+        const type = parts[0].toLowerCase();
+        const name = parts[1].replace(/["']/g, ''); // strip quotes
+
+        let schemaType = 'string';
+        if (type.includes('int') || type.includes('number') || type.includes('float')) {
+          schemaType = 'number';
+        } else if (type.includes('bool')) {
+          schemaType = 'boolean';
+        } else if (type.includes('array') || type.includes('list')) {
+          schemaType = 'array';
+        } else if (type.includes('object')) {
+          schemaType = 'object';
+        }
+
+        properties[name] = { type: schemaType };
+        // For simplicity, let's treat id or key fields as required
+        if (name === 'id' || line.includes('PK') || line.includes('FK')) {
+          required.push(name);
+        }
+      }
+    }
+
+    // Build the JSON schema for response.json
+    const schema = {
+      $schema: 'http://json-schema.org/draft-07/schema#',
+      title: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} Contract`,
+      type: 'object',
+      properties: properties,
+      required: required.length > 0 ? required : undefined
+    };
+
+    // Ensure directory exists
+    const entityDir = path.join(CONTRACTS_DIR, entityName);
+    fs.mkdirSync(entityDir, { recursive: true });
+
+    const contractPath = path.join(entityDir, 'response.json');
+    fs.writeFileSync(contractPath, JSON.stringify(schema, null, 2), 'utf8');
+    console.log(`✓ Synchronized contract schema for: ${entityName} -> ${contractPath}`);
+    parsedEntities++;
+  }
+
+  console.log(`Success: Synchronized ${parsedEntities} entities from ERD to Contracts.`);
+}
+
+// 2. Sync from API Contracts to ERD Diagram
+function syncToErd() {
+  if (!fs.existsSync(CONTRACTS_DIR)) {
+    console.error(`Contracts directory not found: ${CONTRACTS_DIR}`);
+    process.exit(1);
+  }
+
+  console.log(`Scanning API contracts under: ${CONTRACTS_DIR}`);
+  const entities = fs.readdirSync(CONTRACTS_DIR);
+  
+  let erdContent = 'erDiagram\n\n';
+  let hasContent = false;
+
+  for (const entity of entities) {
+    const responsePath = path.join(CONTRACTS_DIR, entity, 'response.json');
+    if (!fs.existsSync(responsePath)) continue;
+
+    try {
+      const schema = JSON.parse(fs.readFileSync(responsePath, 'utf8'));
+      const properties = schema.properties || {};
+      
+      const entityUpper = entity.toUpperCase();
+      erdContent += `  ${entityUpper} {\n`;
+
+      for (const [fieldName, fieldMeta] of Object.entries(properties)) {
+        let fieldType = fieldMeta.type || 'string';
+        if (fieldType === 'number') fieldType = 'int';
+        if (fieldType === 'boolean') fieldType = 'bool';
+        
+        erdContent += `    ${fieldType} ${fieldName}\n`;
+      }
+
+      erdContent += `  }\n\n`;
+      hasContent = true;
+    } catch (err) {
+      console.error(`Error parsing contract for ${entity}:`, err.message);
+    }
+  }
+
+  if (!hasContent) {
+    console.log('No valid response.json contracts found to synchronize.');
+    return;
+  }
+
+  // Ensure diagram directory exists
+  fs.mkdirSync(path.dirname(ERD_PATH), { recursive: true });
+  fs.writeFileSync(ERD_PATH, erdContent.trim() + '\n', 'utf8');
+  console.log(`✓ Successfully compiled and synchronized database-erd.mmd: ${ERD_PATH}`);
+}
+
+// Execute core flow
+if (args[0] === '--from-erd') {
+  syncFromErd();
+} else {
+  syncToErd();
+}

package/scripts/test_generator.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+/**
+ * Contract-Driven Test Auto-Generator
+ * Part of Genesis Codex Harness v0.1.7
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function printUsage() {
+  console.log('Usage:');
+  console.log('  node scripts/test_generator.js <endpoint-name>');
+  console.log('Example:');
+  console.log('  node scripts/test_generator.js products');
+  process.exit(1);
+}
+
+const args = process.argv.slice(2);
+if (args.length !== 1) {
+  printUsage();
+}
+
+const endpoint = args[0].toLowerCase();
+const CONTRACT_DIR = path.resolve(process.cwd(), 'contracts/api', endpoint);
+const OUTPUT_DIR = path.resolve(process.cwd(), 'tests/integration');
+
+if (!fs.existsSync(CONTRACT_DIR)) {
+  console.error(`Error: API Contract directory does not exist for: ${endpoint}`);
+  console.error(`Please define contracts at: ${CONTRACT_DIR}`);
+  process.exit(1);
+}
+
+const requestPath = path.join(CONTRACT_DIR, 'request.json');
+const responsePath = path.join(CONTRACT_DIR, 'response.json');
+
+if (!fs.existsSync(responsePath)) {
+  console.error(`Error: Response contract not found: ${responsePath}`);
+  process.exit(1);
+}
+
+// Read and parse response schema/contract
+let schema = {};
+try {
+  schema = JSON.parse(fs.readFileSync(responsePath, 'utf8'));
+} catch (e) {
+  console.error(`Error parsing response.json:`, e.message);
+  process.exit(1);
+}
+
+// Read request sample if available
+let requestSample = '{}';
+if (fs.existsSync(requestPath)) {
+  try {
+    requestSample = fs.readFileSync(requestPath, 'utf8');
+  } catch (e) {}
+}
+
+const properties = schema.properties || {};
+const requiredFields = schema.required || Object.keys(properties);
+
+// Construct test cases content
+let testSuiteCode = `/**
+ * Integration Test for Endpoint: /api/${endpoint}
+ * Automatically generated by Genesis Contract-Driven Test Generator (v0.1.7)
+ * Strictly Enforces TDD Contract Compliance.
+ */
+
+const assert = require('assert');
+
+describe('GET /api/${endpoint} - TDD Contract Compliance Test Suite', () => {
+  
+  it('should respond with 200 OK and match the API response contract keys', async () => {
+    // Mock or execute fetch to the implementation endpoint
+    // In production, replace with real server request:
+    // const res = await fetch('http://localhost:3000/api/${endpoint}');
+    
+    // For TDD skeletal validation, we verify structural alignment
+    const mockResponse = {
+      status: 200,
+      data: ${JSON.stringify(generateMockData(properties), null, 6)}
+    };
+
+    assert.strictEqual(mockResponse.status, 200, 'Response status must be 200 OK');
+    const data = mockResponse.data;
+
+    // Validate presence of required contract keys
+    const requiredKeys = ${JSON.stringify(requiredFields)};
+    for (const key of requiredKeys) {
+      assert.ok(key in data, \`Contract mismatch: Required property "\${key}" is missing from the API response\`);
+    }
+
+    // Validate value types
+`;
+
+for (const [key, meta] of Object.entries(properties)) {
+  const expectedType = meta.type || 'string';
+  testSuiteCode += `    assert.strictEqual(typeof data.${key}, '${expectedType}', 'Property "${key}" must be of type "${expectedType}"');\n`;
+}
+
+testSuiteCode += `  });
+
+  it('should reject invalid or malformed payloads with 400 Bad Request', async () => {
+    const invalidPayload = {}; // Empty payload
+    const mockErrResponse = {
+      status: 400,
+      error: 'Bad Request - Malformed schema structure'
+    };
+
+    assert.strictEqual(mockErrResponse.status, 400, 'Must return 400 Bad Request');
+    assert.ok('error' in mockErrResponse, 'Must contain error message');
+  });
+});
+`;
+
+// Ensure output tests directory exists
+fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+const outputFilePath = path.join(OUTPUT_DIR, `${endpoint}.test.js`);
+fs.writeFileSync(outputFilePath, testSuiteCode, 'utf8');
+
+console.log(`✓ Executable TDD Integration Test Suite successfully generated:`);
+console.log(`  -> ${outputFilePath}`);
+
+// Helper to generate mock data from properties
+function generateMockData(props) {
+  const mock = {};
+  for (const [key, val] of Object.entries(props)) {
+    const type = val.type || 'string';
+    if (type === 'number') {
+      mock[key] = 123;
+    } else if (type === 'boolean') {
+      mock[key] = true;
+    } else if (type === 'array') {
+      mock[key] = [];
+    } else if (type === 'object') {
+      mock[key] = {};
+    } else {
+      mock[key] = 'mock_string_value';
+    }
+  }
+  return mock;
+}