polen 0.11.0-next.15 → 0.11.0-next.17

package/src/cli/commands/hero-image.ts

@@ -0,0 +1,282 @@
+import { Api } from '#api/$'
+import { AiImageGeneration } from '#lib/ai-image-generation/$'
+import { Catalog } from '#lib/catalog/$'
+import { ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
+import { Command, Options } from '@effect/cli'
+import { FileSystem } from '@effect/platform'
+import { NodeFileSystem } from '@effect/platform-node'
+import { Console, Effect, Option } from 'effect'
+import * as Path from 'node:path'
+import { projectParameter } from '../_/parameters.js'
+
+/**
+ * Backup existing hero image to hero-previous-{number}.{ext}
+ */
+const backupExistingHeroImage = (dir: string) =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const publicDir = Path.join(dir, 'public')
+    const heroExtensions = ['svg', 'png', 'jpg', 'jpeg', 'webp']
+
+    // Find existing hero image
+    let existingHeroPath: string | null = null
+    let existingExt: string | null = null
+
+    for (const ext of heroExtensions) {
+      const heroPath = Path.join(publicDir, `hero.${ext}`)
+      const exists = yield* fs.exists(heroPath)
+      if (exists) {
+        existingHeroPath = heroPath
+        existingExt = ext
+        break
+      }
+    }
+
+    if (!existingHeroPath || !existingExt) {
+      // No existing hero image to backup
+      return
+    }
+
+    // Find next available backup number
+    let backupNumber = 1
+    while (true) {
+      const backupPath = Path.join(publicDir, `hero-previous-${backupNumber}.${existingExt}`)
+      const backupExists = yield* fs.exists(backupPath)
+      if (backupExists) {
+        // Backup file exists, try next number
+        backupNumber++
+      } else {
+        // This backup slot is available
+        yield* fs.rename(existingHeroPath, backupPath)
+        yield* Console.log(`📦 Backed up existing hero.${existingExt} to hero-previous-${backupNumber}.${existingExt}`)
+        break
+      }
+    }
+  })
+
+export const heroImage = Command.make(
+  'hero-image',
+  {
+    project: projectParameter,
+    overwrite: Options.boolean('overwrite').pipe(
+      Options.withDescription('Skip backup and overwrite existing hero image'),
+      Options.withDefault(false),
+    ),
+  },
+  ({ project, overwrite }) =>
+    Effect.gen(function*() {
+      // Get project directory
+      const dir = ensureOptionalAbsoluteWithCwd(Option.getOrUndefined(project))
+
+      // Load config
+      const configInput = yield* Api.Config.load({ dir })
+      const config = yield* Api.Config.normalizeInput(configInput, dir)
+
+      // Check if home hero is configured
+      if (!config.home || config.home.enabled === false) {
+        yield* Console.log('❌ Home page not enabled in polen.config.ts')
+        return
+      }
+
+      const heroConfig = config.home.hero
+      if (!heroConfig || !heroConfig.enabled) {
+        yield* Console.log('❌ Hero section not enabled in polen.config.ts')
+        return
+      }
+
+      // Extract AI config and layout from the raw input (since it's not in normalized config)
+      const rawHero = (configInput as any)?.home?.hero
+      const rawHeroImage = rawHero?.heroImage
+      const layout = rawHero?.layout || heroConfig.layout || 'asymmetric'
+      // Check for custom prompt in hero.prompt or heroImage.ai.prompt
+      const customPrompt = rawHero?.prompt || rawHeroImage?.ai?.prompt
+      if (customPrompt) {
+        yield* Console.log(`📝 Using custom prompt from config`)
+      }
+      let aiConfig: any = {}
+
+      if (rawHeroImage && typeof rawHeroImage === 'object' && rawHeroImage.ai) {
+        aiConfig = rawHeroImage.ai
+        if (!aiConfig.enabled) {
+          yield* Console.log('❌ AI hero image generation not enabled')
+          yield* Console.log('💡 Set ai.enabled: true in your hero image config')
+          return
+        }
+        yield* Console.log('✨ Generating hero image with Pollinations.ai...')
+      } else {
+        // Use defaults if no AI config
+        yield* Console.log('✨ Generating hero image with Pollinations.ai (default settings)...')
+        yield* Console.log('💡 To customize, add this to your polen.config.ts:')
+        yield* Console.log(`
+  home: {
+    hero: {
+      layout: 'asymmetric',  // or 'cinematic', 'auto'
+      heroImage: {
+        ai: {
+          enabled: true,
+          style: 'modern',  // or: minimalist, abstract, vibrant, etc.
+          seed: 12345,     // for reproducible generation
+          nologo: true,    // hide Pollinations logo
+        }
+      }
+    }
+  }`)
+        aiConfig = {
+          enabled: true,
+          style: 'modern',
+          nologo: true,
+        }
+      }
+
+      // Load and analyze schema if available
+      let schema = undefined
+      const schemaResult = yield* Api.Schema.loadOrNull(config)
+      if (schemaResult?.data) {
+        try {
+          const latestSchema = Catalog.getLatest(schemaResult.data)
+          if (latestSchema?.definition) {
+            schema = latestSchema.definition
+            const context = AiImageGeneration.analyzeSchema(schema)
+            const domain = context.domain || 'general'
+            const mainTypes = context.mainTypes.slice(0, 3).join(', ')
+            yield* Console.log(`📊 Schema analysis: ${domain} API`)
+            if (mainTypes) {
+              yield* Console.log(`   Types detected: ${mainTypes}`)
+            }
+          }
+        } catch (error) {
+          // Schema processing failed, continue without it
+          yield* Console.log('⚠️  Schema processing failed, generating generic image')
+        }
+      }
+
+      // Determine dimensions based on layout
+      let width = 1200
+      let height = 400
+
+      if (layout === 'asymmetric') {
+        // Square/portrait aspect ratio for side-by-side layout
+        width = 800
+        height = 800
+        yield* Console.log(`📐 Layout: asymmetric (square aspect ratio)`)
+      } else if (layout === 'cinematic') {
+        // Wide aspect ratio for full-width banner
+        width = 1600
+        height = 400
+        yield* Console.log(`📐 Layout: cinematic (wide aspect ratio)`)
+      } else {
+        // Auto: same as asymmetric now since asymmetric is the default
+        width = 800
+        height = 800
+        yield* Console.log(`📐 Layout: auto (using asymmetric aspect ratio)`)
+      }
+
+      // Generate image - default to 'illustration' style for asymmetric layout
+      const defaultStyle = layout === 'asymmetric' ? 'illustration' : 'modern'
+      const style = aiConfig.style || defaultStyle
+      yield* Console.log(`🎨 Style: ${style}`)
+      if (layout === 'asymmetric' && !aiConfig.style) {
+        yield* Console.log(`   (Using illustration style for better placement next to text)`)
+      }
+      yield* Console.log('🤖 Using Pollinations.ai (free, no API key required)')
+
+      const service = new AiImageGeneration.AiImageGenerationService()
+      const generationConfig = {
+        config: {
+          enabled: true,
+          style,
+          prompt: customPrompt,
+          width: aiConfig.width || width,
+          height: aiConfig.height || height,
+          seed: aiConfig.seed,
+          nologo: aiConfig.nologo !== false,
+          cache: false, // Disable cache to get fresh images
+        },
+        schema,
+        projectName: config.name,
+        layout,
+      }
+
+      // Get topics from config if available
+      const topics = (configInput as any)?.home?.topics
+
+      // Build the prompt that will be used
+      const schemaContext = schema
+        ? { ...AiImageGeneration.analyzeSchema(schema), topics }
+        : {
+          mainTypes: [],
+          queryNames: [],
+          mutationNames: [],
+          subscriptionNames: [],
+          suggestedTheme: 'modern API',
+          topics,
+        }
+
+      const finalPrompt = customPrompt || AiImageGeneration.buildPrompt(
+        schemaContext,
+        style,
+        undefined,
+        layout,
+      )
+
+      yield* Console.log(`📝 Prompt: ${finalPrompt.substring(0, 150)}...`)
+
+      // Let errors bubble up naturally
+      const image = yield* Effect.promise(() => service.generate(generationConfig))
+
+      if (!image) {
+        yield* Console.log('❌ Failed to generate image')
+        return
+      }
+
+      // Download image
+      yield* Console.log('📥 Downloading generated image...')
+      yield* Console.log(`   Pollinations URL: ${image.url}`)
+
+      // Wait a moment for Pollinations to generate the image on-demand
+      yield* Effect.sleep('2 seconds')
+
+      const response = yield* Effect.promise(() => fetch(image.url))
+
+      if (!response.ok) {
+        yield* Console.log(`❌ Failed to download image: ${response.statusText}`)
+        return
+      }
+
+      const buffer = yield* Effect.promise(() => response.arrayBuffer())
+
+      // Backup existing hero image unless --overwrite is specified
+      if (!overwrite) {
+        yield* backupExistingHeroImage(dir)
+      }
+
+      // Save to public directory
+      const fs = yield* FileSystem.FileSystem
+      const outputPath = Path.join(dir, 'public', 'hero.png')
+      const publicDir = Path.join(dir, 'public')
+
+      // Ensure public directory exists
+      yield* fs.makeDirectory(publicDir, { recursive: true }).pipe(
+        Effect.catchIf(
+          error => error._tag === 'SystemError' && error.reason === 'AlreadyExists',
+          () => Effect.succeed(undefined),
+        ),
+      )
+
+      // Write the image file
+      yield* fs.writeFile(outputPath, new Uint8Array(buffer))
+
+      yield* Console.log(`✅ Saved to: public/hero.png`)
+      yield* Console.log(`\n📝 Polen will automatically use this Pollinations-generated image.`)
+      yield* Console.log(`   To regenerate with different settings, run this command again.`)
+      yield* Console.log(`   To use a custom image instead, update your config:`)
+      yield* Console.log(`
+  home: {
+    hero: {
+      heroImage: '/custom-hero.png'
+    }
+  }`)
+    }).pipe(Effect.provide(NodeFileSystem.layer)),
+).pipe(
+  Command.withDescription('Generate AI hero image using Pollinations.ai'),
+)

