@codeyam/codeyam-cli 0.1.0-bleeding-edge.8afd3ee → 0.1.0-staging.09652b8

package/analyzer-template/packages/ai/src/lib/generateStatementAnalysis.ts

@@ -152,85 +152,52 @@ export default async function generateStatementAnalysis({
   return { sha, structure, equivalentVariables, llmCall };
 }
 
-const SYSTEM_MESSAGE = (reservedStrategies: string[]) => `**Task:**  
+const SYSTEM_MESSAGE = (
+  reservedStrategies: string[],
+) => `Analyze a code snippet to extract:
 
-We have a code snippet we need to analyze.
+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)
 
-We want to determine:
+## Type Rules
 
-1) What is the data structure of the variables in the code snippet?
-3) What variables or aspects of variables are equivalent in the code snippet?
+- Use type annotations when available; otherwise infer from context or use "unknown"
+- Non-primitive types are "object"
+- Function calls are "function"
 
-If there is any type information in the code snippet leverage it to inform the data structure of the variables but do not otherwise worry about it or include it. If a type is not a primitive simply label it as "object".
+## Equivalency Rules
 
-**Definitions:**
+For assignments like \`const a = b\`, record \`"a": "b"\`.
 
-Data Structure: 
-- Every variable in the code snippet has a data structure.
-- The data structure of a variable is the type of data it holds. For example, a variable could hold a string, a number, an array, an object, a function, etc.
-- We want to identify every aspect of every variable in the code snippet.
+For destructuring like \`const { x } = obj\`, record \`"x": "obj.x"\`.
 
-Example:
-\`\`\`typescript
-const { name, age } = person;
-\`\`\`
+For function calls like \`const result = foo(arg)\`:
+- Record \`"result": "foo(arg).functionCallReturnValue"\`
+- Record \`"foo(arg).signature[0]": "arg"\`
 
-In this case three variables are declared: \`name\`, \`age\`, and \`person\` so the overall structure would be:
+For destructured function returns like \`const { data } = foo()\`:
+- Record \`"data": "foo().functionCallReturnValue.data"\`
 
-\`\`\`json
-{
-  "structure": {
-    "person": "object",
-    "person.name": "string",
-    "person.age": "number"
-    "name": "string",
-    "age": "number"
-  }
-}
-\`\`\`
-
-Equivalent Variables:
-- In the code variables or aspects of a variable may be assigned to one another, passed in as arguments to a function call, or assigned to the return value of a function call.
-- We want to track all of these equivalent variables so that we can merge the data structure of all equivalencies together.
-- The key should be the variable or aspect of a variable that is recieving existing data from the other variable, which is the path.
+## Example
 
-Example:
 \`\`\`typescript
-const { name, hobbies } = person;
-hobbies[0].started = selectedHobby.alreadyStarted;
+const { name } = person;
+const result = process(name);
 \`\`\`
 
-Here we have a number of equivalencies:
-
-\`\`\`
-{
-  "equivalentVariables": {
-    "name": "person.name",
-    "hobbies": "person.hobbies",
-    "hobbies[0].started": "selectedHobby.alreadyStarted"    
-  }
-}
-\`\`\`
-
-**Response:**
-
-Combine these together to form the response:
-
 \`\`\`json
 {
   "structure": {
     "person": "object",
     "person.name": "string",
-    "person.hobbies": "array",
-    "person.hobbies[0]": "object",
-    "person.hobbies[0].started": "boolean",
-    "selectedHobby": "object",
-    "selectedHobby.alreadyStarted": "boolean"
+    "name": "string",
+    "process(name)": "function",
+    "result": "unknown"
   },
   "equivalentVariables": {
     "name": "person.name",
-    "hobbies": "person.hobbies",
-    "hobbies[0].started": "selectedHobby.alreadyStarted"    
+    "process(name).signature[0]": "name",
+    "result": "process(name).functionCallReturnValue"
   }
 }
 \`\`\`
@@ -239,10 +206,7 @@ ${relevantExamples(reservedStrategies)}
 
 ---
 
-**Important:**
-
-- Take your time and analyze the code snippet carefully. Capture all the data structures, function calls, and equivalencies you can find. If you miss any the simulation will fail.
-- Double check your work to ensure nothing was missed and all rules are followed.
+Analyze carefully. Missing equivalencies will cause simulation failures.
 `;
 
 function keywords(reservedStrategies: string[]) {
@@ -348,7 +312,20 @@ const STRATEGIES = {
     name: 'Basic Variable Assignment',
     examples: [
       {
-        name: 'Simple',
+        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": {
@@ -363,7 +340,7 @@ const STRATEGIES = {
   }`,
       },
       {
-        name: 'Basic Deconstruction',
+        name: 'Destructuring',
         code: `const { name, age } = getPerson(personId);`,
         response: `{
     "structure": {
@@ -404,10 +381,10 @@ const STRATEGIES = {
         response: `{
     "structure": {
       "person": "object",
-      "options: "object"
+      "options": "object"
     },
     "equivalentVariables": {
-      "person": "signature[0]": 
+      "person": "signature[0]",
       "options": "signature[1]"
     }
   }`,
@@ -477,7 +454,7 @@ const STRATEGIES = {
       "name": "string",
       "title": "string",
       "category": "string",
-      "age": "number",
+      "age": "number"
     },
     "equivalentVariables": {
       "name": "signature[0].name",
@@ -932,10 +909,10 @@ const STRATEGIES = {
         response: `{
     "structure": {
       "age": "number",
-      "returnValue": "number",
+      "returnValue": "number"
     },
     "equivalentVariables": {
-      "returnValue: "age"
+      "returnValue": "age"
     }
   }`,
       },
@@ -988,7 +965,7 @@ const STRATEGIES = {
     "structure": {
       "items": "array",
       "items.filter(cyScope1())": "function",
-      "cyScope1()" : "function",
+      "cyScope1()": "function",
       "List()": "function",
       "div()": "function"
     },
@@ -1684,7 +1661,7 @@ const STRATEGIES = {
     "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"
+   "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"
   }
 }`,

package/analyzer-template/packages/ai/src/lib/getLLMCallStats.ts

@@ -2,13 +2,6 @@ import OpenAI from 'openai';
 import { getLLMCallCost } from './getLLMCallCost';
 import { AI, LlmCallStats } from './types';
 
-/**
- * It looks like this function can be massively simplified, and I (AG) think
- * that we aren't using openrouter anymore. But, until this is figured out, it
- * might not be worth refactoring and messing something subtle up. Ideally
- * whatever implicit functionality is in here can be represented in the new
- * `getLLMCallStats` such that this get replaced by it.
- */
 export function getLLMCallStats({
   chatRequest,
   chatCompletion,
@@ -28,13 +21,6 @@ export function getLLMCallStats({
       error: JSON.stringify(chatCompletion.error),
     };
   }
-  if (!chatRequest.model) {
-    // this was previously used to indicate openrouter calls, but we aren't
-    // doing that anymore and anyway it was a pretty obscure way to indicate
-    // that state of affairs. if we bring multi-provider back, we will want
-    // to rewrite a fair bit of this.
-    return null;
-  }
 
   const usage = chatCompletion.usage || {
     prompt_tokens: 0,

package/analyzer-template/packages/ai/src/lib/modelInfo.ts

@@ -27,6 +27,14 @@ export interface ModelInfo {
 
 export const MODEL_INFO: Record<AI.Model, ModelInfo> = {
   // OpenAI models - served directly by OpenAI
+  [AI.Model.OPENAI_GPT5_1]: {
+    id: AI.Model.OPENAI_GPT5_1,
+    provider: OPENAI_PROVIDER,
+    apiModelName: 'gpt-5.1',
+    maxCompletionTokens: 128000,
+    pricing: { input: 1.25, output: 10.0 },
+    reasoningEffort: 'none',
+  },
   [AI.Model.OPENAI_GPT5]: {
     id: AI.Model.OPENAI_GPT5,
     provider: OPENAI_PROVIDER,
@@ -175,6 +183,13 @@ export const MODEL_INFO: Record<AI.Model, ModelInfo> = {
     maxCompletionTokens: 200000,
     pricing: { input: 3.0, output: 15.0 },
   },
+  [AI.Model.ANTHROPIC_CLAUDE_4_5_OPUS]: {
+    id: AI.Model.ANTHROPIC_CLAUDE_4_5_OPUS,
+    provider: ANTHROPIC_PROVIDER,
+    apiModelName: 'claude-opus-4-5',
+    maxCompletionTokens: 200000,
+    pricing: { input: 5.0, output: 25.0 },
+  },
 
   // Deprecated models (kept for backward compatibility)
   [AI.Model.PHIND_CODELLAMA]: {

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChangesEntityDocumentationGenerator.ts

@@ -4,44 +4,19 @@ export default function generateChangesEntityDocumentationGenerator(
   entity: Entity,
   previousDocumentation: string,
 ) {
-  return `A function recently changed. Here is the current documentation for that function:
+  return `## Task
+Review if the existing documentation is still accurate after code changes. If accurate, respond "No changes needed". Otherwise, provide updated documentation.
 
-"""
+## Current Documentation
 ${previousDocumentation}
-"""  
 
-and here is the new code for ${entity.name}:
-  
-"""
+## Updated Code
+\`\`\`typescript
 ${entity.code}
-"""
-
-If the existing documentation is still accurate please respond with "No changes needed". 
-
-Otherwise, please update the documentation to reflect the changes in the code. Using these instructions:
-
-- Start with an overview that describes the overall intent of the code. Be concise in your language. Immediately start with the intent of the code. Here is an example Overview:
-
-\`\`\` Overview
-Displays details about a specific Git commit. It shows the commit message, author, date, and provides a link to the commit on GitHub. Users can copy the commit SHA to their clipboard, with a visual indication of the copy action.
 \`\`\`
 
-Note that it does not mention the name of the function but dives directly into what the code does in concise language followed by a small amount of detail.
-
-- Next, specify the inputs (with details about types, how the input is used, and examples) and expected outputs (with details about types and examples).
-
-- Finally, provide examples of how the code can be used with clear inputs and outputs for each example. Provide diverse examples (there's no need to include repetitive examples). 
-
-Write the documentation as markdown. Be concise. Use bullets when possible. No one wants to read long paragraphs of text. 
-
-Provide no other text than the documentation in proper markdown using the headers below.
-
-## Overview
-
-## Inputs
-
-## Output
+## Overview Example
+Good: "Displays details about a specific Git commit. Shows the commit message, author, date, and provides a link to GitHub."
 
-## Examples
-`;
+Bad: "The CommitDetails function takes a commit object..." (mentions the function name)`;
 }

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChangesEntityScenarioDataGenerator.ts

@@ -52,77 +52,69 @@ export default function generateChangesEntityScenarioDataGenerator(
   defaultScenarioData?: ScenarioData,
   incompleteResponse?: string,
 ) {
-  return `${
-    incompleteResponse
-      ? `## Incomplete Response
-
-Here is the incomplete response. Please use this and the following data to complete the response, only returning the missing data.
-
-Just pick up where this response left off. It will be improper json but we will combine the responses into proper json.
-
-\`\`\` START INCOMPLETE RESPONSE \`\`\`
+  const incompleteSection = incompleteResponse
+    ? `## Incomplete Response
+Continue from where this left off (combine for valid JSON):
+\`\`\`
 ${incompleteResponse}
-\`\`\` END INCOMPLETE RESPONSE \`\`\`
+\`\`\`
 
 `
-      : ''
-  }## Scenario
-  
-This scenario needs mock data to support it. Here are the keyAttributeInstructions for generating this scenario:
-\`\`\`
-${JSON.stringify(
-  {
-    name: scenario.name,
-    description: scenario.description,
-    keyAttributeInstructions: scenario.metadata.keyAttributeInstructions,
-  },
-  null,
-  2,
-)}
-\`\`\`
+    : '';
 
-## Existing Scenario
-  
-Here are the "keyAttributeInstructions" and data for this scenario before this more recent code change. Please maintain the existing data as effectively as possible while fulfilling the new data structure and "keyAttributeInstructions".
-\`\`\`
-${JSON.stringify(
-  {
-    name: existingScenario.name,
-    data: filterData(structure, existingScenario.metadata.data),
-  },
-  null,
-  2,
-)}
-\`\`\`
-${
-  defaultScenarioData
-    ? `
-## Default Scenario
+  const scenarioJson = JSON.stringify(
+    {
+      name: scenario.name,
+      description: scenario.description,
+      keyAttributeInstructions: scenario.metadata.keyAttributeInstructions,
+    },
+    null,
+    2,
+  );
 
-Data for the default scenario. Do not modify it. The data you are generating will be merged into it to create the full data.
-\`\`\`
+  const existingJson = JSON.stringify(
+    {
+      name: existingScenario.name,
+      data: filterData(structure, existingScenario.metadata.data),
+    },
+    null,
+    2,
+  );
+
+  const defaultSection = defaultScenarioData
+    ? `
+## Default Scenario Data (merge base, do not modify)
+\`\`\`json
 ${JSON.stringify(defaultScenarioData.data, null, 2)}
 \`\`\`
 `
-    : ''
-}
-${
-  structure.dataForMocks
-    ? `The mockData structure (for the default scenario provide robust values for the entire structure):
-\`\`\`
+    : '';
+
+  const mockDataSection = structure.dataForMocks
+    ? `## mockData Structure
+\`\`\`json
 ${JSON.stringify(structure.dataForMocks, null, 2)}
-\`\`\`
-`
-    : 'There is no mockData for this file. Return {} for the mockData.'
-}
-    
-${
-  structure.arguments
-    ? `The argumentsData structure (for the default scenario provide robust values for the entire structure):
-\`\`\`
+\`\`\``
+    : '## mockData Structure\nNone—return `{}` for mockData.';
+
+  const argumentsSection = structure.arguments
+    ? `## argumentsData Structure
+\`\`\`json
 ${JSON.stringify(structure.arguments, null, 2)}
+\`\`\``
+    : '## argumentsData Structure\nNone—return `[]` for argumentsData.';
+
+  return `${incompleteSection}## Scenario (new instructions)
+\`\`\`json
+${scenarioJson}
 \`\`\`
-`
-    : 'There is no argumentsData for this file. Return [] for the argumentsData.'
-}`;
+
+## Existing Scenario (preserve where possible)
+\`\`\`json
+${existingJson}
+\`\`\`
+${defaultSection}
+${mockDataSection}
+
+${argumentsSection}`;
 }

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChangesEntityScenariosGenerator.ts

@@ -41,7 +41,7 @@ export default function generateChangesEntityScenariosGenerator({
     const filePath = (attr as any).filePath;
     const entityName = (attr as any).originalEntityName;
 
-    if (!filePath || !entityName) continue; // Skip if missing required fields
+    if (!filePath || !entityName) continue;
 
     if (!relevantDependentKeyAttributes[filePath]) {
       relevantDependentKeyAttributes[filePath] = {};
@@ -52,128 +52,112 @@ export default function generateChangesEntityScenariosGenerator({
     relevantDependentKeyAttributes[filePath][entityName].push(attr);
   }
 
-  return `Added Key Attributes:
-
-\`\`\`
-${
-  addedKeyAttributes && addedKeyAttributes.length > 0
-    ? JSON.stringify(
-        addedKeyAttributes.map((ka) => ({
-          dataStructurePath: ka.dataStructurePath, // Full path in mockData
-          localVariable: ka.internalPath, // Local variable name
-          description: ka.description,
-          validValueOptions: ka.validValueOptions,
-        })),
-        null,
-        2,
-      )
-    : 'None'
-}
-\`\`\`
-
-Removed Key Attributes:
-
-\`\`\`
-${removedKeyAttributes && removedKeyAttributes.length > 0 ? JSON.stringify(removedKeyAttributes, null, 2) : 'None'}
-\`\`\`
-
-${
-  changedDataStructureFields.length > 0
-    ? `Changed Data Structure Fields:
-
-The following fields in the data structure have changed (type changed, added, or removed):
-
-\`\`\`
+  const formatKeyAttrs = (attrs: Analysis['metadata']['keyAttributes']) =>
+    attrs.map((ka) => ({
+      dataStructurePath: ka.dataStructurePath,
+      localVariable: ka.internalPath,
+      description: ka.description,
+      validValueOptions: ka.validValueOptions,
+    }));
+
+  const addedSection =
+    addedKeyAttributes?.length > 0
+      ? JSON.stringify(formatKeyAttrs(addedKeyAttributes), null, 2)
+      : 'None';
+
+  const removedSection =
+    removedKeyAttributes?.length > 0
+      ? JSON.stringify(removedKeyAttributes, null, 2)
+      : 'None';
+
+  const changedFieldsSection =
+    changedDataStructureFields.length > 0
+      ? `
+## Changed Data Structure Fields
+Fields that changed type, were added, or removed:
+\`\`\`json
 ${JSON.stringify(changedDataStructureFields, null, 2)}
 \`\`\`
 
-**IMPORTANT**: For scenarios that reference these changed fields in their keyAttributeInstructions, you MUST regenerate those specific instructions to match the new data structure. For example:
-- If "stats.visualEntities" changed from an array to a number, update keyAttributeInstructions from "Array of 10 objects" to "10 (count of visual entities)"
-- If a field was removed, remove it from keyAttributeInstructions
-- If a field was added, you may add it to keyAttributeInstructions if relevant for the scenario
-
-Fields that did NOT change can retain their existing keyAttributeInstructions.
-
+**Update keyAttributeInstructions for affected scenarios** (e.g., if "stats.visualEntities" changed from array to number).
 `
-    : ''
-}
-Existing Key Attributes:
-
-\`\`\`
+      : '';
+
+  const existingScenariosJson = JSON.stringify(
+    existingScenarios
+      .filter((s) => (error ? !!s.metadata.error : !s.metadata.error))
+      .map((s) => ({
+        name: s.name,
+        description: s.description,
+        keyAttributeInstructions: s.metadata.keyAttributeInstructions,
+        playwrightInstructions: s.metadata.playwrightInstructions,
+      })),
+    null,
+    2,
+  );
+
+  const diffSection = commitDiff
+    ? `
+## Code Change (Diff)
+\`\`\`diff
+${commitDiff}
+\`\`\``
+    : '';
+
+  const dependencySection =
+    !error &&
+    relevantDependentKeyAttributes &&
+    Object.keys(relevantDependentKeyAttributes).length > 0
+      ? `
+## Dependency Key Attributes
+\`\`\`json
 ${JSON.stringify(
-  keyAttributes.map((ka) => ({
-    dataStructurePath: ka.dataStructurePath, // Full path in mockData
-    localVariable: ka.internalPath, // Local variable name
-    description: ka.description,
-    validValueOptions: ka.validValueOptions,
-  })),
+  Object.keys(relevantDependentKeyAttributes).reduce((acc: any, path) => {
+    acc[path] = Object.keys(relevantDependentKeyAttributes[path]).reduce(
+      (entityAcc: any, entityName) => {
+        entityAcc[entityName] = relevantDependentKeyAttributes[path][
+          entityName
+        ].map((ka: any) => ({
+          dataStructurePath: ka.dataStructurePath,
+          localVariable: ka.path || ka.internalPath,
+          description: ka.description,
+          validValueOptions: ka.validValueOptions,
+        }));
+        return entityAcc;
+      },
+      {},
+    );
+    return acc;
+  }, {}),
   null,
   2,
 )}
-\`\`\`
-
-Existing Scenarios:
+\`\`\``
+      : '';
 
+  return `## Added Key Attributes
+\`\`\`json
+${addedSection}
 \`\`\`
-${JSON.stringify(
-  existingScenarios
-    .filter((s) => (error ? !!s.metadata.error : !s.metadata.error))
-    .map((s) => ({
-      name: s.name,
-      description: s.description,
-      keyAttributeInstructions: s.metadata.keyAttributeInstructions,
-      playwrightInstructions: s.metadata.playwrightInstructions,
-    })),
-  null,
-  2,
-)}
-\`\`\`
-
-${
-  commitDiff
-    ? `
-Code Change:
 
+## Removed Key Attributes
+\`\`\`json
+${removedSection}
 \`\`\`
-${commitDiff}
+${changedFieldsSection}
+## Current Key Attributes
+\`\`\`json
+${JSON.stringify(formatKeyAttrs(keyAttributes), null, 2)}
 \`\`\`
-`
-    : ''
-}
-Function Code:
 
+## Existing Scenarios
+\`\`\`json
+${existingScenariosJson}
 \`\`\`
-${entity.code}
-\`\`\`
+${diffSection}
 
-${
-  !error &&
-  relevantDependentKeyAttributes &&
-  Object.keys(relevantDependentKeyAttributes).length > 0
-    ? `Key Attributes for Dependencies:
-\`\`\`
-${JSON.stringify(
-  Object.keys(relevantDependentKeyAttributes).reduce((acc: any, path) => {
-    acc[path] = Object.keys(
-      (relevantDependentKeyAttributes as any)[path],
-    ).reduce((entityAcc: any, entityName) => {
-      entityAcc[entityName] = (relevantDependentKeyAttributes as any)[path][
-        entityName
-      ].map((ka: any) => ({
-        dataStructurePath: ka.dataStructurePath, // Full path in mockData
-        localVariable: ka.path || ka.internalPath, // Local variable name
-        description: ka.description,
-        validValueOptions: ka.validValueOptions,
-      }));
-      return entityAcc;
-    }, {});
-    return acc;
-  }, {}),
-  null,
-  2,
-)}
-\`\`\``
-    : ''
-}
-`;
+## Current Code
+\`\`\`typescript
+${entity.code}
+\`\`\`${dependencySection}`;
 }