@codeyam/codeyam-cli 0.1.0-staging.da5baf5 → 0.1.0-staging.e38f7bd

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

@@ -31,12 +31,6 @@ export default function generateDataStructure({
     awsLog('CodeYam: Generating data structure for', {
       filePath: entity.filePath,
       entityName: entity.name,
-      // dependentAnalyses: Object.keys(dependentAnalyses).flatMap((path) =>
-      //   Object.keys(dependentAnalyses[path]).flatMap((entityName) => ({
-      //     path,
-      //     entityName,
-      //   })),
-      // ),
     });
 
     const allImportedExports = [
@@ -51,6 +45,58 @@ export default function generateDataStructure({
           ),
       ),
     ];
+
+    // For implicit dependencies (like root.tsx layouts), include their mocked nodeModuleImports
+    // This ensures layout file dependencies (like useLoaderData in root.tsx) are included in dataForMocks
+    // when simulating routes that are wrapped by those layout files
+    for (const importedExport of entity.metadata.importedExports ?? []) {
+      if (
+        !('isImplicitDependency' in importedExport) ||
+        !importedExport.isImplicitDependency
+      ) {
+        continue;
+      }
+
+      // Look up the implicit dependency's analysis
+      const implicitDepAnalysis =
+        dependentAnalyses[importedExport.filePath]?.[importedExport.name];
+
+      // Access nodeModuleImports from the entity attached to the analysis
+      const nodeModuleImports =
+        implicitDepAnalysis?.entity?.metadata?.nodeModuleImports;
+      if (!nodeModuleImports) {
+        continue;
+      }
+
+      // Add the implicit dependency's mocked nodeModuleImports to allImportedExports
+      for (const moduleName of Object.keys(nodeModuleImports)) {
+        const moduleImports = nodeModuleImports[moduleName] || [];
+        for (const imported of moduleImports) {
+          if (!imported.isMocked) continue;
+
+          // Only add if not already present (avoid duplicates)
+          const alreadyExists = allImportedExports.some(
+            (existing) =>
+              existing.filePath === moduleName &&
+              existing.name === imported.name,
+          );
+
+          if (!alreadyExists) {
+            allImportedExports.push({
+              filePath: moduleName,
+              name: imported.name,
+              isDefault: imported.isDefault,
+              isMocked: imported.isMocked,
+              calls: imported.calls ? [...imported.calls] : undefined,
+              callVariableNames: imported.callVariableNames
+                ? [...imported.callVariableNames]
+                : undefined,
+            });
+          }
+        }
+      }
+    }
+
     const nonMockedDependentAnalyses: ReadonlyAnalysisMap =
       allImportedExports.reduce((acc, importedExport) => {
         if (importedExport.isMocked) return acc;
@@ -63,6 +109,55 @@ export default function generateDataStructure({
         const relevantDependencyAnalysis =
           dependentAnalyses[lookupPath]?.[importedExport.name];
 
+        // DEBUG: Track buildBranchFileMap and fileComparisons
+        if (
+          importedExport.name === 'buildBranchFileMap' ||
+          entity.name === 'GitView'
+        ) {
+          console.log('🔍 DEBUG generateDataStructure:', {
+            entityName: entity.name,
+            importedExportName: importedExport.name,
+            lookupPath,
+            hasAnalysis: !!relevantDependencyAnalysis,
+            signatureSchema:
+              relevantDependencyAnalysis?.metadata?.mergedDataStructure
+                ?.signatureSchema,
+            dependencySchemas: relevantDependencyAnalysis?.metadata
+              ?.mergedDataStructure?.dependencySchemas
+              ? Object.keys(
+                  relevantDependencyAnalysis.metadata.mergedDataStructure
+                    .dependencySchemas,
+                )
+              : null,
+          });
+          if (
+            relevantDependencyAnalysis?.metadata?.mergedDataStructure
+              ?.signatureSchema
+          ) {
+            const sig =
+              relevantDependencyAnalysis.metadata.mergedDataStructure
+                .signatureSchema;
+            console.log(
+              '🔍 DEBUG buildBranchFileMap signature keys:',
+              Object.keys(sig),
+            );
+            // Look for fileComparisons in the signature
+            for (const key of Object.keys(sig)) {
+              if (
+                key.includes('fileComparisons') ||
+                key.includes('entityDiff')
+              ) {
+                console.log(
+                  '🔍 DEBUG Found relevant key:',
+                  key,
+                  '=',
+                  JSON.stringify(sig[key], null, 2),
+                );
+              }
+            }
+          }
+        }
+
         if (!relevantDependencyAnalysis) {
           // console.info(
           //   'CodeYam Warn: No relevant dependency analysis found for importedExport',
@@ -129,6 +224,7 @@ export default function generateDataStructure({
     // );
 
     const { isolatedDataStructure } = entity.metadata;
+
     const mergedDataStructure = mergeInDependentDataStructure({
       importedExports: allImportedExports,
       dependentAnalyses: nonMockedDependentAnalyses,
@@ -143,6 +239,39 @@ export default function generateDataStructure({
       dependencySchemas: isolatedDataStructure?.dependencySchemas || {},
     });
 
+    // DEBUG: Check merged result for GitView
+    if (entity.name === 'GitView') {
+      console.log(
+        '🔍 DEBUG GitView mergedDataStructure dependency schemas:',
+        Object.keys(mergedDataStructure.dependencySchemas || {}),
+      );
+      for (const filePath of Object.keys(
+        mergedDataStructure.dependencySchemas || {},
+      )) {
+        for (const depName of Object.keys(
+          mergedDataStructure.dependencySchemas[filePath] || {},
+        )) {
+          const depSchema =
+            mergedDataStructure.dependencySchemas[filePath][depName];
+          console.log(
+            `🔍 DEBUG Merged dep ${filePath}/${depName} signature keys:`,
+            Object.keys(depSchema.signatureSchema || {}),
+          );
+          // Look for fileComparisons
+          for (const key of Object.keys(depSchema.signatureSchema || {})) {
+            if (key.includes('fileComparisons') || key.includes('entityDiff')) {
+              console.log(
+                '🔍 DEBUG MERGED Found relevant key:',
+                key,
+                '=',
+                JSON.stringify(depSchema.signatureSchema[key], null, 2),
+              );
+            }
+          }
+        }
+      }
+    }
+
     mergedDataStructure.environmentVariables =
       isolatedDataStructure.environmentVariables || [];
 
@@ -202,6 +331,28 @@ export default function generateDataStructure({
       mergedDataStructure.dependencySchemas,
     );
 
+    // DEBUG: Check dataForMocks for GitView
+    if (entity.name === 'GitView') {
+      console.log(
+        '🔍 DEBUG GitView dataForMocks keys:',
+        Object.keys(dataForMocks),
+      );
+      for (const key of Object.keys(dataForMocks)) {
+        if (
+          key.includes('buildBranchFileMap') ||
+          key.includes('fileComparisons') ||
+          key.includes('entityDiff')
+        ) {
+          console.log(
+            '🔍 DEBUG dataForMocks relevant key:',
+            key,
+            '=',
+            JSON.stringify(dataForMocks[key], null, 2),
+          );
+        }
+      }
+    }
+
     // console.info(
     //   'CODEYAM DEBUG: dataForMocks',
     //   JSON.stringify(
@@ -215,6 +366,24 @@ export default function generateDataStructure({
     //   ),
     // );
 
+    // Log union types in signatureSchema before processing
+    const unionTypeEntries = Object.entries(
+      mergedDataStructure.signatureSchema,
+    ).filter(
+      ([_, value]) =>
+        typeof value === 'string' &&
+        value.includes("'") &&
+        value.includes(' | '),
+    );
+    if (unionTypeEntries.length > 0) {
+      console.log(
+        `[UNION-TYPE] generateDataStructure for ${entity.name}: Found union types in signatureSchema:`,
+      );
+      unionTypeEntries.forEach(([key, value]) => {
+        console.log(`[UNION-TYPE]   "${key}": ${value}`);
+      });
+    }
+
     const finalizedArgumentsSchema = fillInDirectSchemaGapsAndUnknowns({
       schema: { ...mergedDataStructure.signatureSchema },
     });

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

@@ -74,6 +74,7 @@ export default async function generateKeyAttributes({
       () =>
         generateEntityKeyAttributes({
           entity,
+          mergedDataStructure: analysis.metadata.mergedDataStructure,
           model,
         }),
       `Generating entity key attributes`,
@@ -82,6 +83,7 @@ export default async function generateKeyAttributes({
 
     const relevantDependentKeyAttributes = gatherRelevantDependentKeyAttributes(
       entity,
+      analysis.metadata.mergedDataStructure,
       dependentAnalyses,
     );
 
@@ -92,6 +94,10 @@ export default async function generateKeyAttributes({
         // Spread to convert readonly arrays to mutable arrays (with fallback for undefined)
         validValueOptions: [...(ka.validValueOptions ?? [])],
         errorValueOptions: [...(ka.errorValueOptions ?? [])],
+        // Convert readonly dependencies array to mutable if present
+        ...(ka.dependencies && {
+          dependencies: ka.dependencies.map((dep) => ({ ...dep })),
+        }),
       })),
     ].filter(
       (ka, index, self) =>

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

@@ -61,20 +61,24 @@ export function gatherDataForMocks(
     for (const importedExport of allImportedExports) {
       const localDataForMocks =
         activeAnalysis.metadata?.scenariosDataStructure?.dataForMocks ?? {};
-      const relevantKey = Object.keys(localDataForMocks).find((key) =>
-        key.startsWith(importedExport.name),
+      // Find relevant keys - handle both old format (starts with name)
+      // and new variable-qualified format ("varName <- functionName")
+      const relevantKeys = Object.keys(localDataForMocks).filter(
+        (key) =>
+          key.startsWith(importedExport.name) ||
+          key.endsWith(` <- ${importedExport.name}`),
       );
 
       // console.info('CODEYAM DEBUG: Processing import', {
       //   importedExportName: importedExport.name,
       //   importedExportFilePath: importedExport.filePath,
-      //   relevantKey,
+      //   relevantKeys,
       //   hasLocalDataForMocks: Object.keys(localDataForMocks).length > 0,
       //   localDataForMocksKeys: Object.keys(localDataForMocks),
       // });
 
       // First, if we have local data for this mock, add it
-      if (relevantKey) {
+      for (const relevantKey of relevantKeys) {
         const localDataForMock = localDataForMocks[relevantKey];
 
         // console.info('CODEYAM DEBUG: Found relevantKey', {

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

@@ -398,6 +398,7 @@ export default function mergeInDependentDataStructure({
                   const postfix = joinParenthesesAndArrays(
                     schemaPathParts.slice(matchedUpToIndex),
                   );
+
                   entry.equivalentPostfixes[postfix] = entry
                     .equivalentPostfixes[postfix]
                     ? bestValueFromOptions([
@@ -673,6 +674,7 @@ export default function mergeInDependentDataStructure({
           equivalentRoot.schemaRootPath,
           relevantPostfix,
         ]);
+
         schema[newSchemaPath] = postfixValue;
       }
 
@@ -680,6 +682,77 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  // Propagate equivalency-derived attributes to generic function call variants.
+  // When attributes are traced via equivalencies (e.g., fileComparisons from buildDataMap.signature[2]),
+  // they get written to non-generic paths (returnValue.data.x or funcName().functionCallReturnValue.data.x).
+  // If the ORIGINAL input schema has generic variants (funcName<T>().functionCallReturnValue.data),
+  // we need to copy the attributes to those paths too.
+  for (const filePath in mergedDataStructure.dependencySchemas) {
+    for (const depName in mergedDataStructure.dependencySchemas[filePath]) {
+      const depSchema =
+        mergedDataStructure.dependencySchemas[filePath][depName];
+      const returnValueSchema = depSchema.returnValueSchema;
+
+      // Look at the ORIGINAL input dependencySchemas for generic variants,
+      // since the merged schema may have lost them during equivalency processing
+      const originalSchema = dependencySchemas?.[filePath]?.[depName];
+      const schemaToSearchForGenericVariants =
+        originalSchema?.returnValueSchema || returnValueSchema;
+
+      // Find all unique generic variants of this function
+      // e.g., useFetcher<BranchEntityDiffResult>() from useFetcher<BranchEntityDiffResult>().functionCallReturnValue.data
+      const genericVariants = new Set<string>();
+      const genericRegex = new RegExp(
+        `^${depName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}<[^>]+>\\(\\)`,
+      );
+
+      for (const path in schemaToSearchForGenericVariants) {
+        const match = path.match(genericRegex);
+        if (match) {
+          genericVariants.add(match[0]);
+        }
+      }
+
+      if (genericVariants.size === 0) continue;
+
+      // For each returnValue. path or non-generic function call path,
+      // create corresponding paths for each generic variant
+      const pathsToAdd: [string, string][] = [];
+
+      for (const path in returnValueSchema) {
+        const value = returnValueSchema[path];
+
+        // Handle returnValue. paths
+        if (path.startsWith('returnValue.')) {
+          const suffix = path.slice('returnValue.'.length);
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+        // Handle non-generic function call paths like depName().functionCallReturnValue.x
+        else if (path.startsWith(`${depName}().functionCallReturnValue.`)) {
+          const suffix = path.slice(
+            `${depName}().functionCallReturnValue.`.length,
+          );
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+      }
+
+      // Add the new generic variant paths
+      for (const [path, value] of pathsToAdd) {
+        returnValueSchema[path] = value;
+      }
+    }
+  }
+
   // For mocked dependencies: copy paths from dependencySchemas (usage info) and normalize
   // returnValue. paths that were created by equivalency processing.
   // This ensures all paths use the consistent functionName().functionCallReturnValue. format.
@@ -853,6 +926,40 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  // Ensure ALL dependencies from the input dependencySchemas are preserved.
+  // Some dependencies (like .d.ts type declaration files) may not have:
+  // - Equivalencies with the root scope
+  // - A dependent analysis (they're just type declarations)
+  // - Be marked as mocked
+  // Without this, their schemas would be lost entirely.
+  //
+  // IMPORTANT: Only add schemas for dependencies that weren't already processed.
+  // If a dependency has an existing schema (even an empty one), it means the
+  // existing processing (mocked dependencies, equivalencies, dependentAnalyses)
+  // has already handled it and may have intentionally filtered out certain paths.
+  for (const filePath in dependencySchemas) {
+    for (const name in dependencySchemas[filePath]) {
+      const srcSchema = dependencySchemas[filePath][name];
+      if (!srcSchema) continue;
+
+      // Check if this dependency was already processed by any other mechanism
+      const existingSchema =
+        mergedDataStructure.dependencySchemas[filePath]?.[name];
+
+      // Only add if no existing schema at all - this means the dependency
+      // wasn't processed through equivalencies, mocked dependencies, or dependentAnalyses
+      if (!existingSchema) {
+        const depSchema = findOrCreateDependentSchemas({ filePath, name });
+        for (const path in srcSchema.returnValueSchema) {
+          depSchema.returnValueSchema[path] = srcSchema.returnValueSchema[path];
+        }
+        for (const path in srcSchema.signatureSchema) {
+          depSchema.signatureSchema[path] = srcSchema.signatureSchema[path];
+        }
+      }
+    }
+  }
+
   // writeFile(
   //   'mergeInDependentDataStructure-debug-result.json',
   //   // rootScopeName,

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

@@ -176,9 +176,19 @@ export default function mergeValidatedDataStructures({
       }
     }
 
-    for (const mockName in dependentAnalysis?.metadata?.scenariosDataStructure
-      ?.dataForMocks ?? {}) {
+    const dependencyDataForMocks =
+      dependentAnalysis?.metadata?.scenariosDataStructure?.dataForMocks ?? {};
+    for (const mockName in dependencyDataForMocks) {
       addMockDataForEntity(mockName);
+
+      // If addMockDataForEntity didn't find matching entries in validatedVariables,
+      // copy the dependency's value directly. This handles cases like usePathname()
+      // which returns a simple "string" type but isn't in the root's validatedVariables.
+      if (dataForMocks[mockName] === undefined) {
+        dataForMocks[mockName] = dependencyDataForMocks[
+          mockName
+        ] as JsonTypeDefinition;
+      }
     }
   }
 

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

@@ -3,7 +3,7 @@ import { ProjectAnalyzer } from '../ProjectAnalyzer';
 import getImportedExports from './getImportedExports';
 import { getFrameworkForFile, isFrameworkRoute } from '~codeyam/utils';
 import findOrCreateEntity from './analyze/findOrCreateEntity';
-import { generateSha, loadEntities, upsertEntities } from '~codeyam/supabase';
+import { generateSha, loadEntities, upsertEntities } from '~codeyam/database';
 import { AnalysisContext } from '../analysisContext';
 import analyzeFrameworkRoute from './analyzeFrameworkRoute';
 

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,wBAAgB,qBAAqB,CAAC,EACpC,UAAU,EACV,GAAG,EACH,WAAgC,EAChC,gBAAwC,GACzC,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAU7C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,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 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 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,UAAU,qBAAqB,CAAC,EACpC,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,UAAU,uBAAuB,CAAC,EACtC,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

@@ -13,12 +13,13 @@
   "dependencies": {
     "@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-dynamodb": "^3.956.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-sqs": "^3.940.0",
-    "@aws-sdk/lib-storage": "^3.899.0",
+    "@aws-sdk/client-ecs": "^3.956.0",
+    "@aws-sdk/client-s3": "^3.940.0",
+    "@aws-sdk/client-sqs": "^3.956.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';

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

@@ -0,0 +1,62 @@
+import {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+interface GetPresignedUploadUrlArgs {
+  bucketName: string;
+  key: string;
+  contentType?: string;
+  expiresInSeconds?: number;
+}
+
+interface GetPresignedDownloadUrlArgs {
+  bucketName: string;
+  key: string;
+  expiresInSeconds?: number;
+}
+
+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 function getPresignedUploadUrl({
+  bucketName,
+  key,
+  contentType = 'application/gzip',
+  expiresInSeconds = DEFAULT_UPLOAD_EXPIRY,
+}: GetPresignedUploadUrlArgs): Promise<string> {
+  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 function getPresignedDownloadUrl({
+  bucketName,
+  key,
+  expiresInSeconds = DEFAULT_DOWNLOAD_EXPIRY,
+}: GetPresignedDownloadUrlArgs): Promise<string> {
+  const s3Client = new S3Client({});
+
+  const command = new GetObjectCommand({
+    Bucket: bucketName,
+    Key: key,
+  });
+
+  return getSignedUrl(s3Client, command, { expiresIn: expiresInSeconds });
+}

package/analyzer-template/packages/database/client.ts

@@ -0,0 +1,35 @@
+/**
+ * This index file re-exports modules which are safe to use in a browser
+ * environment with our current set of polyfills. Two considerations:
+ * - It must compile: it can't rely on node modules we don't polyfill
+ * - It must use Supabase for its REST capabilities. None of the db.ts
+ *   infrastructure must be invoked in this file or any of its imports.
+ *
+ *   Kysely itself is fine.
+ */
+
+export { getSupabase, getAdminSupabase } from './src/lib/supabase';
+
+export type { SupabaseClient } from '@supabase/supabase-js';
+export { default as upsertFiles_Client } from './src/lib/client/upsertFiles_Client';
+export { default as loadAnalyses_Client } from './src/lib/client/loadAnalysesInClient';
+export { default as loadBranches_Client } from './src/lib/client/loadBranches_Client';
+export { default as loadAnalysis_Client } from './src/lib/client/loadAnalysis_Client';
+
+export { default as listenForCommits_Client } from './src/lib/client/listenForCommits_Client';
+
+export { default as dbToAnalysis } from './src/lib/dbToAnalysis';
+export { default as dbToBranch } from './src/lib/dbToBranch';
+export { default as dbToCommit } from './src/lib/dbToCommit';
+export { default as dbToEntity } from './src/lib/dbToEntity';
+export { default as dbToFile } from './src/lib/dbToFile';
+export { default as dbToProject } from './src/lib/dbToProject';
+export { default as dbToScenario } from './src/lib/dbToScenario';
+export { default as dbToUserScenario } from './src/lib/dbToUserScenario';
+export { default as dbToScenarioComment } from './src/lib/dbToScenarioComment';
+
+// NOTE: generateSha is NOT exported here because it uses Node's crypto module
+// which is server-only. Import from '~codeyam/database' (server) instead.
+
+// Export ONLY types from tableRelations (no runtime code that imports Kysely)
+export type * from './src/lib/kysely/tableRelationsTypes';

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

@@ -0,0 +1,31 @@
+{
+  "name": "@codeyam/supabase",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "jest --watchAll --verbose"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@supabase/supabase-js": "2.88.0",
+    "better-sqlite3": "^12.4.1",
+    "fetch-retry": "^6.0.0",
+    "kysely": "^0.28.5",
+    "pg": "^8.16.3"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/jest": "^30.0.0",
+    "@types/pg": "^8.15.5",
+    "@types/ws": "^8.18.1"
+  }
+}