@zodic/shared 0.0.248 → 0.0.250

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/schema.ts

@@ -189,8 +189,10 @@ export const astroReports = sqliteTable(
     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'),
+    descriptionTemplateId: text('description_template_id').references(
+      () => astroDescriptionTemplates.id,
+      { onDelete: 'set null' }
+    ), // NEW: Foreign key to astro_description_templates.id
     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`),
@@ -209,8 +211,10 @@ export const houseReports = sqliteTable(
     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'),
+    descriptionTemplateId: text('description_template_id').references(
+      () => astroDescriptionTemplates.id,
+      { onDelete: 'set null' }
+    ), // NEW: Foreign key to astro_description_templates.id
     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`),
@@ -218,6 +222,7 @@ export const houseReports = sqliteTable(
   },
   (t) => [
     index('house_reports_sign_house_idx').on(t.sign, t.house), // Optimized index for sign + house lookups
+    index('house_reports_description_template_idx').on(t.descriptionTemplateId), // NEW: Index for foreign key performance
   ]
 );
 
@@ -228,8 +233,10 @@ export const aspectReports = sqliteTable(
     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'),
+    descriptionTemplateId: text('description_template_id').references(
+      () => astroDescriptionTemplates.id,
+      { onDelete: 'set null' }
+    ), // NEW: Foreign key to astro_description_templates.id
     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`),
@@ -239,11 +246,8 @@ export const aspectReports = sqliteTable(
     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_combined_idx').on(t.aspectingPlanet, t.aspectedPlanet, t.aspect),
+    index('aspect_reports_description_template_idx').on(t.descriptionTemplateId), // NEW: Index for foreign key performance
   ]
 );
 
@@ -251,17 +255,38 @@ export const astroFeatureReports = sqliteTable(
   'astro_feature_reports',
   {
     id: text('id').primaryKey(), // Unique identifier
-    featureType: text('feature_type').notNull(), // e.g., "moon_phase", "element", "mode", "hemisphere_east_west", "hemisphere_north_south", "dominant_sign"
-    name: text('name').notNull(), // e.g., "last-quarter-moon", "fire", "cardinal", "east-west", "north-south", "capricorn"
-    enDescription: text('en_description'), // Introductory text in English
-    ptDescription: text('pt_description'), // Introductory text in Portuguese
+    featureType: text('feature_type').notNull(), // e.g., "moon_phase", "element", "mode", "hemisphere_east_west", "hemisphere_north_south"
+    name: text('name').notNull(), // e.g., "last-quarter-moon", "fire", "cardinal", "east", "north"
+    descriptionTemplateId: text('description_template_id').references(
+      () => astroDescriptionTemplates.id,
+      { onDelete: 'set null' }
+    ), // NEW: Foreign key to astro_description_templates.id
     enReport: text('en_report'), // Full report content in English (JSON string)
     ptReport: text('pt_report'), // Full report content in Portuguese (JSON string)
     createdAt: integer('created_at').default(sql`CURRENT_TIMESTAMP`),
     updatedAt: integer('updated_at').default(sql`CURRENT_TIMESTAMP`),
   },
   (t) => [
-    index('astro_feature_reports_type_name_idx').on(t.featureType, t.name), // Optimized for lookups by type and name
+    index('astro_feature_reports_type_name_idx').on(t.featureType, t.name),
+    index('astro_feature_reports_description_template_idx').on(t.descriptionTemplateId), // NEW: Index for foreign key performance
+  ]
+);
+
+export const astroDescriptionTemplates = sqliteTable(
+  'astro_description_templates',
+  {
+    id: text('id').primaryKey(), // Unique identifier
+    entityType: text('entity_type').notNull(), // e.g., "planet", "key_point", "karmic_point", "arabic_part", "house", "aspect", "moon_phase", "element", "mode", "hemisphere_east_west", "hemisphere_north_south"
+    name: text('name').notNull(), // Slug (e.g., "last-quarter-moon", "fire", "cardinal", "east", "house_1")
+    enName: text('en_name'), // Optional human-readable name in English (e.g., "Last Quarter Moon", "Fire")
+    ptName: text('pt_name'), // Optional human-readable name in Portuguese (e.g., "Lua Minguante", "Fogo")
+    enDescription: text('en_description').notNull(), // Shared 150–180 word intro in English
+    ptDescription: text('pt_description').notNull(), // Shared 150–180 word intro in Portuguese
+    createdAt: integer('created_at').default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: integer('updated_at').default(sql`CURRENT_TIMESTAMP`),
+  },
+  (t) => [
+    index('astro_description_templates_type_name_idx').on(t.entityType, t.name), // Optimized for lookups by type and slug
   ]
 );
 

package/package.json

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

package/types/scopes/generic.ts

@@ -45,6 +45,31 @@ export interface AstrologicalReport {
   sections: Record<string, ContentItem[]>;
 }
 
+export interface AstroReportRow {
+  id: string;
+  type?: string; // For astroReports
+  name?: string;
+  sign?: string;
+  house?: number;
+  featureType?: string; // For astroFeatureReports
+  enReport: string | null;
+  ptReport: string | null;
+  enDescription?: string | null;
+  ptDescription?: string | null;
+  createdAt: number | null;
+  updatedAt: number | null;
+}
+
+export interface DescriptionTemplateRow {
+  id: string;
+  entityType: string;
+  name: string;
+  enDescription: string | null;
+  ptDescription: string | null;
+  createdAt: number | null;
+  updatedAt: number | null;
+}
+
 export type AstroReportParams =
   | {
       reportType: 'sign';

package/utils/astroPrompts/index.ts

@@ -49,6 +49,12 @@ interface AspectParams {
   aspectingType: AspectType;
 }
 
+interface DescriptionParams {
+  entityType: string;
+  name: string;
+  isGeneric?: boolean; // Flag for generic descriptions (aspects, moon phases, elements, modes, hemispheres)
+}
+
 export const astroPrompts = {
   planetOrPoint: ({ type, sign, pointName }: PlanetOrPointParams): string => {
     const validTypes = ['planet', 'key_point', 'karmic_point', 'arabic_part'];
@@ -224,4 +230,24 @@ export const astroPrompts = {
         throw new Error(`Unknown feature type in params: ${params}`);
     }
   },
+
+  makeIntroDescription: ({ entityType, name, isGeneric }: DescriptionParams): string => {
+    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
+      [Single block of plain text with English version]
+      -- PT
+      [Single block of plain text with Portuguese version]
+    `.trim();
+
+    if (isGeneric) {
+      return `
+        ${baseFormat.replace("astrological", "astrological concept representing").replace("about the astrological", "about what the")}
+      `.trim();
+    } else {
+      return `${baseFormat} ${name ? `named ${name}.` : ""}`.trim();
+    }
+  },
 };

