@zodic/shared 0.0.249 → 0.0.251

package/app/services/ConceptService.ts

@@ -10,6 +10,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { cleanText, schema } from '../..';
 import {
   aspectReports,
+  astroDescriptionTemplates,
   astroFeatureReports,
   astroReports,
   conceptsData,
@@ -18,8 +19,11 @@ import {
 import {
   AstrologicalReport,
   AstroReportParams,
+  AstroReportRow,
+  ChatMessages,
   Concept,
   ControlNetConfig,
+  DescriptionTemplateRow,
   Languages,
 } from '../../types';
 import {
@@ -27,6 +31,7 @@ import {
   sizes,
   StructuredConceptContent,
 } from '../../types/scopes/legacy';
+import { astroPrompts } from '../../utils/astroPrompts';
 import { leonardoInitImages } from '../../utils/initImages';
 import { buildConceptKVKey } from '../../utils/KVKeysBuilders';
 import { AppContext } from '../base/AppContext';
@@ -2006,132 +2011,105 @@ export class ConceptService {
     console.log(`✅ Stored duplicate keys for ${conceptSlug} in cache.`);
   }
 
-  // ? ASTRO PROCESSING
   async generateAstroReportContent(
-    params: AstroReportParams,
+    params: AstroReportParams | { entityType: string; name: string; override?: boolean },
     override: boolean = false
   ): Promise<void> {
-    console.log(
-      `🚀 Generating report 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;
 
-    // Log the params for debugging
-    console.log(
-      `🔍 Received params: reportType=${params.reportType}, featureType=${
-        (params as any).featureType || 'N/A'
-      }, subtype=${(params as any).subtype || 'N/A'}`
-    );
-
-    // Determine table and where clause
-    switch (params.reportType) {
-      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),
-          eq(astroReports.sign, params.sign),
-          isNull(astroReports.house)
-        );
-        break;
-      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),
-          eq(astroReports.house, params.house),
-          isNull(astroReports.sign)
-        );
-        break;
-      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}`
-        );
-        table = aspectReports;
-        whereClause = and(
-          eq(aspectReports.aspectingPlanet, params.aspectingPlanet),
-          eq(aspectReports.aspectedPlanet, params.aspectedPlanet),
-          eq(aspectReports.aspect, params.aspectingType)
-        );
-        break;
-      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');
-          switch (params.subtype) {
-            case 'balanced':
-              nameValue = 'balanced';
-              break;
-            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'
-                );
-              nameValue = `${params.dominantElement}-${params.lackingElement}`;
-              break;
-            default:
-              throw new Error(`Unknown element subtype: ${params}`);
+    let report: AstroReportRow | DescriptionTemplateRow;
+    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}`);
+          table = astroReports;
+          whereClause = and(
+            eq(astroReports.name, params.pointName),
+            eq(astroReports.sign, params.sign),
+            isNull(astroReports.house)
+          );
+          break;
+        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),
+            eq(astroReports.house, params.house),
+            isNull(astroReports.sign)
+          );
+          break;
+        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}`);
+          table = aspectReports;
+          whereClause = and(
+            eq(aspectReports.aspectingPlanet, params.aspectingPlanet),
+            eq(aspectReports.aspectedPlanet, params.aspectedPlanet),
+            eq(aspectReports.aspect, params.aspectingType)
+          );
+          break;
+        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");
+            switch (params.subtype) {
+              case "balanced":
+                nameValue = "balanced";
+                break;
+              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");
+                nameValue = `${params.dominantElement}-${params.lackingElement}`;
+                break;
+              default:
+                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");
+            nameValue = params.name;
           }
-        } else {
-          if (!('name' in params))
-            throw new Error('Missing name for non-element feature report');
-          nameValue = params.name;
-        }
-        whereClause = and(
-          eq(astroFeatureReports.featureType, params.featureType),
-          eq(astroFeatureReports.name, nameValue)
-        );
-        break;
-      default:
-        console.error(
-          `❌ Unknown report type: ${params}. Params: ${JSON.stringify(params)}`
-        );
-        throw new Error(`Unknown report type: ${params}`);
-    }
-
-    const report = await db.select().from(table).where(whereClause).get();
-    if (!report) {
-      console.error(`❌ No report found for ${JSON.stringify(params)}`);
-      throw new Error(`❌ No report found for ${JSON.stringify(params)}`);
+          whereClause = and(
+            eq(astroFeatureReports.featureType, params.featureType),
+            eq(astroFeatureReports.name, nameValue)
+          );
+          break;
+        default:
+          throw new Error(`Unknown report type: ${(params as any).reportType}`);
+      }
+      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}`);
+      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;
     }
 
     const id = report.id;
-    const hasContent = report.enReport && report.ptReport;
+    const hasContent = isReport
+      ? (report as AstroReportRow).enReport && (report as AstroReportRow).ptReport
+      : (report as DescriptionTemplateRow).enDescription && (report as DescriptionTemplateRow).ptDescription;
 
     if (!override && hasContent) {
       console.log(`⚡ Content already exists for ${id}, skipping`);
@@ -2142,57 +2120,57 @@ export class ConceptService {
     const maxAttempts = 2;
 
     while (attempts < maxAttempts) {
-      let phase = 'generation';
+      let phase = "generation";
       try {
         attempts++;
-        console.log(
-          `🔄 Attempt ${attempts} to generate report content for ${id}...`
-        );
+        console.log(`🔄 Attempt ${attempts} to generate ${isReport ? "report" : "description"} content for ${id}...`);
 
-        const messages = this.context
-          .buildLLMMessages()
-          .generateAstroReportContent({ params });
-        console.log(`📨 Sending messages to AI: ${JSON.stringify(messages)}`);
+        let messages: ChatMessages;
+        if (isReport) {
+          messages = this.context.buildLLMMessages().generateAstroReportContent({ params: params as AstroReportParams });
+        } else {
+          messages = this.generateDescriptionMessages(params);
+        }
 
-        const response = await this.context
-          .api()
-          .callTogether.single(messages, {});
+        console.log(`📨 Sending messages to AI: ${JSON.stringify(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 ? '...' : ''
-          }`
-        );
-
-        const { enReport, ptReport } =
-          await this.parseAstrologicalReportContent(
-            params.reportType,
-            response
-          );
-
-        console.log(`💾 Storing report content for ${id}`);
-        await db
-          .update(table)
-          .set({
-            enReport: JSON.stringify(enReport),
-            ptReport: JSON.stringify(ptReport),
-          })
-          .where(eq(table.id, id))
-          .run();
+        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);
+          console.log(`💾 Storing report content for ${id}`);
+          await db
+            .update(table as any)
+            .set({
+              enReport: JSON.stringify(enReport),
+              ptReport: JSON.stringify(ptReport),
+            })
+            .where(eq((table as any).id, id))
+            .run();
+        } else {
+          const { enDescription, ptDescription } = await this.parseDescriptionContent(response);
+          console.log(`💾 Storing description content for ${id}`);
+          await db
+            .update(table as any)
+            .set({
+              enDescription,
+              ptDescription,
+            })
+            .where(eq(astroDescriptionTemplates.id, id))
+            .run();
+        }
 
-        console.log(`✅ Report 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:${params.reportType}:${id}`;
+        const failureKey = `failures:astro:${isReport ? (params as AstroReportParams).reportType : "description"}:${id}`;
         await this.context.kvConceptFailuresStore().put(
           failureKey,
           JSON.stringify({
@@ -2205,20 +2183,78 @@ export class ConceptService {
         );
 
         if (attempts >= maxAttempts) {
-          console.error(
-            `🚨 All ${maxAttempts} attempts failed at phase ${phase} for ${id}`
-          );
-          throw new Error(
-            `Failed to generate content 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));
       }
     }
   }
 
