@zodic/shared 0.0.239 → 0.0.241

package/app/services/ConceptService.ts

@@ -7,9 +7,20 @@ import { drizzle } from 'drizzle-orm/d1';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
 import { v4 as uuidv4 } from 'uuid';
-import { schema } from '../..';
-import { conceptsData } from '../../db/schema';
-import { Concept, ControlNetConfig, Languages } from '../../types';
+import { cleanText, schema } from '../..';
+import {
+  aspectReports,
+  astroReports,
+  conceptsData,
+  houseReports,
+} from '../../db/schema';
+import {
+  AstrologicalReport,
+  AstroReportParams,
+  Concept,
+  ControlNetConfig,
+  Languages,
+} from '../../types';
 import {
   KVConcept,
   sizes,
@@ -1993,4 +2004,249 @@ export class ConceptService {
 
     console.log(`✅ Stored duplicate keys for ${conceptSlug} in cache.`);
   }
+
+  // ? ASTRO PROCESSING
+  async generateAstroReportContent(
+    params: AstroReportParams,
+    override: boolean = false
+  ): Promise<void> {
+    console.log(
+      `🚀 Generating report content for ${JSON.stringify(
+        params
+      )}, override: ${override}`
+    );
+
+    const db = drizzle(this.context.env.DB);
+    let table, idField, whereClause;
+
+    // Determine table and ID
+    switch (params.reportType) {
+      case 'sign':
+      case 'house':
+        table = astroReports;
+        idField =
+          params.reportType === 'sign'
+            ? sql`SELECT id FROM astro_reports WHERE name = ${params.pointName} AND sign = ${params.sign} AND house IS NULL`
+            : sql`SELECT id FROM astro_reports WHERE name = ${params.pointName} AND house = ${params.house} AND sign IS NULL`;
+        break;
+      case 'signInHouse':
+        table = houseReports;
+        idField = sql`SELECT id FROM house_reports WHERE sign = ${params.sign} AND house = ${params.houseNumber}`;
+        break;
+      case 'aspect':
+        table = aspectReports;
+        idField = sql`SELECT id FROM aspect_reports WHERE aspecting_planet = ${params.aspectingPlanet} AND aspected_planet = ${params.aspectedPlanet} AND aspect = ${params.aspectingType}`;
+        break;
+      default:
+        throw new Error(`Unknown report type: ${(params as any).reportType}`);
+    }
+
+    const report = await db
+      .select()
+      .from(table)
+      .where(sql`${idField}`)
+      .get();
+    if (!report) {
+      throw new Error(`❌ No report found for ${JSON.stringify(params)}`);
+    }
+
+    const id = report.id;
+    const hasContent = report.enReport && report.ptReport;
+
+    if (!override && hasContent) {
+      console.log(`⚡ Content already exists for ${id}, skipping`);
+      return;
+    }
+
+    let attempts = 0;
+    const maxAttempts = 2;
+
+    while (attempts < maxAttempts) {
+      let phase = 'generation';
+      try {
+        attempts++;
+        console.log(`🔄 Attempt ${attempts} to generate report content...`);
+
+        // Use buildLLMMessages().generateAstroReportContent
+        const messages = this.context
+          .buildLLMMessages()
+          .generateAstroReportContent({ params });
+
+        const response = await this.context
+          .api()
+          .callTogether.single(messages, {});
+        if (!response) {
+          throw new Error(`❌ AI returned an empty response`);
+        }
+
+        phase = 'parsing';
+
+        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();
+
+        console.log(`✅ Report content stored for ${id}`);
+        return;
+      } catch (error) {
+        console.error(
+          `❌ Attempt ${attempts} failed at phase: ${phase}`,
+          (error as Error).message
+        );
+
+        const failureKey = `failures:astro:${params.reportType}:${id}`;
+        await this.context.kvConceptFailuresStore().put(
+          failureKey,
+          JSON.stringify({
+            error: (error as Error).message,
+            attempt: attempts,
+            phase,
+            params,
+            timestamp: new Date().toISOString(),
+          })
+        );
+
+        if (attempts >= maxAttempts) {
+          console.error(
+            `🚨 All ${maxAttempts} attempts failed at phase ${phase}`
+          );
+          throw new Error(
+            `Failed to generate content after ${maxAttempts} attempts`
+          );
+        }
+
+        console.log('🔁 Retrying...');
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+      }
+    }
+  }
+
+  async parseAstrologicalReportContent(
+    reportType: AstroReportParams['reportType'],
+    response: string
+  ): Promise<{
+    enReport: AstrologicalReport['sections'];
+    ptReport: AstrologicalReport['sections'];
+  }> {
+    console.log(`📌 [START] Parsing report content for ${reportType}`);
+
+    try {
+      const parsed = this.parseAstrologicalReport(response); // Your existing parser
+
+      const enReport = parsed.find((r) => r.language === 'EN');
+      const ptReport = parsed.find((r) => r.language === 'PT');
+
+      if (!enReport || !ptReport) {
+        throw new Error(`❌ Missing EN or PT report in response`);
+      }
+
+      console.log(
+        `✅ Parsed EN report sections:`,
+        Object.keys(enReport.sections)
+      );
+      console.log(
+        `✅ Parsed PT report sections:`,
+        Object.keys(ptReport.sections)
+      );
+
+      return {
+        enReport: enReport.sections,
+        ptReport: ptReport.sections,
+      };
+    } catch (error) {
+      console.error(`❌ Parsing failed for ${reportType}`);
+
+      const failureKey = `failures:astro:parsing:${reportType}:${new Date().toISOString()}`;
+      await this.context.kvConceptFailuresStore().put(
+        failureKey,
+        JSON.stringify({
+          error: (error as Error).message,
+          reportType,
+          response,
+          timestamp: new Date().toISOString(),
+        })
+      );
+
+      throw error;
+    }
+  }
+
+  private parseAstrologicalReport(response: string): AstrologicalReport[] {
+    const reports: AstrologicalReport[] = [];
+    const languageSections = response
+      .split(/--\s*(EN|PT)\s*\n/)
+      .filter(Boolean);
+
+    for (let i = 0; i < languageSections.length; i += 2) {
+      const language = languageSections[i].trim();
+      const content = languageSections[i + 1]?.trim();
+      if (!content || !language.match(/^(EN|PT)$/)) continue;
+
+      const report: AstrologicalReport = {
+        language,
+        title: [],
+        sections: {},
+      };
+
+      const lines = content.split('\n').map((line) => line.trim());
+      let currentSection = '';
+
+      for (const line of lines) {
+        if (line.startsWith('### ') && report.title.length === 0) {
+          report.title.push({
+            type: 'title',
+            content: cleanText(line.replace('### ', '')),
+          });
+          continue;
+        }
+
+        if (line.startsWith('#### ')) {
+          currentSection = cleanText(line.replace('#### ', '').trim());
+          report.sections[currentSection] =
+            report.sections[currentSection] || [];
+          continue;
+        }
+
+        if (!line || !currentSection) continue;
+
+        if (line.match(/^\d+\.\s/) || line.startsWith('- ')) {
+          const listItem = line.replace(/^\d+\.\s|- /, '').trim();
+          const boldMatch = listItem.match(/^\*\*(.+?)\*\*:\s*(.+)$/);
+          if (boldMatch) {
+            report.sections[currentSection].push({
+              type: 'bullet-point',
+              title: cleanText(boldMatch[1]),
+              content: cleanText(boldMatch[2]),
+            });
+          } else {
+            report.sections[currentSection].push({
+              type: 'bullet-point',
+              content: cleanText(listItem),
+            });
+          }
+          continue;
+        }
+
+        report.sections[currentSection].push({
+          type: 'p',
+          content: cleanText(line),
+        });
+      }
+
+      reports.push(report);
+    }
+
+    return reports;
+  }
 }

