@wix/ditto-codegen-public 1.0.192 → 1.0.193

package/dist/out.js

@@ -83827,8 +83827,8 @@ var require_ValidatorFactory = __commonJS({
         if (type === ditto_codegen_types_12.ValidationType.TYPESCRIPT) {
           return new TypescriptValidator_1.default();
         }
-        throw new ditto_codegen_types_12.AutoFixError(`Invalid validator type: ${type}`, {
-          validationType: type
+        throw new ditto_codegen_types_12.ValidationConfigurationError(`Invalid validator type: ${type}`, {
+          validatorType: type
         });
       }
     };
@@ -84034,14 +84034,23 @@ var require_fixFlow = __commonJS({
     var job_context_storage_12 = require_job_context_storage();
     var codeGenerationService_12 = require_codeGenerationService();
     var MAX_ERRORS_PER_BATCH = 20;
+    var MAX_FIX_ATTEMPTS = 3;
+    var toErrorSummary = (error) => ({
+      filePath: error.filePath,
+      line: error.line,
+      message: error.errorMessage
+    });
+    var createErrorComparisonKey = (e) => `${e.filePath}:${e.line ?? "unknown"}:${e.errorMessage}`;
     async function startFixFlow(request) {
       const { projectDir } = request;
       const fixerFactory = new FixerFactory_1.default();
       const validatorFactory = new ValidatorFactory_1.default();
       const validator = validatorFactory.getValidator();
       const fixer = fixerFactory.getFixer();
-      const MAX_FIX_ATTEMPTS = 3;
       const parentContext = job_context_storage_12.jobContextStorage.getStore();
+      if (!parentContext?.jobId) {
+        throw new Error("Fix flow must be called within a job context");
+      }
       const fixTaskId = `fix-flow`;
       const updateFixTask = async (status, payload = {}) => {
         await codeGenerationService_12.codeGenerationService.updateTask(parentContext.jobId, fixTaskId, status, payload);
@@ -84052,9 +84061,13 @@ var require_fixFlow = __commonJS({
         name: "Auto-Fixer",
         status: ditto_codegen_types_12.Status.RUNNING,
         description: "Running automatic code fixes",
-        agentName: "NaiveFixerAgent"
+        agentName: "FixerAgent"
       });
       console.log("\u{1F50D} Running validation and batch fix...");
+      const fixState = {
+        initialErrors: [],
+        lastRunErrors: /* @__PURE__ */ new Map()
+      };
       const processFiles = async (fileEntries, lastRunErrors) => {
         for (const [filePath, fileErrors] of fileEntries) {
           const errorsToFix = fileErrors.slice(0, MAX_ERRORS_PER_BATCH);
@@ -84072,48 +84085,62 @@ var require_fixFlow = __commonJS({
           }
         }
       };
-      const fixState = {
-        accumulatedFixes: 0,
-        lastRunErrors: /* @__PURE__ */ new Map()
+      const getFixedErrors = (remainingErrors) => {
+        const remainingKeys = new Set(remainingErrors.map(createErrorComparisonKey));
+        return fixState.initialErrors.filter((e) => !remainingKeys.has(createErrorComparisonKey(e)));
       };
-      const handleValidationFailure = async (validation, reason) => {
-        const remainingErrors = validation.parsedValidationErrors?.length || 0;
-        const unfixedValidationErrors = validation.validationErrors || "Unknown validation errors";
-        console.log(`\u{1F4CB} ${remainingErrors} errors remaining after fixes`);
-        const errorMessage = `Validation failed: ${reason}. Fixed ${fixState.accumulatedFixes} errors, but ${remainingErrors} remain:
-${unfixedValidationErrors}`;
-        const validationErrors = validation.parsedValidationErrors || [];
+      const buildExhaustedResult = (validation, attemptsMade) => {
+        const remainingErrors = validation.parsedValidationErrors ?? [];
+        const fixedErrors = getFixedErrors(remainingErrors);
+        console.log(`\u{1F4CB} ${remainingErrors.length} errors remaining after ${attemptsMade} fix attempts (fixed ${fixedErrors.length})`);
+        const hasNoParseableErrors = remainingErrors.length === 0;
+        const errorMessage = hasNoParseableErrors ? `Auto-fix exhausted: validation still failing after ${attemptsMade} attempts (no parseable errors)` : `Auto-fix exhausted: ${remainingErrors.length} TypeScript errors remain after ${attemptsMade} attempts`;
         const error = new ditto_codegen_types_12.CodeValidationError(errorMessage, {
           validationType: ditto_codegen_types_12.ValidationType.TYPESCRIPT,
-          errors: validationErrors
+          errors: remainingErrors
         });
-        await updateFixTask(ditto_codegen_types_12.Status.FAILED, { error: errorMessage });
-        throw error;
+        return { error, fixedErrors };
       };
-      const ensureParsedErrorsExist = async (validation) => {
-        const hasParsedErrorsToFix = validation.parsedValidationErrors.length > 0;
-        if (!hasParsedErrorsToFix) {
-          const errorMessage = `Validation failed but no parsed errors available. Raw errors: ${validation.validationErrors}`;
+      const ensureParsedErrorsExist = (validation) => {
+        const parsedErrors = validation.parsedValidationErrors ?? [];
+        if (parsedErrors.length === 0) {
+          const errorMessage = `Validation failed but no parsed errors available. Raw errors: ${validation.validationErrors ?? "No errors"}`;
           console.warn(`\u26A0\uFE0F ${errorMessage}`);
-          await updateFixTask(ditto_codegen_types_12.Status.FAILED, { error: errorMessage });
-          throw new Error(errorMessage);
+          throw new ditto_codegen_types_12.ValidationConfigurationError(errorMessage, {
+            validatorType: validator.type
+          });
         }
       };
       try {
-        for (let attempt = 0; attempt < MAX_FIX_ATTEMPTS; attempt++) {
+        for (let attempt = 1; attempt <= MAX_FIX_ATTEMPTS; attempt++) {
           console.log(`\u{1F504} Fix Attempt ${attempt}/${MAX_FIX_ATTEMPTS}`);
           const currentValidation = await validator.validate(projectDir);
-          if (currentValidation.status === 0) {
+          const validationPassed = currentValidation.status === 0;
+          const isFirstAttempt = attempt === 1;
+          const isLastAttempt = attempt === MAX_FIX_ATTEMPTS;
+          if (validationPassed) {
+            const fixedErrors = getFixedErrors([]);
             console.log(`\u2705 ${validator.type} validation passed - no fixes needed`);
             await updateFixTask(ditto_codegen_types_12.Status.COMPLETED, {
-              description: `Fixed ${fixState.accumulatedFixes} errors.`
+              description: `Fixed ${fixedErrors.length} errors.`,
+              fixedErrors: fixedErrors.map(toErrorSummary)
             });
             return;
           }
-          if (attempt === MAX_FIX_ATTEMPTS - 1) {
-            await handleValidationFailure(currentValidation, `after ${MAX_FIX_ATTEMPTS} fix attempts`);
+          if (isFirstAttempt) {
+            fixState.initialErrors = currentValidation.parsedValidationErrors ?? [];
           }
-          await ensureParsedErrorsExist(currentValidation);
+          if (isLastAttempt) {
+            const { error, fixedErrors } = buildExhaustedResult(currentValidation, attempt);
+            await updateFixTask(ditto_codegen_types_12.Status.COMPLETED, {
+              description: `Completed with ${error.errors.length} unresolved errors after ${attempt} attempts`,
+              warning: error.message,
+              fixedErrors: fixedErrors.map(toErrorSummary),
+              remainingErrors: error.errors.map(toErrorSummary)
+            });
+            throw error;
+          }
+          ensureParsedErrorsExist(currentValidation);
           const totalErrors = currentValidation.parsedValidationErrors.length;
           console.log(`\u{1F4DD} Found ${totalErrors} errors to fix`);
           const errorsByFile = (0, utils_1.mapGroupBy)(currentValidation.parsedValidationErrors, (error) => error.filePath);
@@ -84122,15 +84149,14 @@ ${unfixedValidationErrors}`;
           fixState.lastRunErrors = errorsByFile;
         }
       } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const finalError = new ditto_codegen_types_12.AutoFixError(errorMessage, {
-          validationType: validator.type,
-          cause: error
-        });
+        if (error instanceof ditto_codegen_types_12.CodeValidationError) {
+          throw error;
+        }
+        const codegenError = (0, ditto_codegen_types_12.toCodegenError)(error);
         await updateFixTask(ditto_codegen_types_12.Status.FAILED, {
-          error: finalError.message
+          error: codegenError.message
         });
-        throw finalError;
+        throw codegenError;
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/ditto-codegen-public",
-  "version": "1.0.192",
+  "version": "1.0.193",
   "description": "AI-powered Wix CLI app generator - standalone executable",
   "scripts": {
     "build": "node build.mjs",
@@ -24,5 +24,5 @@
     "@wix/ditto-codegen": "1.0.0",
     "esbuild": "^0.25.9"
   },
-  "falconPackageHash": "63e456b352799d738ee7c3c7beebe3b1adb2c0db877a801ef24a15f4"
+  "falconPackageHash": "416717af517d1fd26dd71583134531f28a30e81a627516f294036aaa"
 }