npm - @codeyam/codeyam-cli - Versions diffs - 0.1.0-staging.b8a55ba → 0.1.0-staging.c90f8c9 - Mend

@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.c90f8c9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (645) hide show

package/analyzer-template/packages/ai/src/lib/findMatchingAttribute.ts DELETED Viewed

@@ -1,102 +0,0 @@
-import { normalizeKey } from '~codeyam/utils';
-import {
-  joinParenthesesAndArrays,
-  splitOutsideParenthesesAndArrays,
-} from './splitOutsideParentheses';
-function findEquivalent(path: string, equivalents: Record<string, string>) {
-  const pathParts = splitOutsideParenthesesAndArrays(path);
-  for (const equivalentKey in equivalents) {
-    const equivalentKeyParts = splitOutsideParenthesesAndArrays(equivalentKey);
-    if (equivalentKeyParts.some((part) => part.startsWith('signature['))) {
-      continue;
-    }
-    const relevantKey = joinParenthesesAndArrays(
-      pathParts.slice(0, equivalentKeyParts.length),
-    );
-    if (equivalentKey === relevantKey) {
-      const equivalentValue = equivalents[equivalentKey];
-      return joinParenthesesAndArrays([
-        equivalentValue,
-        ...pathParts.slice(equivalentKeyParts.length),
-      ]);
-    }
-  }
-}
-function findReverseEquivalent(
-  path: string,
-  equivalents: Record<string, string>,
-) {
-  const pathParts = splitOutsideParenthesesAndArrays(path);
-  for (const [equivalentKey, equivalentValue] of Object.entries(equivalents)) {
-    const equivalentKeyParts = splitOutsideParenthesesAndArrays(equivalentKey);
-    if (equivalentKeyParts.some((part) => part.startsWith('signature['))) {
-      continue;
-    }
-    const equivalentValueParts =
-      splitOutsideParenthesesAndArrays(equivalentValue);
-    const relevantKey = joinParenthesesAndArrays(
-      pathParts.slice(0, equivalentValueParts.length),
-    );
-    if (equivalentValue === relevantKey) {
-      return joinParenthesesAndArrays([
-        equivalentKey,
-        ...pathParts.slice(equivalentValueParts.length),
-      ]);
-    }
-  }
-}
-export default function findMatchingAttribute(
-  attributePath: string,
-  attributesList: string[],
-  equivalents: Record<string, string>,
-) {
-  // console.log("CODEYAM DEBUG: findMatchingAttribute called with", JSON.stringify({
-  //   attributePath,
-  //   attributesList,
-  //   equivalents,
-  // }, null, 2));
-  const equivalent = findEquivalent(attributePath, equivalents);
-  const reverseEquivalent = findReverseEquivalent(attributePath, equivalents);
-  if (attributesList.includes(attributePath)) {
-    if (reverseEquivalent) {
-      return reverseEquivalent;
-    }
-    return attributePath;
-  } else if (equivalent && attributesList.includes(equivalent)) {
-    return equivalent;
-  } else {
-    const normalizedPath = normalizeKey(attributePath);
-    const matchingAttribute = attributesList.find(
-      (attr) => normalizeKey(attr) === normalizedPath,
-    );
-    // If no exact match find the attribute that matches the most characters starting from the beginning
-    if (!matchingAttribute) {
-      const options = attributesList;
-      const normalizedPathCharacters = normalizedPath.split('');
-      for (const attr of options) {
-        const attrCharacters = normalizeKey(attr).split('');
-        const matchLength = normalizedPathCharacters.findIndex(
-          (char, index) => char !== attrCharacters[index],
-        );
-        if (matchLength !== -1) {
-          const matchedPrefix = normalizedPathCharacters.slice(0, matchLength);
-          if (matchedPrefix.length > 0) {
-            return attr;
-          }
-        }
-      }
-    }
-    if (matchingAttribute) return matchingAttribute;
-    return null;
-  }
-}

package/analyzer-template/packages/ai/src/lib/gatherRelevantDependentKeyAttributes.ts DELETED Viewed

