@zodic/shared 0.0.240 → 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/schema.ts

@@ -182,64 +182,68 @@ export const astroAspects = sqliteTable(
 );
 
 export const astroReports = sqliteTable(
-  "astro_reports",
+  'astro_reports',
   {
-    id: text("id").primaryKey(), // Unique identifier
-    type: text("type").notNull(), // 'planet', 'key_point', 'karmic_point', 'hermetic_part'
-    name: text("name").notNull(), // Slug (e.g., 'sun', 'pars_fortuna')
-    sign: text("sign"), // Slug (e.g., 'aries', 'taurus') - nullable for house-only reports
-    house: integer("house"), // Nullable, only for applicable placements
-    enDescription: text("en_description"), // General explanation of the placement
-    ptDescription: text("pt_description"),
-    enReport: text("en_report"), // Full report content in English
-    ptReport: text("pt_report"), // Full report content in Portuguese
-    createdAt: integer("created_at").default(sql`CURRENT_TIMESTAMP`),
-    updatedAt: integer("updated_at").default(sql`CURRENT_TIMESTAMP`),
+    id: text('id').primaryKey(), // Unique identifier
+    type: text('type').notNull(), // 'planet', 'key_point', 'karmic_point', 'arabic_part'
+    name: text('name').notNull(), // Slug (e.g., 'sun', 'pars_fortuna')
+    sign: text('sign'), // Slug (e.g., 'aries', 'taurus') - nullable for house-only reports
+    house: integer('house'), // Nullable, only for applicable placements
+    enDescription: text('en_description'), // General explanation of the placement
+    ptDescription: text('pt_description'),
+    enReport: text('en_report'), // Full report content in English
+    ptReport: text('pt_report'), // Full report content in Portuguese
+    createdAt: integer('created_at').default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: integer('updated_at').default(sql`CURRENT_TIMESTAMP`),
   },
   (t) => [
-    index("astro_reports_type_idx").on(t.type),
-    index("astro_reports_name_sign_idx").on(t.name, t.sign), // Most critical index (name + sign)
-    index("astro_reports_name_house_idx").on(t.name, t.house), // Most critical index (name + house)
+    index('astro_reports_type_idx').on(t.type),
+    index('astro_reports_name_sign_idx').on(t.name, t.sign), // Most critical index (name + sign)
+    index('astro_reports_name_house_idx').on(t.name, t.house), // Most critical index (name + house)
   ]
 );
 
 export const houseReports = sqliteTable(
-  "house_reports",
+  'house_reports',
   {
-    id: text("id").primaryKey(), // Unique identifier
-    sign: text("sign").notNull(), // Lowercase slug (e.g., 'aries', 'taurus')
-    house: integer("house").notNull(), // House placement (1-12)
-    enDescription: text("en_description"), // General explanation of the sign in a house
-    ptDescription: text("pt_description"),
-    enReport: text("en_report"), // Full report content in English
-    ptReport: text("pt_report"), // Full report content in Portuguese
-    createdAt: integer("created_at").default(sql`CURRENT_TIMESTAMP`),
-    updatedAt: integer("updated_at").default(sql`CURRENT_TIMESTAMP`),
+    id: text('id').primaryKey(), // Unique identifier
+    sign: text('sign').notNull(), // Lowercase slug (e.g., 'aries', 'taurus')
+    house: integer('house').notNull(), // House placement (1-12)
+    enDescription: text('en_description'), // General explanation of the sign in a house
+    ptDescription: text('pt_description'),
+    enReport: text('en_report'), // Full report content in English
+    ptReport: text('pt_report'), // Full report content in Portuguese
+    createdAt: integer('created_at').default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: integer('updated_at').default(sql`CURRENT_TIMESTAMP`),
   },
   (t) => [
-    index("house_reports_sign_house_idx").on(t.sign, t.house), // Optimized index for sign + house lookups
+    index('house_reports_sign_house_idx').on(t.sign, t.house), // Optimized index for sign + house lookups
   ]
 );
 
 export const aspectReports = sqliteTable(
-  "aspect_reports",
+  'aspect_reports',
   {
-    id: text("id").primaryKey(), // Unique identifier
-    aspectingPlanet: text("aspecting_planet").notNull(), // Planet/point initiating the aspect (e.g., 'sun', 'mars')
-    aspectedPlanet: text("aspected_planet").notNull(), // Planet/point receiving the aspect (e.g., 'moon', 'venus')
-    aspect: text("aspect").notNull(), // Aspect type ('conjunction', 'trine', 'square', etc.)
-    enDescription: text("en_description"), // General explanation of the aspect
-    ptDescription: text("pt_description"),
-    enReport: text("en_report"), // Full report content in English
-    ptReport: text("pt_report"), // Full report content in Portuguese
-    createdAt: integer("created_at").default(sql`CURRENT_TIMESTAMP`),
-    updatedAt: integer("updated_at").default(sql`CURRENT_TIMESTAMP`),
+    id: text('id').primaryKey(), // Unique identifier
+    aspectingPlanet: text('aspecting_planet').notNull(), // Planet/point initiating the aspect (e.g., 'sun', 'mars')
+    aspectedPlanet: text('aspected_planet').notNull(), // Planet/point receiving the aspect (e.g., 'moon', 'venus')
+    aspect: text('aspect').notNull(), // Aspect type ('conjunction', 'trine', 'square', etc.)
+    enDescription: text('en_description'), // General explanation of the aspect
+    ptDescription: text('pt_description'),
+    enReport: text('en_report'), // Full report content in English
+    ptReport: text('pt_report'), // Full report content in Portuguese
+    createdAt: integer('created_at').default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: integer('updated_at').default(sql`CURRENT_TIMESTAMP`),
   },
   (t) => [
-    index("aspect_reports_aspecting_idx").on(t.aspectingPlanet),
-    index("aspect_reports_aspected_idx").on(t.aspectedPlanet),
-    index("aspect_reports_aspect_idx").on(t.aspect),
-    index("aspect_reports_combined_idx").on(t.aspectingPlanet, t.aspectedPlanet, t.aspect), // Optimized for aspect lookups
+    index('aspect_reports_aspecting_idx').on(t.aspectingPlanet),
+    index('aspect_reports_aspected_idx').on(t.aspectedPlanet),
+    index('aspect_reports_aspect_idx').on(t.aspect),
+    index('aspect_reports_combined_idx').on(
+      t.aspectingPlanet,
+      t.aspectedPlanet,
+      t.aspect
+    ), // Optimized for aspect lookups
   ]
 );
 

