@codeyam/codeyam-cli 0.1.0-staging.09652b8 → 0.1.0-staging.28f73cf

package/analyzer-template/packages/ai/src/lib/worker/SerializableDataStructure.ts

@@ -34,6 +34,28 @@ export interface SerializableFunctionResult {
   environmentVariables: string[];
 }
 
+/**
+ * Enriched conditional usage that includes traced source data path.
+ * The sourceDataPath connects a local variable (used in conditionals) back to
+ * the original data attribute from the attributes map.
+ */
+export interface EnrichedConditionalUsage {
+  /** The local variable path (e.g., "activeTab") */
+  path: string;
+  /** The type of condition this attribute is used in */
+  conditionType: 'truthiness' | 'comparison' | 'switch';
+  /** For comparison conditions, the literal values being compared against */
+  comparedValues?: string[];
+  /** Where this conditional usage occurs */
+  location: 'if' | 'ternary' | 'logical-and' | 'switch';
+  /**
+   * The traced source data path in the format "scopeName.path"
+   * e.g., "useParams().functionCallReturnValue['*']"
+   * This connects the local variable to the original data attribute.
+   */
+  sourceDataPath?: string;
+}
+
 export interface SerializableDataStructure {
   // External function calls array
   externalFunctionCalls: SerializableFunctionCallInfo[];
@@ -48,6 +70,13 @@ export interface SerializableDataStructure {
   equivalentSignatureVariables: Record<string, string>;
 
   environmentVariables: string[];
+
+  /**
+   * Conditional usages with source tracing.
+   * Maps local variable path to array of enriched usages that include
+   * the traced source data path.
+   */
+  conditionalUsages?: Record<string, EnrichedConditionalUsage[]>;
 }
 
 /**
@@ -182,3 +211,13 @@ export function getEquivalentSignatureVariables(
 ): Record<string, string> {
   return dataStructure.equivalentSignatureVariables;
 }
+
+/**
+ * Get enriched conditional usages with source tracing.
+ * Returns the conditional usages map, or empty object if not available.
+ */
+export function getConditionalUsages(
+  dataStructure: SerializableDataStructure,
+): Record<string, EnrichedConditionalUsage[]> {
+  return dataStructure.conditionalUsages ?? {};
+}

package/analyzer-template/packages/analyze/src/lib/FileAnalyzer.ts

@@ -278,11 +278,16 @@ export class FileAnalyzer {
 
         for (let i = 0; i < uniqueRelevantExpressions.length; i++) {
           const relevantExpression = uniqueRelevantExpressions[i];
-          if (
-            relevantExpression.exportName === '*' &&
+          // Resolve namespace imports for local packages (not external libraries).
+          // A module is local if it's not external OR if it resolves to a path outside node_modules
+          // (handles local monorepo packages like @codeyam/ui-components).
+          // If resolvedFileName is undefined, we can't determine location, so treat as external.
+          const isLocalModule =
             resolvedModule &&
-            !resolvedModule.isExternalLibraryImport
-          ) {
+            (!resolvedModule.isExternalLibraryImport ||
+              (resolvedModule.resolvedFileName &&
+                !resolvedModule.resolvedFileName.includes('node_modules')));
+          if (relevantExpression.exportName === '*' && isLocalModule) {
             uniqueRelevantExpressions.splice(i, 1);
             uniqueRelevantExpressions.push(
               ...this.resolveNamespaceImport(
@@ -295,11 +300,18 @@ export class FileAnalyzer {
         }
 
         if (uniqueRelevantExpressions.length > 0) {
-          // Debug logging for ./types imports
+          // A module is external if TypeScript says so AND the resolved path is in node_modules.
+          // This handles local monorepo packages (like @codeyam/ui-components) which TypeScript
+          // marks as isExternalLibraryImport=true because they're symlinked, but actually
+          // resolve to files inside the project (not in node_modules).
+          const isExternalLibrary =
+            (resolvedModule?.isExternalLibraryImport ?? true) &&
+            (resolvedModule?.resolvedFileName?.includes('node_modules') ??
+              true);
           return [
             importedFilePath,
             {
-              externalLibrary: resolvedModule?.isExternalLibraryImport ?? true,
+              externalLibrary: isExternalLibrary,
               resolvedPath: resolvedModule?.resolvedFileName,
               exportInfos: uniqueRelevantExpressions,
             },

package/analyzer-template/packages/analyze/src/lib/asts/nodes/index.ts

@@ -163,7 +163,8 @@ export function isFunction(
     ts.isFunctionDeclaration(node) ||
     ts.isFunctionExpression(node) ||
     ts.isArrowFunction(node) ||
-    ts.isCallExpression(node)
+    ts.isCallExpression(node) ||
+    ts.isClassDeclaration(node)
   );
 }
 

package/analyzer-template/packages/analyze/src/lib/files/analyze/analyzeEntities/prepareDataStructures.ts

@@ -12,7 +12,7 @@ import {
   getReturnValue,
   getSourceEquivalencies,
   getUsageEquivalencies,
-  getConditionalUsagesFromCode,
+  getConditionalUsages,
   detectWrapperRequirements,
 } from '~codeyam/ai';
 import type { AnalysisOptions } from '../analyzeEntities';
@@ -94,11 +94,6 @@ export default async function prepareEntityDataStructures(
           }
         }
 
-        // Extract conditional usages from the entity code for key attribute detection
-        const conditionalUsages = entity.code
-          ? getConditionalUsagesFromCode(entity.code)
-          : {};
-
         entity.metadata.isolatedDataStructure = {
           signatureSchema: deduplicateFunctionSchemas(
             isolatedDataStructure.signatureSchema,
@@ -110,10 +105,8 @@ export default async function prepareEntityDataStructures(
             isolatedDataStructure.equivalentSignatureVariables,
           dependencySchemas: clonedDependencySchemas,
           environmentVariables: isolatedDataStructure.environmentVariables,
-          conditionalUsages:
-            Object.keys(conditionalUsages).length > 0
-              ? conditionalUsages
-              : undefined,
+          // Use enriched conditional usages with source tracing from analysis
+          conditionalUsages: isolatedDataStructure.conditionalUsages,
         };
 
         // Detect wrapper requirements (Context providers, etc.)
@@ -290,6 +283,9 @@ async function getEntityDataStructureAndFunctionCalls({
   const clonedRawSignature = { ...rawSignature };
   const clonedRawReturnValue = { ...rawReturnValue };
 
+  // Get enriched conditional usages with source tracing
+  const conditionalUsages = getConditionalUsages(dataStructure);
+
   const isolatedDataStructure = {
     signatureSchema: deduplicateFunctionSchemas(clonedRawSignature),
     returnValueSchema: deduplicateFunctionSchemas(clonedRawReturnValue),
@@ -297,6 +293,8 @@ async function getEntityDataStructureAndFunctionCalls({
       getEquivalentSignatureVariables(dataStructure),
     dependencySchemas,
     environmentVariables: dataStructure.environmentVariables,
+    conditionalUsages:
+      Object.keys(conditionalUsages).length > 0 ? conditionalUsages : undefined,
   };
 
   const functionCalls: Record<string, string[]> = {};

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

@@ -18,7 +18,7 @@ import {
   upsertEntities,
 } from '~codeyam/supabase';
 import { getCandidatesReadyForCapture as getAnalysesReadyForCapture } from './dependencyResolver';
-import { awsLog, awsLogDebugLevel } from '~codeyam/utils';
+import { awsLog, awsLogDebugLevel, Semaphore } from '~codeyam/utils';
 
 const MAX_CONCURRENT_ANALYSES = 100; // fairly arbitrary, but more isn't necessarily better
 
@@ -133,6 +133,10 @@ export default async function analyzeEntities({
   const markedReady = new Set<string>(); // Analyses we've attempted to mark ready
   const analyses: Analysis[] = [];
 
+  // Semaphore to serialize CPU-intensive Structure phase while allowing
+  // I/O-bound KeyAttributes LLM calls to run in parallel
+  const structureSemaphore = new Semaphore(1);
+
   const analysesAlreadyCompletedAtStart =
     commit?.metadata?.currentRun?.analysesCompleted ?? 0;
 
@@ -442,6 +446,7 @@ export default async function analyzeEntities({
           analyzeAsDependency: !allRootEntities.some(
             (e) => e.filePath === entity.filePath && e.name === entity.name,
           ),
+          structureSemaphore,
           ...options,
           force,
         }),

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

@@ -73,14 +73,16 @@ export default async function gatherEntityMap({
     );
 
     if (!importedFile) {
+      // Skip dependencies when the file is not found in project.files.
+      // This commonly happens when a universal mock intercepts the import:
+      // 1. TypeScript resolves @formbricks/types/errors to the mock file
+      // 2. The original packages/types/errors.ts is never imported
+      // 3. So it's not in getSourceFiles() and thus not in project.files
+      // 4. Since the mock handles the import, we don't need to analyze the original
       console.log(
-        `CodeYam Error: File not found while gathering entity map: ${importedExportFilePath}`,
-        entity.filePath,
-        entity.name,
-      );
-      throw new Error(
-        `File not found while gathering entity map: ${importedExportFilePath}`,
+        `CodeYam Warning: Skipping dependency - file not in project.files (likely mocked): ${importedExportFilePath}`,
       );
+      continue;
     }
 
     let importedEntity = context.getEntity(

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

@@ -99,19 +99,11 @@ function traverseEntity(
     );
 
     if (!dependentEntity) {
-      console.log(
-        'CodeYam Error: trackEntityCircularDependencies: Dependent entity not found',
-        {
-          entityFilePath: entity.filePath,
-          entityName: entity.name,
-          dependencyFilePath,
-          dependencyName,
-          fileEntities: context.getEntityNamesForFile(dependencyFilePath),
-        },
-      );
-      throw new Error(
-        'trackEntityCircularDependencies: Dependent entity not found',
-      );
+      // Skip dependencies when the entity is not found in context.
+      // This commonly happens when a universal mock intercepts the import:
+      // - gatherEntityMap skips adding the entity because the file isn't in project.files
+      // - The mock handles the import at runtime, so we don't need to track it
+      continue;
     }
 
     // Recursively traverse (will skip if already visited)

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

@@ -16,7 +16,12 @@ import { AI } from '~codeyam/ai';
 import extractDiffLines from './extractDiffLines';
 import analyzeCodeChange from './analyzeCodeChange';
 import relevantDiffPart from './relevantDiffPart';
-import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
+import {
+  awsLog,
+  awsLogDebugLevel,
+  pushAnalysisError,
+  Semaphore,
+} from '~codeyam/utils';
 
 export interface AnalyzeChangeArgs {
   previousAnalysis: Analysis;
@@ -29,6 +34,8 @@ export interface AnalyzeChangeArgs {
   steps?: string[];
   updateProgress?: (detail: string) => void;
   model: AI.Model;
+  /** Semaphore to serialize CPU-intensive Structure phase */
+  structureSemaphore?: Semaphore;
 }
 
 export default async function analyzeChange({
@@ -42,6 +49,7 @@ export default async function analyzeChange({
   steps,
   updateProgress,
   model,
+  structureSemaphore,
 }: AnalyzeChangeArgs) {
   analysis.entity = entity;
   awsLog('CodeYam: Analyzing change entity', {
@@ -79,24 +87,35 @@ export default async function analyzeChange({
       });
     }
 
+    // Structure phase: CPU-intensive, serialize via semaphore if provided
     if (!steps || steps.includes(Step.Structure)) {
-      awsLogDebugLevel(
-        1,
-        `Merging dependent data structures for ${entity.name}...`,
-      );
+      if (structureSemaphore) {
+        await structureSemaphore.acquire();
+      }
+      try {
+        awsLogDebugLevel(
+          1,
+          `Merging dependent data structures for ${entity.name}...`,
+        );
 
-      const { step: dataStructureStep } = await recordStep(
-        'generateDataStructure',
-        () =>
-          generateDataStructure({
-            entity,
-            dependentAnalyses,
-            analysis,
-          }),
-      );
-      analysis.status.steps.push(dataStructureStep);
+        const { step: dataStructureStep } = await recordStep(
+          'generateDataStructure',
+          () =>
+            generateDataStructure({
+              entity,
+              dependentAnalyses,
+              analysis,
+            }),
+        );
+        analysis.status.steps.push(dataStructureStep);
+      } finally {
+        if (structureSemaphore) {
+          structureSemaphore.release();
+        }
+      }
     }
 
+    // KeyAttributes phase: I/O-bound LLM call, can run in parallel with other entities' Structure
     if (!steps || steps.includes(Step.KeyAttributes)) {
       awsLogDebugLevel(1, `Determining key attributes for ${entity.name}...`);
 

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

@@ -31,7 +31,12 @@ import relevantDiffPart from './relevantDiffPart';
 import { Step } from './enums/steps';
 import { ImmutableAnalysisContext } from '../analysisContext';
 import generateAnalyzedTreeSha from './analyze/generateAnalyzedTreeSha';
-import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
+import {
+  awsLog,
+  awsLogDebugLevel,
+  pushAnalysisError,
+  Semaphore,
+} from '~codeyam/utils';
 
 export interface AnalyzeEntityArgs {
   project: Project;
@@ -50,6 +55,8 @@ export interface AnalyzeEntityArgs {
   forceAll?: boolean;
   updateProgress?: (detail: string) => void;
   modelString?: string;
+  /** Semaphore to serialize CPU-intensive Structure phase */
+  structureSemaphore?: Semaphore;
 }
 
 /**
@@ -77,6 +84,7 @@ export default async function analyzeEntity({
   forceAll,
   updateProgress,
   modelString,
+  structureSemaphore,
 }: AnalyzeEntityArgs): Promise<{
   analysis: Analysis;
   dependentAnalyses?: ReadonlyAnalysisMap;
@@ -476,6 +484,7 @@ export default async function analyzeEntity({
             steps,
             updateProgress,
             model,
+            structureSemaphore,
           })
         : analyzeInitial({
             analysis,
@@ -485,6 +494,7 @@ export default async function analyzeEntity({
             steps,
             updateProgress,
             model,
+            structureSemaphore,
           }),
     ]);
 
@@ -498,8 +508,12 @@ export default async function analyzeEntity({
     analysis = analysisResult.analysis;
 
     analysis.completedAt = new Date().toISOString();
-    // Don't set analyzedTreeSha when ONLY_DATA_STRUCTURE=true, so full analysis can re-analyze later
-    if (process.env.ONLY_DATA_STRUCTURE !== 'true') {
+    // Don't set analyzedTreeSha when:
+    // 1. ONLY_DATA_STRUCTURE=true - so full analysis can re-analyze later
+    // 2. analyzeAsDependency=true - dependency analyses only generate Structure+KeyAttributes,
+    //    not scenarios. Leaving analyzedTreeSha unset allows partial analysis detection to work
+    //    when the entity is later analyzed directly.
+    if (process.env.ONLY_DATA_STRUCTURE !== 'true' && !analyzeAsDependency) {
       analysis.analyzedTreeSha = generateAnalyzedTreeSha(analysis);
     }
   } catch (error) {

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

@@ -12,7 +12,12 @@ import {
   type ReadonlyAnalysisMap,
 } from '~codeyam/types';
 import { upsertAnalysesWithScenarios } from '~codeyam/supabase';
-import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
+import {
+  awsLog,
+  awsLogDebugLevel,
+  pushAnalysisError,
+  Semaphore,
+} from '~codeyam/utils';
 import generateKeyAttributes from './scenarios/generateKeyAttributes';
 
 export interface AnalyzeInitialArgs {
@@ -23,6 +28,8 @@ export interface AnalyzeInitialArgs {
   steps?: string[];
   updateProgress?: (detail: string) => void;
   model: AI.Model;
+  /** Semaphore to serialize CPU-intensive Structure phase */
+  structureSemaphore?: Semaphore;
 }
 
 export default async function analyzeInitial({
@@ -33,6 +40,7 @@ export default async function analyzeInitial({
   steps,
   updateProgress,
   model,
+  structureSemaphore,
 }: AnalyzeInitialArgs) {
   analysis.entity = entity;
   awsLog('CodeYam: Analyzing initial entity', {
@@ -47,22 +55,32 @@ export default async function analyzeInitial({
   });
 
   try {
+    // Structure phase: CPU-intensive, serialize via semaphore if provided
     if (!steps || steps.includes(Step.Structure)) {
-      awsLogDebugLevel(
-        1,
-        `Merging dependent data structures for ${entity.name}...`,
-      );
-
-      const { step: dataStructureStep } = await recordStep(
-        'generateDataStructure',
-        () =>
-          generateDataStructure({
-            entity,
-            dependentAnalyses,
-            analysis,
-          }),
-      );
-      analysis.status.steps.push(dataStructureStep);
+      if (structureSemaphore) {
+        await structureSemaphore.acquire();
+      }
+      try {
+        awsLogDebugLevel(
+          1,
+          `Merging dependent data structures for ${entity.name}...`,
+        );
+
+        const { step: dataStructureStep } = await recordStep(
+          'generateDataStructure',
+          () =>
+            generateDataStructure({
+              entity,
+              dependentAnalyses,
+              analysis,
+            }),
+        );
+        analysis.status.steps.push(dataStructureStep);
+      } finally {
+        if (structureSemaphore) {
+          structureSemaphore.release();
+        }
+      }
     }
 
     // Short-circuit for test mocking: only generate data structure, skip key attributes and scenarios
@@ -73,6 +91,7 @@ export default async function analyzeInitial({
       return { analysis };
     }
 
+    // KeyAttributes phase: I/O-bound LLM call, can run in parallel with other entities' Structure
     if (!steps || steps.includes(Step.KeyAttributes)) {
       awsLogDebugLevel(1, `Determining key attributes for ${entity.name}...`);
 

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

@@ -54,8 +54,14 @@ export default function generateDataStructure({
     const nonMockedDependentAnalyses: ReadonlyAnalysisMap =
       allImportedExports.reduce((acc, importedExport) => {
         if (importedExport.isMocked) return acc;
+        // Use resolvedFilePath when available (for re-exports from index files)
+        // to find the actual analysis of the component
+        const lookupPath =
+          ('resolvedFilePath' in importedExport &&
+            importedExport.resolvedFilePath) ||
+          importedExport.filePath;
         const relevantDependencyAnalysis =
-          dependentAnalyses[importedExport.filePath]?.[importedExport.name];
+          dependentAnalyses[lookupPath]?.[importedExport.name];
 
         if (!relevantDependencyAnalysis) {
           // console.info(

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

@@ -8,6 +8,7 @@ import measureAndReportExecutionTime from '../../utils/measureAndReportExecution
 import { AI, generateEntityKeyAttributes } from '~codeyam/ai';
 import { awsLog } from '~codeyam/utils';
 import { gatherRelevantDependentKeyAttributes } from '~codeyam/ai';
+import { gatherDataForMocks } from './generateScenarioData';
 
 export interface GenerateEntityKeyAttributesArgs {
   entity: Entity;
@@ -28,7 +29,14 @@ export default async function generateKeyAttributes({
 }: GenerateEntityKeyAttributesArgs): Promise<void> {
   if (!['visual', 'library'].includes(entity.entityType)) return;
 
-  const structure = { ...analysis.metadata.scenariosDataStructure };
+  // Merge direct dataForMocks with recursively gathered data from dependencies
+  const structure = {
+    arguments: analysis.metadata.scenariosDataStructure?.arguments ?? [],
+    dataForMocks: {
+      ...(analysis.metadata.scenariosDataStructure?.dataForMocks ?? {}),
+      ...gatherDataForMocks(analysis, dependentAnalyses),
+    },
+  };
 
   awsLog(`🔮 Generating ${error ? 'error ' : ''}scenarios for`, {
     filePath: entity.filePath,

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

@@ -104,8 +104,13 @@ export function gatherDataForMocks(
       // regardless of whether we found a relevantKey above.
       // This ensures transitive dependencies are included.
       // For example: Activity -> CurrentActivityTab -> useLastLogLine
+      // Use resolvedFilePath when available (for re-exports from index files)
+      const lookupPath =
+        ('resolvedFilePath' in importedExport &&
+          importedExport.resolvedFilePath) ||
+        importedExport.filePath;
       const dependentAnalysis =
-        dependentAnalyses?.[importedExport.filePath]?.[importedExport.name];
+        dependentAnalyses?.[lookupPath]?.[importedExport.name];
 
       if (dependentAnalysis && !analysesGathered.has(dependentAnalysis.id)) {
         analysesGathered.add(dependentAnalysis.id);

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

@@ -7,6 +7,7 @@ import {
 import measureAndReportExecutionTime from '../../utils/measureAndReportExecutionTime';
 import { AI, generateEntityScenarios } from '~codeyam/ai';
 import { awsLog } from '~codeyam/utils';
+import { gatherDataForMocks } from './generateScenarioData';
 
 export interface GenerateScenariosArgs {
   entity: Entity;
@@ -27,7 +28,14 @@ export default async function generateScenarios({
 }: GenerateScenariosArgs): Promise<void> {
   if (!['visual', 'library'].includes(entity.entityType)) return;
 
-  const structure = { ...analysis.metadata.scenariosDataStructure };
+  // Merge direct dataForMocks with recursively gathered data from dependencies
+  const structure = {
+    arguments: analysis.metadata.scenariosDataStructure?.arguments ?? [],
+    dataForMocks: {
+      ...(analysis.metadata.scenariosDataStructure?.dataForMocks ?? {}),
+      ...gatherDataForMocks(analysis, dependentAnalyses),
+    },
+  };
 
   awsLog(`🔮 Generating ${error ? 'error ' : ''}scenarios for`, {
     filePath: entity.filePath,

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.d.ts

@@ -0,0 +1,23 @@
+interface GetPresignedUploadUrlArgs {
+    bucketName: string;
+    key: string;
+    contentType?: string;
+    expiresInSeconds?: number;
+}
+interface GetPresignedDownloadUrlArgs {
+    bucketName: string;
+    key: string;
+    expiresInSeconds?: number;
+}
+/**
+ * Generate a presigned URL for uploading a file to S3.
+ * The client can PUT directly to this URL without AWS credentials.
+ */
+export declare function getPresignedUploadUrl({ bucketName, key, contentType, expiresInSeconds, }: GetPresignedUploadUrlArgs): Promise<string>;
+/**
+ * Generate a presigned URL for downloading a file from S3.
+ * Anyone with this URL can GET the file without AWS credentials.
+ */
+export declare function getPresignedDownloadUrl({ bucketName, key, expiresInSeconds, }: GetPresignedDownloadUrlArgs): Promise<string>;
+export {};
+//# sourceMappingURL=getPresignedUrl.d.ts.map

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPresignedUrl.d.ts","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAOA,UAAU,yBAAyB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,2BAA2B;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,EAC1C,UAAU,EACV,GAAG,EACH,WAAgC,EAChC,gBAAwC,GACzC,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAU7C;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,EAC5C,UAAU,EACV,GAAG,EACH,gBAA0C,GAC3C,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAS/C"}

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.js

@@ -0,0 +1,30 @@
+import { S3Client, PutObjectCommand, GetObjectCommand, } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+const DEFAULT_UPLOAD_EXPIRY = 2 * 60 * 60; // 2 hours
+const DEFAULT_DOWNLOAD_EXPIRY = 24 * 60 * 60; // 24 hours
+/**
+ * Generate a presigned URL for uploading a file to S3.
+ * The client can PUT directly to this URL without AWS credentials.
+ */
+export async function getPresignedUploadUrl({ bucketName, key, contentType = 'application/gzip', expiresInSeconds = DEFAULT_UPLOAD_EXPIRY, }) {
+    const s3Client = new S3Client({});
+    const command = new PutObjectCommand({
+        Bucket: bucketName,
+        Key: key,
+        ContentType: contentType,
+    });
+    return getSignedUrl(s3Client, command, { expiresIn: expiresInSeconds });
+}
+/**
+ * Generate a presigned URL for downloading a file from S3.
+ * Anyone with this URL can GET the file without AWS credentials.
+ */
+export async function getPresignedDownloadUrl({ bucketName, key, expiresInSeconds = DEFAULT_DOWNLOAD_EXPIRY, }) {
+    const s3Client = new S3Client({});
+    const command = new GetObjectCommand({
+        Bucket: bucketName,
+        Key: key,
+    });
+    return getSignedUrl(s3Client, command, { expiresIn: expiresInSeconds });
+}
+//# sourceMappingURL=getPresignedUrl.js.map

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPresignedUrl.js","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAe7D,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU;AACrD,MAAM,uBAAuB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,WAAW;AAEzD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,EAC1C,UAAU,EACV,GAAG,EACH,WAAW,GAAG,kBAAkB,EAChC,gBAAgB,GAAG,qBAAqB,GACd;IAC1B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;QACR,WAAW,EAAE,WAAW;KACzB,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,EAC5C,UAAU,EACV,GAAG,EACH,gBAAgB,GAAG,uBAAuB,GACd;IAC5B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC;QACnC,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,GAAG;KACT,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAC1E,CAAC"}

package/analyzer-template/packages/aws/package.json

@@ -11,14 +11,15 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@aws-sdk/client-codebuild": "^3.940.0",
+    "@aws-sdk/client-codebuild": "^3.948.0",
     "@aws-sdk/client-cloudwatch-logs": "^3.940.0",
     "@aws-sdk/client-dynamodb": "^3.899.0",
-    "@aws-sdk/client-ecr": "^3.946.0",
+    "@aws-sdk/client-ecr": "^3.948.0",
     "@aws-sdk/client-ecs": "^3.937.0",
-    "@aws-sdk/client-s3": "^3.899.0",
+    "@aws-sdk/client-s3": "^3.940.0",
     "@aws-sdk/client-sqs": "^3.940.0",
-    "@aws-sdk/lib-storage": "^3.899.0",
+    "@aws-sdk/lib-storage": "^3.940.0",
+    "@aws-sdk/s3-request-presigner": "^3.940.0",
     "@aws-sdk/util-dynamodb": "^3.902.0"
   }
 }

package/analyzer-template/packages/aws/s3/index.ts

@@ -1,2 +1,6 @@
 // Direct export for s3 functions only
 export { default as s3UploadFile } from '../src/lib/s3/uploadFileToS3';
+export {
+  getPresignedUploadUrl,
+  getPresignedDownloadUrl,
+} from '../src/lib/s3/getPresignedUrl';