@@ -1,409 +0,0 @@
-import {
-  DataStructure,
-  Entity,
-  ReadonlyAnalysis,
-  ReadonlyAnalysisMap,
-} from '~codeyam/types';
-import {
-  joinParenthesesAndArrays,
-  splitOutsideParenthesesAndArrays,
-} from './splitOutsideParentheses';
-import { gatherAttributesMap } from './promptGenerators/gatherAttributesMap';
-export default function gatherRelevantDependentKeyAttributes(
-  entity: Pick<Entity, 'name' | 'metadata'>,
-  mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>,
-  dependentAnalyses: ReadonlyAnalysisMap,
-) {
-  // console.info(
-  //   'CODEYAM DEBUG: gatherRelevantDependentKeyAttributes inputs',
-  //   entity.name,
-  //   JSON.stringify(
-  //     {
-  //       entity: {
-  //         metadata: {
-  //           isolatedDataStructure:
-  //             entity.metadata?.isolatedDataStructure,
-  //         },
-  //       },
-  //       dependentAnalyses: Object.keys(dependentAnalyses).reduce(
-  //         (acc, path) => {
-  //           acc[path] = Object.keys(dependentAnalyses[path]).reduce(
-  //             (entityAcc, entityName) => {
-  //               entityAcc[entityName] = {
-  //                 metadata: {
-  //                   keyAttributes:
-  //                     dependentAnalyses[path][entityName].metadata
-  //                       .keyAttributes,
-  //                 },
-  //                 entity: {
-  //                   metadata: {
-  //                     isolatedDataStructure:
-  //                       dependentAnalyses[path][entityName].entity.metadata
-  //                         ?.isolatedDataStructure,
-  //                   },
-  //                 },
-  //               };
-  //               return entityAcc;
-  //             },
-  //             {},
-  //           );
-  //           return acc;
-  //         },
-  //         {} as Record<string, Record<string, Record<string, unknown>[]>>,
-  //       ),
-  //     },
-  //     null,
-  //     2,
-  //   ),
-  // );
-  const isolatedDataStructure = entity.metadata?.isolatedDataStructure;
-  const equivalentSignatureVariables =
-    isolatedDataStructure?.equivalentSignatureVariables ?? {};
-  const { associationMap } = gatherAttributesMap(
-    isolatedDataStructure ?? mergedDataStructure,
-    mergedDataStructure,
-    equivalentSignatureVariables,
-  );
-  const dependencySchemas = mergedDataStructure?.dependencySchemas;
-  const relevantDependentKeyAttributes: ReadonlyAnalysis['metadata']['keyAttributes'][0][] =
-    [];
-  Object.keys(dependentAnalyses).forEach((path) => {
-    Object.keys(dependentAnalyses[path]).forEach((entityName) => {
-      const dependentAnalysis = dependentAnalyses[path][entityName];
-      const dependentKeyAtttributes =
-        dependentAnalysis?.metadata?.keyAttributes;
-      if (!dependentKeyAtttributes || dependentKeyAtttributes.length === 0)
-        return;
-      const dependencySchema = dependencySchemas?.[path]?.[entityName];
-      const signatureSchema = dependencySchema?.signatureSchema;
-      if (!signatureSchema) return;
-      // Get sourceEquivalencies from the dependent analysis's mergedDataStructure,
-      // not from dependencySchemas (which doesn't store them)
-      const sourceEquivalencies =
-        dependentAnalysis?.metadata?.mergedDataStructure?.sourceEquivalencies ??
-        {};
-      // Build a fallback mapping from parent's usageEquivalencies
-      // This helps when the child's sourceEquivalencies don't have a mapping
-      // For example, if parent passes `entity` to child's `signature[0]`,
-      // usageEquivalencies might have: entity -> [{schemaPath: 'signature[0]', scopeNodeName: entityName}]
-      const usageEquivalencies = mergedDataStructure?.usageEquivalencies ?? {};
-      const signatureToParentPath: Record<string, string> = {};
-      for (const parentPath in usageEquivalencies) {
-        const usages = usageEquivalencies[parentPath];
-        for (const usage of usages) {
-          if (usage.scopeNodeName !== entityName) continue;
-          // Extract signature path from schemaPath
-          // Format can be:
-          // 1. "functionName(args).signature[N]" or "functionName(args).signature[N].property" (real data)
-          // 2. "signature[N]" or "signature[N].property" (simplified/test format)
-          let signaturePath: string;
-          const signatureIndex = usage.schemaPath.indexOf('.signature[');
-          if (signatureIndex !== -1) {
-            // Full format: extract "signature[N]" or "signature[N].property" after the dot
-            signaturePath = usage.schemaPath.slice(signatureIndex + 1);
-          } else if (usage.schemaPath.startsWith('signature[')) {
-            // Simplified format: already starts with signature[
-            signaturePath = usage.schemaPath;
-          } else {
-            continue;
-          }
-          // Map child's signature path to parent's path
-          // e.g., 'signature[0]' -> 'entity'
-          signatureToParentPath[signaturePath] = parentPath;
-        }
-      }
-      // If sourceEquivalencies is empty but the child has mocked imports,
-      // only propagate key attributes that come from mocked data sources
-      // (not props that the parent passes to the child)
-      if (Object.keys(sourceEquivalencies).length === 0) {
-        // Collect names of mocked imports
-        const importedExports =
-          dependentAnalysis.entity?.metadata?.importedExports ?? [];
-        const nodeModuleImports =
-          dependentAnalysis.entity?.metadata?.nodeModuleImports ?? {};
-        const mockedImportNames = new Set<string>();
-        // Collect mocked names from importedExports
-        for (const imp of importedExports) {
-          if ((imp as { isMocked?: boolean }).isMocked) {
-            mockedImportNames.add((imp as { name: string }).name);
-          }
-        }
-        // Collect mocked names from nodeModuleImports
-        for (const imports of Object.values(nodeModuleImports)) {
-          for (const imp of imports as any[]) {
-            if ((imp as { isMocked?: boolean }).isMocked) {
-              mockedImportNames.add((imp as { name: string }).name);
-            }
-          }
-        }
-        if (mockedImportNames.size > 0) {
-          for (const dependentKeyAttribute of dependentKeyAtttributes) {
-            // Include key attributes that come from controllable data sources:
-            // 1. Mocked data sources (like getScenarioDisplayState())
-            // 2. Arguments/props passed to the child (signature[N].*)
-            // Exclude attributes that are clearly just the prop name itself (like "size")
-            const externalPath = dependentKeyAttribute.externalPath || '';
-            const dataStructurePath =
-              dependentKeyAttribute.dataStructurePath || '';
-            const comesFromMockedSource = Array.from(mockedImportNames).some(
-              (mockedName) =>
-                externalPath.includes(`${mockedName}(`) ||
-                externalPath.includes(`${mockedName}.`) ||
-                dataStructurePath.includes(`${mockedName}(`) ||
-                dataStructurePath.includes(`${mockedName}.`) ||
-                dataStructurePath.startsWith(mockedName),
-            );
-            // Check if it comes from an argument (signature[N].something.deeper)
-            // but not just a simple prop like "size" or "isOutdated"
-            const comesFromArgument =
-              externalPath.startsWith('signature[') &&
-              // Must have nested path (at least one dot after the prop name)
-              // e.g., signature[0].scenario.metadata.* is OK
-              // but signature[0].size is not (it's just a simple prop)
-              (externalPath.match(/\./g) || []).length >= 2;
-            if (comesFromMockedSource || comesFromArgument) {
-              relevantDependentKeyAttributes.push({
-                ...dependentKeyAttribute,
-                dependentEntityName: entityName,
-                originalEntityName: entityName,
-                filePath: path,
-              } as any);
-            }
-          }
-          return;
-        }
-        // No mocked imports, try usageEquivalencies fallback for direct argument usage
-        if (Object.keys(signatureToParentPath).length > 0) {
-          for (const dependentKeyAttribute of dependentKeyAtttributes) {
-            if (!dependentKeyAttribute.externalPath?.startsWith('signature['))
-              continue;
-            const dependentKeyAttributeExternalPathParts =
-              splitOutsideParenthesesAndArrays(
-                dependentKeyAttribute.externalPath,
-              );
-            // Try to find a matching signature path
-            for (
-              let i = dependentKeyAttributeExternalPathParts.length;
-              i > 0;
-              i--
-            ) {
-              const subExternalPath = joinParenthesesAndArrays(
-                dependentKeyAttributeExternalPathParts.slice(0, i),
-              );
-              if (signatureToParentPath[subExternalPath]) {
-                const parentPath = signatureToParentPath[subExternalPath];
-                // parentPath is already in parent's schema format (e.g., "signature[0].entity" or just "entity")
-                // We need to handle both cases
-                const parentPathStartsWithSignature =
-                  parentPath.startsWith('signature[');
-                let externalPath = parentPathStartsWithSignature
-                  ? parentPath
-                  : `signature[0].${parentPath}`;
-                // internalPath is parentPath without the signature[N]. prefix
-                let internalPath: string | undefined =
-                  parentPathStartsWithSignature
-                    ? parentPath.replace(/^signature\[\d+\]\./, '')
-                    : parentPath;
-                if (i < dependentKeyAttributeExternalPathParts.length) {
-                  const remainingPath = joinParenthesesAndArrays(
-                    dependentKeyAttributeExternalPathParts.slice(i),
-                  );
-                  externalPath = `${externalPath}.${remainingPath}`;
-                  internalPath = `${internalPath}.${remainingPath}`;
-                }
-                // Look up in associationMap for proper internal path
-                if (associationMap[externalPath]) {
-                  internalPath = associationMap[externalPath];
-                }
-                relevantDependentKeyAttributes.push({
-                  ...dependentKeyAttribute,
-                  dependentEntityName: entityName,
-                  originalEntityName: entityName,
-                  filePath: path,
-                  internalPath,
-                  externalPath,
-                  dataStructurePath: internalPath,
-                } as any);
-                break;
-              }
-            }
-          }
-        }
-        return;
-      }
-      for (const dependentKeyAttribute of dependentKeyAtttributes) {
-        const dependentKeyAttributeExternalPathParts =
-          splitOutsideParenthesesAndArrays(dependentKeyAttribute.externalPath);
-        let matchFound = false;
-        // First, try to match using child's sourceEquivalencies
-        for (
-          let i = dependentKeyAttributeExternalPathParts.length;
-          i > 0;
-          i--
-        ) {
-          const subExternalPath = joinParenthesesAndArrays(
-            dependentKeyAttributeExternalPathParts.slice(0, i),
-          );
-          // Use the sourceEquivalencies from the child's analysis
-          for (const sourceEquivalencyPath in sourceEquivalencies) {
-            const sourceEquivalencyPathParts = splitOutsideParenthesesAndArrays(
-              sourceEquivalencyPath,
-            );
-            const relevantSourceEquivalencyPath = joinParenthesesAndArrays(
-              sourceEquivalencyPathParts.slice(1),
-            );
-            if (relevantSourceEquivalencyPath !== subExternalPath) continue;
-            const sourcePath =
-              sourceEquivalencies[sourceEquivalencyPath][0]?.schemaPath;
-            if (!sourcePath) continue;
-            let externalPath = sourcePath;
-            let internalPath: string | undefined = associationMap[sourcePath];
-            if (i < dependentKeyAttributeExternalPathParts.length) {
-              externalPath = joinParenthesesAndArrays([
-                externalPath,
-                ...dependentKeyAttributeExternalPathParts.slice(i),
-              ]);
-              // Only build internalPath if we have a valid base path from associationMap
-              // Otherwise leave it undefined to avoid paths like "undefined.foo.bar"
-              if (internalPath !== undefined) {
-                internalPath = joinParenthesesAndArrays([
-                  internalPath,
-                  ...dependentKeyAttributeExternalPathParts.slice(i),
-                ]);
-              }
-            }
-            const dependentEntityName =
-              dependentKeyAttribute.dependentEntityName
-                ? `${dependentKeyAttribute.dependentEntityName} (through ${entityName})`
-                : entityName;
-            relevantDependentKeyAttributes.push({
-              ...dependentKeyAttribute,
-              dependentEntityName,
-              originalEntityName: entityName, // Original entity name without "(through X)"
-              filePath: path, // File path for restructuring into nested format
-              internalPath,
-              externalPath,
-              // Transform dataStructurePath to parent's path structure
-              dataStructurePath: internalPath,
-            } as any);
-            matchFound = true;
-            break;
-          }
-          if (matchFound) break;
-        }
-        // Fallback: if no sourceEquivalency match, try using parent's usageEquivalencies
-        // This handles direct argument usage like entity.entityType
-        if (
-          !matchFound &&
-          dependentKeyAttribute.externalPath?.startsWith('signature[')
-        ) {
-          // Try to find a matching signature path in the usageEquivalencies-derived map
-          for (
-            let i = dependentKeyAttributeExternalPathParts.length;
-            i > 0;
-            i--
-          ) {
-            const subExternalPath = joinParenthesesAndArrays(
-              dependentKeyAttributeExternalPathParts.slice(0, i),
-            );
-            if (signatureToParentPath[subExternalPath]) {
-              const parentPath = signatureToParentPath[subExternalPath];
-              // parentPath is already in parent's schema format (e.g., "signature[0].entity" or just "entity")
-              // We need to handle both cases
-              const parentPathStartsWithSignature =
-                parentPath.startsWith('signature[');
-              let externalPath = parentPathStartsWithSignature
-                ? parentPath
-                : `signature[0].${parentPath}`;
-              // internalPath is parentPath without the signature[N]. prefix
-              let internalPath: string | undefined =
-                parentPathStartsWithSignature
-                  ? parentPath.replace(/^signature\[\d+\]\./, '')
-                  : parentPath;
-              if (i < dependentKeyAttributeExternalPathParts.length) {
-                const remainingPath = joinParenthesesAndArrays(
-                  dependentKeyAttributeExternalPathParts.slice(i),
-                );
-                externalPath = `${externalPath}.${remainingPath}`;
-                internalPath = `${internalPath}.${remainingPath}`;
-              }
-              // Look up the full external path in associationMap for proper internal path
-              const fullExternalPath = externalPath;
-              if (associationMap[fullExternalPath]) {
-                internalPath = associationMap[fullExternalPath];
-              }
-              const dependentEntityName =
-                dependentKeyAttribute.dependentEntityName
-                  ? `${dependentKeyAttribute.dependentEntityName} (through ${entityName})`
-                  : entityName;
-              relevantDependentKeyAttributes.push({
-                ...dependentKeyAttribute,
-                dependentEntityName,
-                originalEntityName: entityName,
-                filePath: path,
-                internalPath,
-                externalPath,
-                dataStructurePath: internalPath,
-              } as any);
-              matchFound = true;
-              break;
-            }
-          }
-        }
-      }
-    });
-  });
-  return relevantDependentKeyAttributes;
-}