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

package/src/api/static/rebase.ts

@@ -1,6 +1,9 @@
 import { TinyGlobby } from '#dep/tiny-globby/index'
-import { Fs, Path } from '@wollybeard/kit'
-import { Err } from '@wollybeard/kit'
+import { S } from '#lib/kit-temp/effect'
+import { FileSystem } from '@effect/platform'
+import { NodeFileSystem } from '@effect/platform-node'
+import { Effect, Exit } from 'effect'
+import * as NodePath from 'node:path'
 import { buildManifest, type PolenBuildManifest } from './manifest.js'
 
 export type RebasePlan = RebaseOverwritePlan | RebaseCopyPlan
@@ -19,38 +22,53 @@ export interface RebaseCopyPlan {
 }
 
 export const rebase = async (plan: RebasePlan): Promise<void> => {
-  // 1. Validate source is a Polen build
-  const manifestResult = await buildManifest.read(plan.sourcePath)
-  if (Err.is(manifestResult)) {
-    throw new Error(`Polen build manifest not found at: ${Path.join(plan.sourcePath, `.polen`, `build.json`)}`)
-  }
-  const manifest = manifestResult
-
-  // 2. Validate newBasePath is valid URL path
-  if (!isValidUrlPath(plan.newBasePath)) {
-    throw new Error(`Invalid base path: ${plan.newBasePath}`)
-  }
-
-  // 3. Handle copy vs mutate
-  let workingPath: string
-  if (plan.changeMode === `copy`) {
-    if (await Fs.exists(plan.targetPath)) {
-      const isEmpty = await Fs.isEmptyDir(plan.targetPath)
-      if (!isEmpty) {
-        throw new Error(`Target path already exists and is not empty: ${plan.targetPath}`)
+  const rebaseEffect = Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+
+    // 1. Validate source is a Polen build
+    const manifestResult = yield* Effect.promise(() => buildManifest.read(plan.sourcePath))
+    if (Exit.isFailure(manifestResult)) {
+      return yield* Effect.fail(
+        new Error(`Polen build manifest not found at: ${NodePath.join(plan.sourcePath, `.polen`, `build.json`)}`),
+      )
+    }
+    const manifest = manifestResult.value
+
+    // 2. Validate newBasePath is valid URL path
+    if (!isValidUrlPath(plan.newBasePath)) {
+      return yield* Effect.fail(new Error(`Invalid base path: ${plan.newBasePath}`))
+    }
+
+    // 3. Handle copy vs mutate
+    let workingPath: string
+    if (plan.changeMode === `copy`) {
+      const targetExists = yield* fs.exists(plan.targetPath)
+      if (targetExists) {
+        const isEmpty = yield* isEmptyDirectory(plan.targetPath)
+        if (!isEmpty) {
+          return yield* Effect.fail(
+            new Error(`Target path already exists and is not empty: ${plan.targetPath}`),
+          )
+        }
       }
+      yield* copyDirectory(plan.sourcePath, plan.targetPath)
+      workingPath = plan.targetPath
+    } else {
+      workingPath = plan.sourcePath
     }
-    await Fs.copyDir({ from: plan.sourcePath, to: plan.targetPath })
-    workingPath = plan.targetPath
-  } else {
-    workingPath = plan.sourcePath
-  }
 
-  // 4. Update HTML files with new base path
-  await updateHtmlFiles(workingPath, manifest.basePath, plan.newBasePath)
+    // 4. Update HTML files with new base path
+    yield* updateHtmlFiles(workingPath, manifest.basePath, plan.newBasePath)
+
+    // 5. Update manifest
+    yield* updateManifest(workingPath, { basePath: plan.newBasePath })
+  })
 
-  // 5. Update manifest
-  await updateManifest(workingPath, { basePath: plan.newBasePath })
+  return Effect.runPromise(
+    rebaseEffect.pipe(
+      Effect.provide(NodeFileSystem.layer),
+    ),
+  )
 }
 
 //