package/package.json

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

package/types/scopes/generic.ts

@@ -1,3 +1,5 @@
+import { AspectType, PointSlug, ZodiacSign } from "./legacy";
+
 export type Provider = 'google' | 'facebook';
 
 export type ProviderInfo = {
@@ -31,6 +33,44 @@ export type AstroEntity = {
   house: number;
 };
 
+export interface ContentItem {
+  type: "title" | "subtitle" | "p" | "bullet-point";
+  title?: string;
+  content: string;
+}
+
+export interface AstrologicalReport {
+  language: string;
+  title: ContentItem[];
+  sections: Record<string, ContentItem[]>;
+}
+
+
+export type AstroReportParams =
+  | {
+      reportType: "sign";
+      type: "planet" | "key_point" | "karmic_point" | "arabic_part";
+      pointName: PointSlug;
+      sign: ZodiacSign;
+    }
+  | {
+      reportType: "house";
+      type: "planet" | "karmic_point"; // Only planets and karmic points for house reports
+      pointName: PointSlug;
+      house: number;
+    }
+  | {
+      reportType: "signInHouse";
+      sign: ZodiacSign;
+      houseNumber: number;
+    }
+  | {
+      reportType: "aspect";
+      aspectingPlanet: PointSlug;
+      aspectedPlanet: PointSlug;
+      aspectingType: AspectType;
+    };
+
 export type NatalChartInterpretation = {
   planets: Planet[];
   houses: House[];

package/types/scopes/legacy.ts

@@ -3,18 +3,18 @@ import { BackendBindings } from './cloudflare';
 import { ControlNetConfig, Gender } from './generic';
 
 export const zodiacSigns = [
-  "aries",
-  "taurus",
-  "gemini",
-  "cancer",
-  "leo",
-  "virgo",
-  "libra",
-  "scorpio",
-  "sagittarius",
-  "capricorn",
-  "aquarius",
-  "pisces",
+  'aries',
+  'taurus',
+  'gemini',
+  'cancer',
+  'leo',
+  'virgo',
+  'libra',
+  'scorpio',
+  'sagittarius',
+  'capricorn',
+  'aquarius',
+  'pisces',
 ] as const;
 export type ZodiacSignSlug = (typeof zodiacSigns)[number];
 
@@ -22,55 +22,61 @@ export type ZodiacSignSlug = (typeof zodiacSigns)[number];
 export const houses = Array.from({ length: 12 }, (_, i) => i + 1);
 
 // Aspects
-export const aspects = ["conjunction", "opposition", "trine", "square", "sextile"] as const;
+export const aspects = [
+  'conjunction',
+  'opposition',
+  'trine',
+  'square',
+  'sextile',
+] as const;
 export type AspectType = (typeof aspects)[number];
 
 export const pointTypes: Record<PointSlug, string> = {
-  sun: "planet",
-  moon: "planet",
-  mercury: "planet",
-  venus: "planet",
-  mars: "planet",
-  jupiter: "planet",
-  saturn: "planet",
-  uranus: "planet",
-  neptune: "planet",
-  pluto: "planet",
-  ascendant: "key_point",
-  descendant: "key_point",
-  midheaven: "key_point",
-  imum_coeli: "key_point",
-  north_node: "karmic_point",
-  south_node: "karmic_point",
-  chiron: "karmic_point",
-  lilith: "hermetic_part",
-  vertex: "hermetic_part",
-  antivertex: "hermetic_part",
-  pars_fortuna: "hermetic_part",
-  pars_spiritus: "hermetic_part",
-  pars_victoria: "hermetic_part",
-  pars_amoris: "hermetic_part",
-  pars_eros: "hermetic_part",
-  pars_fortitudo: "hermetic_part",
-  pars_necessitatis: "hermetic_part",
+  sun: 'planet',
+  moon: 'planet',
+  mercury: 'planet',
+  venus: 'planet',
+  mars: 'planet',
+  jupiter: 'planet',
+  saturn: 'planet',
+  uranus: 'planet',
+  neptune: 'planet',
+  pluto: 'planet',
+  ascendant: 'key_point',
+  descendant: 'key_point',
+  midheaven: 'key_point',
+  imum_coeli: 'key_point',
+  north_node: 'karmic_point',
+  south_node: 'karmic_point',
+  chiron: 'karmic_point',
+  lilith: 'arabic_part',
+  vertex: 'arabic_part',
+  antivertex: 'arabic_part',
+  pars_fortuna: 'arabic_part',
+  pars_spiritus: 'arabic_part',
+  pars_victoria: 'arabic_part',
+  pars_amoris: 'arabic_part',
+  pars_eros: 'arabic_part',
+  pars_fortitudo: 'arabic_part',
+  pars_necessitatis: 'arabic_part',
 };
 
 // Subset of 14 points for aspects
 export const aspectPoints: PointSlug[] = [
-  "sun",
-  "moon",
-  "mercury",
-  "venus",
-  "mars",
-  "jupiter",
-  "saturn",
-  "uranus",
-  "neptune",
-  "pluto",
-  "ascendant",
-  "descendant",
-  "midheaven",
-  "imum_coeli",
+  'sun',
+  'moon',
+  'mercury',
+  'venus',
+  'mars',
+  'jupiter',
+  'saturn',
+  'uranus',
+  'neptune',
+  'pluto',
+  'ascendant',
+  'descendant',
+  'midheaven',
+  'imum_coeli',
 ];
 
 export type PointSlug = keyof typeof pointNameMap;

package/utils/astroPrompts/index.ts

@@ -1,9 +1,14 @@
-import { PointSlug, ZodiacSign, zodiacSignMap } from '../../types/scopes/legacy';
+import {
+  AspectType,
+  PointSlug,
+  ZodiacSign,
+  zodiacSignMap,
+} from '../../types/scopes/legacy';
 import { pointNameMap } from './pointNameMap';
 
 // Interfaces for each function's parameters
 interface PlanetOrPointParams {
-  type: 'planet' | 'key_point' | 'karmic_point' | 'hermetic_part';
+  type: 'planet' | 'key_point' | 'karmic_point' | 'arabic_part';
   sign: ZodiacSign;
   pointName: PointSlug;
 }
@@ -16,13 +21,36 @@ interface HouseParams {
 interface AspectParams {
   aspectingPlanet: PointSlug;
   aspectedPlanet: PointSlug;
-  aspectingType: string; // e.g., "conjunct", "square", "trine"
+  aspectingType: AspectType; // e.g., "conjunct", "square", "trine"
+}
+
+// Parameters for each prompt type
+interface PlanetOrPointParams {
+  type: 'planet' | 'key_point' | 'karmic_point' | 'arabic_part';
+  sign: ZodiacSign;
+  pointName: PointSlug;
+}
+
+interface HousePlacementParams {
+  type: 'planet' | 'key_point' | 'karmic_point' | 'arabic_part';
+  house: number; // e.g., "1", "2", etc.
+  pointName: PointSlug;
+}
+
+interface HouseParams {
+  houseNumber: number;
+  sign: ZodiacSign;
+}
+
+interface AspectParams {
+  aspectingPlanet: PointSlug;
+  aspectedPlanet: PointSlug;
+  aspectingType: AspectType;
 }
 
-// Modular astroPrompts object
 export const astroPrompts = {
   planetOrPoint: ({ type, sign, pointName }: PlanetOrPointParams): string => {
-    const validTypes = ['planet', 'key_point', 'karmic_point', 'hermetic_part'];
+    const validTypes = ['planet', 'key_point', 'karmic_point', 'arabic_part'];
     if (!validTypes.includes(type)) {
       throw new Error(
         `Invalid type for planetOrPoint: ${type}. Must be one of ${validTypes.join(
@@ -48,6 +76,37 @@ export const astroPrompts = {
     `.trim();
   },
 
+  housePlacement: ({
+    type,
+    house,
+    pointName,
+  }: HousePlacementParams): string => {
+    const validTypes = ['planet', 'key_point', 'karmic_point', 'arabic_part'];
+    if (!validTypes.includes(type)) {
+      throw new Error(
+        `Invalid type for housePlacement: ${type}. Must be one of ${validTypes.join(
+          ', '
+        )}`
+      );
+    }
+
+    const formattedPointName = pointNameMap[pointName] || pointName;
+    return `
+      Make me a report for the astrological placement: ${formattedPointName} in House ${house}.
+      The response should include an English version and a Portuguese version.
+      Use "###" for titles and "####" for subtitles.
+      The response format should be exactly like this:
+
+      -- EN
+
+      [English Report - structured with headings, sections, and detailed explanations]
+
+      -- PT
+
+      [Portuguese Report - structured exactly the same as the English version]
+    `.trim();
+  },
+
   house: ({ houseNumber, sign }: HouseParams): string => {
     return `
       Make me a report for the astrological placement: House ${houseNumber} in ${zodiacSignMap[sign]}.
@@ -88,4 +147,3 @@ export const astroPrompts = {
     `.trim();
   },
 };
-

package/utils/buildMessages.ts

@@ -1,4 +1,11 @@
-import { BackendBindings, ChatMessages, Concept, Crown } from '../types';
+import {
+  AstroReportParams,
+  BackendBindings,
+  ChatMessages,
+  Concept,
+  Crown,
+} from '../types';
+import { astroPrompts } from './astroPrompts';
 import { conceptPrompts } from './conceptPrompts';
 import { mapConceptToPlanets } from './mapConceptToPlanets';
 
@@ -280,4 +287,55 @@ export const buildLLMMessages = (env: BackendBindings) => ({
       content: `Translate this concept name into Brazilian Portuguese: "${englishName}"`,
     },
   ],
+
+  generateAstroReportContent: ({
+    params,
+  }: {
+    params: AstroReportParams;
+  }): ChatMessages => {
+    let prompt: string;
+
+    switch (params.reportType) {
+      case 'sign':
+        prompt = astroPrompts.planetOrPoint({
+          type: params.type,
+          sign: params.sign,
+          pointName: params.pointName,
+        });
+        break;
+
+      case 'house':
+        prompt = astroPrompts.housePlacement({
+          type: params.type,
+          house: params.house,
+          pointName: params.pointName,
+        });
+        break;
+
+      case 'signInHouse':
+        prompt = astroPrompts.house({
+          houseNumber: params.houseNumber,
+          sign: params.sign,
+        });
+        break;
+
+      case 'aspect':
+        prompt = astroPrompts.aspect({
+          aspectingPlanet: params.aspectingPlanet,
+          aspectedPlanet: params.aspectedPlanet,
+          aspectingType: params.aspectingType,
+        });
+        break;
+
+      default:
+        throw new Error(`Unknown report type: ${(params as any).reportType}`);
+    }
+
+    return [
+      {
+        role: 'user',
+        content: prompt,
+      },
+    ];
+  },
 });

package/utils/index.ts

@@ -129,3 +129,11 @@ export function chunkArray<T>(array: T[], size: number): T[][] {
   }
   return result;
 }
+
+// Utility function to clean text
+export function cleanText(text: string): string {
+  return text.replace(/\"/g, ''); // Replace \" with "
+  // Add more replacements here if needed, e.g.:
+  // .replace(/\\'/g, "'") // Replace \' with '
+  // .replace(/[^\w\s.,!?":'-]/g, "") // Remove all but common punctuation
+}