@codeyam/codeyam-cli 0.1.22 → 0.1.23

package/analyzer-template/.build-info.json

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-03-24T14:27:03.288Z",
-  "buildTime": 1774362423288,
-  "gitCommit": "af072353c0de778f2916c445dec0ca98b1ee7180",
+  "buildTimestamp": "2026-03-25T14:20:38.638Z",
+  "buildTime": 1774448438638,
+  "gitCommit": "c7c95ab59975fd59b8a33c1299058ba1fca32a62",
   "nodeVersion": "v20.20.1",
-  "contentHash": "2352c3294573a7af51e18b678f86299d7a1fe24cbf8427cdfcd4472c2f613df6",
-  "buildNumber": 1216,
-  "semanticVersion": "0.1.1216",
-  "version": "0.1.1216 (2026-03-24T14:27+2352c32)"
+  "contentHash": "1ef6e4857c54ba0e5ddecacacdd26bdc64e7a25cd41e9f154b5ea6e3cd5525dc",
+  "buildNumber": 1223,
+  "semanticVersion": "0.1.1223",
+  "version": "0.1.1223 (2026-03-25T14:20+1ef6e48)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[3/24/2026, 2:27:03 PM] > codeyam-combo@1.0.0 mergeDependencies
-[3/24/2026, 2:27:03 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[3/25/2026, 2:20:38 PM] > codeyam-combo@1.0.0 mergeDependencies
+[3/25/2026, 2:20:38 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[3/24/2026, 2:27:03 PM] Merged dependencies into root package.json
+[3/25/2026, 2:20:38 PM] Merged dependencies into root package.json
 

package/analyzer-template/packages/ai/src/lib/astScopes/methodSemantics.ts

@@ -895,6 +895,132 @@ export class UseStateSemantics implements MethodSemantics {
   }
 }
 
+// ─── Set/Map method semantics ──────────────────────────────────────────
+//
+// Set/Map membership operations (.has, .delete, .add, .get, .set, .clear)
+// don't create data flow equivalencies — they're membership checks or
+// mutations, not transformations that propagate schema structure.
+// Without these semantics, code like `filterRatings.has(articleId)` creates
+// spurious equivalencies (332 entries in the Margo LibraryPage case).
+
+/**
+ * Set.has() / Map.has() — membership check, returns boolean
+ */
+export class CollectionHasSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'boolean';
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    _sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    context.addType(methodCallPath, 'boolean');
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Set.delete() / Map.delete() — removal, returns boolean
+ */
+export class CollectionDeleteSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'boolean';
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    _sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    context.addType(methodCallPath, 'boolean');
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Set.add() — adds an element, returns the Set (for chaining)
+ */
+export class SetAddSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'object'; // Returns the Set itself
+  }
+
+  addEquivalences(
+    _methodCallPath: StructuredPath,
+    _sourcePath: StructuredPath,
+    _context: AnalysisContext,
+  ): void {
+    // No equivalencies — add() doesn't create data flow
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Set.clear() / Map.clear() — removes all elements, returns void
+ */
+export class CollectionClearSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'void';
+  }
+
+  addEquivalences(): void {
+    // No equivalencies
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Map.get() — retrieves a value by key, returns unknown (value type)
+ */
+export class MapGetSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'unknown';
+  }
+
+  addEquivalences(
+    _methodCallPath: StructuredPath,
+    _sourcePath: StructuredPath,
+    _context: AnalysisContext,
+  ): void {
+    // No equivalencies — the return value type depends on the map contents
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
+/**
+ * Map.set() — sets a key-value pair, returns the Map (for chaining)
+ */
+export class MapSetSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'object'; // Returns the Map itself
+  }
+
+  addEquivalences(): void {
+    // No equivalencies
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
 /**
  * Create and populate the registry with method semantics
  */
@@ -930,6 +1056,15 @@ export function createMethodRegistry(): MethodSemanticsRegistry {
   registry.register('useState', new UseStateSemantics(), 'React');
   registry.register('useMemo', new UseMemoSemantics(), 'React');
 
+  // Register Set/Map collection methods.
+  // Only .has() and .delete() are safe to register by method name — they always
+  // return boolean regardless of the collection type (Set, Map, WeakSet, WeakMap,
+  // FormData, URLSearchParams, etc.).
+  // .add(), .clear(), .get(), .set() are too ambiguous across different types
+  // and can't be registered until the lookup code supports class-aware resolution.
+  registry.register('has', new CollectionHasSemantics());
+  registry.register('delete', new CollectionDeleteSemantics());
+
   return registry;
 }
 

package/analyzer-template/packages/ai/src/lib/astScopes/nodeToSource.ts

@@ -54,6 +54,25 @@ export function nodeToSource(
   //   return serializeBindingElement(node, sourceFile, options);
   // }
 
+  // Object/array/function literals should be marked as literal paths.
+  // This prevents them from creating sourceEquivalencies when used as
+  // function call arguments (e.g., setUndoEntry({ label: '...', undo: ... })).
+  // Without this, the full source text of the literal (300-500 chars for complex
+  // objects) gets embedded in path strings, creating expensive-to-parse
+  // equivalency entries that don't contribute useful schema information.
+  if (ts.isObjectLiteralExpression(node)) {
+    return StructuredPath.createLiteralPath(node.getText(sourceFile), 'object');
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    return StructuredPath.createLiteralPath(node.getText(sourceFile), 'array');
+  }
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    return StructuredPath.createLiteralPath(
+      node.getText(sourceFile),
+      'function',
+    );
+  }
+
   // Fallback for unsupported node types
   return StructuredPath.fromBase(node.getText(sourceFile));
 }

package/analyzer-template/packages/ai/src/lib/astScopes/paths.ts

@@ -406,11 +406,18 @@ export class StructuredPath {
           } else {
             // Convert each argument to its string representation
             const argsStr = funcSegment.args
-              .map((arg) =>
-                arg.toStringWithSegments(arg.base, arg.segments, {
+              .map((arg) => {
+                // For literal arguments (object/array/function literals),
+                // use a compact placeholder instead of the full source text.
+                // This prevents 300-500 char inline objects from being embedded
+                // in call signature paths, which creates expensive equivalencies.
+                if (arg.isLiteral()) {
+                  return `{...}`;
+                }
+                return arg.toStringWithSegments(arg.base, arg.segments, {
                   withReturnValues: doRenderNestedFunctionCallReturnValue,
-                }),
-              )
+                });
+              })
               .join(', ');
             result += `(${argsStr})`;
           }

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateDataStructure.ts

@@ -538,9 +538,10 @@ export default function generateDataStructure({
       dependencySchemas: isolatedDataStructure?.dependencySchemas || {},
     });
 
+    const mergeTimedOut = !!(mergedDataStructure as any).timedOut;
     awsLogDebugLevel(
       1,
-      `mergeInDependentDataStructure complete for ${entity.name}: ` +
+      `mergeInDependentDataStructure ${mergeTimedOut ? 'PARTIAL' : 'complete'} for ${entity.name}: ` +
         `${Object.keys(mergedDataStructure.signatureSchema).length} sig, ` +
         `${Object.keys(mergedDataStructure.returnValueSchema).length} ret, ${Date.now() - mergeStart}ms`,
     );
@@ -921,6 +922,9 @@ export default function generateDataStructure({
 
     analysis.metadata ||= {};
     analysis.metadata.mergedDataStructure = mergedDataStructure;
+    if (mergeTimedOut) {
+      (analysis.metadata as any).mergeTimedOut = true;
+    }
 
     const checkGenDeadline = (phase: string) => {
       if (Date.now() > genDeadline) {