@zodic/shared 0.0.244 → 0.0.246

package/app/services/ConceptService.ts

@@ -2048,6 +2048,31 @@ export class ConceptService {
           eq(aspectReports.aspect, params.aspectingType)
         );
         break;
+        case "feature":
+          table = astroFeatureReports;
+          let nameValue: string;
+          if (params.featureType === "element") {
+            switch (params.subtype) {
+              case "balanced":
+                nameValue = "balanced";
+                break;
+              case "pure":
+                nameValue = params.dominantElement;
+                break;
+              case "preponderant_lacking":
+                nameValue = `${params.dominantElement}-${params.lackingElement}`;
+                break;
+              default:
+                throw new Error(`Unknown element subtype: ${(params as any).subtype}`);
+            }
+          } else {
+            nameValue = params.name;
+          }
+          whereClause = and(
+            eq(astroFeatureReports.featureType, params.featureType),
+            eq(astroFeatureReports.name, nameValue)
+          );
+          break;
       default:
         throw new Error(`Unknown report type: ${(params as any).reportType}`);
     }
@@ -2204,9 +2229,9 @@ export class ConceptService {
       console.log(`🔢 Split into ${lines.length} lines`);
   
       let currentSection = '';
-  
-      for (const line of lines) {
-        console.log(`📏 Processing line: "${line}"`);
+      for (let j = 0; j < lines.length; j++) {
+        const line = lines[j];
+        console.log(`📏 Processing line ${j + 1}: "${line}"`);
   
         if (line.startsWith('### ') && report.title.length === 0) {
           const titleContent = cleanText(line.replace('### ', ''));
@@ -2233,15 +2258,28 @@ export class ConceptService {
         if (line.match(/^\d+\.\s/) || line.startsWith('- ')) {
           const listItem = line.replace(/^\d+\.\s|- /, '').trim();
           console.log(`🔹 Bullet point detected: "${listItem}"`);
-          const boldMatch = listItem.match(/^\*\*(.+?)\*\*[:\s]*(.+)$/);
+          const boldMatch = listItem.match(/^\*\*(.+?)\*\*[:\s]*(.+)?$/); // Updated to allow standalone bold
+  
           if (boldMatch) {
             const title = cleanText(boldMatch[1]);
-            const content = cleanText(boldMatch[2]);
-            console.log(`✅ Bold match found - Title: "${title}", Content: "${content}"`);
+            let content = boldMatch[2] ? cleanText(boldMatch[2]) : '';
+  
+            // Look ahead for content if none on the same line
+            if (!content && j + 1 < lines.length) {
+              const nextLine = lines[j + 1];
+              console.log(`🔍 Checking next line for content: "${nextLine}"`);
+              if (nextLine && !nextLine.match(/^\d+\.\s|- /) && !nextLine.startsWith('#### ') && !nextLine.startsWith('### ')) {
+                content = cleanText(nextLine);
+                console.log(`✅ Found content in next line: "${content}"`);
+                j++; // Skip the next line since we’ve consumed it
+              }
+            }
+  
+            console.log(`✅ Bold match found - Title: "${title}", Content: "${content || 'None'}"`);
             report.sections[currentSection].push({
               type: 'bullet-point',
               title,
-              content,
+              content: content || '', // Empty string if no content found
             });
           } else {
             console.log(`❌ No bold match - Full content: "${listItem}"`);

package/db/schema.ts

@@ -247,6 +247,24 @@ export const aspectReports = sqliteTable(
   ]
 );
 
+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
+    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
+  ]
+);
+
 export const concepts = sqliteTable(
   'concepts',
   {

package/package.json

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

package/types/scopes/generic.ts

@@ -1,4 +1,4 @@
-import { AspectType, PointSlug, ZodiacSign } from "./legacy";
+import { AspectType, PointSlug, ZodiacSign } from './legacy';
 
 export type Provider = 'google' | 'facebook';
 
@@ -34,7 +34,7 @@ export type AstroEntity = {
 };
 
 export interface ContentItem {
-  type: "title" | "subtitle" | "p" | "bullet-point";
+  type: 'title' | 'subtitle' | 'p' | 'bullet-point';
   title?: string;
   content: string;
 }
@@ -45,30 +45,50 @@ export interface AstrologicalReport {
   sections: Record<string, ContentItem[]>;
 }
 
-
 export type AstroReportParams =
   | {
-      reportType: "sign";
-      type: "planet" | "key_point" | "karmic_point" | "arabic_part";
+      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
+      reportType: 'house';
+      type: 'planet' | 'karmic_point'; // Only planets and karmic points for house reports
       pointName: PointSlug;
       house: number;
     }
   | {
-      reportType: "signInHouse";
+      reportType: 'signInHouse';
       sign: ZodiacSign;
       houseNumber: number;
     }
   | {
-      reportType: "aspect";
+      reportType: 'aspect';
       aspectingPlanet: PointSlug;
       aspectedPlanet: PointSlug;
       aspectingType: AspectType;
+    }
+  | { reportType: 'feature'; featureType: 'moon_phase'; name: string }
+  | { reportType: 'feature'; featureType: 'element'; subtype: 'balanced' }
+  | {
+      reportType: 'feature';
+      featureType: 'element';
+      subtype: 'pure';
+      dominantElement: string;
+    }
+  | {
+      reportType: 'feature';
+      featureType: 'element';
+      subtype: 'preponderant_lacking';
+      dominantElement: string;
+      lackingElement: string;
+    }
+  | { reportType: 'feature'; featureType: 'mode'; name: string }
+  | {
+      reportType: 'feature';
+      featureType: 'hemisphere_east_west' | 'hemisphere_north_south';
+      name: 'east' | 'west' | 'north' | 'south';
     };
 
 export type NatalChartInterpretation = {

package/types/scopes/legacy.ts

@@ -31,6 +31,47 @@ export const aspects = [
 ] as const;
 export type AspectType = (typeof aspects)[number];
 
+export interface BalancedElementParams {
+  featureType: "element";
+  subtype: "balanced";
+}
+
+export interface PureElementParams {
+  featureType: "element";
+  subtype: "pure";
+  dominantElement: string; // e.g., "fire"
+}
+
+export interface PreponderantLackingElementParams {
+  featureType: "element";
+  subtype: "preponderant_lacking";
+  dominantElement: string; // e.g., "fire"
+  lackingElement: string; // e.g., "water"
+}
+
+export type ElementParams = BalancedElementParams | PureElementParams | PreponderantLackingElementParams;
+
+export interface MoonPhaseParams {
+  featureType: "moon_phase";
+  name: string; // e.g., "last-quarter"
+}
+
+export interface ModeParams {
+  featureType: "mode";
+  name: string; // e.g., "cardinal"
+}
+
+export interface HemisphereParams {
+  featureType: "hemisphere_east_west" | "hemisphere_north_south";
+  name: "east" | "west" | "north" | "south"; // Highlighted hemisphere
+}
+
+export type FeatureParams = 
+  | MoonPhaseParams 
+  | ElementParams 
+  | ModeParams 
+  | HemisphereParams;
+
 export const pointTypes: Record<PointSlug, string> = {
   sun: 'planet',
   moon: 'planet',

package/utils/astroPrompts/index.ts

@@ -1,5 +1,6 @@
 import {
   AspectType,
+  FeatureParams,
   PointSlug,
   ZodiacSign,
   zodiacSignMap,
@@ -146,4 +147,81 @@ export const astroPrompts = {
       [Portuguese Report - structured exactly the same as the English version]
     `.trim();
   },
+
+  feature: (params: FeatureParams): string => {
+    const baseFormat = `
+      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();
+
+    switch (params.featureType) {
+      case "moon_phase": {
+        const formattedName = params.name
+          .split('-')
+          .map((word: string) => word.charAt(0).toUpperCase() + word.slice(1))
+          .join(' ');
+        return `
+          Make me an astrological report for a person born under the Moon Phase: ${formattedName}.
+          ${baseFormat}
+        `.trim();
+      }
+
+      case "element": {
+        switch (params.subtype) {
+          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);
+            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);
+            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}`);
+        }
+      }
+
+      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";
+        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}
+        `.trim();
+      }
+
+      default:
+        throw new Error(`Unknown feature type in params: ${params}`);
+    }
+  },
 };