@zodic/shared 0.0.251 → 0.0.253

package/app/services/ConceptService.ts

@@ -2012,22 +2012,30 @@ export class ConceptService {
   }
 
   async generateAstroReportContent(
-    params: AstroReportParams | { entityType: string; name: string; override?: boolean },
+    params:
+      | AstroReportParams
+      | { entityType: string; name: string; override?: boolean },
     override: boolean = false
   ): Promise<void> {
-    console.log(`🚀 Generating content for ${JSON.stringify(params)}, override: ${override}`);
+    console.log(
+      `🚀 Generating content for ${JSON.stringify(
+        params
+      )}, override: ${override}`
+    );
 
     const db = drizzle(this.context.env.DB);
     let table, whereClause;
 
     let report: AstroReportRow | DescriptionTemplateRow;
-    const isReport = "reportType" in params;
+    const isReport = 'reportType' in params;
 
     if (isReport) {
       // Handle existing report types (sign, house, signInHouse, aspect, feature)
       switch (params.reportType) {
-        case "sign":
-          console.log(`🗂️ Handling sign report: type=${params.type}, pointName=${params.pointName}, sign=${params.sign}`);
+        case 'sign':
+          console.log(
+            `🗂️ Handling sign report: type=${params.type}, pointName=${params.pointName}, sign=${params.sign}`
+          );
           table = astroReports;
           whereClause = and(
             eq(astroReports.name, params.pointName),
@@ -2035,8 +2043,10 @@ export class ConceptService {
             isNull(astroReports.house)
           );
           break;
-        case "house":
-          console.log(`🗂️ Handling house report: type=${params.type}, pointName=${params.pointName}, house=${params.house}`);
+        case 'house':
+          console.log(
+            `🗂️ Handling house report: type=${params.type}, pointName=${params.pointName}, house=${params.house}`
+          );
           table = astroReports;
           whereClause = and(
             eq(astroReports.name, params.pointName),
@@ -2044,16 +2054,20 @@ export class ConceptService {
             isNull(astroReports.sign)
           );
           break;
-        case "signInHouse":
-          console.log(`🗂️ Handling signInHouse report: sign=${params.sign}, houseNumber=${params.houseNumber}`);
+        case 'signInHouse':
+          console.log(
+            `🗂️ Handling signInHouse report: sign=${params.sign}, houseNumber=${params.houseNumber}`
+          );
           table = houseReports;
           whereClause = and(
             eq(houseReports.sign, params.sign),
             eq(houseReports.house, params.houseNumber)
           );
           break;
-        case "aspect":
-          console.log(`🗂️ Handling aspect report: aspectingPlanet=${params.aspectingPlanet}, aspectedPlanet=${params.aspectedPlanet}, aspectingType=${params.aspectingType}`);
+        case 'aspect':
+          console.log(
+            `🗂️ Handling aspect report: aspectingPlanet=${params.aspectingPlanet}, aspectedPlanet=${params.aspectedPlanet}, aspectingType=${params.aspectingType}`
+          );
           table = aspectReports;
           whereClause = and(
             eq(aspectReports.aspectingPlanet, params.aspectingPlanet),
@@ -2061,29 +2075,46 @@ export class ConceptService {
             eq(aspectReports.aspect, params.aspectingType)
           );
           break;
-        case "feature":
-          console.log(`🗂️ Handling feature report: featureType=${params.featureType}, ${JSON.stringify(params)}`);
+        case 'feature':
+          console.log(
+            `🗂️ Handling feature report: featureType=${
+              params.featureType
+            }, ${JSON.stringify(params)}`
+          );
           table = astroFeatureReports;
           let nameValue: string;
-          if (params.featureType === "element") {
-            if (!("subtype" in params)) throw new Error("Missing subtype for element feature report");
+          if (params.featureType === 'element') {
+            if (!('subtype' in params))
+              throw new Error('Missing subtype for element feature report');
             switch (params.subtype) {
-              case "balanced":
-                nameValue = "balanced";
+              case 'balanced':
+                nameValue = 'balanced';
                 break;
-              case "pure":
-                if (!("dominantElement" in params)) throw new Error("Missing dominantElement for pure element report");
+              case 'pure':
+                if (!('dominantElement' in params))
+                  throw new Error(
+                    'Missing dominantElement for pure element report'
+                  );
                 nameValue = params.dominantElement;
                 break;
-              case "preponderant_lacking":
-                if (!("dominantElement" in params) || !("lackingElement" in params)) throw new Error("Missing dominantElement or lackingElement for preponderant_lacking element report");
+              case 'preponderant_lacking':
+                if (
+                  !('dominantElement' in params) ||
+                  !('lackingElement' in params)
+                )
+                  throw new Error(
+                    'Missing dominantElement or lackingElement for preponderant_lacking element report'
+                  );
                 nameValue = `${params.dominantElement}-${params.lackingElement}`;
                 break;
               default:
-                throw new Error(`Unknown element subtype: ${(params as any).subtype}`);
+                throw new Error(
+                  `Unknown element subtype: ${(params as any).subtype}`
+                );
             }
           } else {
-            if (!("name" in params)) throw new Error("Missing name for non-element feature report");
+            if (!('name' in params))
+              throw new Error('Missing name for non-element feature report');
             nameValue = params.name;
           }
           whereClause = and(
@@ -2094,22 +2125,36 @@ export class ConceptService {
         default:
           throw new Error(`Unknown report type: ${(params as any).reportType}`);
       }
-      report = await db.select().from(table as any).where(whereClause).get() as AstroReportRow;
+      report = (await db
+        .select()
+        .from(table as any)
+        .where(whereClause)
+        .get()) as AstroReportRow;
     } else {
       // Handle description templates
-      console.log(`🗂️ Handling description template: entityType=${params.entityType}, name=${params.name}`);
+      console.log(
+        `🗂️ Handling description template: entityType=${params.entityType}, name=${params.name}`
+      );
       table = astroDescriptionTemplates;
       whereClause = and(
         eq(astroDescriptionTemplates.entityType, params.entityType),
         eq(astroDescriptionTemplates.name, params.name)
       );
-      report = await db.select().from(table as any).where(whereClause).get() as DescriptionTemplateRow;
+      report = (await db
+        .select()
+        .from(table as any)
+        .where(whereClause)
+        .get()) as DescriptionTemplateRow;
     }
 
     const id = report.id;
     const hasContent = isReport
-      ? (report as AstroReportRow).enReport && (report as AstroReportRow).ptReport
-      : (report as DescriptionTemplateRow).enDescription && (report as DescriptionTemplateRow).ptDescription;
+      ? (report as AstroReportRow).enReport &&
+        (report as AstroReportRow).ptReport
+      : (report as DescriptionTemplateRow).enDescription !==
+          'Pending generation' &&
+        (report as DescriptionTemplateRow).ptDescription !==
+          'Pendente de geração';
 
     if (!override && hasContent) {
       console.log(`⚡ Content already exists for ${id}, skipping`);
@@ -2120,29 +2165,47 @@ export class ConceptService {
     const maxAttempts = 2;
 
     while (attempts < maxAttempts) {
-      let phase = "generation";
+      let phase = 'generation';
       try {
         attempts++;
-        console.log(`🔄 Attempt ${attempts} to generate ${isReport ? "report" : "description"} content for ${id}...`);
+        console.log(
+          `🔄 Attempt ${attempts} to generate ${
+            isReport ? 'report' : 'description'
+          } content for ${id}...`
+        );
 
         let messages: ChatMessages;
         if (isReport) {
-          messages = this.context.buildLLMMessages().generateAstroReportContent({ params: params as AstroReportParams });
+          messages = this.context
+            .buildLLMMessages()
+            .generateAstroReportContent({
+              params: params as AstroReportParams,
+            });
         } else {
           messages = this.generateDescriptionMessages(params);
         }
 
         console.log(`📨 Sending messages to AI: ${JSON.stringify(messages)}`);
-        const response = await this.context.api().callTogether.single(messages, {});
+        const response = await this.context
+          .api()
+          .callTogether.single(messages, {});
         if (!response) {
           throw new Error(`❌ AI returned an empty response for ${id}`);
         }
 
-        phase = "parsing";
-        console.log(`📝 Received AI response for ${id}: ${response.slice(0, 200)}${response.length > 200 ? "..." : ""}`);
+        phase = 'parsing';
+        console.log(
+          `📝 Received AI response for ${id}: ${response.slice(0, 200)}${
+            response.length > 200 ? '...' : ''
+          }`
+        );
 
         if (isReport) {
-          const { enReport, ptReport } = await this.parseAstrologicalReportContent((params as AstroReportParams).reportType, response);
+          const { enReport, ptReport } =
+            await this.parseAstrologicalReportContent(
+              (params as AstroReportParams).reportType,
+              response
+            );
           console.log(`💾 Storing report content for ${id}`);
           await db
             .update(table as any)
@@ -2153,7 +2216,8 @@ export class ConceptService {
             .where(eq((table as any).id, id))
             .run();
         } else {
-          const { enDescription, ptDescription } = await this.parseDescriptionContent(response);
+          const { enDescription, ptDescription } =
+            await this.parseDescriptionContent(response);
           console.log(`💾 Storing description content for ${id}`);
           await db
             .update(table as any)
@@ -2165,12 +2229,19 @@ export class ConceptService {
             .run();
         }
 
-        console.log(`✅ ${isReport ? "Report" : "Description"} content stored for ${id}`);
+        console.log(
+          `✅ ${isReport ? 'Report' : 'Description'} content stored for ${id}`
+        );
         return;
       } catch (error) {
-        console.error(`❌ Attempt ${attempts} failed at phase: ${phase} for ${id}`, (error as Error).message);
+        console.error(
+          `❌ Attempt ${attempts} failed at phase: ${phase} for ${id}`,
+          (error as Error).message
+        );
 
-        const failureKey = `failures:astro:${isReport ? (params as AstroReportParams).reportType : "description"}:${id}`;
+        const failureKey = `failures:astro:${
+          isReport ? (params as AstroReportParams).reportType : 'description'
+        }:${id}`;
         await this.context.kvConceptFailuresStore().put(
           failureKey,
           JSON.stringify({
@@ -2183,11 +2254,17 @@ export class ConceptService {
         );
 
         if (attempts >= maxAttempts) {
-          console.error(`🚨 All ${maxAttempts} attempts failed at phase ${phase} for ${id}`);
-          throw new Error(`Failed to generate ${isReport ? "report" : "description"} for ${id} after ${maxAttempts} attempts`);
+          console.error(
+            `🚨 All ${maxAttempts} attempts failed at phase ${phase} for ${id}`
+          );
+          throw new Error(
+            `Failed to generate ${
+              isReport ? 'report' : 'description'
+            } for ${id} after ${maxAttempts} attempts`
+          );
         }
 
-        console.log("🔁 Retrying...");
+        console.log('🔁 Retrying...');
         await new Promise((resolve) => setTimeout(resolve, 2000));
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zodic/shared",
-  "version": "0.0.251",
+  "version": "0.0.253",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {

package/utils/astroPrompts/index.ts

@@ -170,7 +170,7 @@ export const astroPrompts = {
     `.trim();
 
     switch (params.featureType) {
-      case "moon_phase": {
+      case 'moon_phase': {
         const formattedName = params.name
           .split('-')
           .map((word: string) => word.charAt(0).toUpperCase() + word.slice(1))
@@ -181,45 +181,58 @@ export const astroPrompts = {
         `.trim();
       }
 
-      case "element": {
+      case 'element': {
         switch (params.subtype) {
-          case "balanced":
+          case 'balanced':
             return `
               Make me an astrological report for a person with a balanced elemental distribution in their birth chart.
               ${baseFormat}
             `.trim();
-          case "pure": {
-            const dominant = params.dominantElement.charAt(0).toUpperCase() + params.dominantElement.slice(1);
+          case 'pure': {
+            const dominant =
+              params.dominantElement.charAt(0).toUpperCase() +
+              params.dominantElement.slice(1);
             return `
               Make me an astrological report for a person with a preponderance of the ${dominant} element in their birth chart.
               ${baseFormat}
             `.trim();
           }
-          case "preponderant_lacking": {
-            const dominant = params.dominantElement.charAt(0).toUpperCase() + params.dominantElement.slice(1);
-            const lacking = params.lackingElement.charAt(0).toUpperCase() + params.lackingElement.slice(1);
+          case 'preponderant_lacking': {
+            const dominant =
+              params.dominantElement.charAt(0).toUpperCase() +
+              params.dominantElement.slice(1);
+            const lacking =
+              params.lackingElement.charAt(0).toUpperCase() +
+              params.lackingElement.slice(1);
             return `
               Make me an astrological report for a person with a preponderance of the ${dominant} element and a lack of the ${lacking} element in their birth chart.
               ${baseFormat}
             `.trim();
           }
           default:
-            throw new Error(`Unknown element subtype: ${(params as any).subtype}`);
+            throw new Error(
+              `Unknown element subtype: ${(params as any).subtype}`
+            );
         }
       }
 
-      case "mode": {
-        const formattedName = params.name.charAt(0).toUpperCase() + params.name.slice(1);
+      case 'mode': {
+        const formattedName =
+          params.name.charAt(0).toUpperCase() + params.name.slice(1);
         return `
           Make me an astrological report for a person with a preponderance of the ${formattedName} mode in their birth chart.
           ${baseFormat}
         `.trim();
       }
 
-      case "hemisphere_east_west":
-      case "hemisphere_north_south": {
-        const direction = params.name.charAt(0).toUpperCase() + params.name.slice(1);
-        const hemisphereType = params.featureType === "hemisphere_east_west" ? "East-West" : "North-South";
+      case 'hemisphere_east_west':
+      case 'hemisphere_north_south': {
+        const direction =
+          params.name.charAt(0).toUpperCase() + params.name.slice(1);
+        const hemisphereType =
+          params.featureType === 'hemisphere_east_west'
+            ? 'East-West'
+            : 'North-South';
         return `
           Make me an astrological report for a person with the ${direction}ern hemisphere emphasized in their birth chart, based on the ${hemisphereType} orientation.
           ${baseFormat}
@@ -231,9 +244,47 @@ export const astroPrompts = {
     }
   },
 
-  makeIntroDescription: ({ entityType, name, isGeneric }: DescriptionParams): string => {
+  makeIntroDescription: ({
+    entityType,
+    name,
+    isGeneric,
+  }: DescriptionParams): string => {
+    // Format name for human-readable display (capitalize and handle special cases)
+    const formatName = (entityType: string, name: string): string => {
+      switch (entityType) {
+        case 'planet':
+        case 'key_point':
+        case 'karmic_point':
+        case 'arabic_part':
+          // Capitalize first letter and handle special cases (e.g., "pars_amoris" -> "Pars Amoris")
+          return name
+            .split('_')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+        case 'house':
+          return `House ${name.replace('house_', '')}`; // e.g., "house_1" -> "House 1"
+        case 'aspect':
+        case 'mode':
+        case 'element':
+        case 'moon_phase':
+          return name
+            .split('_')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+        case 'hemisphere_east_west':
+        case 'hemisphere_north_south':
+          return name
+            .split('_')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+        default:
+          return name.charAt(0).toUpperCase() + name.slice(1);
+      }
+    };
+
+    const formattedName = formatName(entityType, name);
+
     const baseFormat = `
-      Make me an introductory, explanatory description of 150 to 180 words about the astrological ${entityType}.
       The result must have an English version and a Portuguese version.
       The result format must be exactly like the following:
       -- EN
@@ -244,10 +295,29 @@ export const astroPrompts = {
 
     if (isGeneric) {
       return `
-        ${baseFormat.replace("astrological", "astrological concept representing").replace("about the astrological", "about what the")}
+        Make me an introductory, explanatory description of 150 to 180 words about the astrological concept of the ${formattedName}.
+        ${baseFormat}
       `.trim();
     } else {
-      return `${baseFormat} ${name ? `named ${name}.` : ""}`.trim();
+      switch (entityType) {
+        case 'planet':
+        case 'key_point':
+        case 'karmic_point':
+        case 'arabic_part':
+          return `
+            Make me an introductory, explanatory description of 150 to 180 words about what the astrological placement: ${formattedName}.
+            ${baseFormat}
+          `.trim();
+        case 'house':
+          return `
+            Make me an introductory, explanatory description of 150 to 180 words about the astrological placement: ${formattedName}.
+            ${baseFormat}
+          `.trim();
+        default:
+          throw new Error(
+            `Unknown entity type for specific description: ${entityType}`
+          );
+      }
     }
   },
 };