polen 0.11.0-next.15 → 0.11.0-next.16

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()
+    }),
+)

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'