package/db/migrations/0001_mysterious_mystique.sql

@@ -0,0 +1,47 @@
+CREATE TABLE `aspect_reports` (
+	`id` text PRIMARY KEY NOT NULL,
+	`aspecting_planet` text NOT NULL,
+	`aspected_planet` text NOT NULL,
+	`aspect` text NOT NULL,
+	`en_description` text,
+	`pt_description` text,
+	`en_report` text,
+	`pt_report` text,
+	`created_at` integer DEFAULT CURRENT_TIMESTAMP,
+	`updated_at` integer DEFAULT CURRENT_TIMESTAMP
+);
+--> statement-breakpoint
+CREATE INDEX `aspect_reports_aspecting_idx` ON `aspect_reports` (`aspecting_planet`);--> statement-breakpoint
+CREATE INDEX `aspect_reports_aspected_idx` ON `aspect_reports` (`aspected_planet`);--> statement-breakpoint
+CREATE INDEX `aspect_reports_aspect_idx` ON `aspect_reports` (`aspect`);--> statement-breakpoint
+CREATE INDEX `aspect_reports_combined_idx` ON `aspect_reports` (`aspecting_planet`,`aspected_planet`,`aspect`);--> statement-breakpoint
+CREATE TABLE `astro_reports` (
+	`id` text PRIMARY KEY NOT NULL,
+	`type` text NOT NULL,
+	`name` text NOT NULL,
+	`sign` text,
+	`house` integer,
+	`en_description` text,
+	`pt_description` text,
+	`en_report` text,
+	`pt_report` text,
+	`created_at` integer DEFAULT CURRENT_TIMESTAMP,
+	`updated_at` integer DEFAULT CURRENT_TIMESTAMP
+);
+--> statement-breakpoint
+CREATE INDEX `astro_reports_type_idx` ON `astro_reports` (`type`);--> statement-breakpoint
+CREATE INDEX `astro_reports_name_sign_idx` ON `astro_reports` (`name`,`sign`);--> statement-breakpoint
+CREATE INDEX `astro_reports_name_house_idx` ON `astro_reports` (`name`,`house`);--> statement-breakpoint
+CREATE TABLE `house_reports` (
+	`id` text PRIMARY KEY NOT NULL,
+	`sign` text NOT NULL,
+	`house` integer NOT NULL,
+	`en_description` text,
+	`pt_description` text,
+	`en_report` text,
+	`pt_report` text,
+	`created_at` integer DEFAULT CURRENT_TIMESTAMP,
+	`updated_at` integer DEFAULT CURRENT_TIMESTAMP
+);
+--> statement-breakpoint
+CREATE INDEX `house_reports_sign_house_idx` ON `house_reports` (`sign`,`house`);