@codeyam/codeyam-cli 0.0.0 → 0.1.0-staging.036391e

package/packages/ai/src/lib/generateStatementAnalysis.js

@@ -0,0 +1,1709 @@
+import completionCall from "./completionCall.js";
+import { saveLlmCall } from "../../../../packages/aws/dynamodb/index.js";
+import generateEntityPropsStructureGenerator from "./promptGenerators/generateEntityPropsStructureGenerator.js";
+import identifyReserved, { ReservedFeature } from "./identifyReserved.js";
+import splitOutsideParentheses from "./splitOutsideParentheses.js";
+import { generateSha, loadStatement, saveStatement } from "../../../../packages/database/index.js";
+import { parseJsonSafe } from "../../../../packages/ai/index.js";
+export default async function generateStatementAnalysis({ entity, scope, issues, model, }) {
+    const sha = generateSha(scope.text);
+    const existingStatement = await loadStatement(sha);
+    if (existingStatement) {
+        const { structure, equivalentVariables } = JSON.parse(existingStatement.results);
+        return { structure, equivalentVariables, sha };
+    }
+    const prompt = generateEntityPropsStructureGenerator({
+        code: scope.text,
+    });
+    const reservedStrategies = identifyReserved(scope.text).map((feature) => feature.toString());
+    const response = await completionCall({
+        type: 'generateStatementAnalysis',
+        systemMessage: SYSTEM_MESSAGE(reservedStrategies),
+        prompt,
+        model,
+    });
+    const llmCall = await saveLlmCall({
+        object_type: 'entity',
+        object_id: entity.sha,
+        propsJson: {
+            entity: {
+                sha: entity.sha,
+                name: entity.name,
+                filePath: entity.filePath,
+                code: entity.code,
+            },
+            scope,
+            model,
+        },
+        ...response.stats,
+    });
+    const { completion: responseString } = response;
+    if (!responseString) {
+        console.log('CodeYam Error: Generating entity variable relations failed: No response from AI');
+        return null;
+    }
+    console.log(`LLMCall ${llmCall ? llmCall.id : 'N/A'}: ${entity.filePath} ${entity.name} scope statement (${scope.name}) :>> `);
+    const parse = (s) => {
+        try {
+            const { structure, equivalentVariables } = parseJsonSafe(s.replace(/await\s+/g, '').replace(/\?/g, ''));
+            return { structure, equivalentVariables };
+        }
+        catch (e) {
+            console.info("CodeYam Error: Couldn't parse response from AI");
+            console.info(scope.text);
+            console.info(response);
+            console.info(e);
+            throw e;
+        }
+    };
+    const { structure, equivalentVariables } = parse(responseString);
+    await saveStatement({
+        sha,
+        llmCallId: llmCall.id,
+        text: scope.text,
+        results: JSON.stringify({ structure, equivalentVariables }, null, 2),
+        issues,
+    });
+    // console.info(prompt);
+    // console.info(SYSTEM_MESSAGE(reservedStrategies));
+    // console.info(scope.text);
+    // console.info({
+    //   reservedStrategies: reservedStrategies.map((s) => ({
+    //     name: s,
+    //     exampleCount: STRATEGIES[s]?.examples?.length ?? 0,
+    //   })),
+    // });
+    for (const keyPath in structure) {
+        const parts = splitOutsideParentheses(keyPath);
+        if (parts[parts.length - 1].match(/\(.*?\)/)) {
+            structure[keyPath] = 'function';
+        }
+        const clean = (s) => s.replace(/\?\./g, '.');
+        const cleanKeyPath = clean(keyPath);
+        if (cleanKeyPath === keyPath)
+            continue;
+        structure[cleanKeyPath] = clean(structure[keyPath]);
+        delete structure[keyPath];
+    }
+    for (const keyPath in equivalentVariables) {
+        const value = equivalentVariables[keyPath];
+        const valueParts = splitOutsideParentheses(value);
+        const lastValue = valueParts[valueParts.length - 1];
+        if (lastValue.match(/\(.*?\)/)) {
+            equivalentVariables[keyPath] = `${value}.functionCallReturnValue`;
+        }
+        const keyPathParts = splitOutsideParentheses(keyPath);
+        const lastKeyPath = keyPathParts[keyPathParts.length - 1];
+        if (lastKeyPath.match(/\(.*?\)/)) {
+            equivalentVariables[`${keyPath}.signature[0]`] =
+                equivalentVariables[keyPath];
+            delete equivalentVariables[keyPath];
+        }
+        if (keyPath.includes('functionCallReturnValue')) {
+            if (!equivalentVariables[equivalentVariables[keyPath]]) {
+                equivalentVariables[equivalentVariables[keyPath]] = keyPath;
+            }
+            delete equivalentVariables[keyPath];
+        }
+    }
+    return { sha, structure, equivalentVariables, llmCall };
+}
+const SYSTEM_MESSAGE = (reservedStrategies) => `Analyze a code snippet to extract:
+
+1. **structure**: The data type of each variable and property path (string, number, boolean, array, object, function, or unknown)
+2. **equivalentVariables**: Assignments between variables, where the key is the target (left side) and value is the source (right side)
+
+## Type Rules
+
+- Use type annotations when available; otherwise infer from context or use "unknown"
+- Non-primitive types are "object"
+- Function calls are "function"
+
+## Equivalency Rules
+
+For assignments like \`const a = b\`, record \`"a": "b"\`.
+
+For destructuring like \`const { x } = obj\`, record \`"x": "obj.x"\`.
+
+For function calls like \`const result = foo(arg)\`:
+- Record \`"result": "foo(arg).functionCallReturnValue"\`
+- Record \`"foo(arg).signature[0]": "arg"\`
+
+For destructured function returns like \`const { data } = foo()\`:
+- Record \`"data": "foo().functionCallReturnValue.data"\`
+
+## Example
+
+\`\`\`typescript
+const { name } = person;
+const result = process(name);
+\`\`\`
+
+\`\`\`json
+{
+  "structure": {
+    "person": "object",
+    "person.name": "string",
+    "name": "string",
+    "process(name)": "function",
+    "result": "unknown"
+  },
+  "equivalentVariables": {
+    "name": "person.name",
+    "process(name).signature[0]": "name",
+    "result": "process(name).functionCallReturnValue"
+  }
+}
+\`\`\`
+${keywords(reservedStrategies)}
+${relevantExamples(reservedStrategies)}
+
+---
+
+Analyze carefully. Missing equivalencies will cause simulation failures.
+`;
+function keywords(reservedStrategies) {
+    const messages = [];
+    for (const strategy of reservedStrategies) {
+        switch (strategy) {
+            case ReservedFeature.FunctionCallWithPositionalArguments:
+            case ReservedFeature.FunctionCallWithPositionalAndNamedArguments:
+                messages.push(`- "signature[n]": The nth argument of a function call. For example, "foo(arg1, arg2)" has "signature[0]" equal to arg1 and "signature[1]" equal to arg2.`);
+                break;
+            case ReservedFeature.FunctionCallWithNamedArguments:
+            case ReservedFeature.FunctionCallWithPositionalAndNamedArguments:
+                messages.push(`- "signature[n].name": A named variable in the nth argument of a function call. For example, "foo({ name, age })" has "signature[0].name" equal to name and "signature[0].age" equal to age.`);
+                break;
+            case ReservedFeature.FunctionWithPositionalArguments:
+            case ReservedFeature.FunctionWithPositionalAndNamedArguments:
+            case ReservedFeature.ArrowFunctionWithPositionalArguments:
+            case ReservedFeature.ArrowFunctionWithPositionalAndNamedArguments:
+                messages.push(`- "signature[n]": The nth argument of a function definition. For example, "(arg1, arg2) => {...}" has arg1 equal to "signature[0]" and "arg2" equal to "signature[1]".`);
+                break;
+            case ReservedFeature.FunctionWithNamedArguments:
+            case ReservedFeature.FunctionWithPositionalAndNamedArguments:
+            case ReservedFeature.FunctionWithComplexNamedArguments:
+            case ReservedFeature.ArrowFunctionWithNamedArguments:
+            case ReservedFeature.ArrowFunctionWithPositionalAndNamedArguments:
+                messages.push(`- "signature[n].name": A named variable in the nth argument of a function definition. For example, "({ arg1, arg2 }) => {...}" has arg1 equal to "signature[0].arg1" and "arg2" equal to "signature[1].arg2".`);
+                break;
+            case ReservedFeature.FunctionCallWithReturnValue:
+                messages.push(`- "functionCallReturnValue": The return value of a function call. For example, "const result = foo(arg1, arg2);" has "result" equal to "foo(arg1, arg2).functionCallReturnValue". The "functionCallReturnValue" is always on the right hand side of the "equivalentVariables" because no data can be assigned to it.`);
+                break;
+            case ReservedFeature.Return:
+                messages.push(`- "returnValue": If this snippet is a return statement then the "returnValue" should be in the "equivalentVariables" section. For example, "return { name, age };" has "returnValue.name" equal to "name" and "returnValue.age" equal to "age".`);
+                break;
+            case ReservedFeature.ReturnValueWithJSX:
+                messages.push(`- "JSX": If this snippet has a return value that is JSX then you can simple label it as JSX (e.g. \`{ "returnValue": "JSX" }\`).`);
+                break;
+        }
+    }
+    if (messages.length === 0)
+        return '';
+    return `
+**Keywords:**
+
+${messages.filter((m, index, self) => self.indexOf(m) === index).join('\n\n')}
+
+`;
+}
+function relevantExamples(reservedStrategies) {
+    if (reservedStrategies.length === 0)
+        reservedStrategies = ['simple'];
+    return `**Relevant Examples**
+
+${reservedStrategies
+        .map((strategy) => {
+        const info = STRATEGIES[strategy];
+        if (!info)
+            return '';
+        return `**${info.name}**
+${info.explanation
+            ? `${info.explanation}
+
+`
+            : ''}
+${info.examples
+            .map((ex, i) => {
+            return `**Example ${i + 1} ${ex.name}:**
+
+\`\`\`typescript
+${ex.code}
+\`\`\`
+
+Response:
+\`\`\`json
+${ex.response}
+\`\`\`
+`;
+        })
+            .join('\n\n')}`;
+    })
+        .join('\n\n')}`;
+}
+const STRATEGIES = {
+    simple: {
+        name: 'Basic Variable Assignment',
+        examples: [
+            {
+                name: 'Simple Assignment',
+                code: `const selectedPerson = person;`,
+                response: `{
+    "structure": {
+      "selectedPerson": "unknown",
+      "person": "unknown"
+    },
+    "equivalentVariables": {
+      "selectedPerson": "person"
+    }
+  }`,
+            },
+            {
+                name: 'Property Assignment',
+                code: `selectedPerson.position = position.name;`,
+                response: `{
+    "structure": {
+      "selectedPerson": "object",
+      "selectedPerson.position": "string",
+      "position": "object",
+      "position.name": "string"
+    },
+    "equivalentVariables": {
+      "selectedPerson.position": "position.name"
+    }
+  }`,
+            },
+            {
+                name: 'Destructuring',
+                code: `const { name, age } = getPerson(personId);`,
+                response: `{
+    "structure": {
+      "personId": "string",
+      "name": "string",
+      "age": "number",
+      "getPerson(personId)": "function"
+    },
+    "equivalentVariables": {
+      "name": "getPerson(personId).functionCallReturnValue.name",
+      "age": "getPerson(personId).functionCallReturnValue.age"
+    }
+  }`,
+            },
+        ],
+    },
+    function: {
+        name: 'Function Definitions',
+        examples: [
+            {
+                name: 'Function Definition',
+                code: `function foo() { /* function body */ }`,
+                response: `{
+    "structure": {},
+    "equivalentVariables": {}
+  }`,
+            },
+        ],
+    },
+    functionWithPositionalArguments: {
+        name: 'Function Definition with Positional Arguments',
+        explanation: 'This snippet is a function definition (the wrapper function) that accepts positional arguments. Please capture the arguments passed into this function.',
+        examples: [
+            {
+                name: 'Function Definition with Positional Arguments',
+                code: `function foo(person, options) { /* function body */ }`,
+                response: `{
+    "structure": {
+      "person": "object",
+      "options": "object"
+    },
+    "equivalentVariables": {
+      "person": "signature[0]",
+      "options": "signature[1]"
+    }
+  }`,
+            },
+        ],
+    },
+    functionWithNamedArguments: {
+        name: 'Function Definition with Named Arguments',
+        examples: [
+            {
+                name: 'Function Definition with Named Arguments',
+                code: `function foo({ name, age }) { /* function body */ }`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number"
+    },
+    "equivalentVariables": {
+      "name": "signature[0].name",
+      "age": "signature[0].age"
+    }
+  }`,
+            },
+            {
+                name: 'Function Definition with Named Argument That Has Type (ignore the type)',
+                code: `function foo({ person }: { person: Person }) { /* function body */ }`,
+                response: `{
+    "structure": {
+      "person": "object"
+    },
+    "equivalentVariables": {
+      "person": "signature[0].person"
+    }
+  }`,
+            },
+            {
+                name: 'Function Definition with Named Array Argument',
+                code: `function foo({ items }: { items: Item[] }) { /* function body */ }`,
+                response: `{
+    "structure": {
+      "items": "array",
+      "items[]": "unknown"
+    },
+    "equivalentVariables": {
+      "items": "signature[0].items"
+    }
+  }`,
+            },
+        ],
+    },
+    functionWithComplexNamedArguments: {
+        name: 'Function Definition with Complex Named Arguments',
+        examples: [
+            {
+                name: 'Function Definition with Named Arguments',
+                code: `function PreviewCard({
+  name,
+  hobbies: { title, category }[],
+  age
+}: {
+  name: string;
+  hobbies: Hobby[];
+  age: number;
+}) { /* function body */ }`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "title": "string",
+      "category": "string",
+      "age": "number"
+    },
+    "equivalentVariables": {
+      "name": "signature[0].name",
+      "title": "signature[0].hobbies.title",
+      "category": "signature[0].hobbies.category",
+      "age": "signature[0].age"
+    }
+  }`,
+            },
+        ],
+    },
+    functionWithPositionalAndNamedArguments: {
+        name: 'Function Definition with Positional and Named Arguments',
+        examples: [
+            {
+                name: 'Function Definition with Positional and Named Arguments',
+                code: `function foo(name, { age, hobbies }) { /* function body */ }`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number",
+      "hobbies": "array"
+    },
+    "equivalentVariables": {
+      "signature[0]": "name",
+      "signature[1].age": "age",
+      "signature[1].hobbies": "hobbies"
+    }
+  }`,
+            },
+        ],
+    },
+    functionCall: {
+        name: 'Function Calls',
+        examples: [
+            {
+                name: 'Function Call No Arguments',
+                code: `foo();`,
+                response: `{
+    "structure": {
+      "foo()": "function"
+    },
+    "equivalentVariables": {}
+  }`,
+            },
+            {
+                name: 'Function Call As An Argument',
+                code: `foo(cyScope2());`,
+                response: `{
+    "structure": {
+      "foo(cyScope2())": "function",
+      "cyScope2()": "function"
+    },
+    "equivalentVariables": {
+      "foo(cyScope2()).signature[0]": "cyScope2().functionCallReturnValue"
+    }
+  }`,
+            },
+        ],
+    },
+    functionCallWithPositionalArguments: {
+        name: 'Function Call with Positional Arguments',
+        explanation: 'There is one or more functions being called in this snippet. Please capture it and its positional arguments. Be sure to differentiate between called functions and a function definition.',
+        examples: [
+            {
+                name: 'Function Call with Positional Arguments',
+                code: `foo(person.name, person.age);`,
+                response: `{
+    "structure": {
+      "person": "object",
+      "person.name": "string",
+      "person.age": "number",
+      "foo(person.name, person.age)": "function"
+    },
+    "equivalentVariables": {
+      "foo(person.name, person.age).signature[0]": "person.name",
+      "foo(person.name, person.age).signature[1]": "person.age"
+    }
+  }`,
+            },
+            {
+                name: 'Function Call with Function Call as a Positional Argument',
+                code: `const biz = baz(cyScope5());`,
+                response: `{
+    "structure": {
+      "cyScope5()": "function",
+      "baz(cyScope5())": "function",
+      "biz": "unknown"
+    },
+    "equivalentVariables": {
+      "baz(cyScope5()).signature[0]": "cyScope5().functionCallReturnValue",
+      "biz": "baz(cyScope5()).functionCallReturnValue"
+    }
+  }`,
+            },
+            {
+                name: 'Function Call with Complex Positional Arguments',
+                code: `const bar = foo(person.name, isSelected(), [group]);`,
+                response: `{
+    "structure": {
+      "person": "object",
+      "person.name": "string",
+      "group": "string",
+      "foo(person.name, isSelected(), [group])": "function",
+      "isSelected()": "function"
+      "bar": "unknown"
+    },
+    "equivalentVariables": {
+      "foo(person.name, isSelected(), [group]).signature[0]": "person.name",
+      "foo(person.name, isSelected(), [group]).signature[1]": "isSelected().functionCallReturnValue",
+      "foo(person.name, isSelected(), [group]).signature[2][0]": "group",
+      "bar": "foo(person.name, isSelected(), [group]).functionCallReturnValue"
+    }
+  }`,
+            },
+        ],
+    },
+    functionCallWithNamedArguments: {
+        name: 'Function Call with Named Arguments',
+        examples: [
+            {
+                name: 'Function Call with Named Arguments',
+                code: `foo({ name, age }) { /* function body */ }`,
+                response: `{
+      "structure": {
+        "name": "string",
+        "age": "number",
+        "foo({ name, age })": "function"
+      },
+      "equivalentVariables": {
+        "foo({ name, age }).signature[0].name": "name",
+        "foo({ name, age }).signature[0].age": "age"
+      }
+    }`,
+            },
+            {
+                name: 'Function Call with Complex Named Arguments',
+                code: `foo({ name, selected: isSelected(), options: { name, dependencies: [group] } }) { /* function body */ }`,
+                response: `{
+      "structure": {
+        "name": "string",
+        "group": "string",
+        "isSelected()": "function",
+        "foo({ name, selected: isSelected(), options: { name, dependencies: [group] } })": "function"  
+      },
+      "equivalentVariables": {
+        "foo({ name, selected: isSelected(), options: { name, dependencies: [group] } }).signature[0].name": "name",
+        "foo({ name, selected: isSelected(), options: { name, dependencies: [group] } }).signature[0].selected": "isSelected().functionCallReturnValue",
+        "foo({ name, selected: isSelected(), options: { name, dependencies: [group] } }).signature[0].options.dependencies[0]": "group"
+      }
+    }`,
+            },
+        ],
+    },
+    functionCallWithPositionalAndNamedArguments: {
+        name: 'Function Call with Positional and Named Arguments',
+        examples: [
+            {
+                name: 'Function Call with Positional and Named Arguments',
+                code: `foo(name, { age, hobbies }) { /* function body */ }`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number",
+      "hobbies": "array",
+      "foo(name, { age, hobbies })": "function"
+    },
+    "equivalentVariables": {
+      "foo(name, { age, hobbies }).signature[0]": "name",
+      "foo(name, { age, hobbies }).signature[1].age": "age",
+      "foo(name, { age, hobbies }).signature[1].hobbies": "hobbies"
+    }
+  }`,
+            },
+        ],
+    },
+    functionCallWithReturnValue: {
+        name: 'Function Call with Return Value',
+        explanation: "Be sure to capture the functionCallReturnValue. It always goes on the right side of the equivalentVariables because it can't be assigned to. You do not need to describe the return value of the function in the structure section. Simply capture its equivalent values in the equivalentVariables section.",
+        examples: [
+            {
+                name: 'Function Call with Return Value',
+                code: `const data = foo(arg1, arg2);`,
+                response: `{
+    "structure": {
+      "data": "unknown",
+      "arg1": "unknown",
+      "arg2": "unknown",
+      "foo(arg1, arg2)": "function"
+    },
+    "equivalentVariables": {
+      "foo(arg1, arg2).signature[0]": "arg1",
+      "foo(arg1, arg2).signature[1]": "arg2",
+      "data": "foo(arg1, arg2).functionCallReturnValue"
+    }
+  };`,
+            },
+            {
+                name: 'Async Function Call with Return Value',
+                code: `const foo = async bar({ selected });`,
+                response: `{
+    "structure": {
+      "foo": "unknown",
+      "selected": "unknown",
+      "bar({ selected })": "function"
+    },
+    "equivalentVariables": {
+      "bar({ selected }).signature[0].selected": "selected",
+      "foo": "bar({ selected }).functionCallReturnValue"
+    }
+  };`,
+            },
+            {
+                name: 'Function Call with Return Value used as Argument',
+                code: `baz({ height: getHeight(), selected: isSelected(person) });`,
+                response: `{
+    "structure": {
+      "person": "object",
+      "getHeight()": "function",
+      "isSelected(person)": "function",
+      "baz({ height: getHeight(), selected: isSelected(person) })": "function"
+    },
+    "equivalentVariables": {
+      "baz({ height: getHeight(), selected: isSelected(person) }).signature[0].height": "getHeight().functionCallReturnValue",
+      "baz({ height: getHeight(), selected: isSelected(person) }).signature[0].selected": "isSelected(person).functionCallReturnValue",
+      "isSelected(person).signature[0]": "person"
+    }
+  };`,
+            },
+        ],
+    },
+    functionCallWithReturnValueObjectDeconstructed: {
+        name: 'Function Call with Deconstructed Return Value',
+        examples: [
+            {
+                name: 'Function Call with Deconstructed Return Value',
+                code: `const { name, age } = foo(arg1);`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number",
+      "foo(arg1)": "function"
+    },
+    "equivalentVariables": {
+      "foo(arg1).signature[0]": "arg1",
+      "name": "foo().functionCallReturnValue.name",
+      "age": "foo().functionCallReturnValue.age"
+    }
+  }`,
+            },
+        ],
+    },
+    functionCallWithReturnValueArrayDeconstructed: {
+        name: 'Function Call with Deconstructed Return Value',
+        examples: [
+            {
+                name: 'Function Call with Deconstructed Return Value',
+                code: `const [name, age] = foo();`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number",
+      "foo()": "function"
+    },
+    "equivalentVariables": {
+      "name": "foo().functionCallReturnValue[0]",
+      "age": "foo().functionCallReturnValue[1]"
+    }
+  }`,
+            },
+        ],
+    },
+    arrowFunction: {
+        name: 'Arrow Function',
+        examples: [
+            {
+                name: 'Arrow Function',
+                code: `const foo = () => { /* function body */ };`,
+                response: `{
+    "structure": {},
+    "equivalentVariables": {}
+  }`,
+            },
+        ],
+    },
+    anonymousArrowFunction: {
+        name: 'Anonymous Arrow Function',
+        explanation: 'This code snippet is an anonymous arrow function. You do not need to record anything about it as it has no arguments.',
+        examples: [
+            {
+                name: 'Anonymous Arrow Function With No Arguments',
+                code: `() => { /* function body */ };`,
+                response: `{
+    "structure": {},
+    "equivalentVariables": {}
+  }`,
+            },
+        ],
+    },
+    anonymousArrowFunctionWithPositionalArguments: {
+        name: 'Anonymous Arrow Function with Positional Arguments',
+        explanation: 'This code snippet is an anonymous arrow function with positional arguments. Be sure to capture the arguments passed into this arrow function.',
+        examples: [
+            {
+                name: 'Anonymous Arrow Function With Positional Arguments',
+                code: `(arg1, arg2) => { /* function body */ };`,
+                response: `{
+    "structure": {
+      "arg1": "unknown",
+      "arg2": "unknown"
+    },
+    "equivalentVariables": {
+      "arg1": "signature[0]",
+      "arg2": "signature[1]" 
+    }
+  }`,
+            },
+        ],
+    },
+    anonymousArrowFunctionWithNamedArguments: {
+        name: 'Anonymous Arrow Function With Named Arguments',
+        explanation: 'This code snippet is an anonymous arrow function with named arguments. Be sure to capture the arguments passed into this arrow function.',
+        examples: [
+            {
+                name: 'Anonymous Arrow Function With Implicit Return Value',
+                code: `({ name, age }) => ({ name, age })`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number"
+    },
+    "equivalentVariables": {
+      "name": "signature[0].name",
+      "age": "signature[0].age",
+      "returnValue.name": "name",
+      "returnValue.age": "age"
+    }
+  }`,
+            },
+        ],
+    },
+    anonymousArrowFunctionWithImplicitJSXReturnValue: {
+        name: 'Anonymous Arrow Function With Implicit JSX Return Value',
+        explanation: 'This code snippet is an anonymous arrow function with an implicit JSX return value. Be sure to capture any arguments passed into the function and note that the return value is JSX.',
+        examples: [
+            {
+                name: 'Anonymous Arrow Function With JSX Return Value',
+                code: `(arg1) => (
+    <Component name={arg1} />
+  )`,
+                response: `{
+    "structure": {
+      "arg1": "string",
+      "Component()": "function"
+    },
+    "equivalentVariables": {
+      "arg1": "signature[0]",
+      "Component().signature[0].name": "arg1",
+      "returnValue": "JSX"
+    }
+  }`,
+            },
+        ],
+    },
+    arrowFunctionWithPositionalArguments: {
+        name: 'Arrow Function with Positional Arguments',
+        explanation: 'This code snippet is an arrow function with positional arguments. Be sure to capture the arguments passed into this arrow function.',
+        examples: [
+            {
+                name: 'Arrow Function with Positional Arguments',
+                code: `const foo = (a, b) => { /* function body */ };`,
+                response: `{
+    "structure": {
+      "a": "string",
+      "b": "string"
+    },
+    "equivalentVariables": {
+      "a": "signature[0]",
+      "b": "signature[1]"
+    }
+  }`,
+            },
+            {
+                name: 'Anonymous Arrow Function with Positional Arguments',
+                code: `(arg1, arg2) => { /* function body */ };`,
+                response: `{
+    "structure": {
+      "arg1": "unknown",
+      "arg2": "unknown"
+    },
+    "equivalentVariables": {
+      "arg1": "signature[0]",
+      "arg2": "signature[1]"
+    }
+  }`,
+            },
+        ],
+    },
+    arrowFunctionWithNamedArguments: {
+        name: 'Arrow Function With Named Arguments',
+        examples: [
+            {
+                name: 'Arrow Function with Named Arguments',
+                code: `const foo = ({ name, age }) => { /* function body */ };`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "string"
+    },
+    "equivalentVariables": {
+      "name": "signature[0].name",
+      "age": "signature[0].age"
+    }
+  }`,
+            },
+        ],
+    },
+    arrowFunctionWithPositionalAndNamedArguments: {
+        name: 'Arrow Function with Positional and Named Arguments',
+        examples: [
+            {
+                name: 'Arrow Function with Positional and Named Arguments',
+                code: `const foo = (a, { b, c }) => { /* function body */ };`,
+                response: `{
+    "structure": {
+      "a": "string",
+      "b": "string",
+      "c": "string"
+    },
+    "equivalentVariables": {
+      "a": "signature[0]",
+      "b": "signature[1].b",
+      "c": "signature[1].c"
+    }
+  }`,
+            },
+        ],
+    },
+    return: {
+        name: 'Return Value',
+        examples: [
+            {
+                name: 'Simple Return',
+                code: `return age;`,
+                response: `{
+    "structure": {
+      "age": "number",
+      "returnValue": "number"
+    },
+    "equivalentVariables": {
+      "returnValue": "age"
+    }
+  }`,
+            },
+            {
+                name: 'Deconstructed Return',
+                code: `return { name, age };`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number",
+      "returnValue": "object",
+      "returnValue.name": "string",
+      "returnValue.age": "number"
+    },
+    "equivalentVariables": {
+      "returnValue.name": "name",
+      "returnValue.age": "age"
+    }
+  }`,
+            },
+        ],
+    },
+    returnValueWithJSX: {
+        name: 'Return with JSX',
+        examples: [
+            {
+                name: 'Return with JSX',
+                code: `return <Person name={name} age={age} />;`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number",
+      "Person()": "function"
+    },
+    "equivalentVariables": {
+      "Person().signature[0].name": "name",
+      "Person().signature[0].age": "age",
+      "returnValue": "JSX"
+    }
+  }`,
+            },
+            {
+                name: 'Return with Complex JSX',
+                code: `return (
+      <div>
+        <List items={items.filter(cyScope1())} />
+      </div>
+    );`,
+                response: `{
+    "structure": {
+      "items": "array",
+      "items.filter(cyScope1())": "function",
+      "cyScope1()": "function",
+      "List()": "function",
+      "div()": "function"
+    },
+    "equivalentVariables": {
+      "items.filter(cyScope1()).signature[0]": "cyScope1().functionCallReturnValue",
+      "div().signature[0].children": "List().functionCallReturnValue",
+      "List().signature[0].items": "items",
+      "returnValue": "JSX"
+    }
+  }`,
+            },
+        ],
+    },
+    implicitReturn: {
+        name: 'An Implicit Return Value',
+        examples: [
+            {
+                name: 'Implicit Return',
+                code: `const foo = (a, b) => ({ name: a, age: b });`,
+                response: `{
+    "structure": {
+      "a": "string",
+      "b": "string",
+      "returnValue": "object",
+      "returnValue.name": "string",
+      "returnValue.age": "string"
+    },
+    "equivalentVariables": {
+      "a": "signature[0]",
+      "b": "signature[1]",
+      "returnValue.name": "a",
+      "returnValue.age": "b"
+    }
+  }`,
+            },
+            {
+                name: 'Anonymous Function Implicit JSX Return',
+                code: `(arg1) => (
+    <div>{arg1}</div>
+  );`,
+                response: `{
+    "structure": {
+      "arg1": "string",
+      "div()": "function"
+    },
+    "equivalentVariables": {
+      "arg1": "signature[0]",
+      "div().signature[0].children": "arg1",
+      "returnValue": "JSX"
+    }
+  }`,
+            },
+        ],
+    },
+    jsx: {
+        name: 'JSX Elements',
+        examples: [
+            {
+                name: 'Simple JSX',
+                code: `<PersonCard />`,
+                response: `{
+    "structure": {
+      "PersonCard()": "function"
+    },
+    "equivalentVariables": {}
+  }`,
+            },
+        ],
+    },
+    jsxWithProps: {
+        name: 'JSX with Props',
+        explanation: "This code snippet has one or more JSX Elements that have props. The JSX element itself is a function call and each prop is a named argument to that function, represented with the 'signature[0]' keyword.",
+        examples: [
+            {
+                name: 'JSX with Props',
+                code: `<div className={className} style={style}></div>`,
+                response: `{
+    "structure": {
+      "className": "string",
+      "style": "object",
+      "div()": "function"
+    },
+    "equivalentVariables": {
+      "div().signature[0].className": "className",
+      "div().signature[0].style": "style"
+    }
+  }`,
+            },
+            {
+                name: 'Named JSX with Props',
+                code: `<Person name={person.name} age={person.age} />`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "object",
+      "Person()": "function"
+    },
+    "equivalentVariables": {
+      "Person().signature[0].name": "name",
+      "Person().signature[0].age": "age"
+    }
+  }`,
+            },
+            {
+                name: 'Complex JSX with Props',
+                code: `<Entity
+  id={entity.id}   
+  analysisKey={analysis.key}
+  onClick={handleClick}
+  className={className}
+  userName={user.name}     
+/>`,
+                response: `{
+    "structure": {
+      "entity": "object",
+      "entity.id": "string",
+      "analysis": "object",
+      "analysis.key": "string",
+      "handleClick()": "function",
+      "className": "string",
+      "user": "object",
+      "user.name": "string",
+      "Entity()": "function"
+    },
+    "equivalentVariables": {
+      "Entity().signature[0].id": "entity.id",
+      "Entity().signature[0].analysisKey": "analysis.key",
+      "Entity().signature[0].onClick": "handleClick",
+      "Entity().signature[0].className": "className",
+      "Entity().signature[0].userName": "user.name"
+    }
+  }`,
+            },
+        ],
+    },
+    functionCallWithinJSXProp: {
+        name: 'Function Call within JSX Prop',
+        examples: [
+            {
+                name: 'Function Call within JSX Prop',
+                code: `<Person name={getName()} />`,
+                response: `{
+    "structure": {
+      "getName()": "function",
+      "Person()": "function"
+    },
+    "equivalentVariables": {
+      "Person().signature[0].name": "getName().functionCallReturnValue"
+    }
+  }`,
+            },
+            {
+                name: 'JSX with function calls that take arguments within props',
+                code: `<ItemPreview
+  name={item.name}
+  img={getImg(item)}  
+  cost={determineCostForItem(item)}
+/>`,
+                response: `{
+  "structure": {
+    "item": "object",
+    "item.name": "string",
+    "item.priceAttributes": "object",
+    "getImg(item)": "function",
+    "determineCostForItem(item.priceAttributes)": "function",
+    "ItemPreview()": "function"
+  },
+  "equivalentVariables": {
+    "ItemPreview().signature[0].name": "item.name",
+    "ItemPreview().signature[0].img": "getImg(item).functionCallReturnValue",
+    "ItemPreview().signature[0].cost": "determineCostForItem(item).functionCallReturnValue",
+    "getImg(item).signature[0]": "item",
+    "determineCostForItem(item.priceAttributes).signature[0]": "item.priceAttributes"
+  }
+}`,
+            },
+            {
+                name: 'JSX with function calls that take complex arguments within props',
+                code: `<Preview
+  title={getTitle()}
+  img={getImg(preview.image, preview.size)}  
+  selected={isSelected({ preview })}
+/>`,
+                response: `{
+  "structure": {
+    "preview": "object",
+    "preview.image": "string",
+    "preview.size": "string",
+    "getTitle()": "function",
+    "getImg(preview.image, preview.size)": "function",
+    "isSelected({ preview })": "function",
+    "Preview()": "function"
+  },
+  "equivalentVariables": {
+    "Preview().signature[0].title": "getTitle().functionCallReturnValue",
+    "Preview().signature[0].img": "getImg(preview.image, preview.size).functionCallReturnValue",
+    "Preview().signature[0].selected": "isSelected({ preview }).functionCallReturnValue",
+    "getImg(preview.image, preview.size).signature[0]": "preview.image",
+    "getImg(preview.image, preview.size).signature[1]": "preview.size",
+    "isSelected({ preview }).signature[0].preview": "preview"
+  }
+}`,
+            },
+        ],
+    },
+    jsxWithChildren: {
+        name: 'JSX Elements with Children',
+        examples: [
+            {
+                name: 'JSX with Children',
+                code: `<div>{name}</div>`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "div()": "function"
+    },
+    "equivalentVariables": {
+      "div().signature[0].children": "name"
+    }
+  }`,
+            },
+            {
+                name: 'JSX with Props and Children',
+                code: `(selectedName) => <ListItem 
+    className={className} 
+    selected={name === selectedName}
+    onClick={handleClick}
+  >
+    {name}
+  </List>`,
+                response: `{
+    "structure": {
+      "className": "string",
+      "name": "string",
+      "selectedName": "string",
+      "handleClick()": "function",
+      "ListItem()": "function"
+    },
+    "equivalentVariables": {
+      "selectedName": "signature[0]",
+      "ListItem().signature[0].className": "className",
+      "ListItem().signature[0].selected": "name === selectedName",
+      "ListItem().signature[0].onClick": "handleClick",
+      "ListItem().signature[0].children": "name",
+      "returnValue": "JSX"
+    }
+  }`,
+            },
+        ],
+    },
+    nestedJSX: {
+        name: 'Nested JSX Elements',
+        examples: [
+            {
+                name: 'Nested JSX',
+                code: `<div>
+    <PersonCard name={name} age={age} />
+  </div>`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number",
+      "PersonCard()": "function",
+      "div()": "function"
+    },
+    "equivalentVariables": {
+      "PersonCard().signature[0].name": "name",
+      "PersonCard().signature[0].age": "age",
+      "div().signature[0].children": "PersonCard().functionCallReturnValue"
+    }
+  }`,
+            },
+            {
+                name: 'Return Value with Nested JSX',
+                code: `return <Link>
+    <Emoji name={name} className={className} />
+  </Link>`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "className": "string",
+      "Link()": "function",
+      "Emoji()": "function"
+    },
+    "equivalentVariables": {
+      "Link().signature[0].children": "Emoji().functionCallReturnValue",
+      "Emoji().signature[0].name": "name",
+      "Emoji().signature[0].className": "className",
+      "returnValue": "JSX"
+    }
+  }`,
+            },
+        ],
+    },
+    arrayMap: {
+        name: 'An array.map()',
+        examples: [
+            {
+                name: 'Map',
+                code: `items.map(cyScope1());`,
+                response: `{
+    "structure": {
+      "items": "array",
+      "cyScope1()": "function",
+      "items.map(cyScope1())": "function"
+    },
+    "equivalentVariables": {
+      "items.map(cyScope1()).signature[0]": "cyScope1().functionCallReturnValue"
+    }
+  }`,
+            },
+        ],
+    },
+    arrayMapInJsx: {
+        name: 'An array.map() in JSX',
+        examples: [
+            {
+                name: 'Map in JSX',
+                code: `return (
+    <div>
+      {items.map(cyScope1())}
+    </div>
+  );`,
+                response: `{
+    "structure": {
+      "items": "array",
+      "cyScope1()": "function",
+      "items.map(cyScope1())": "function",
+      "div()": "function"
+    },
+    "equivalentVariables": {
+      "div().signature[0].children": "items.map(cyScope1()).functionCallReturnValue",
+      "items.map(cyScope1()).signature[0]": "cyScope1().functionCallReturnValue",
+      "returnValue": "JSX"
+    }
+  }`,
+            },
+            {
+                name: 'Map in JSX with other children',
+                code: `return (
+    <div>
+      {name}
+      {friends.map(cyScope1())}
+      {cyScope2}
+    </div>
+  );`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "friends": "array",
+      "cyScope1()": "function",
+      "items.map(cyScope1())": "function",
+      "cyScope2": "unknown",
+      "div()": "function"
+    },
+    "equivalentVariables": {
+      "div().signature[0].children": "name",
+      "div().signature[1].children": "friends.map(cyScope1()).functionCallReturnValue",
+      "div().signature[2].children": "cyScope2",
+      "friends.map(cyScope1()).signature[0]": "cyScope1().functionCallReturnValue",
+      "returnValue": "JSX"
+    }
+  }`,
+            },
+            {
+                name: 'Multiple maps in JSX',
+                code: `return (
+    <div>
+      {items.map(cyScope1()).map(cyScope2())}
+    </div>
+  );`,
+                response: `{
+    "structure": {
+      "items": "array",
+      "cyScope1()": "function",
+      "cyScope2()": "function",
+      "items.map(cyScope1())": "function",
+      "items.map(cyScope1()).map(cyScope2())": "function",
+      "div()": "function"
+    },
+    "equivalentVariables": {
+      "div().signature[0].children": "items.map(cyScope1()).map(cyScope2()).functionCallReturnValue",
+      "items.map(cyScope1()).signature[0]": "cyScope1().functionCallReturnValue",
+      "items.map(cyScope1()).map(cyScope2()).signature[0]": "cyScope2().functionCallReturnValue",
+      "returnValue": "JSX"
+    }
+  }`,
+            },
+        ],
+    },
+    for: {
+        name: 'A For Loop',
+        examples: [
+            {
+                name: 'Simple For Loop',
+                code: `for (let i = 0; i < items.length; i++) { /* loop body */ }`,
+                response: `{
+    "structure": {
+      "items": "array",
+      "items[]": "unknown",
+      "i": "number"
+    },
+    "equivalentVariables": {}
+  }`,
+            },
+        ],
+    },
+    forOf: {
+        name: 'A for-of Loop',
+        examples: [
+            {
+                name: 'For Loop with Array',
+                code: `for (const item of items) { /* loop body */ }`,
+                response: `{
+    "structure": {
+      "items": "array",
+      "items[]": "unknown",
+      "item": "unknown"
+    },
+    "equivalentVariables": {
+      "item": "items[]"
+    }
+  }`,
+            },
+        ],
+    },
+    while: {
+        name: 'A While Loop',
+        examples: [
+            {
+                name: 'Simple While Loop',
+                code: `while (condition) { /* loop body */ }`,
+                response: `{
+    "structure": {
+      "condition": "boolean"
+    },
+    "equivalentVariables": {}
+  }`,
+            },
+        ],
+    },
+    if: {
+        name: 'An If Statement',
+        examples: [
+            {
+                name: 'Simple If Statement',
+                code: `if (condition) { /* if body */ }`,
+                response: `{
+    "structure": {
+      "condition": "boolean"
+    },
+    "equivalentVariables": {}
+  }`,
+            },
+        ],
+    },
+    forIn: {
+        name: 'A for-in Loop',
+        examples: [
+            {
+                name: 'Simple For In Loop',
+                code: `for (const key in obj) { /* loop body */ }`,
+                response: `{
+    "structure": {
+      "obj": "object",
+      "key": "string"
+    },
+    "equivalentVariables": {
+      "key": "obj[*key*]"
+    }
+  }`,
+            },
+        ],
+    },
+    switch: {
+        name: 'A Switch Statement',
+        examples: [
+            {
+                name: 'Simple Switch Statement',
+                code: `switch (value) {
+    case 1:
+      /* case 1 body */
+      break;
+    case 2:
+      /* case 2 body */
+      break;
+  }`,
+                response: `{
+    "structure": {
+      "value": "unknown"
+    },
+    "equivalentVariables": {}
+  }`,
+            },
+        ],
+    },
+    ternary: {
+        name: 'Ternary Operator',
+        examples: [
+            {
+                name: 'Simple Ternary',
+                code: `const value = condition ? trueValue : falseValue;`,
+                response: `{
+    "structure": {
+      "condition": "boolean",
+      "trueValue": "unknown",
+      "falseValue": "unknown",
+      "value": "unknown"
+    },
+    "equivalentVariables": {
+      "value": "trueValue",
+    }
+  }`,
+            },
+        ],
+    },
+    stringInterpolation: {
+        name: 'String Interpolation',
+        explanation: 'Interpolated strings are not equivalent to anything, but please extract any variable structure that is exposed within the string.',
+        examples: [
+            {
+                name: 'Simple String Interpolation',
+                code: `const message = \`Hello, \${name}!\`;`,
+                response: `{
+  "structure": {
+    "name": "string",
+    "message": "string"
+  },
+  "equivalentVariables": {}
+}`,
+            },
+            {
+                name: 'String Interpolation with Complex Structure',
+                code: `const message = \`Hello, \${person.name}! You are \${person.age} years old.\`;`,
+                response: `{
+  "structure": {
+    "person": "object",
+    "person.name": "string",  
+    "person.age": "number",
+    "message": "string"
+  },
+  "equivalentVariables": {}
+}`,
+            },
+        ],
+    },
+    useState: {
+        name: 'useState React Hook',
+        explanation: 'We need to track the state variable and the setter function for each useState call so this is a special case.',
+        examples: [
+            {
+                name: 'useState with Default Value',
+                code: `const [person, setPerson] = useState<Person>(selectedPerson);`,
+                response: `{
+  "structure": {
+    "person": "unknown",
+    "setPerson": "function",
+    "useState<Person>(selectedPerson)": "function"
+  },
+  "equivalentVariables": {
+    "useState<Person>(selectedPerson).signature[0]": "selectedPerson",
+    "[person, setPerson]": "useState<Person>(selectedPerson).functionCallReturnValue"
+  }
+}`,
+            },
+            {
+                name: 'useState with No Default Value',
+                code: `const [name, setName] = useState();`,
+                response: `{
+  "structure": {
+    "name": "unknown",
+    "setName": "function",
+    "useState()": "function"
+  },
+  "equivalentVariables": {
+    "[name, setName]": "useState().functionCallReturnValue"
+  }
+}`,
+            },
+        ],
+    },
+    useEffect: {
+        name: 'useEffect React Hook',
+        explanation: 'The useEffect hook does not affect the structure or equivalentVariables so it can be ignored',
+        examples: [
+            {
+                name: 'Simple useEffect',
+                code: `useEffect(cyScope1(), [name]);`,
+                response: `{
+  "structure": {
+    "name": "unknown",
+    "cyScope1()": "function",
+  },
+  "equivalentVariables": {}
+}`,
+            },
+        ],
+    },
+    functionCallWithReturnValueObjectDestructured: {
+        name: 'Function Call with Destructured Return Value',
+        examples: [
+            {
+                name: 'Function Call with Destructured Return Value',
+                code: `const { name, age } = foo();`,
+                response: `{
+    "structure": {
+      "name": "string",
+      "age": "number",
+      "foo()": "function"
+    },
+    "equivalentVariables": {
+      "foo().signature[0]": "unknown",
+      "name": "foo().functionCallReturnValue.name",
+      "age": "foo().functionCallReturnValue.age"
+    }
+  }`,
+            },
+        ],
+    },
+    destructuring: {
+        name: 'Destructured Instantiation',
+        examples: [
+            {
+                name: 'Simple Destructuring',
+                code: `const { name, age } = api.fetchPerson();`,
+                response: `{
+  "structure": {
+    "api": "object",
+    "api.fetchPerson()": "function",
+    "name": "string",
+    "age": "number"
+  },
+  "equivalentVariables": {
+    "name": "api.fetchPerson().functionCallReturnValue.name",
+    "age": "api.fetchPerson().functionCallReturnValue.age"
+  }
+}`,
+            },
+        ],
+    },
+    repeatedMethodChaining: {
+        name: 'Repeated Method Chaining',
+        explanation: "With long method chains it's crucial to capture the full structure of the chain, especially for the functionCallReturnValue.",
+        examples: [
+            {
+                name: 'Simple Method Chaining',
+                code: `const biz = foo(arg1)
+  .bar({ arg2, arg3 })
+  .bar()
+  .baz(arg4, arg5)
+  .boo();`,
+                response: `{
+  "structure": {
+    "arg1": "unknown",
+    "arg2": "unknown",
+    "arg3": "unknown",
+    "arg4": "unknown",
+    "arg5": "unknown",
+    "foo(arg1)": "function",
+    "foo(arg1).bar({ arg2, arg3 })": "function",
+    "foo(arg1).bar({ arg2, arg3 }).bar()": "function",
+    "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5)": "function",
+    "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5).boo()": "function"
+  },
+  "equivalentVariables": {
+   "biz": "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5).boo().functionCallReturnValue"
+  }
+}`,
+            },
+            {
+                name: 'Method Chaining with Destructured Value',
+                code: `const { data, error } = foo(arg1)
+  .bar({ arg2, arg3 })
+  .bar()
+  .baz(arg4, arg5)
+  .boo();`,
+                response: `{
+  "structure": {
+    "arg1": "unknown",
+    "arg2": "unknown",
+    "arg3": "unknown",
+    "arg4": "unknown",
+    "arg5": "unknown",
+    "foo(arg1)": "function",
+    "foo(arg1).bar({ arg2, arg3 })": "function",
+    "foo(arg1).bar({ arg2, arg3 }).bar()": "function",
+    "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5)": "function",
+    "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5).boo()": "function"
+  },
+  "equivalentVariables": {
+   "data": "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5).boo().functionCallReturnValue.data",
+   "error": "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5).boo().functionCallReturnValue.error"
+  }
+}`,
+            },
+        ],
+    },
+    alternativeValues: {
+        name: 'Alternative Values',
+        explanation: 'We are focused on discovering the structure of the variables, so alternative values are simlply two things with at least partially equivalent structures.',
+        examples: [
+            {
+                name: 'Alternative Values',
+                code: `const name = person.name || "Unknown";`,
+                response: `{
+    "structure": {
+      "person": "object",
+      "person.name": "string",
+      "name": "string"
+    },
+    "equivalentVariables": {
+      "name": "person.name"
+    }
+  }`,
+            },
+            {
+                name: 'Alternative Values with Two Variables',
+                code: `const selectedPerson = group.selectedPerson || person;`,
+                response: `{
+    "structure": {
+      "group": "object",
+      "group.selectedPerson": "object",
+      "person": "object",
+      "selectedPerson": "object"
+    },
+    "equivalentVariables": {
+      "selectedPerson": "group.selectedPerson",
+      "group.selectedPerson": "person"
+    }
+  }`,
+            },
+        ],
+    },
+    nullishCoalescing: {
+        name: 'Nullish Coalescing',
+        explanation: 'We are focused on discovering the structure of the variables so create an equivalency with the variable path before the ?? operator. Do not worry about the default value.',
+        examples: [
+            {
+                name: 'Basic Default Value',
+                code: `const name = person.name ?? "Unknown";`,
+                response: `{
+    "structure": {
+      "person": "object",
+      "person.name": "string",
+      "name": "string"
+    },
+    "equivalentVariables": {
+      "name": "person.name"
+    }
+  }`,
+            },
+            {
+                name: 'Object as Default Value',
+                code: `const selectedPerson = group.selectedPerson ?? person;`,
+                response: `{
+    "structure": {
+      "group": "object",
+      "group.selectedPerson": "object",
+      "person": "object",
+      "selectedPerson": "object"
+    },
+    "equivalentVariables": {
+      "selectedPerson": "group.selectedPerson",
+      "group.selectedPerson": "person"
+    }
+  }`,
+            },
+        ],
+    },
+    arrayFilter: {
+        name: 'Array Filter',
+        examples: [
+            {
+                name: 'Simple Array Filter',
+                code: `const selectedItems = items.filter(cyScope1());`,
+                response: `{
+    "structure": {
+      "items": "array",
+      "cyScope1()": "function",
+      "items.filter(cyScope1())": "function"
+    },
+    "equivalentVariables": {
+      "selectedItems": "items.filter(cyScope1()).functionCallReturnValue",
+      "items.filter(cyScope1()).signature[0]": "cyScope1().functionCallReturnValue"
+    }
+  }`,
+            },
+        ],
+    },
+    functionCallReturnValueInFunctionCall: {
+        name: "A Function Call's Return Value Used in Another Function Call",
+        examples: [
+            {
+                name: 'Function Call Return Value in Another Function Call',
+                code: `const selectedItems = items.filter(cyScope1()).map(cyScope2());`,
+                response: `{
+  "structure": {
+    "selectedItems": "array",
+    "items": "array",
+    "cyScope1()": "function",
+    "cyScope2()": "function",
+    "items.filter(cyScope1())": "function",
+    "items.filter(cyScope1()).map(cyScope2())": "function"
+  },
+  "equivalentVariables": {
+    "selectedItems": "items.filter(cyScope1()).map(cyScope2()).functionCallReturnValue",
+    "items.filter(cyScope1()).signature[0]": "cyScope1().functionCallReturnValue",
+    "items.filter(cyScope1()).map(cyScope2()).signature[0]": "cyScope2().functionCallReturnValue"
+  }
+}`,
+            },
+        ],
+    },
+};
+//# sourceMappingURL=generateStatementAnalysis.js.map