@wix/ditto-codegen-public 1.0.191 → 1.0.193

package/dist/out.js

@@ -36576,6 +36576,7 @@ var require_CodegenAIProxyService = __commonJS({
               isEnabled: true,
               functionId: payload.agentName
             },
+            ...payload.experimental_repairText ? { experimental_repairText: payload.experimental_repairText } : {},
             maxOutputTokens: 1e4,
             maxRetries: 3,
             temperature: 0
@@ -72986,6 +72987,7 @@ var require_IterationAgent = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.IterationAgent = void 0;
     var zod_1 = require_zod();
+    var ai_1 = require_dist8();
     var iteration_agent_prompt_1 = require_iteration_agent_prompt();
     var AgentsRegistry_1 = require_AgentsRegistry();
     var codegen_common_logic_1 = require_dist9();
@@ -72994,16 +72996,17 @@ var require_IterationAgent = __commonJS({
     var codeGenerationService_12 = require_codeGenerationService();
     var extensionFormatters_1 = require_extensionFormatters();
     var contextBuilders_1 = require_contextBuilders();
+    var MAX_NAME_LENGTH = 30;
     var CurrentExtensionSchema = zod_1.z.object({
       extensionType: zod_1.z.enum(codegen_common_logic_1.codeGenerationExtensionTypes).describe("The extension kind to trigger"),
-      name: zod_1.z.string().min(2).describe("Short, human-readable name for the extension. Less than 30 chars."),
+      name: zod_1.z.string().min(2).max(MAX_NAME_LENGTH).describe(`Short, human-readable name for the extension. Less than ${MAX_NAME_LENGTH} chars.`),
       relatedSpis: zod_1.z.array(zod_1.z.string()).optional().describe("Optional value, only for SPI extensions - specify the SPI types"),
       paths: zod_1.z.array(zod_1.z.string()).describe("Paths relevant for this extension"),
       relevantUserRequest: zod_1.z.string().describe("What part of the user request this extension should do, do not reference other extensions.")
     });
     var AdditionalExtensionSchema = zod_1.z.object({
       extensionType: zod_1.z.enum(codegen_common_logic_1.codeGenerationExtensionTypes).describe("The extension kind to add"),
-      name: zod_1.z.string().min(2).max(30).describe("Short, human-readable name for the extension. Less than 30 chars."),
+      name: zod_1.z.string().min(2).max(MAX_NAME_LENGTH).describe(`Short, human-readable name for the extension. Less than ${MAX_NAME_LENGTH} chars.`),
       relatedSpis: zod_1.z.array(zod_1.z.string()).optional().describe("Optional value, only for SPI extensions - specify the SPI types"),
       relevantUserRequest: zod_1.z.string().describe("What part of the user request this extension should do, do not reference other extensions.")
     });
@@ -73040,6 +73043,34 @@ var require_IterationAgent = __commonJS({
           })) || []
         };
       }
+      async repairNameTooLong({ text, error }) {
+        if (!ai_1.TypeValidationError.isInstance(error)) {
+          return text;
+        }
+        const cause = error.cause;
+        const hasNameTooLongIssue = cause?.issues?.some((issue) => issue.code === "too_big" && issue.path?.at(-1) === "name");
+        if (!hasNameTooLongIssue) {
+          return text;
+        }
+        const parsed = JSON.parse(text);
+        const hasCurrentExtensionsIssue = parsed.currentExtensions && cause?.issues?.some((issue) => issue.path?.includes("currentExtensions"));
+        const hasAdditionalExtensionsIssue = parsed.additionalExtensions && cause?.issues?.some((issue) => issue.path?.includes("additionalExtensions"));
+        if (hasCurrentExtensionsIssue) {
+          for (const ext of parsed.currentExtensions) {
+            if (ext.name && ext.name.length > MAX_NAME_LENGTH) {
+              ext.name = ext.name.slice(0, MAX_NAME_LENGTH);
+            }
+          }
+        }
+        if (hasAdditionalExtensionsIssue) {
+          for (const ext of parsed.additionalExtensions) {
+            if (ext.name && ext.name.length > MAX_NAME_LENGTH) {
+              ext.name = ext.name.slice(0, MAX_NAME_LENGTH);
+            }
+          }
+        }
+        return JSON.stringify(parsed);
+      }
       buildUserPrompt({ chatHistory, currentUserRequest, previousResources, extensionSelectorResult }) {
         const sections = (0, contextBuilders_1.buildContextSections)(chatHistory, currentUserRequest, previousResources);
         sections.push(`
@@ -73063,7 +73094,8 @@ ${(0, extensionFormatters_1.formatContextExtensions)(extensionSelectorResult.con
           provider: constants_1.LLM_PROVIDERS.ANTHROPIC,
           model: constants_1.LLM_MODELS.CLAUDE_3_5_HAIKU_LATEST,
           schema: IterationPlanSchema,
-          agentName: this.name
+          agentName: this.name,
+          experimental_repairText: this.repairNameTooLong
         });
         const resultObject = {
           currentExtensions: result.object.currentExtensions.map((ext) => ({
@@ -83795,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
         });
       }
     };
@@ -84002,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);
@@ -84020,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);
@@ -84040,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 ?? [];
+          }
+          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;
           }
-          await ensureParsedErrorsExist(currentValidation);
+          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);
@@ -84090,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.191",
+  "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": "5b67b19500c5227d223ef15b69d91c8c965fbd2aa2cabee9f5ac410a"
+  "falconPackageHash": "416717af517d1fd26dd71583134531f28a30e81a627516f294036aaa"
 }