package/utils/buildMessages.ts

@@ -327,7 +327,91 @@ export const buildLLMMessages = (env: BackendBindings) => ({
         });
         break;
 
+      case 'feature':
+        if (params.featureType === 'element') {
+          if (!('subtype' in params))
+            throw new Error('Missing subtype for element feature report');
+          switch (params.subtype) {
+            case 'balanced':
+              prompt = astroPrompts.feature({
+                featureType: 'element',
+                subtype: 'balanced',
+              });
+              break;
+            case 'pure':
+              if (!('dominantElement' in params))
+                throw new Error(
+                  'Missing dominantElement for pure element report'
+                );
+              prompt = astroPrompts.feature({
+                featureType: 'element',
+                subtype: 'pure',
+                dominantElement: 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'
+                );
+              prompt = astroPrompts.feature({
+                featureType: 'element',
+                subtype: 'preponderant_lacking',
+                dominantElement: params.dominantElement,
+                lackingElement: 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');
+          // Narrow featureType to ensure it matches FeatureParams
+          switch (params.featureType) {
+            case 'moon_phase':
+            case 'mode':
+              prompt = astroPrompts.feature({
+                featureType: params.featureType,
+                name: params.name,
+              });
+              break;
+            case 'hemisphere_east_west':
+            case 'hemisphere_north_south':
+              if (
+                !(
+                  ['east', 'west'].includes(params.name) ||
+                  ['north', 'south'].includes(params.name)
+                )
+              ) {
+                throw new Error(
+                  `Invalid name "${params.name}" for ${params.featureType}`
+                );
+              }
+              prompt = astroPrompts.feature({
+                featureType: params.featureType,
+                name: params.name as 'east' | 'west' | 'north' | 'south',
+              });
+              break;
+            default:
+              throw new Error(
+                `Unknown feature type: ${(params as any).featureType}`
+              );
+          }
+        }
+        break;
+
       default:
+        console.error(
+          `❌ Unknown report type: ${
+            (params as any).reportType
+          }. Params: ${JSON.stringify(params)}`
+        );
         throw new Error(`Unknown report type: ${(params as any).reportType}`);
     }