@@ -61,6 +79,48 @@ export const rebase = async (plan: RebasePlan): Promise<void> => {
 //
 //
 
+const isEmptyDirectory = (path: string): Effect.Effect<boolean, Error, FileSystem.FileSystem> =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const entries = yield* fs.readDirectory(path).pipe(
+      Effect.mapError((error) => new Error(`Failed to read directory: ${error}`)),
+    )
+    return entries.length === 0
+  })
+
+const copyDirectory = (from: string, to: string): Effect.Effect<void, Error, FileSystem.FileSystem> =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+
+    // Ensure target directory exists
+    yield* fs.makeDirectory(to, { recursive: true }).pipe(
+      Effect.mapError((error) => new Error(`Failed to create target directory: ${error}`)),
+    )
+
+    // Read source directory
+    const entries = yield* fs.readDirectory(from).pipe(
+      Effect.mapError((error) => new Error(`Failed to read source directory: ${error}`)),
+    )
+
+    // Copy each entry
+    for (const entry of entries) {
+      const sourcePath = NodePath.join(from, entry)
+      const targetPath = NodePath.join(to, entry)
+
+      const fileInfo = yield* fs.stat(sourcePath).pipe(
+        Effect.mapError((error) => new Error(`Failed to stat ${sourcePath}: ${error}`)),
+      )
+
+      if (fileInfo.type === 'Directory') {
+        yield* copyDirectory(sourcePath, targetPath)
+      } else {
+        yield* fs.copyFile(sourcePath, targetPath).pipe(
+          Effect.mapError((error) => new Error(`Failed to copy file ${sourcePath}: ${error}`)),
+        )
+      }
+    }
+  })
+
 // TODO: this is very generic, factor out to kit-temp
 const isValidUrlPath = (path: string): boolean => {
   // URL path should start with / and not contain invalid characters
@@ -72,69 +132,98 @@ const isValidUrlPath = (path: string): boolean => {
   return urlPathRegex.test(path)
 }
 
-const updateHtmlFiles = async (buildPath: string, oldBasePath: string, newBasePath: string): Promise<void> => {
-  // Find all HTML files recursively
-  const htmlFiles = await findHtmlFiles(buildPath)
-
-  for (const htmlFile of htmlFiles) {
-    await updateHtmlFile(htmlFile, oldBasePath, newBasePath)
-  }
-}
-
-const findHtmlFiles = async (dir: string): Promise<string[]> => {
-  return await TinyGlobby.glob(`**/*.html`, {
-    absolute: true,
-    cwd: dir,
-    onlyFiles: true,
+const updateHtmlFiles = (
+  buildPath: string,
+  oldBasePath: string,
+  newBasePath: string,
+): Effect.Effect<void, Error, FileSystem.FileSystem> =>
+  Effect.gen(function*() {
+    // Find all HTML files recursively
+    const htmlFiles = yield* findHtmlFiles(buildPath)
+
+    // Update all HTML files in parallel
+    yield* Effect.all(
+      htmlFiles.map(htmlFile => updateHtmlFile(htmlFile, oldBasePath, newBasePath)),
+      { concurrency: 'unbounded' },
+    )
   })
-}
 
-const updateHtmlFile = async (filePath: string, oldBasePath: string, newBasePath: string): Promise<void> => {
-  const content = await Fs.read(filePath)
+const findHtmlFiles = (dir: string): Effect.Effect<string[], Error, never> =>
+  Effect.tryPromise({
+    try: () =>
+      TinyGlobby.glob(`**/*.html`, {
+        absolute: true,
+        cwd: dir,
+        onlyFiles: true,
+      }),
+    catch: (error) => new Error(`Failed to find HTML files: ${error}`),
+  })
 
-  if (content === null) {
-    throw new Error(`Could not read HTML file: ${filePath}`)
-  }
+const updateHtmlFile = (
+  filePath: string,
+  oldBasePath: string,
+  newBasePath: string,
+): Effect.Effect<void, Error, FileSystem.FileSystem> =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
 
-  // Simple regex-based approach to update base tag
-  // Look for existing base tag first
-  const baseTagRegex = /<base\s+href\s*=\s*["']([^"']*)["'][^>]*>/i
+    const content = yield* fs.readFileString(filePath).pipe(
+      Effect.mapError((error) => new Error(`Could not read HTML file ${filePath}: ${error}`)),
+    )
 
-  let updatedContent: string
+    // Simple regex-based approach to update base tag
+    // Look for existing base tag first
+    const baseTagRegex = /<base\s+href\s*=\s*["']([^"']*)["'][^>]*>/i
 
-  if (baseTagRegex.test(content)) {
-    // Update existing base tag
-    updatedContent = content.replace(baseTagRegex, `<base href="${newBasePath}">`)
-  } else {
-    // Insert new base tag in head
-    const headRegex = /<head[^>]*>/i
-    const headMatch = headRegex.exec(content)
+    let updatedContent: string
 
-    if (headMatch) {
-      const insertPosition = headMatch.index + headMatch[0].length
-      updatedContent = content.slice(0, insertPosition)
-        + `\n  <base href="${newBasePath}">`
-        + content.slice(insertPosition)
+    if (baseTagRegex.test(content)) {
+      // Update existing base tag
+      updatedContent = content.replace(baseTagRegex, `<base href="${newBasePath}">`)
     } else {
-      throw new Error(`Could not find <head> tag in HTML file: ${filePath}`)
+      // Insert new base tag in head
+      const headRegex = /<head[^>]*>/i
+      const headMatch = headRegex.exec(content)
+
+      if (headMatch) {
+        const insertPosition = headMatch.index + headMatch[0].length
+        updatedContent = content.slice(0, insertPosition)
+          + `\n  <base href="${newBasePath}">`
+          + content.slice(insertPosition)
+      } else {
+        return yield* Effect.fail(
+          new Error(`Could not find <head> tag in HTML file: ${filePath}`),
+        )
+      }
     }
-  }
 
-  await Fs.write({ path: filePath, content: updatedContent })
-}
+    yield* fs.writeFileString(filePath, updatedContent).pipe(
+      Effect.mapError((error) => new Error(`Failed to write HTML file ${filePath}: ${error}`)),
+    )
+  })
 
-const updateManifest = async (buildPath: string, updates: Partial<PolenBuildManifest>): Promise<void> => {
-  const manifestPath = Path.join(buildPath, `.polen`, `build.json`)
-  const manifestResult = await buildManifest.read(buildPath)
-  if (Err.is(manifestResult)) {
-    throw new Error(`Polen build manifest not found at: ${manifestPath}`)
-  }
-  const currentManifest = manifestResult
+const updateManifest = (
+  buildPath: string,
+  updates: Partial<PolenBuildManifest>,
+): Effect.Effect<void, Error, FileSystem.FileSystem> =>
+  Effect.gen(function*() {
+    const manifestPath = NodePath.join(buildPath, `.polen`, `build.json`)
+    const manifestResult = yield* Effect.promise(() => buildManifest.read(buildPath))
+
+    if (Exit.isFailure(manifestResult)) {
+      return yield* Effect.fail(
+        new Error(`Polen build manifest not found at: ${manifestPath}`),
+      )
+    }
+    const currentManifest = manifestResult.value
 
-  const updatedManifest = { ...currentManifest, ...updates }
+    const updatedManifest = { ...currentManifest, ...updates }
 
-  await Fs.write({
-    path: manifestPath,
-    content: JSON.stringify(updatedManifest, null, 2),
+    const writeResult = yield* Effect.promise(() => buildManifest.write(updatedManifest, buildPath))
+    if (Exit.isFailure(writeResult)) {
+      const error = writeResult.cause
+      return yield* Effect.fail(
+        new Error(`Failed to write manifest: ${error}`),
+      )
+    }
   })
-}

package/src/cli/_/parameters.ts

@@ -8,3 +8,10 @@ export const projectParameter = z
   .string()
   .optional()
   .describe(`The path to the project directory. Default is CWD (current working directory).`)
+
+export const allowGlobalParameter = z
+  .boolean()
+  .optional()
+  .describe(
+    `Allow using global Polen in a project with local Polen. Not recommended as it can cause version conflicts.`,
+  )

package/src/cli/commands/build.ts

@@ -1,10 +1,21 @@
 // @ts-nocheck
 import { Api } from '#api/index'
-import { projectParameter } from '#cli/_/parameters'
+import { allowGlobalParameter, projectParameter } from '#cli/_/parameters'
 import { ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
+import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
 import { Command } from '@molt/command'
+import { Effect } from 'effect'
 import { z } from 'zod'
 
+// todo remove these inline defs once using effect cli instead of molt
+export const BuildArchitectureEnum = {
+  ssg: `ssg`,
+  spa: `spa`,
+  ssr: `ssr`,
+} as const
+
+export const BuildArchitecture = z.nativeEnum(BuildArchitectureEnum)
+
 const args = Command.create()
   .parameter(`--debug -d`, z.boolean().default(false))
   .parameter(
@@ -13,7 +24,7 @@ const args = Command.create()
   )
   .parameter(
     `--architecture -a`,
-    Api.Config.BuildArchitecture.default('ssg').describe('Which kind of application architecture to output.'),
+    BuildArchitecture.default('ssg').describe('Which kind of application architecture to output.'),
   )
   .parameter(
     `--base -b`,
@@ -23,6 +34,7 @@ const args = Command.create()
     `--port`,
     z.number().optional().describe('Default port for the SSR application'),
   )
+  .parameter(`--allow-global`, allowGlobalParameter)
   .settings({
     parameters: {
       environment: {
@@ -42,18 +54,22 @@ if (!await Api.Project.validateProjectDirectory(dir)) {
   process.exit(1)
 }
 
-await Api.Builder.build({
-  dir,
-  overrides: {
-    build: {
-      architecture: args.architecture,
-      base: args.base,
-    },
-    server: {
-      port: args.port,
-    },
-    advanced: {
-      debug: args.debug,
+await Effect.runPromise(
+  Api.Builder.build({
+    dir,
+    overrides: {
+      build: {
+        architecture: args.architecture,
+        base: args.base,
+      },
+      server: {
+        port: args.port,
+      },
+      advanced: {
+        debug: args.debug,
+      },
     },
-  },
-})
+  }).pipe(
+    Effect.provide(NodeFileSystem.layer),
+  ),
+)

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

@@ -1,5 +1,5 @@
 import { Api } from '#api/index'
-import { projectParameter } from '#cli/_/parameters'
+import { allowGlobalParameter, projectParameter } from '#cli/_/parameters'
 import { ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
 import { Command } from '@molt/command'
 import consola from 'consola'
@@ -9,6 +9,7 @@ const args = Command.create()
     `--project -p`,
     projectParameter,
   )
+  .parameter(`--allow-global`, allowGlobalParameter)
   .settings({
     parameters: {
       environment: {

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

@@ -1,4 +1,5 @@
 import { Api } from '#api/index'
+import { allowGlobalParameter } from '#cli/_/parameters'
 import { Command } from '@molt/command'
 import { z } from 'zod'
 
@@ -7,6 +8,7 @@ const args = Command.create()
     `--depth -d`,
     z.number().min(0).max(5).default(2).describe(`Maximum depth for directory tree display`),
   )
+  .parameter(`--allow-global`, allowGlobalParameter)
   .settings({
     parameters: {
       environment: {

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

@@ -1,5 +1,5 @@
 import { Api } from '#api/index'
-import { projectParameter } from '#cli/_/parameters'
+import { allowGlobalParameter, projectParameter } from '#cli/_/parameters'
 import { ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
 import { Command } from '@molt/command'
 import { Fs, Path } from '@wollybeard/kit'
@@ -10,6 +10,7 @@ const args = Command.create()
     `--project -p`,
     projectParameter,
   )
+  .parameter(`--allow-global`, allowGlobalParameter)
   .parse()
 
 const dir = ensureOptionalAbsoluteWithCwd(args.project)

package/src/cli/commands/dev.ts

@@ -1,10 +1,13 @@
 // @ts-nocheck
 import { Api } from '#api/index'
-import { projectParameter } from '#cli/_/parameters'
+import { allowGlobalParameter, projectParameter } from '#cli/_/parameters'
 import { Vite } from '#dep/vite/index'
 import { ensureOptionalAbsoluteWithCwd } from '#lib/kit-temp'
+import { toViteUserConfig } from '#vite/config'
+import * as NodeFileSystem from '@effect/platform-node/NodeFileSystem'
 import { Command } from '@molt/command'
 import { Err } from '@wollybeard/kit'
+import { Effect } from 'effect'
 import { z } from 'zod'
 
 const args = Command.create()
@@ -22,6 +25,7 @@ const args = Command.create()
     `--port`,
     z.number().optional().describe('Port to run the development server on'),
   )
+  .parameter(`--allow-global`, allowGlobalParameter)
   .settings({
     parameters: {
       environment: {
@@ -41,20 +45,26 @@ if (!await Api.Project.validateProjectDirectory(dir)) {
   process.exit(1)
 }
 
-const viteUserConfig = await Api.ConfigResolver.fromFile({
-  dir,
-  overrides: {
-    build: {
-      base: args.base,
-    },
-    server: {
-      port: args.port,
-    },
-    advanced: {
-      debug: args.debug,
+const polenConfig = await Effect.runPromise(
+  Api.ConfigResolver.fromFile({
+    dir,
+    overrides: {
+      build: {
+        base: args.base,
+      },
+      server: {
+        port: args.port,
+      },
+      advanced: {
+        debug: args.debug,
+      },
     },
-  },
-})
+  }).pipe(
+    Effect.provide(NodeFileSystem.layer),
+  ),
+)
+
+const viteUserConfig = toViteUserConfig(polenConfig)
 
 const viteDevServer = await Err.tryCatch(() => Vite.createServer(viteUserConfig))
 

package/src/cli/commands/open.ts

@@ -8,9 +8,11 @@
  */
 
 import { Api } from '#api/index'
+import { allowGlobalParameter } from '#cli/_/parameters'
 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 { Err, Fs, Json, Path, Rec } from '@wollybeard/kit'
@@ -59,6 +61,7 @@ const args = Command.create()
         `Enable or disable caching. By default this command caches fetched schemas for re-use.`,
       ),
   )
+  .parameter(`--allow-global`, allowGlobalParameter)
   .settings({
     parameters: {
       environment: {
@@ -158,7 +161,7 @@ const schema = await load(
 const config = await Api.ConfigResolver.fromMemory({
   root: await Fs.makeTemporaryDirectory(),
   schema: {
-    dataSources: {
+    sources: {
       data: {
         versions: [
           {
@@ -173,7 +176,8 @@ const config = await Api.ConfigResolver.fromMemory({
   },
 })
 
-const viteDevServer = await Vite.createServer(config)
+const viteConfig = toViteUserConfig(config)
+const viteDevServer = await Vite.createServer(viteConfig)
 
 await viteDevServer.listen()
 

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

@@ -1,8 +1,10 @@
 // @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'
 
 const args = Command.create()
@@ -18,6 +20,7 @@ const args = Command.create()
     `--target -t`,
     z.string().optional().describe('Target directory for copy mode (if not provided, mutate in place)'),
   )
+  .parameter(`--allow-global`, allowGlobalParameter)
   .parse()
 
 const plan: Api.Static.RebasePlan = args.target
@@ -33,4 +36,9 @@ const plan: Api.Static.RebasePlan = args.target
     newBasePath: args.newBasePath,
   }
 
-await Task.runAndExit(Api.Static.rebase, plan)
+// Wrap the Promise-based API to make it Effect-based
+const rebaseEffect = (plan: Api.Static.RebasePlan) => Effect.promise(() => Api.Static.rebase(plan))
+
+await Effect.runPromise(
+  Task.runAndExit(rebaseEffect, plan),
+)

package/src/cli/index.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import { checkGlobalVsLocal } from '#lib/kit-temp'
 import { Cli, Path } from '@wollybeard/kit'
 import manifest from '../../package.json' with { type: 'json' }
 
@@ -9,5 +10,32 @@ if (process.argv.includes(`--version`) || process.argv.includes(`-v`)) {
   process.exit(0)
 }
 
+// Check for global vs local Polen conflict
+// The --allow-global flag is handled inside checkGlobalVsLocal
+try {
+  await checkGlobalVsLocal({
+    packageName: 'polen',
+    currentExecutablePath: process.argv[1] ?? '',
+    errorMessageTemplate: {
+      title: 'Global Polen detected in project with local Polen',
+      explanation:
+        'You are running the global Polen CLI in a project that has Polen installed locally. This can cause version mismatches, cache conflicts, and unexpected behavior.',
+      solutions: [
+        'pnpm exec polen <command>',
+        'npx polen <command>',
+        './node_modules/.bin/polen <command>',
+      ],
+    },
+  })
+} 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)

package/src/cli-effect/_/parameters.ts

@@ -0,0 +1,17 @@
+import { Args, Options } from '@effect/cli'
+
+/**
+ * Common parameter schemas for Effect CLI commands
+ */
+
+export const projectParameter = Args.text({ name: 'project' }).pipe(
+  Args.optional,
+  Args.withDescription('The path to the project directory. Default is CWD (current working directory).'),
+)
+
+export const allowGlobalParameter = Options.boolean('allow-global').pipe(
+  Options.optional,
+  Options.withDescription(
+    'Allow using global Polen in a project with local Polen. Not recommended as it can cause version conflicts.',
+  ),
+)