package/src/cli/commands/open.ts

@@ -1,184 +1,183 @@
-// @ts-nocheck
-/*
- * Examples
- *
- * polen open --introspect https://api.graphql-hive.com/graphql
- * polen open --introspect https://api.github.com/graphql --introspection-headers '{"Authorization": "Bearer $GITHUB_TOKEN"}'
- * polen open --sdl https://docs.github.com/public/fpt/schema.docs.graphql
- */
-
-import { Api } from '#api/index'
-import { allowGlobalParameter } from '#cli/_/parameters'
+import { Api } from '#api/$'
 import { Vite } from '#dep/vite/index'
 import { Grafaid } from '#lib/grafaid'
 import { GraphqlSchemaLoader } from '#lib/graphql-schema-loader'
 import { toViteUserConfig } from '#vite/config'
-import { Command } from '@molt/command'
-import type { Fn } from '@wollybeard/kit'
+import { Command, Options } from '@effect/cli'
 import { Err, Fs, Json, Path, Rec } from '@wollybeard/kit'
+import { Effect, Option } from 'effect'
 import { homedir } from 'node:os'
-import { z } from 'zod'
-
-const args = Command.create()
-  .parameter(
-    `--introspection-headers --inh`,
-    z
-      .string()
-      .optional()
-      .describe(
-        `Include headers in the introspection query request sent when using --introspection-url. Format is JSON Object.`,
-      ),
-  )
-  .parametersExclusive(`source`, ($) =>
-    $.parameter(`--introspect --in -i`, {
-      schema: z
-        .string()
-        .url()
-        .describe(
-          `Get the schema by sending a GraphQL introspection query to this URL.`,
-        ),
-    })
-      .parameter(`--sdl -s`, {
-        schema: z
-          .string()
-          .describe(
-            `Get the schema from a GraphQL Schema Definition Language file. Can be a path to a local file or an HTTP URL to a remote one.`,
-          ),
-      })
-      .parameter(`--name -n`, {
-        schema: z
-          .enum([`github`, `hive`])
-          .describe(
-            `Pick from a well known public API. Polen already knows how to fetch the schema for these APIs.`,
-          ),
-      }))
-  .parameter(
-    `--cache`,
-    z
-      .boolean()
-      .default(true)
-      .describe(
-        `Enable or disable caching. By default this command caches fetched schemas for re-use.`,
-      ),
-  )
-  .parameter(`--allow-global`, allowGlobalParameter)
-  .settings({
-    parameters: {
-      environment: {
-        $default: {
-          // todo prfix seting doesn't seem to work with Molt!
-          prefix: `POLEN_CREATE_`,
-          enabled: false,
-        },
-      },
-    },
-  })
-  .parse()
+import { allowGlobalParameter } from '../_/parameters.js'
+
+// Define introspection headers option
+const introspectionHeaders = Options.text('introspection-headers').pipe(
+  Options.withAlias('inh'),
+  Options.optional,
+  Options.withDescription(
+    'Include headers in the introspection query request sent when using --introspection-url. Format is JSON Object.',
+  ),
+)
+
+// Define mutually exclusive source options
+const introspectUrl = Options.text('introspect').pipe(
+  Options.withAlias('in'),
+  Options.withAlias('i'),
+  Options.optional,
+  Options.withDescription('Get the schema by sending a GraphQL introspection query to this URL.'),
+)
 
