polen 0.11.0-next.13 → 0.11.0-next.15

package/src/cli-effect/commands/build.ts

@@ -0,0 +1,66 @@
+import { Api } from '#api/index'
+import { ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
+import { Command, Options } from '@effect/cli'
+import { Effect, Option } from 'effect'
+import { allowGlobalParameter, projectParameter } from '../_/parameters.js'
+
+// Define all the options exactly matching the original
+const debug = Options.boolean('debug').pipe(
+  Options.withAlias('d'),
+  Options.withDefault(false),
+  Options.withDescription('Enable debug mode'),
+)
+
+const architecture = Options.choice('architecture', ['ssg', 'ssr']).pipe(
+  Options.withAlias('a'),
+  Options.withDefault('ssg' as const),
+  Options.withDescription('Which kind of application architecture to output.'),
+)
+
+const base = Options.text('base').pipe(
+  Options.withAlias('b'),
+  Options.optional,
+  Options.withDescription('Base public path for deployment (e.g., /my-project/)'),
+)
+
+const port = Options.integer('port').pipe(
+  Options.optional,
+  Options.withDescription('Default port for the SSR application'),
+)
+
+export const build = Command.make(
+  'build',
+  {
+    debug,
+    project: projectParameter,
+    architecture,
+    base,
+    port,
+    allowGlobal: allowGlobalParameter,
+  },
+  ({ debug, project, architecture, base, port, allowGlobal }) =>
+    Effect.gen(function*() {
+      const dir = ensureOptionalAbsoluteWithCwd(Option.getOrUndefined(project))
+
+      const isValidProject = yield* Effect.promise(() => Api.Project.validateProjectDirectory(dir))
+      if (!isValidProject) {
+        return yield* Effect.fail(new Error('Invalid project directory'))
+      }
+
+      yield* Api.Builder.build({
+        dir,
+        overrides: {
+          build: {
+            architecture,
+            base: Option.getOrUndefined(base),
+          },
+          server: {
+            port: Option.getOrUndefined(port),
+          },
+          advanced: {
+            debug,
+          },
+        },
+      })
+    }),
+)

package/src/cli-effect/commands/cache/delete.ts

@@ -0,0 +1,21 @@
+import { Api } from '#api/index'
+import { ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
+import { Command } from '@effect/cli'
+import consola from 'consola'
+import { Effect, Option } from 'effect'
+import { allowGlobalParameter, projectParameter } from '../../_/parameters.js'
+
+export const cacheDelete = Command.make(
+  'delete',
+  {
+    project: projectParameter,
+    allowGlobal: allowGlobalParameter,
+  },
+  ({ project, allowGlobal }) =>
+    Effect.gen(function*() {
+      const dir = ensureOptionalAbsoluteWithCwd(Option.getOrUndefined(project))
+
+      yield* Effect.promise(() => Api.Cache.deleteAll(dir))
+      consola.success('Polen caches deleted')
+    }),
+)

package/src/cli-effect/commands/cache/show.ts

@@ -0,0 +1,99 @@
+import { Api } from '#api/index'
+import { Command, Options } from '@effect/cli'
+import { Effect } from 'effect'
+import { allowGlobalParameter } from '../../_/parameters.js'
+
+const depth = Options.integer('depth').pipe(
+  Options.withAlias('d'),
+  Options.withDefault(2),
+  Options.withDescription('Maximum depth for directory tree display'),
+)
+
+// Helper to format bytes
+const formatBytes = (bytes: number): string => {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`
+}
+
+// Helper to render directory tree
+const renderTree = (nodes: Api.Cache.TreeNode[], prefix = '', isLast = true): string[] => {
+  const lines: string[] = []
+
+  nodes.forEach((node, index) => {
+    const isLastNode = index === nodes.length - 1
+    const connector = isLastNode ? '└─' : '├─'
+    const extension = isLastNode ? '  ' : '│ '
+
+    let line = `${prefix}${connector} ${node.name}`
+    if (node.type === 'file' && node.size !== undefined) {
+      line += ` (${formatBytes(node.size)})`
+    }
+    lines.push(line)
+
+    if (node.children && node.children.length > 0) {
+      const childLines = renderTree(node.children, prefix + extension, isLastNode)
+      lines.push(...childLines)
+    }
+  })
+
+  return lines
+}
+
+export const cacheShow = Command.make(
+  'show',
+  {
+    depth,
+    allowGlobal: allowGlobalParameter,
+  },
+  ({ depth, allowGlobal }) =>
+    Effect.gen(function*() {
+      // Get cache info
+      const info = yield* Effect.promise(() => Api.Cache.info({ depth }))
+
+      console.log(`Root: ${info.rootPath}`)
+      console.log()
+
+      // Development assets
+      console.log(`Development assets: ${info.developmentAssets.path.replace(info.rootPath + '/', '')}`)
+      if (info.developmentAssets.exists) {
+        const size = info.developmentAssets.size ? ` (${formatBytes(info.developmentAssets.size)})` : ''
+        console.log(`  Status: exists${size}`)
+
+        if (info.developmentAssets.tree && info.developmentAssets.tree.length > 0) {
+          console.log('  Contents:')
+          const treeLines = renderTree(info.developmentAssets.tree, '    ')
+          treeLines.forEach(line => console.log(line))
+        }
+      } else {
+        console.log('  Status: empty')
+      }
+
+      console.log()
+
+      // Vite cache
+      console.log('Vite:')
+      if (info.vite.exists) {
+        const size = info.vite.size ? ` (${formatBytes(info.vite.size)})` : ''
+        console.log(`  Status: exists${size}`)
+
+        if (info.vite.optimizedDependencies && info.vite.optimizedDependencies.length > 0) {
+          const deps = info.vite.optimizedDependencies
+          const showing = Math.min(10, deps.length)
+          const more = deps.length - showing
+
+          console.log(`  Optimized dependencies (${deps.length}):`)
+          deps.slice(0, showing).forEach(dep => {
+            console.log(`    ${dep.name} (${formatBytes(dep.size)})`)
+          })
+
+          if (more > 0) {
+            console.log(`    ... (${more} more)`)
+          }
+        }
+      } else {
+        console.log('  Status: empty')
+      }
+    }),
+)

package/src/cli-effect/commands/cache.ts

@@ -0,0 +1,27 @@
+import { Command } from '@effect/cli'
+import { Console, Effect } from 'effect'
+
+// Import subcommands
+import { cacheDelete } from './cache/delete.js'
+import { cacheShow } from './cache/show.js'
+
+// Default cache command that shows usage
+const cacheDefault = Command.make(
+  'cache',
+  {},
+  () =>
+    Effect.gen(function*() {
+      yield* Console.error(`Usage: polen cache <command>
+
+Commands:
+  delete    Delete all Polen-generated caches
+  show      Display information about Polen caches
+`)
+      return yield* Effect.fail(new Error('No cache subcommand specified'))
+    }),
+)
+
+// Export the cache command with subcommands
+export const cache = cacheDefault.pipe(
+  Command.withSubcommands([cacheDelete, cacheShow]),
+)

package/src/cli-effect/commands/config/create.ts

@@ -0,0 +1,49 @@
+import { Api } from '#api/index'
+import { ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
+import { Command } from '@effect/cli'
+import { Fs, Path } from '@wollybeard/kit'
+import consola from 'consola'
+import { Effect, Option } from 'effect'
+import { allowGlobalParameter, projectParameter } from '../../_/parameters.js'
+
+export const configCreate = Command.make(
+  'create',
+  {
+    project: projectParameter,
+    allowGlobal: allowGlobalParameter,
+  },
+  ({ project, allowGlobal }) =>
+    Effect.gen(function*() {
+      const dir = ensureOptionalAbsoluteWithCwd(Option.getOrUndefined(project))
+
+      const isValidProject = yield* Effect.promise(() => Api.Project.validateProjectDirectory(dir))
+      if (!isValidProject) {
+        return yield* Effect.fail(new Error('Invalid project directory'))
+      }
+
+      const fileName = 'polen.config.ts'
+      const fileContent = `import { Polen } from 'polen'
+
+export default Polen.defineConfig({
+  // Your configuration options
+})
+`
+
+      const filePath = Path.join(dir, fileName)
+
+      const exists = yield* Effect.promise(() => Fs.exists(filePath))
+      if (exists) {
+        consola.info(`Polen configuration file already exists at ${fileName}`)
+        return
+      }
+
+      yield* Effect.promise(() =>
+        Fs.write({
+          path: filePath,
+          content: fileContent,
+        })
+      )
+
+      consola.success(`Created Polen configuration file at ${fileName}`)
+    }),
+)

package/src/cli-effect/commands/config.ts

@@ -0,0 +1,25 @@
+import { Command } from '@effect/cli'
+import { consola } from 'consola'
+import { Effect } from 'effect'
+
+// Import subcommands
+import { configCreate } from './config/create.js'
+
+// Default config command that shows usage
+const configDefault = Command.make(
+  'config',
+  {},
+  () =>
+    Effect.gen(function*() {
+      consola.info('Available config commands:')
+      console.log('')
+      console.log('  polen config create    Create a Polen configuration file')
+      console.log('')
+      consola.info('Run a command to see its help.')
+    }),
+)
+
+// Export the config command with subcommands
+export const config = configDefault.pipe(
+  Command.withSubcommands([configCreate]),
+)

package/src/cli-effect/commands/create.ts

@@ -0,0 +1,167 @@
+import { Api } from '#api/index'
+import { Args, Command, Options } from '@effect/cli'
+import { Err, Fs, Manifest, Name, Path, Str } from '@wollybeard/kit'
+import * as Ansis from 'ansis'
+import consola from 'consola'
+import { Console, Effect, Option } from 'effect'
+import { $ } from 'zx'
+
+// Define all the options and arguments exactly matching the original
+const nameArg = Args.text({ name: 'name' }).pipe(
+  Args.optional,
+  Args.withDescription(
+    'The name of your project. Used by the package name and the default path. Defaults to a random name.',
+  ),
+)
+
+const pathArg = Args.text({ name: 'path' }).pipe(
+  Args.optional,
+  Args.withDescription(
+    'The path to a directory to create your project. Must point to an empty or non-existing directory. Defaults to a new directory named after your project in your cwd (current working directory).',
+  ),
+)
+
+const link = Options.boolean('link').pipe(
+  Options.withDefault(false),
+  Options.withDescription(
+    'When installing polen, do so as a link. You must have Polen globally linked on your machine.',
+  ),
+)
+
+const version = Options.text('version').pipe(
+  Options.optional,
+  Options.withDescription('Version of Polen to use. Defaults to latest release. Ignored if --link is used.'),
+)
+
+const example = Options.choice('example', ['hive']).pipe(
+  Options.withDefault('hive' as const),
+  Options.withDescription('The example to use to scaffold your project.'),
+)
+
+const getProjectRoot = async (args: { name?: string; path?: string }): Promise<string> => {
+  if (args.path) {
+    if (await Api.Project.validateProjectDirectory(args.path, { mustExist: false, mustBeEmpty: true })) {
+      return args.path
+    }
+    throw new Error('Invalid project directory')
+  }
+
+  const name = Str.Case.kebab(args.name ?? Name.generate())
+
+  const findUsableName = async (isRetry?: true): Promise<string> => {
+    const projectRoot = Path.join(process.cwd(), name + (isRetry ? `-${Date.now().toString(36).substring(2, 8)}` : ''))
+    const stat = await Fs.stat(projectRoot)
+    if (Fs.isNotFoundError(stat)) return projectRoot
+    if (stat.isDirectory() && await Fs.isEmptyDir(projectRoot)) return projectRoot
+    return await findUsableName(true)
+  }
+
+  return await findUsableName()
+}
+
+const copyGitRepositoryTemplate = async (input: {
+  repository: {
+    url: URL
+    templatePath: string
+  }
+  destinationPath: string
+  exampleName: string
+}): Promise<void> => {
+  try {
+    const tmpDirPath = await Fs.makeTemporaryDirectory()
+    const cleanup = async () => await Fs.remove(tmpDirPath)
+
+    try {
+      // Clone only the specific example directory using sparse checkout
+      await $({
+        quiet: true,
+      })`git clone --depth 1 --filter=blob:none --sparse ${input.repository.url.href} ${tmpDirPath}`
+      await $`cd ${tmpDirPath} && git sparse-checkout set ${input.repository.templatePath}`
+
+      const templatePath = Path.join(tmpDirPath, input.repository.templatePath)
+
+      // Verify the example exists
+      if (!await Fs.exists(templatePath)) {
+        consola.error(
+          `Example "${input.exampleName}" not found in the Polen repository. Are you using the latest version of the CLI?`,
+        )
+        await cleanup()
+        throw new Error(`Example not found`)
+      }
+
+      await Fs.copyDir({
+        from: templatePath,
+        to: input.destinationPath,
+      })
+    } finally {
+      await cleanup()
+    }
+  } catch (error) {
+    consola.error(`Failed to scaffold example`)
+    Err.log(Err.ensure(error))
+    throw error
+  }
+}
+
+export const create = Command.make(
+  'create',
+  {
+    name: nameArg,
+    path: pathArg,
+    link,
+    version,
+    example,
+  },
+  ({ name, path, link, version, example }) =>
+    Effect.gen(function*() {
+      const finalName = Str.Case.kebab(Option.getOrUndefined(name) ?? Name.generate())
+      const nameValue = Option.getOrUndefined(name)
+      const pathValue = Option.getOrUndefined(path)
+      const projectRoot = yield* Effect.promise(() =>
+        getProjectRoot({
+          ...(nameValue && { name: nameValue }),
+          ...(pathValue && { path: pathValue }),
+        })
+      )
+      const project$ = $({ cwd: projectRoot })
+
+      console.log('')
+      consola.info(`Creating your Polen project "${Ansis.green(Str.Case.title(finalName))}"`)
+
+      consola.info(`Initializing with example "${Ansis.green(Str.Case.title(example))}"`)
+      yield* Effect.promise(() =>
+        copyGitRepositoryTemplate({
+          repository: {
+            url: new URL('https://github.com/the-guild-org/polen'),
+            templatePath: Path.join('examples', example),
+          },
+          destinationPath: projectRoot,
+          exampleName: example,
+        })
+      )
+
+      yield* Effect.promise(() =>
+        Manifest.resource.update((manifest) => {
+          manifest.name = finalName
+          manifest.description = 'A new project'
+          manifest.packageManager = 'pnpm@10.11.0'
+          if (manifest.dependencies) {
+            delete manifest.dependencies['polen'] // Repo uses links, we will install polen next.
+          }
+        }, projectRoot)
+      )
+
+      if (link) {
+        yield* Effect.promise(() => project$`pnpm link polen`)
+      } else {
+        const versionStr = Option.getOrUndefined(version)
+        const fqpn = `polen${versionStr ? `@${versionStr}` : ''}`
+        consola.info(`Installing ${Ansis.magenta(fqpn)}`)
+        yield* Effect.promise(() => project$`pnpm add ${fqpn}`)
+      }
+
+      consola.success('Your project is ready! Get Started:')
+      console.log('')
+      console.log(Ansis.magenta(`  cd ${Path.relative(process.cwd(), projectRoot)} && pnpm dev`))
+    }),
+)

package/src/cli-effect/commands/dev.ts

@@ -0,0 +1,72 @@
+import { Api } from '#api/index'
+import { Vite } from '#dep/vite/index'
+import { ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
+import { toViteUserConfig } from '#vite/config'
+import { Command, Options } from '@effect/cli'
+import { Err } from '@wollybeard/kit'
+import { Effect, Option } from 'effect'
+import { allowGlobalParameter, projectParameter } from '../_/parameters.js'
+
+// Define all the options exactly matching the original
+const debug = Options.boolean('debug').pipe(
+  Options.withAlias('d'),
+  Options.optional,
+  Options.withDescription('Enable debug mode'),
+)
+
+const base = Options.text('base').pipe(
+  Options.withAlias('b'),
+  Options.optional,
+  Options.withDescription('Base public path for deployment (e.g., /my-project/)'),
+)
+
+const port = Options.integer('port').pipe(
+  Options.optional,
+  Options.withDescription('Port to run the development server on'),
+)
+
+export const dev = Command.make(
+  'dev',
+  {
+    debug,
+    project: projectParameter,
+    base,
+    port,
+    allowGlobal: allowGlobalParameter,
+  },
+  ({ debug, project, base, port, allowGlobal }) =>
+    Effect.gen(function*() {
+      const dir = ensureOptionalAbsoluteWithCwd(Option.getOrUndefined(project))
+
+      const isValidProject = yield* Effect.promise(() => Api.Project.validateProjectDirectory(dir))
+      if (!isValidProject) {
+        return yield* Effect.fail(new Error('Invalid project directory'))
+      }
+
+      const polenConfig = yield* Api.ConfigResolver.fromFile({
+        dir,
+        overrides: {
+          build: {
+            base: Option.getOrUndefined(base),
+          },
+          server: {
+            port: Option.getOrUndefined(port),
+          },
+          advanced: {
+            debug: Option.getOrUndefined(debug),
+          },
+        },
+      })
+
+      const viteUserConfig = toViteUserConfig(polenConfig)
+      const viteDevServerResult = yield* Effect.promise(() => Err.tryCatch(() => Vite.createServer(viteUserConfig)))
+
+      if (Err.is(viteDevServerResult)) {
+        Err.log(viteDevServerResult)
+        return yield* Effect.fail(new Error('Failed to create Vite dev server'))
+      }
+
+      yield* Effect.promise(() => viteDevServerResult.listen())
+      viteDevServerResult.printUrls()
+    }),
+)