@zodic/shared 0.0.37 → 0.0.38

package/base/AppContext.ts

@@ -0,0 +1,93 @@
+import { drizzle } from 'drizzle-orm/d1';
+import { Api } from '../api';
+import * as schema from '../db/schema';
+import { BackendBindings } from '../types';
+import { buildChatGPTMessages } from '../utils/buildMessages';
+
+export class AppContext {
+  private _drizzle?: ReturnType<typeof drizzle>;
+
+  constructor(public env: BackendBindings) {}
+
+  buildChatGPTMessages() {
+    return buildChatGPTMessages(this.env);
+  }
+
+  kvCosmicMirrorArchetypesStore() {
+    if (!this.env.KV_COSMIC_MIRROR_ARCHETYPES) {
+      throw new Error(
+        'KV_COSMIC_MIRROR_ARCHETYPES is not defined in the environment.'
+      );
+    }
+    return this.env.KV_COSMIC_MIRROR_ARCHETYPES;
+  }
+
+  kvConceptsStore() {
+    if (!this.env.KV_CONCEPTS) {
+      throw new Error(
+        'KV_COSMIC_MIRROR_ARCHETYPES is not defined in the environment.'
+      );
+    }
+    return this.env.KV_CONCEPTS;
+  }
+
+  kvGenerationStore() {
+    if (!this.env.KV_GENERATION_MANAGEMENT) {
+      throw new Error(
+        'KV_GENERATION_MANAGEMENT is not defined in the environment.'
+      );
+    }
+    return this.env.KV_GENERATION_MANAGEMENT;
+  }
+
+  kvUserGenerationStore() {
+    if (!this.env.KV_USER_GENERATIONS) {
+      throw new Error('KV_USER_GENERATIONS is not defined in the environment.');
+    }
+    return this.env.KV_GENERATION_MANAGEMENT;
+  }
+
+  kvPromptsStore() {
+    if (!this.env.KV_LEONARDO_PROMPTS) {
+      throw new Error('KV_LEONARDO_PROMPTS is not defined in the environment.');
+    }
+    return this.env.KV_LEONARDO_PROMPTS;
+  }
+
+  kvUserProductStatus() {
+    if (!this.env.KV_USER_PRODUCT_STATUS) {
+      throw new Error('KV_LEONARDO_PROMPTS is not defined in the environment.');
+    }
+    return this.env.KV_USER_PRODUCT_STATUS;
+  }
+
+  api() {
+    return Api(this.env);
+  }
+
+  drizzle() {
+    if (!this._drizzle) {
+      if (!this.env.DB) {
+        throw new Error('Database binding (DB) is not defined.');
+      }
+      this._drizzle = drizzle(this.env.DB, { schema });
+    }
+
+    return this._drizzle;
+  }
+
+  get queues() {
+    return {
+      conceptGenerationQueue: this.conceptGenerationQueue(),
+    };
+  }
+
+  private conceptGenerationQueue() {
+    if (!this.env.CONCEPT_GENERATION_QUEUE) {
+      throw new Error(
+        'CONCEPT_GENERATION_QUEUE is not defined in the environment.'
+      );
+    }
+    return this.env.CONCEPT_GENERATION_QUEUE;
+  }
+}

package/db/schema.ts