-// cache
+const sdlPath = Options.text('sdl').pipe(
+  Options.withAlias('s'),
+  Options.optional,
+  Options.withDescription(
+    'Get the schema from a GraphQL Schema Definition Language file. Can be a path to a local file or an HTTP URL to a remote one.',
+  ),
+)
+
+const namedSchema = Options.choice('name', ['github', 'hive']).pipe(
+  Options.withAlias('n'),
+  Options.optional,
+  Options.withDescription(
+    'Pick from a well known public API. Polen already knows how to fetch the schema for these APIs.',
+  ),
+)
 
-const cacheDir = Path.join(homedir(), `.polen`, `cache`, `cli`, `open`)
+const cache = Options.boolean('cache').pipe(
+  Options.withDefault(true),
+  Options.withDescription('Enable or disable caching. By default this command caches fetched schemas for re-use.'),
+)
+
+// Cache implementation
+const cacheDir = Path.join(homedir(), '.polen', 'cache', 'cli', 'open')
 
-const bsae64Codec = {
-  encode: (str: string) => Buffer.from(str).toString(`base64`),
-  decode: (str: string) => Buffer.from(str, `base64`).toString(`utf-8`),
+const base64Codec = {
+  encode: (str: string) => Buffer.from(str).toString('base64'),
+  decode: (str: string) => Buffer.from(str, 'base64').toString('utf-8'),
 }
 
-const cacheWrite = async (source: string, schema: Grafaid.Schema.Schema) => {
-  if (!args.cache) return
+const cacheWrite = async (source: string, schema: Grafaid.Schema.Schema, useCache: boolean) => {
+  if (!useCache) return
 
   await Err.tryCatchIgnore(async () => {
-    const fileName = bsae64Codec.encode(source)
+    const fileName = base64Codec.encode(source)
     const filePath = Path.join(cacheDir, fileName)
     const sdl = Grafaid.Schema.print(schema)
     await Fs.write({ path: filePath, content: sdl })
   })
 }
 
-const cacheRead = async (source: string) => {
-  if (!args.cache) return null
+const cacheRead = async (source: string, useCache: boolean) => {
+  if (!useCache) return null
 
   return Err.tryCatchIgnore(async () => {
-    const fileName = bsae64Codec.encode(source)
+    const fileName = base64Codec.encode(source)
     const filePath = Path.join(cacheDir, fileName)
     const sdl = await Fs.read(filePath)
     if (!sdl) return null
-    return Grafaid.Schema.fromAST(Grafaid.Schema.AST.parse(sdl))
+    const documentNode = await Effect.runPromise(Grafaid.Schema.AST.parse(sdl))
+    return await Effect.runPromise(Grafaid.Schema.fromAST(documentNode))
   })
 }
 
-const cache = {
-  read: cacheRead,
-  write: cacheWrite,
-}
+const wrapCache = (fn: typeof GraphqlSchemaLoader.load, useCache: boolean) => {
+  const wrapped = (...args: Parameters<typeof GraphqlSchemaLoader.load>) =>
+    Effect.gen(function*() {
+      const cacheKey = JSON.stringify(args)
+      const cachedSchema = yield* Effect.promise(() => cacheRead(cacheKey, useCache))
 
-const wrapCache = <fn extends Fn.AnyAnyAsync>(fn: fn): fn => {
-  const wrapped = async (...args: Parameters<fn>) => {
-    const cacheKey = JSON.stringify(args)
-    const cachedSchema = await cache.read(cacheKey)
+      if (cachedSchema) {
+        return cachedSchema
+      }
 
-    if (cachedSchema) {
-      return cachedSchema
-    }
+      // GraphqlSchemaLoader.load returns Effect<GraphQLSchema, Error, FileSystem>
+      const value = yield* fn(...args)
 
-    const value = await fn(...args)
+      yield* Effect.promise(() => cacheWrite(cacheKey, value, useCache))
 
-    await cache.write(cacheKey, value)
-
-    return value
-  }
+      return value
+    })
 
-  return wrapped as any
+  return wrapped
 }
 
-// cache end
-
-// todo: use a proper validation, e.g. zod, better yet: allow to specify the validation in molt itself
 const parseHeaders = (headersJsonEncoded: string): Record<string, string> => {
   const headersJson = Json.codec.decode(headersJsonEncoded)
   if (!Rec.is(headersJson)) {
-    console.log(`--introspection-headers must be a JSON object.`)
-    process.exit(1)
+    throw new Error('--introspection-headers must be a JSON object.')
   }
   return headersJson as any
 }
 
-const load = wrapCache(GraphqlSchemaLoader.load)
-const schema = await load(
-  args.source._tag === `name`
-    ? { type: `name`, name: args.source.value }
-    : args.source._tag === `sdl`
-    ? { type: `sdl`, pathOrUrl: args.source.value }
-    : {
-      type: `introspect`,
-      url: args.source.value,
-      headers: args.introspectionHeaders
-        ? parseHeaders(args.introspectionHeaders)
-        : undefined,
-    },
-)
-
-const config = await Api.ConfigResolver.fromMemory({
-  root: await Fs.makeTemporaryDirectory(),
-  schema: {
-    sources: {
-      data: {
-        versions: [
-          {
-            before: Grafaid.Schema.empty,
-            after: schema,
-            changes: [],
-            date: new Date(),
-          },
-        ],
-      },
-    },
+export const open = Command.make(
+  'open',
+  {
+    introspectionHeaders,
+    introspectUrl,
+    sdlPath,
+    namedSchema,
+    cache,
+    allowGlobal: allowGlobalParameter,
   },
-})
-
-const viteConfig = toViteUserConfig(config)
-const viteDevServer = await Vite.createServer(viteConfig)
+  ({ introspectionHeaders, introspectUrl, sdlPath, namedSchema, cache, allowGlobal }) =>
+    Effect.gen(function*() {
+      // Validate that exactly one source option is provided
+      const introspectValue = Option.getOrUndefined(introspectUrl)
+      const sdlValue = Option.getOrUndefined(sdlPath)
+      const namedValue = Option.getOrUndefined(namedSchema)
+      const headersValue = Option.getOrUndefined(introspectionHeaders)
+
+      const sources = [introspectValue, sdlValue, namedValue].filter(Boolean)
+      if (sources.length === 0) {
+        return yield* Effect.fail(new Error('Must specify one of: --introspect, --sdl, or --name'))
+      }
+      if (sources.length > 1) {
+        return yield* Effect.fail(new Error('Cannot specify multiple source options'))
+      }
+
+      // Determine source type and value
+      let sourceConfig: any
+
+      if (introspectValue) {
+        sourceConfig = {
+          type: 'introspect',
+          url: introspectValue,
+          headers: headersValue ? parseHeaders(headersValue) : undefined,
+        }
+      } else if (sdlValue) {
+        sourceConfig = {
+          type: 'sdl',
+          pathOrUrl: sdlValue,
+        }
+      } else if (namedValue) {
+        sourceConfig = {
+          type: 'name',
+          name: namedValue,
+        }
+      }
+
+      const load = wrapCache(GraphqlSchemaLoader.load, cache)
+      const schema = yield* load(sourceConfig)
+
+      const tempDir = yield* Effect.promise(() => Fs.makeTemporaryDirectory())
+      const config = yield* Api.ConfigResolver.fromMemory({
+        schema: {
+          sources: {
+            memory: {
+              revisions: [
+                {
+                  date: new Date(),
+                  value: schema,
+                },
+              ],
+            },
+          },
+        },
+      }, tempDir)
 
-await viteDevServer.listen()
+      const viteConfig = toViteUserConfig(config)
+      const viteDevServer = yield* Effect.promise(() => Vite.createServer(viteConfig))
 
-viteDevServer.printUrls()
+      yield* Effect.promise(() => viteDevServer.listen())
+      viteDevServer.printUrls()
+    }),
+)