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

package/src/cli/commands/static/rebase.ts

@@ -1,44 +1,66 @@
-// @ts-nocheck
-import { Api } from '#api/index'
-import { allowGlobalParameter } from '#cli/_/parameters'
-import { Task } from '#lib/task'
-import { Command } from '@molt/command'
-import { Err, Path } from '@wollybeard/kit'
-import { Effect } from 'effect'
-import { z } from 'zod'
+import { Api } from '#api/$'
+import { Args, Command, Options } from '@effect/cli'
+import { Effect, Option } from 'effect'
+import { allowGlobalParameter } from '../../_/parameters.js'
 
-const args = Command.create()
-  .parameter(
-    `source`,
-    z.string().describe('Path to the Polen build directory to rebase'),
-  )
-  .parameter(
-    `newBasePath`,
-    z.string().describe('New base path for the build (e.g., /new-path/)'),
-  )
-  .parameter(
-    `--target -t`,
-    z.string().optional().describe('Target directory for copy mode (if not provided, mutate in place)'),
-  )
-  .parameter(`--allow-global`, allowGlobalParameter)
-  .parse()
+const source = Args.text({ name: 'source' }).pipe(
+  Args.withDescription('Path to the Polen build directory to rebase'),
+)
+
+const newBasePath = Args.text({ name: 'newBasePath' }).pipe(
+  Args.withDescription('New base path for the build (e.g., /new-path/)'),
+)
+
+const target = Options.text('target').pipe(
+  Options.withAlias('t'),
+  Options.optional,
+  Options.withDescription('Target directory for copy mode (if not provided, mutate in place)'),
+)
+
+export const staticRebase = Command.make(
+  'rebase',
+  {
+    source,
+    newBasePath,
+    target,
+    allowGlobal: allowGlobalParameter,
+  },
+  ({ source, newBasePath, target, allowGlobal }) =>
+    Effect.gen(function*() {
+      const targetPath = Option.getOrUndefined(target)
+      const plan: Api.Static.RebasePlan = targetPath
+        ? {
+          changeMode: 'copy',
+          sourcePath: source,
+          targetPath: targetPath,
+          newBasePath,
+        }
+        : {
+          changeMode: 'mutate',
+          sourcePath: source,
+          newBasePath,
+        }
 
-const plan: Api.Static.RebasePlan = args.target
-  ? {
-    changeMode: 'copy',
-    sourcePath: args.source,
-    targetPath: args.target,
-    newBasePath: args.newBasePath,
-  }
-  : {
-    changeMode: 'mutate',
-    sourcePath: args.source,
-    newBasePath: args.newBasePath,
-  }
+      // Direct Effect execution with timing and error handling
+      const start = Date.now()
 
-// Wrap the Promise-based API to make it Effect-based
-const rebaseEffect = (plan: Api.Static.RebasePlan) => Effect.promise(() => Api.Static.rebase(plan))
+      const result = yield* Effect.promise(() => Api.Static.rebase(plan))
+        .pipe(
+          Effect.tap(() => {
+            const duration = Date.now() - start
+            console.log(`Task: rebase`)
+            console.log(`Duration: ${duration}ms`)
+            console.log(`Input: ${JSON.stringify(plan, null, 2)}`)
+          }),
+          Effect.tapError((error) => {
+            const duration = Date.now() - start
+            console.error(`Task: rebase failed`)
+            console.error(`Duration: ${duration}ms`)
+            console.error(`Error:`, error)
+            return Effect.succeed(undefined)
+          }),
+        )
 
-await Effect.runPromise(
-  Task.runAndExit(rebaseEffect, plan),
+      return result
+    }),
 )

package/src/cli/commands/static.ts

@@ -1,9 +1,39 @@
-#!/usr/bin/env node
+import { Command } from '@effect/cli'
+import $ from 'ansis'
+import { Console, Effect } from 'effect'
 
-import { Cli, Path } from '@wollybeard/kit'
+// Import subcommands
+import { staticRebase } from './static/rebase.js'
 
-// Remove the "static" argument before dispatching to subcommands
-process.argv = process.argv.slice(0, 2).concat(process.argv.slice(3))
+const h2 = (str: string) => {
+  return $.bold.black.bgWhiteBright(` ${str.toUpperCase()} `)
+}
 
-const commandsDir = Path.join(import.meta.dirname, `static`)
-await Cli.dispatch(commandsDir)
+const code = (str: string) => {
+  if (!$.isSupported()) return `\`${str}\``
+  return $.magenta(str)
+}
+
+// Default static command that shows usage
+const staticDefault = Command.make(
+  'static',
+  {},
+  () =>
+    Effect.gen(function*() {
+      yield* Console.log(`${$.bold.redBright`POLEN 🌺`} ${$.dim(`static commands`)}`)
+      yield* Console.log('Manage static builds and deployments.')
+      yield* Console.log('')
+      yield* Console.log('')
+      yield* Console.log(`${h2('commands')}`)
+      yield* Console.log('')
+      yield* Console.log(`${$.dim`$ polen static`} ${$.cyanBright('rebase')}`)
+      yield* Console.log('')
+      yield* Console.log(`${$.dim`Get help for a command with ${code('polen static <command> --help')}`}`)
+      yield* Console.log('')
+    }),
+)
+
+// Export the static command with subcommands
+export const staticCommand = staticDefault.pipe(
+  Command.withSubcommands([staticRebase]),
+)

package/src/cli/index.ts

@@ -1,17 +1,111 @@
 #!/usr/bin/env node
 
 import { checkGlobalVsLocal } from '#lib/kit-temp'
-import { Cli, Path } from '@wollybeard/kit'
+import { Command, HelpDoc, Span } from '@effect/cli'
+import { NodeContext, NodeRuntime } from '@effect/platform-node'
+import { Console, Effect } from 'effect'
 import manifest from '../../package.json' with { type: 'json' }
+import { allowGlobalParameter } from './_/parameters.js'
 
-// Handle --version flag
-if (process.argv.includes(`--version`) || process.argv.includes(`-v`)) {
+// Import all commands
+import { build } from './commands/build.js'
+import { cache } from './commands/cache.js'
+import { config } from './commands/config.js'
+import { create } from './commands/create.js'
+import { dev } from './commands/dev.js'
+import { heroImage } from './commands/hero-image.js'
+import { open } from './commands/open.js'
+import { staticCommand } from './commands/static.js'
+
+// Define the main Polen command
+const polenMain = Command.make(
+  'polen',
+  { allowGlobal: allowGlobalParameter },
+  ({ allowGlobal }) => Console.log('Polen Effect CLI - Use --help to see available commands'),
+)
+
+// Combine all commands into the main CLI
+const command = polenMain.pipe(
+  Command.withSubcommands([
+    dev,
+    build,
+    create,
+    open,
+    cache,
+    config,
+    heroImage,
+    staticCommand,
+  ]),
+)
+
+// Export the CLI command for documentation generation
+export const polenCli = command
+
+// Create custom colorful summary
+const summary = Span.spans([
+  Span.error('POLEN 🌺'), // Red colored text
+  Span.text(' '),
+  Span.weak(`v${manifest.version}`),
+  Span.text('\n'),
+  Span.text('A framework for delightful GraphQL developer portals.'),
+])
+
+// Create custom footer with commands and links
+const commandsList = HelpDoc.descriptionList([
+  [Span.code('$ polen build'), HelpDoc.p('Build your documentation site')],
+  [Span.code('$ polen cache'), HelpDoc.p('Manage the GraphQL schema cache')],
+  [Span.code('$ polen config'), HelpDoc.p('Manage Polen configuration')],
+  [Span.code('$ polen create'), HelpDoc.p('Create a new Polen project')],
+  [Span.code('$ polen dev'), HelpDoc.p('Start the development server')],
+  [Span.code('$ polen hero-image'), HelpDoc.p('Generate a hero image for your site')],
+  [Span.code('$ polen open'), HelpDoc.p('Open your documentation site')],
+  [Span.code('$ polen static'), HelpDoc.p('Serve the static build')],
+])
+
+// Format links like the non-Effect CLI with arrows
+const learnMoreContent = HelpDoc.p(
+  Span.spans([
+    Span.text('Source Code  →  '),
+    Span.uri('https://github.com/the-guild-org/polen'),
+    Span.text('\n'),
+    Span.text('Built By     →  '),
+    Span.uri('https://the-guild.dev'),
+    Span.text('\n'),
+    Span.text('Ecosystem    →  '),
+    Span.uri('https://graphql.org'),
+  ]),
+)
+
+const footer = HelpDoc.blocks([
+  HelpDoc.h2(Span.strong('COMMANDS')),
+  commandsList,
+  HelpDoc.empty,
+  HelpDoc.p(
+    Span.concat(
+      Span.weak(`Get help for a command with `),
+      Span.code('polen <command> --help'),
+    ),
+  ),
+  HelpDoc.empty,
+  HelpDoc.h2(Span.strong('LEARN MORE')),
+  learnMoreContent,
+])
+
+// Set up and run the CLI application
+const cli = Command.run(command, {
+  name: 'Polen',
+  version: manifest.version,
+  summary,
+  footer,
+})
+
+// Handle version flag manually since Effect CLI handles it differently
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
   console.log(manifest.version)
   process.exit(0)
 }
 
 // Check for global vs local Polen conflict
-// The --allow-global flag is handled inside checkGlobalVsLocal
 try {
   await checkGlobalVsLocal({
     packageName: 'polen',
@@ -28,14 +122,15 @@ try {
     },
   })
 } catch (error) {
-  console.error(error instanceof Error ? error.message : String(error))
   process.exit(1)
 }
 
 // Remove --allow-global from argv before dispatching to commands
 // This prevents "Unknown flag" errors in individual commands
 const filteredArgv = process.argv.filter(arg => arg !== '--allow-global')
-process.argv = filteredArgv
 
-const commandsDir = Path.join(import.meta.dirname, `commands`)
-await Cli.dispatch(commandsDir)
+NodeRuntime.runMain(
+  cli(filteredArgv).pipe(
+    Effect.provide(NodeContext.layer),
+  ),
+)

package/src/lib/ai-image-generation/$$.ts

@@ -0,0 +1,2 @@
+export * from './ai-image-generation.js'
+export * from './service.js'

package/src/lib/ai-image-generation/$.test.ts

@@ -0,0 +1,344 @@
+import { Effect } from 'effect'
+import { buildSchema } from 'graphql'
+import { describe, expect, test } from 'vitest'
+import { AiImageGeneration } from './$.js'
+
+describe('AI Image Generation', () => {
+  describe('analyzeSchema', () => {
+    test('extracts context from e-commerce schema', () => {
+      const schema = buildSchema(`
+        type Product {
+          id: ID!
+          name: String!
+          price: Float!
+        }
+        
+        type Cart {
+          id: ID!
+          items: [Product!]!
+        }
+        
+        type Query {
+          products: [Product!]!
+          cart(id: ID!): Cart
+        }
+        
+        type Mutation {
+          addToCart(productId: ID!): Cart!
+        }
+      `)
+
+      const context = AiImageGeneration.analyzeSchema(schema)
+
+      expect(context.domain).toBe('e-commerce')
+      expect(context.suggestedTheme).toBe('digital marketplace')
+      expect(context.mainTypes).toContain('Product')
+      expect(context.mainTypes).toContain('Cart')
+      expect(context.queryNames).toContain('products')
+      expect(context.mutationNames).toContain('addToCart')
+    })
+
+    test('extracts context from social media schema', () => {
+      const schema = buildSchema(`
+        type User {
+          id: ID!
+          name: String!
+        }
+        
+        type Post {
+          id: ID!
+          author: User!
+          content: String!
+        }
+        
+        type Comment {
+          id: ID!
+          post: Post!
+          author: User!
+          text: String!
+        }
+        
+        type Query {
+          users: [User!]!
+          posts: [Post!]!
+        }
+      `)
+
+      const context = AiImageGeneration.analyzeSchema(schema)
+
+      expect(context.domain).toBe('social')
+      expect(context.suggestedTheme).toBe('connected network')
+      expect(context.mainTypes).toContain('User')
+      expect(context.mainTypes).toContain('Post')
+      expect(context.mainTypes).toContain('Comment')
+    })
+
+    test('extracts context from analytics schema', () => {
+      const schema = buildSchema(`
+        type Metric {
+          id: ID!
+          name: String!
+          value: Float!
+        }
+        
+        type Report {
+          id: ID!
+          metrics: [Metric!]!
+        }
+        
+        type Dashboard {
+          id: ID!
+          reports: [Report!]!
+        }
+        
+        type Query {
+          dashboard: Dashboard!
+          metrics: [Metric!]!
+        }
+      `)
+
+      const context = AiImageGeneration.analyzeSchema(schema)
+
+      expect(context.domain).toBe('analytics')
+      expect(context.suggestedTheme).toBe('data visualization')
+      expect(context.mainTypes).toContain('Metric')
+      expect(context.mainTypes).toContain('Report')
+      expect(context.mainTypes).toContain('Dashboard')
+    })
+
+    test('handles generic schema without specific domain', () => {
+      const schema = buildSchema(`
+        type Item {
+          id: ID!
+          name: String!
+        }
+        
+        type Query {
+          items: [Item!]!
+        }
+      `)
+
+      const context = AiImageGeneration.analyzeSchema(schema)
+
+      expect(context.domain).toBeUndefined()
+      expect(context.suggestedTheme).toBeUndefined()
+      expect(context.mainTypes).toContain('Item')
+    })
+  })
+
+  describe('buildPrompt', () => {
+    test('uses custom prompt when provided', () => {
+      const context: AiImageGeneration.SchemaContext = {
+        mainTypes: [],
+        queryNames: [],
+        mutationNames: [],
+        subscriptionNames: [],
+      }
+
+      const prompt = AiImageGeneration.buildPrompt(
+        context,
+        'modern',
+        'Beautiful landscape with mountains',
+      )
+
+      expect(prompt).toContain('Beautiful landscape with mountains')
+      expect(prompt).toContain('modern clean design')
+    })
+
+    test('generates e-commerce themed prompt', () => {
+      const context: AiImageGeneration.SchemaContext = {
+        mainTypes: ['Product', 'Cart'],
+        queryNames: ['products'],
+        mutationNames: ['addToCart'],
+        subscriptionNames: [],
+        domain: 'e-commerce',
+        suggestedTheme: 'digital marketplace',
+      }
+
+      const prompt = AiImageGeneration.buildPrompt(context, 'vibrant')
+
+      expect(prompt).toContain('digital marketplace')
+      expect(prompt).toContain('all about transactions, style, markets, trade, living')
+      expect(prompt).toContain('vibrant colors')
+      expect(prompt).toContain('no text')
+    })
+
+    test('generates social themed prompt', () => {
+      const context: AiImageGeneration.SchemaContext = {
+        mainTypes: ['User', 'Post'],
+        queryNames: ['users'],
+        mutationNames: [],
+        subscriptionNames: [],
+        domain: 'social',
+        suggestedTheme: 'connected network',
+      }
+
+      const prompt = AiImageGeneration.buildPrompt(context, 'futuristic')
+
+      expect(prompt).toContain('connected network')
+      expect(prompt).toContain('all about community, connections, sharing, communication, networks')
+      expect(prompt).toContain('futuristic sci-fi')
+      expect(prompt).toContain('no text')
+    })
+
+    test('generates analytics themed prompt', () => {
+      const context: AiImageGeneration.SchemaContext = {
+        mainTypes: ['Metric', 'Dashboard'],
+        queryNames: ['metrics'],
+        mutationNames: [],
+        subscriptionNames: [],
+        domain: 'analytics',
+        suggestedTheme: 'data visualization',
+      }
+
+      const prompt = AiImageGeneration.buildPrompt(context, 'technical')
+
+      expect(prompt).toContain('data visualization')
+      expect(prompt).toContain('all about data, insights, metrics, visualization, trends')
+      expect(prompt).toContain('technical blueprint')
+      expect(prompt).toContain('no text')
+    })
+
+    test.for([
+      { style: 'modern' as const, expected: 'modern clean design' },
+      { style: 'minimalist' as const, expected: 'minimalist flat design' },
+      { style: 'abstract' as const, expected: 'abstract artistic' },
+      { style: 'geometric' as const, expected: 'geometric patterns' },
+      { style: 'gradient' as const, expected: 'gradient mesh' },
+    ])('includes style description for "$style"', ({ style, expected }) => {
+      const context: AiImageGeneration.SchemaContext = {
+        mainTypes: [],
+        queryNames: [],
+        mutationNames: [],
+        subscriptionNames: [],
+      }
+
+      const prompt = AiImageGeneration.buildPrompt(context, style)
+      expect(prompt).toContain(expected)
+    })
+  })
+
+  describe('Pollinations Provider', () => {
+    test('generates correct URL format', async () => {
+      const { generateImage } = await import('./providers/pollinations.js')
+
+      const result = await generateImage({
+        prompt: 'Abstract API visualization',
+        width: 1200,
+        height: 400,
+        nologo: true,
+      })
+
+      expect(result.url).toContain('https://image.pollinations.ai/prompt/')
+      expect(result.url).toContain('Abstract%20API%20visualization')
+      expect(result.url).toContain('width=1200')
+      expect(result.url).toContain('height=400')
+      expect(result.url).toContain('nologo=true')
+      expect(result.cached).toBe(false)
+    })
+
+    test('includes seed when provided', async () => {
+      const { generateImage } = await import('./providers/pollinations.js')
+
+      const result = await generateImage({
+        prompt: 'Test prompt',
+        seed: 12345,
+      })
+
+      expect(result.url).toContain('seed=12345')
+    })
+  })
+
+  describe('AiImageConfig Schema', () => {
+    test('validates correct configuration', () => {
+      const config = {
+        enabled: true,
+        style: 'modern' as const,
+        width: 1200,
+        height: 400,
+        seed: 12345,
+        nologo: true,
+        cache: true,
+      }
+
+      const result = Effect.runSync(AiImageGeneration.decode(config))
+      expect(result).toEqual(config)
+    })
+
+    test('accepts optional fields', () => {
+      const config = {
+        enabled: true,
+      }
+
+      const result = Effect.runSync(AiImageGeneration.decode(config))
+      expect(result).toEqual(config)
+    })
+
+    test('validates seed field', () => {
+      const config = {
+        enabled: true,
+        seed: 42,
+      }
+
+      const result = Effect.runSync(AiImageGeneration.decode(config))
+      expect(result.seed).toBe(42)
+    })
+
+    test('validates nologo field', () => {
+      const config = {
+        enabled: true,
+        nologo: false,
+      }
+
+      const result = Effect.runSync(AiImageGeneration.decode(config))
+      expect(result.nologo).toBe(false)
+    })
+
+    test('validates art style values', () => {
+      const validStyles = [
+        'modern',
+        'minimalist',
+        'abstract',
+        'technical',
+        'vibrant',
+        'professional',
+        'futuristic',
+        'gradient',
+        'geometric',
+        'illustration',
+      ]
+
+      for (const style of validStyles) {
+        const config = {
+          enabled: true,
+          style: style as AiImageGeneration.ArtStyle,
+        }
+
+        const result = Effect.runSync(AiImageGeneration.decode(config))
+        expect(result.style).toBe(style)
+      }
+    })
+  })
+
+  describe('Service caching', () => {
+    test('generates cache key from prompt', () => {
+      const service = new AiImageGeneration.AiImageGenerationService()
+
+      // Access private method through type assertion for testing
+      const getCacheKey = (service as any).getCacheKey.bind(service)
+
+      const key1 = getCacheKey('test prompt')
+      const key2 = getCacheKey('different prompt')
+
+      // Same prompt should generate same key
+      expect(getCacheKey('test prompt')).toBe(key1)
+
+      // Different prompts should generate different keys
+      expect(key1).not.toBe(key2)
+
+      // All keys should have pollinations prefix
+      expect(key1).toContain('hero-pollinations-')
+      expect(key2).toContain('hero-pollinations-')
+    })
+  })
+})

package/src/lib/ai-image-generation/$.ts

@@ -0,0 +1 @@
+export * as AiImageGeneration from './$$.js'