+  private generateDescriptionMessages({
+    entityType,
+    name,
+    isGeneric,
+  }: {
+    entityType: string;
+    name: string;
+    isGeneric?: boolean;
+  }): ChatMessages {
+    const prompt = astroPrompts.makeIntroDescription({
+      entityType,
+      name,
+      isGeneric,
+    });
+    return [{ role: 'user', content: prompt }];
+  }
+
+  async parseDescriptionContent(
+    response: string
+  ): Promise<{ enDescription: string; ptDescription: string }> {
+    console.log(`📌 [START] Parsing description content`);
+
+    try {
+      const enMatch = response.match(/-- EN\s*([\s\S]+?)-- PT/);
+      const ptMatch = response.match(/-- PT\s*([\s\S]+)/);
+
+      if (!enMatch || !ptMatch) {
+        throw new Error(`❌ Missing EN or PT description in response`);
+      }
+
+      const enDescription = enMatch[1].trim();
+      const ptDescription = ptMatch[1].trim();
+
+      console.log(
+        `✅ Parsed EN description: ${enDescription.slice(0, 100)}${
+          enDescription.length > 100 ? '...' : ''
+        }`
+      );
+      console.log(
+        `✅ Parsed PT description: ${ptDescription.slice(0, 100)}${
+          ptDescription.length > 100 ? '...' : ''
+        }`
+      );
+
+      return { enDescription, ptDescription };
+    } catch (error) {
+      console.error(`❌ Parsing failed for description`);
+
+      const failureKey = `failures:astro:parsing:description:${new Date().toISOString()}`;
+      await this.context.kvConceptFailuresStore().put(
+        failureKey,
+        JSON.stringify({
+          error: (error as Error).message,
+          response,
+          timestamp: new Date().toISOString(),
+        })
+      );
+
+      throw error;
+    }
+  }
+
   async parseAstrologicalReportContent(
     reportType: AstroReportParams['reportType'],
     response: string

package/db/migrations/0003_thin_valeria_richards.sql

@@ -0,0 +1,28 @@
+CREATE TABLE `astro_description_templates` (
+	`id` text PRIMARY KEY NOT NULL,
+	`entity_type` text NOT NULL,
+	`name` text NOT NULL,
+	`en_name` text,
+	`pt_name` text,
+	`en_description` text NOT NULL,
+	`pt_description` text NOT NULL,
+	`created_at` integer DEFAULT CURRENT_TIMESTAMP,
+	`updated_at` integer DEFAULT CURRENT_TIMESTAMP
+);
+--> statement-breakpoint
+CREATE INDEX `astro_description_templates_type_name_idx` ON `astro_description_templates` (`entity_type`,`name`);--> statement-breakpoint
+ALTER TABLE `aspect_reports` ADD `description_template_id` text REFERENCES astro_description_templates(id);--> statement-breakpoint
+CREATE INDEX `aspect_reports_description_template_idx` ON `aspect_reports` (`description_template_id`);--> statement-breakpoint
+ALTER TABLE `aspect_reports` DROP COLUMN `en_description`;--> statement-breakpoint
+ALTER TABLE `aspect_reports` DROP COLUMN `pt_description`;--> statement-breakpoint
+ALTER TABLE `astro_feature_reports` ADD `description_template_id` text REFERENCES astro_description_templates(id);--> statement-breakpoint
+CREATE INDEX `astro_feature_reports_description_template_idx` ON `astro_feature_reports` (`description_template_id`);--> statement-breakpoint
+ALTER TABLE `astro_feature_reports` DROP COLUMN `en_description`;--> statement-breakpoint
+ALTER TABLE `astro_feature_reports` DROP COLUMN `pt_description`;--> statement-breakpoint
+ALTER TABLE `astro_reports` ADD `description_template_id` text REFERENCES astro_description_templates(id);--> statement-breakpoint
+ALTER TABLE `astro_reports` DROP COLUMN `en_description`;--> statement-breakpoint
+ALTER TABLE `astro_reports` DROP COLUMN `pt_description`;--> statement-breakpoint
+ALTER TABLE `house_reports` ADD `description_template_id` text REFERENCES astro_description_templates(id);--> statement-breakpoint
+CREATE INDEX `house_reports_description_template_idx` ON `house_reports` (`description_template_id`);--> statement-breakpoint
+ALTER TABLE `house_reports` DROP COLUMN `en_description`;--> statement-breakpoint
+ALTER TABLE `house_reports` DROP COLUMN `pt_description`;