@@ -159,8 +159,8 @@ export const concepts = sqliteTable(
   'concepts',
   {
     id: text('id').primaryKey(), // Unique Concept ID
-    name: text('name').notNull(), // Name of the Concept (e.g., "The Crown", "The Shield")
-    slug: text('slug').notNull(), // Name of the Concept (e.g., "crown", "shield")
+    name: text('name').notNull(), // Name of the Concept (e.g., "The Crown", "The Amulet")
+    slug: text('slug').notNull(), // Name of the Concept (e.g., "crown", "amulet")
     planet1: text('planet1').notNull(), // First planet (e.g., "Sun")
     planet2: text('planet2').notNull(), // Second planet (e.g., "Moon")
     planet3: text('planet3'), // Third planet (e.g., "Ascendant"), optional for some Concepts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zodic/shared",
-  "version": "0.0.37",
+  "version": "0.0.38",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {
@@ -29,6 +29,7 @@
     "drizzle-orm": "^0.38.0",
     "hono": "^4.6.13",
     "inversify": "^6.2.1",
-    "jose": "^5.9.6"
+    "jose": "^5.9.6",
+    "reflect-metadata": "^0.2.2"
   }
 }

package/services/ConceptService.ts

@@ -0,0 +1,207 @@
+import { inject, injectable } from 'inversify';
+import 'reflect-metadata';
+import { AppContext } from '../base/AppContext';
+import { KVConcept, sizes } from '../types/scopes/legacy';
+
+@injectable()
+export class ConceptService {
+  constructor(@inject(AppContext) private context: AppContext) {}
+
+  /**
+   * Generate basic info for a concept: name, description, and poem.
+   */
+  async generateBasicInfo(
+    conceptSlug: string,
+    combinationString: string
+  ): Promise<void> {
+    const kvKey = `concepts:${conceptSlug}:${combinationString}`;
+    console.log(
+      `Generating basic info for concept: ${conceptSlug}, combination: ${combinationString}`
+    );
+
+    const messages = this.context
+      .buildChatGPTMessages()
+      .generateConceptBasicInfo({
+        combination: combinationString,
+        conceptSlug,
+      });
+
+    const response = await this.context.api().callChatGPT(messages, {});
+    if (!response) {
+      throw new Error(
+        `Failed to generate basic info for concept: ${conceptSlug}`
+      );
+    }
+
+    const { name, description, poem } = this.parseBasicInfoResponse(response);
+
+    // Save basic info to KV
+    const concept = await this.getKVConcept(kvKey);
+    Object.assign(concept, { name, description, poem, status: 'idle' });
+
+    await this.context.kvConceptsStore().put(kvKey, JSON.stringify(concept));
+    console.log(
+      `Basic info stored for concept: ${conceptSlug}, combination: ${combinationString}`
+    );
+  }
+
+  private parseBasicInfoResponse(response: string): {
+    name: string;
+    description: string;
+    poem: string;
+  } {
+    console.log('Parsing basic info response from ChatGPT');
+    const nameMatch = response.match(/- Name: (.+)/);
+    const descriptionMatch = response.match(/- Description: (.+)/);
+    const poemMatch = response.match(/- Poem: (.+)/);
+
+    if (!nameMatch || !descriptionMatch || !poemMatch) {
+      throw new Error('Invalid basic info response format');
+    }
+
+    return {
+      name: nameMatch[1].trim(),
+      description: descriptionMatch[1].trim(),
+      poem: poemMatch[1].trim(),
+    };
+  }
+
+  /**
+   * Generate the Leonardo prompt for a concept.
+   */
+  async generatePrompt(
+    conceptSlug: string,
+    combinationString: string
+  ): Promise<void> {
+    const kvKey = `concepts:${conceptSlug}:${combinationString}`;
+    console.log(
+      `Generating Leonardo prompt for concept: ${conceptSlug}, combination: ${combinationString}`
+    );
+
+    const concept = await this.getKVConcept(kvKey);
+    if (!concept.name || !concept.description || !concept.poem) {
+      throw new Error(
+        `Basic info must be populated before generating prompt for concept: ${conceptSlug}`
+      );
+    }
+
+    const messages = this.context
+      .buildChatGPTMessages()
+      .generateConceptLeonardoPrompt({
+        conceptSlug,
+        combination: combinationString,
+      });
+
+    const response = await this.context.api().callChatGPT(messages, {});
+    if (!response) {
+      throw new Error(
+        `Failed to generate Leonardo prompt for concept: ${conceptSlug}`
+      );
+    }
+
+    concept.leonardoPrompt = response.trim();
+    await this.context.kvConceptsStore().put(kvKey, JSON.stringify(concept));
+    console.log(
+      `Leonardo prompt stored for concept: ${conceptSlug}, combination: ${combinationString}`
+    );
+  }
+
+  /**
+   * Generate additional content for a concept.
+   */
+  async generateContent(
+    conceptSlug: string,
+    combinationString: string
+  ): Promise<void> {
+    const kvKey = `concepts:${conceptSlug}:${combinationString}`;
+    console.log(
+      `Generating additional content for concept: ${conceptSlug}, combination: ${combinationString}`
+    );
+
+    const concept = await this.getKVConcept(kvKey);
+    if (!concept.name || !concept.description || !concept.poem) {
+      throw new Error(
+        `Basic info must be populated before generating content for concept: ${conceptSlug}`
+      );
+    }
+
+    const messages = this.context
+      .buildChatGPTMessages()
+      .generateConceptContent({
+        conceptSlug,
+        combination: combinationString,
+        name: concept.name,
+        description: concept.description,
+        poem: concept.poem,
+      });
+
+    const response = await this.context.api().callChatGPT(messages, {});
+    if (!response) {
+      throw new Error(`Failed to generate content for concept: ${conceptSlug}`);
+    }
+
+    concept.content = response.trim();
+    await this.context.kvConceptsStore().put(kvKey, JSON.stringify(concept));
+    console.log(
+      `Content stored for concept: ${conceptSlug}, combination: ${combinationString}`
+    );
+  }
+
+  /**
+   * Queue image generation for a concept.
+   */
+  async generateImages(
+    conceptSlug: string,
+    combinationString: string
+  ): Promise<void> {
+    const kvKey = `concepts:${conceptSlug}:${combinationString}`;
+    console.log(
+      `Queuing image generation for concept: ${conceptSlug}, combination: ${combinationString}`
+    );
+
+    const concept = await this.getKVConcept(kvKey);
+    if (!concept.leonardoPrompt) {
+      throw new Error(
+        `Leonardo prompt must be populated before generating images for concept: ${conceptSlug}`
+      );
+    }
+
+    const { width, height } = sizes['alchemy']['post4:5'];
+
+    await this.context.api().callLeonardo.generateImage({
+      prompt: concept.leonardoPrompt,
+      width,
+      height,
+    });
+
+    console.log(
+      `Post images queued for concept: ${conceptSlug}, combination: ${combinationString}`
+    );
+  }
+
+  /**
+   * Fetch and initialize a KVConcept object if not present.
+   */
+  private async getKVConcept(kvKey: string): Promise<KVConcept> {
+    const existingData = await this.context
+      .kvConceptsStore()
+      .get<KVConcept>(kvKey, 'json');
+    if (existingData) {
+      return existingData;
+    }
+
+    console.log(
+      `No existing KV data found. Creating default entry for key: ${kvKey}`
+    );
+    return {
+      name: '',
+      description: '',
+      content: '',
+      poem: '',
+      leonardoPrompt: '',
+      postImages: [],
+      reelImages: [null, null, null],
+      status: 'idle',
+    };
+  }
+}

package/tsconfig.json

@@ -14,6 +14,8 @@
     "jsx": "react-jsx",
     "allowSyntheticDefaultImports": true,
     "forceConsistentCasingInFileNames": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "allowJs": true,
     "types": [
       "bun-types" // add Bun global

package/types/scopes/generic.ts

@@ -118,3 +118,17 @@ export type DominantSign = {
   sign_name: string;
   percentage: number;
 };
+
+export type ChatMessages = ChatMessage[];
+export type ChatMessage = {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+};
+
+export interface Crown {
+  sun: string;
+  ascendant: string;
+  moon: string;
+}
+
+export type Concept = 'crown' | 'scepter' | 'amulet' | 'lantern' | 'orb';

package/types/scopes/legacy.ts

@@ -0,0 +1,255 @@
+import { BackendBindings } from './cloudflare';
+import { Gender } from './generic';
+
+export type ConceptPhase =
+  | 'name-description-poem'
+  | 'leonardo-prompt'
+  | 'content'
+  | 'images';
+
+export const zodiacSigns = [
+  'Aries',
+  'Taurus',
+  'Gemini',
+  'Cancer',
+  'Leo',
+  'Virgo',
+  'Libra',
+  'Scorpio',
+  'Sagittarius',
+  'Capricorn',
+  'Aquarius',
+  'Pisces',
+];
+
+export interface ChatGPTOptions {
+  model?: string;
+  options?: Record<string, any>;
+}
+
+export interface LeonardoGenerateImageParams {
+  prompt: string;
+  width: number;
+  height: number;
+  controlNets?: Array<{
+    initImageId: string;
+    initImageType: 'UPLOADED' | 'GENERATED';
+    preprocessorId: number;
+    strengthType: 'Low' | 'Mid' | 'High';
+  }>;
+  quantity?: number;
+}
+
+export type HouseCuspsReport = {
+  planetName: string; // Name of the planet (e.g., "Sun")
+  house: number; // House number (e.g., 5)
+  report: string; // Detailed report or description
+};
+
+export type NatalHouseCuspReport = {
+  house: number; // House number (e.g., 1)
+  sign: string; // Sign associated with the house (e.g., "Aquarius")
+  degree: number; // Degree value (e.g., 303.73276)
+  report: string; // Detailed report or description
+};
+
+export interface LeonardoGeneratePresignedUrlParams {
+  extension: string;
+}
+
+export interface LeonardoUploadImageParams {
+  presignedUrl: string;
+  fields: string;
+  file: Blob | Uint8Array | ArrayBuffer;
+}
+
+export interface LeonardoGenerateImageResponse {
+  sdGenerationJob: {
+    generationId?: string;
+    apiCreditCost?: number;
+  };
+}
+
+export type Size = 'post1:1' | 'post4:5' | 'post1.91:1' | 'reels';
+
+export interface ImageDescriberOptions {
+  imageUrl: string;
+  prompt: string;
+}
+
+export interface Crown {
+  sun: string;
+  ascendant: string;
+  moon: string;
+}
+
+export interface GenerateLeonardoPromptParams {
+  env: BackendBindings;
+  archetypeName: string;
+  archetypeDescription: string;
+  gender: Gender;
+}
+
+export interface GenerateEndpointParams {
+  crown: Crown;
+  gender: Gender;
+}
+
+export type GenerateLeonardoPromptParamsWithoutEnv = Omit<
+  GenerateLeonardoPromptParams,
+  'env'
+>;
+
+export type personalizeCosmicMirrorLeonardoPrompt = {
+  leonardoPrompt: string;
+  traits: string;
+};
+
+export type KVArchetype = {
+  name: string;
+  description: string;
+  content: string;
+  leonardoPrompt: string;
+  virtues: string;
+  images: LeonardoImage[];
+  status: 'idle' | 'generating' | 'completed';
+};
+export type KVConcept = {
+  name: string;
+  description: string;
+  content: string;
+  poem: string;
+  leonardoPrompt: string;
+  postImages: LeonardoImage[]; // Pre-generated in sequence
+  reelImages: Array<LeonardoImage | null>; // Initially null, aligned by index
+  status: 'idle' | 'generating' | 'completed';
+};
+
+export type KVGenerationObject = {
+  crown: string;
+  gender: Gender;
+  archetypeIndex: number;
+  prompt: string;
+};
+
+export type KVUserGenerationObject = {
+  userId: string; // ID of the user
+  productId: string; // ID of the product
+  productName: string;
+  createdAt: string; // Timestamp when the generation was created
+};
+
+export type ArchetypeObj = {
+  name: string;
+  description: string;
+  generationId: string;
+  leonardoPrompt: string;
+  virtues: string;
+  imageCounter: number;
+  images: LeonardoImage[];
+};
+
+export type LeonardoImage = {
+  leonardoId: string;
+  url: string;
+  height: number;
+  width: number;
+};
+
+export interface LeonardoRequestBody {
+  prompt: string;
+  width: number;
+  height: number;
+  negative_prompt: string;
+  num_images: number;
+  modelId: string;
+  presetStyle: string;
+  alchemy: boolean;
+  controlnets?: Array<{
+    initImageId: string;
+    initImageType: string;
+    preprocessorId: number;
+    strengthType: string;
+  }>;
+  init_generation_image_id?: string;
+  init_strength?: number;
+}
+
+export interface LeonardoInitImageResponse {
+  id: string;
+  createdAt: string;
+  userId: string;
+  url: string;
+  type: string; // e.g., "UPLOADED" or "GENERATED"
+  metadata: Record<string, any>; // Optional metadata if available
+}
+
+export type TimezoneResponse = {
+  dstOffset: number; // Daylight Savings Time offset in seconds
+  rawOffset: number; // Raw UTC offset in seconds
+  status: string; // Response status, e.g., "OK"
+  timeZoneId: string; // Time zone ID, e.g., "America/Los_Angeles"
+  timeZoneName: string; // Time zone name, e.g., "Pacific Standard Time"
+};
+
+export type AstrologyPlanetData = {
+  name: string; // Planet name (e.g., "Sun", "Moon")
+  fullDegree: number; // Full degree position of the planet
+  normDegree: number; // Normalized degree (0-29°)
+  speed: number; // Speed of the planet
+  isRetro: 'true' | 'false'; // Retrograde status as a string
+  sign: string; // Sign the planet is in (e.g., "Sagittarius")
+  house: number; // House number (1-12)
+};
+
+export type AstrologyApiResponse = AstrologyPlanetData[];
+
+type Sizes = {
+  [k: string]: {
+    [key in Size]: {
+      width: number;
+      height: number;
+    };
+  };
+};
+
+export const sizes: Sizes = {
+  alchemy: {
+    // closest values of input to get the closest possible values of output fit for the social media
+    'post1:1': {
+      width: 624,
+      height: 624,
+    },
+    'post4:5': {
+      width: 624,
+      height: 784,
+    },
+    'post1.91:1': {
+      width: 912,
+      height: 512,
+    },
+    reels: {
+      width: 756,
+      height: 1344,
+    },
+  },
+  noAlchemy: {
+    // exact values available on leonardo's dashboard
+    'post1:1': {
+      width: 1110,
+      height: 1110,
+    },
+    'post4:5': {
+      width: 990,
+      height: 1240,
+    },
+    'post1.91:1': {
+      width: 1500,
+      height: 810,
+    },
+    reels: {
+      width: 830,
+      height: 1480,
+    },
+  },
+};