@codeandmoney/jargal 0.0.2-RC.3

package/.vscode/launch.json

@@ -0,0 +1,26 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "attach",
+      "name": "Attach",
+      "port": 9229,
+      "skipFiles": ["<node_internals>/**"]
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Execute Command",
+      "skipFiles": ["<node_internals>/**"],
+      "runtimeExecutable": "node",
+      "runtimeArgs": [
+        "--loader",
+        "ts-node/esm",
+        "--no-warnings=ExperimentalWarning"
+      ],
+      "program": "${workspaceFolder}/bin/dev.js",
+      "args": ["hello", "world"]
+    }
+  ]
+}

package/TODO.md

@@ -0,0 +1,2 @@
+1. Write tests
+2. Document

package/actions/ai.ts

@@ -0,0 +1,7 @@
+import type { Action } from "../types.ts"
+
+export function ai(): Action {
+  return function execute( _params ) {
+    throw new Error( "Action is not implemented" )
+  }
+}

package/actions/answer.ts

@@ -0,0 +1,7 @@
+import type { Action } from "../types.ts"
+
+export function answer(): Action {
+  return function execute( _params ) {
+    throw new Error( "Action is not implemented" )
+  }
+}

package/actions/blank.ts

@@ -0,0 +1,62 @@
+import type { Action } from "../types.ts"
+
+export const blank1: Action = () => {
+  console.log( "blank1:", "1" )
+
+  return function execute( _params ) {
+    console.log( "blank1:", "2" )
+
+    return function action() {
+      console.log( "blank1:", "3" )
+    }
+  }
+}
+
+export const blank2: Action = () => {
+  console.log( "blank2:", 1 )
+
+  return function execute( _params ) {
+    console.log( "blank2:", 2 )
+
+    return [
+      function action() {
+        console.log( "blank2:", 3 )
+      },
+
+      function action() {
+        console.log( "blank2:", 4 )
+        return [
+          () => console.log( "blank2:", 4, 1 ),
+          () => console.log( "blank2:", 4, 2 ),
+          () => console.log( "blank2:", 4, 3 ),
+        ]
+      },
+    ]
+  }
+}
+
+export const blank3: Action = () => {
+  console.log( "blank3:", 1 )
+
+  return function execute( _params ) {
+    console.log( "blank3:", 2 )
+  }
+}
+
+export function blankRecursive( depth = 10 ): Action {
+  return () =>
+    Math.random() > 0.5 ? recursive( depth ) : [
+      recursive( depth ),
+    ]
+}
+
+function recursive( depth: number ): Action {
+  if ( depth > 0 ) {
+    return () => {
+      console.log( depth )
+      return [ blank1, blank2, blank3, recursive( depth - 1 ) ]
+    }
+  }
+
+  return () => console.log( 0 )
+}

package/actions/config.ts

@@ -0,0 +1,7 @@
+import type { Action } from "../types.ts"
+
+export function config(): Action {
+  return function execute( _params ) {
+    throw new Error( "Action is not implemented" )
+  }
+}

package/actions/context.ts

@@ -0,0 +1,10 @@
+import { merge } from "es-toolkit"
+import { readonly } from "../lib.ts"
+import type { Action, Context, ContextAction, DeepReadonly } from "../types.ts"
+
+export function context( callback: ContextAction ): Action {
+  return async function execute( params ) {
+    const newContext = await callback( readonly( params.context ) )
+    merge( params.context, newContext )
+  }
+}

package/actions/echo.ts

@@ -0,0 +1,7 @@
+import type { Action } from "../types.ts"
+
+export function echo( message?: string ): Action {
+  return function execute() {
+    console.log( message ?? "Hello, World!" )
+  }
+}

package/actions/exports.ts

@@ -0,0 +1,8 @@
+export { context } from "./context.ts"
+export { prompt } from "./prompt.ts"
+export { parallel } from "./parallel.ts"
+export { write } from "./write.ts"
+export { echo } from "./echo.ts"
+export { validateAnswers } from "./validate_answers.ts"
+export { loadTemplates } from "./load_templates.ts"
+export { renderTemplate } from "./render_template.ts"

package/actions/load_templates.ts

@@ -0,0 +1,33 @@
+import type { ContextAction } from "../types.ts"
+import { promises as fs } from "node:fs"
+import path from "node:path"
+
+export function loadTemplates( templatesPath: string ): ContextAction {
+  return async function execute() {
+    const templates: Map<string, { fullPath: string; realativePath: string; content: string }> = new Map()
+
+    for await ( const fullPath of walkDir( templatesPath ) ) {
+      const realativePath = path.relative( templatesPath, fullPath )
+
+      const contentRaw = await fs.readFile( path.resolve( templatesPath, fullPath ) )
+
+      templates.set( realativePath, { content: new TextDecoder().decode( contentRaw ), fullPath, realativePath } )
+    }
+
+    return { templates }
+  }
+}
+
+async function* walkDir( dir: string ): AsyncGenerator<string, void, void> {
+  const entries = await fs.readdir( dir, { withFileTypes: true } )
+
+  for ( const entry of entries ) {
+    const fullPath = path.join( dir, entry.name )
+
+    if ( entry.isDirectory() ) {
+      yield* walkDir( fullPath )
+    } else if ( entry.isFile() ) {
+      yield fullPath
+    }
+  }
+}

package/actions/modify.ts

@@ -0,0 +1,7 @@
+import type { Action } from "../types.ts"
+
+export function modify(): Action {
+  return function execute( _params ) {
+    throw new Error( "Action is not implemented" )
+  }
+}

package/actions/parallel.ts

@@ -0,0 +1,10 @@
+import { executeAction } from "../runner.ts"
+import type { Action } from "../types.ts"
+
+export function parallel( ...actions: Action[] ): Action {
+  return async function execute( params ) {
+    await Promise.all(
+      actions.map( ( action ) => executeAction( { action, context: params.context, renderer: params.renderer } ) ),
+    )
+  }
+}

package/actions/prompt.ts

@@ -0,0 +1,144 @@
+// deno-lint-ignore-file no-explicit-any
+
+import enquirer from "enquirer"
+import type { Action } from "../types.ts"
+import { EventEmitter } from "node:events"
+
+export function prompt( questions: PromptOptions | PromptOptions[] ): Action {
+  return async function executePrompts( params ) {
+    const answers = await enquirer.prompt( questions )
+
+    if ( !params.context.answers ) {
+      Object.assign( params.context, { answers: {} } )
+    }
+
+    for ( const [ key, value ] of Object.entries( answers ) ) {
+      Object.assign( params.context.answers, { [key]: value } )
+    }
+  }
+}
+
+// NOTE: Stupid enquirer doesn't export types at all!!!
+//       So, I, being stupid dev, just copied them to get better inference
+
+type PromptTypes =
+  | "autocomplete"
+  | "editable"
+  | "form"
+  | "multiselect"
+  | "select"
+  | "survey"
+  | "list"
+  | "scale"
+  | "confirm"
+  | "input"
+  | "invisible"
+  | "list"
+  | "password"
+  | "text"
+  | "numeral"
+  | "snippet"
+  | "sort"
+
+interface BasePromptOptions {
+  name: string | (() => string)
+  type: PromptTypes | (() => PromptTypes)
+  message: string | (() => string) | (() => Promise<string>)
+  prefix?: string
+  initial?: any
+  required?: boolean
+  enabled?: boolean | string
+  disabled?: boolean | string
+  format?( value: string ): string | Promise<string>
+  result?( value: string ): string | Promise<string>
+  skip?: (( state: object ) => boolean | Promise<boolean>) | boolean
+  validate?( value: string ): boolean | string | Promise<boolean | string>
+  onSubmit?( name: string, value: any, prompt: BasePrompt ): boolean | Promise<boolean>
+  onCancel?( name: string, value: any, prompt: BasePrompt ): boolean | Promise<boolean>
+  stdin?: NodeJS.ReadStream
+  stdout?: NodeJS.WriteStream
+}
+
+interface Choice {
+  name: string
+  message?: string
+  value?: unknown
+  hint?: string
+  role?: string
+  enabled?: boolean
+  disabled?: boolean | string
+}
+
+interface ArrayPromptOptions extends BasePromptOptions {
+  type:
+    | "autocomplete"
+    | "editable"
+    | "form"
+    | "multiselect"
+    | "select"
+    | "survey"
+    | "list"
+    | "scale"
+  choices: (string | Choice)[]
+  maxChoices?: number
+  multiple?: boolean
+  initial?: number
+  delay?: number
+  separator?: boolean
+  sort?: boolean
+  linebreak?: boolean
+  edgeLength?: number
+  align?: "left" | "right"
+  scroll?: boolean
+}
+
+interface BooleanPromptOptions extends BasePromptOptions {
+  type: "confirm"
+  initial?: boolean
+}
+
+interface StringPromptOptions extends BasePromptOptions {
+  type: "input" | "invisible" | "list" | "password" | "text"
+  initial?: string
+  multiline?: boolean
+}
+
+interface NumberPromptOptions extends BasePromptOptions {
+  type: "numeral"
+  min?: number
+  max?: number
+  delay?: number
+  float?: boolean
+  round?: boolean
+  major?: number
+  minor?: number
+  initial?: number
+}
+
+interface SnippetPromptOptions extends BasePromptOptions {
+  type: "snippet"
+  newline?: string
+  template?: string
+}
+
+interface SortPromptOptions extends BasePromptOptions {
+  type: "sort"
+  hint?: string
+  drag?: boolean
+  numbered?: boolean
+}
+
+type PromptOptions =
+  | BasePromptOptions
+  | ArrayPromptOptions
+  | BooleanPromptOptions
+  | StringPromptOptions
+  | NumberPromptOptions
+  | SnippetPromptOptions
+  | SortPromptOptions
+
+declare class BasePrompt extends EventEmitter {
+  constructor( options?: PromptOptions )
+  render(): void
+  run(): Promise<any>
+}

package/actions/render_template.ts

@@ -0,0 +1,21 @@
+import type { Action, Context } from "../types.ts"
+import type { WriteActionConfig } from "./write.ts"
+
+export function renderTemplate( { fullpath, template, getData, write }: {
+  template: string
+  fullpath: string
+  getData?: ( ctx: Context ) => Record<string, unknown>
+  write?: ( config: WriteActionConfig ) => Action
+} ): Action {
+  return function execute( params ) {
+    const data = getData?.( params.context ) ?? params.context
+
+    const renderedTemplate = params.renderer.renderString( { template, data } )
+
+    const renderedPath = params.renderer.renderString( { template: fullpath, data } )
+
+    if ( write ) {
+      return write( { content: renderedTemplate, destination: renderedPath } )
+    }
+  }
+}

package/actions/select_generator.ts

@@ -0,0 +1,23 @@
+import { assert } from "@std/assert"
+import type { Action, Config } from "../types.ts"
+import { prompt } from "./prompt.ts"
+import { Renderer } from "../renderer.ts"
+import { runGenerator } from "../runner.ts"
+
+export function selectGenerator( config: Config ): Action {
+  const choices = config.generators.map( ( { name, description } ) => ( { name, hint: description } ) )
+
+  return () => [
+    prompt( [ { type: "select", choices, message: "select", name: "generator" } ] ),
+
+    function runSelectedGenerator( params ) {
+      const generator = config.generators.find( ( generator ) =>
+        generator.name === params?.context?.answers?.generator
+      )
+
+      assert( generator )
+
+      return runGenerator( { context: { errors: [], answers: {} }, renderer: new Renderer(), generator } )
+    },
+  ]
+}

package/actions/use.ts

@@ -0,0 +1,9 @@
+import type { Action } from "../types.ts"
+
+// TODO: implement use in a way, that it can use actions from some repository... Maybe...
+
+export function use(): Action {
+  return function execute( _params ) {
+    throw new Error( "Action is not implemented" )
+  }
+}

package/actions/validate_answers.ts

@@ -0,0 +1,14 @@
+import type { Action } from "../types.ts"
+import * as v from "valibot"
+
+const primitiveSchema = v.union( [ v.pipe( v.string(), v.minLength( 1 ) ), v.boolean() ] )
+
+const defaultSchema = v.record( v.string(), v.union( [ primitiveSchema, v.array( primitiveSchema ) ] ) )
+
+export function validateAnswers<Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(
+  schema?: Schema,
+): Action {
+  return function execute( params ) {
+    v.assert( schema ?? defaultSchema, params.context.answers )
+  }
+}

package/actions/write.ts

@@ -0,0 +1,84 @@
+// TODO: get rid of `node:` imports and "del", "mkdirp" libraries
+import { access } from "node:fs/promises"
+
+import { dirname } from "@std/path"
+
+import type { Action } from "../types.ts"
+
+// type WriteActionConfig = {
+
+//   data?: Record<string, unknown>
+//   destination: string
+//   writeMode?: "skip-if-exists" | "force"
+// } & (
+//   // |{templatePath: string}
+//   | { template: string }
+//   |
+// )
+
+export type WriteActionConfig = {
+  content: string
+  destination: string
+  mode?: "force" | "skip-if-exists"
+}
+
+export function write( config: WriteActionConfig ): Action {
+  return async function execute() {
+    await Deno.mkdir( dirname( config.destination ), { recursive: true } )
+
+    let doesExist = await fileExists( config.destination )
+
+    if ( doesExist && config.mode === "force" ) {
+      await Deno.remove( config.destination, { recursive: true } )
+      doesExist = false
+    }
+
+    if ( doesExist && config.mode !== "skip-if-exists" ) {
+      throw `File already exists\n -> ${config.destination}`
+    }
+
+    if ( doesExist && config.mode === "skip-if-exists" ) {
+      console.info( `[SKIPPED] ${config.destination} (exists)` )
+      return
+    }
+
+    await Deno.writeFile( config.destination, new TextEncoder().encode( config.content ) )
+  }
+
+  // if(eager) {
+  //   return execute()
+  // } else {
+  //   return execute
+  // }
+  // return async ( params ) => {
+  //   await Deno.mkdir( dirname( config.destination ), { recursive: true } )
+
+  //   // const template = ( await readFile( config.template ) ).toString()
+
+  //   const rendered = params.renderer.renderString( { data: config.data ?? {}, template: template } )
+
+  //   const doesExist = await fileExists( config.destination )
+
+  //   if ( doesExist && config.writeMode === "force" ) {
+  //     await Deno.remove( config.destination, { recursive: true } )
+  //   }
+
+  //   if ( doesExist ) {
+  //     if ( config.writeMode === "skip-if-exists" ) {
+  //       console.info( `[SKIPPED] ${config.destination} (exists)` )
+  //       return
+  //     }
+
+  //     throw `File already exists\n -> ${config.destination}`
+  //   }
+
+  //   await Deno.writeFile( config.destination, new TextEncoder().encode( rendered ) )
+  // }
+}
+
+function fileExists( destination: string ) {
+  return access( destination ).then(
+    () => true,
+    () => false,
+  )
+}

package/deno.json

@@ -0,0 +1,30 @@
+{
+  "name": "@codeandmoney/jargal",
+  "version": "0.0.2-RC.3",
+  "description": "Renderer",
+  "license": "MIT",
+  "author": "Code & Money Team",
+  "imports": {
+    "es-toolkit": "jsr:@es-toolkit/es-toolkit@^1.39.10",
+    "@std/assert": "jsr:@std/assert@^1.0.14",
+    "@std/path": "jsr:@std/path@^1.1.2",
+    "valibot": "jsr:@valibot/valibot@^1.1.0",
+    "change-case": "npm:change-case@^5.4.4",
+    "enquirer": "npm:enquirer@^2.4.1",
+    "handlebars": "npm:handlebars@^4.7.8",
+    "title-case": "npm:title-case@^4.3.2"
+  },
+  "exports": {
+    ".": "./mod.ts",
+    "./types": "./types.ts",
+    "./actions": "./actions/exports.ts"
+  },
+  "fmt": {
+    "semiColons": false,
+    "trailingCommas": "onlyMultiLine",
+    "quoteProps": "asNeeded",
+    "indentWidth": 2,
+    "lineWidth": 120,
+    "spaceAround": true
+  }
+}

package/deno.lock

@@ -0,0 +1,115 @@
+{
+  "version": "5",
+  "specifiers": {
+    "jsr:@es-toolkit/es-toolkit@^1.39.10": "1.39.10",
+    "jsr:@std/assert@^1.0.14": "1.0.14",
+    "jsr:@std/internal@^1.0.10": "1.0.10",
+    "jsr:@std/path@^1.1.2": "1.1.2",
+    "jsr:@valibot/valibot@^1.1.0": "1.1.0",
+    "npm:@types/node@*": "24.2.0",
+    "npm:change-case@^5.4.4": "5.4.4",
+    "npm:enquirer@^2.4.1": "2.4.1",
+    "npm:handlebars@^4.7.8": "4.7.8",
+    "npm:title-case@^4.3.2": "4.3.2"
+  },
+  "jsr": {
+    "@es-toolkit/es-toolkit@1.39.10": {
+      "integrity": "8757072a13aa64b3b349ba2b9d7d22fbe7ea6f138506c6cd2222d767cd79918f"
+    },
+    "@std/assert@1.0.14": {
+      "integrity": "68d0d4a43b365abc927f45a9b85c639ea18a9fab96ad92281e493e4ed84abaa4",
+      "dependencies": [
+        "jsr:@std/internal"
+      ]
+    },
+    "@std/internal@1.0.10": {
+      "integrity": "e3be62ce42cab0e177c27698e5d9800122f67b766a0bea6ca4867886cbde8cf7"
+    },
+    "@std/path@1.1.2": {
+      "integrity": "c0b13b97dfe06546d5e16bf3966b1cadf92e1cc83e56ba5476ad8b498d9e3038",
+      "dependencies": [
+        "jsr:@std/internal"
+      ]
+    },
+    "@valibot/valibot@1.1.0": {
+      "integrity": "2617f02b532011b8140926899d420a3e1bbb0fcb7cdf8e7b669df89e7edd7f5f"
+    }
+  },
+  "npm": {
+    "@types/node@24.2.0": {
+      "integrity": "sha512-3xyG3pMCq3oYCNg7/ZP+E1ooTaGB4cG8JWRsqqOYQdbWNY4zbaV0Ennrd7stjiJEFZCaybcIgpTjJWHRfBSIDw==",
+      "dependencies": [
+        "undici-types"
+      ]
+    },
+    "ansi-colors@4.1.3": {
+      "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw=="
+    },
+    "ansi-regex@5.0.1": {
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="
+    },
+    "change-case@5.4.4": {
+      "integrity": "sha512-HRQyTk2/YPEkt9TnUPbOpr64Uw3KOicFWPVBb+xiHvd6eBx/qPr9xqfBFDT8P2vWsvvz4jbEkfDe71W3VyNu2w=="
+    },
+    "enquirer@2.4.1": {
+      "integrity": "sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==",
+      "dependencies": [
+        "ansi-colors",
+        "strip-ansi"
+      ]
+    },
+    "handlebars@4.7.8": {
+      "integrity": "sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==",
+      "dependencies": [
+        "minimist",
+        "neo-async",
+        "source-map",
+        "wordwrap"
+      ],
+      "optionalDependencies": [
+        "uglify-js"
+      ],
+      "bin": true
+    },
+    "minimist@1.2.8": {
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="
+    },
+    "neo-async@2.6.2": {
+      "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="
+    },
+    "source-map@0.6.1": {
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="
+    },
+    "strip-ansi@6.0.1": {
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dependencies": [
+        "ansi-regex"
+      ]
+    },
+    "title-case@4.3.2": {
+      "integrity": "sha512-I/nkcBo73mO42Idfv08jhInV61IMb61OdIFxk+B4Gu1oBjWBPOLmhZdsli+oJCVaD+86pYQA93cJfFt224ZFAA=="
+    },
+    "uglify-js@3.19.3": {
+      "integrity": "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==",
+      "bin": true
+    },
+    "undici-types@7.10.0": {
+      "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="
+    },
+    "wordwrap@1.0.0": {
+      "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q=="
+    }
+  },
+  "workspace": {
+    "dependencies": [
+      "jsr:@es-toolkit/es-toolkit@^1.39.10",
+      "jsr:@std/assert@^1.0.14",
+      "jsr:@std/path@^1.1.2",
+      "jsr:@valibot/valibot@^1.1.0",
+      "npm:change-case@^5.4.4",
+      "npm:enquirer@^2.4.1",
+      "npm:handlebars@^4.7.8",
+      "npm:title-case@^4.3.2"
+    ]
+  }
+}

package/lib.ts

@@ -0,0 +1,147 @@
+// TODO: clean up
+
+import {
+  camelCase,
+  capitalCase,
+  constantCase,
+  dotCase,
+  kebabCase,
+  noCase,
+  pascalCase,
+  pascalSnakeCase,
+  pathCase,
+  sentenceCase,
+  snakeCase,
+  trainCase,
+} from "change-case"
+import { titleCase } from "title-case"
+import { deburr, lowerFirst, startCase, trim } from "es-toolkit"
+
+import type { ActionHooks, ActionHooksChanges, ActionHooksFailures, TextHelpers } from "./types.ts"
+
+//
+// -----
+//
+
+export const textHelpers: TextHelpers = {
+  upperCase: ( str ) => str.toUpperCase(),
+  lowerCase: ( str ) => str.toLowerCase(),
+  camelCase: ( str ) => camelCase( str ),
+  snakeCase: ( str ) => snakeCase( str ),
+  dotCase: ( str ) => dotCase( str ),
+  pathCase: ( str ) => pathCase( str ),
+  sentenceCase: ( str ) => sentenceCase( str ),
+  constantCase: ( str ) => constantCase( str ),
+  titleCase: ( str ) => titleCase( str ),
+  kebabCase: ( str ) => kebabCase( str ),
+  dashCase: ( str ) => kebabCase( str ),
+  kabobCase: ( str ) => kebabCase( str ),
+  pascalCase: ( str ) => pascalCase( str ),
+  properCase: ( str ) => pascalCase( str ),
+  deburr: ( str ) => deburr( str ),
+  lowerFirst: ( str ) => lowerFirst( str ),
+  startCase: ( str ) => startCase( str ),
+  noCase: ( str ) => noCase( str ),
+  capitalCase: ( str ) => capitalCase( str ),
+  pascalSnakeCase: ( str ) => pascalSnakeCase( str ),
+  trainCase: ( str ) => trainCase( str ),
+  trim: ( str ) => trim( str ),
+}
+
+//
+// -----
+//
+
+// import { styleText } from "node:util"
+// const typeDisplay = {
+//   function: styleText( "yellow", "->" ),
+//   add: styleText( "green", "++" ),
+//   addMany: styleText( "green", "+!" ),
+//   modify: `${`${styleText( "green", "+" )}${styleText( "red", "-" )}`}`,
+//   append: styleText( "green", "_+" ),
+//   skip: styleText( "green", "--" ),
+// }
+
+// function typeMap( name: keyof typeof typeDisplay, noMap: boolean = true ) {
+//   const dimType = styleText( "dim", name )
+//   return noMap ? dimType : typeDisplay[name] || dimType
+// }
+
+export class Hooks implements ActionHooks {
+  onComment( message: string ) {
+    console.log( message )
+  }
+
+  onSuccess( change: ActionHooksChanges ) {
+    // let line = ""
+
+    // if ( change.type ) {
+    //   line += ` ${typeMap( change.type )}`
+    // }
+
+    // if ( change.path ) {
+    //   line += ` ${change.path}`
+    // }
+
+    console.log( change )
+  }
+
+  onFailure( failure: ActionHooksFailures ) {
+    // let line = ""
+
+    // if ( failure.type ) {
+    //   line += ` ${typeMap( failure.type )}`
+    // }
+
+    // if ( failure.path ) {
+    //   line += ` ${failure.path}`
+    // }
+
+    // const errorMessage = failure.error || failure.message
+
+    // if ( errorMessage ) {
+    //   line += ` ${errorMessage}`
+    // }
+
+    console.log( failure )
+  }
+}
+
+//
+// -----
+//
+
+const ReadOnlyProxyDescriptor = {
+  // deno-lint-ignore no-explicit-any ban-types
+  get<T extends object>( target: T, key: keyof T & (string & {}) ): any {
+    const value = target[key]
+
+    if ( !isObject( value ) ) {
+      return value
+    }
+
+    return readonly( value )
+  },
+
+  set( _target: object, _key: string ) {
+    throw new ReadOnlyProxyWriteError( "Cannot write on read-only proxy" )
+  },
+
+  deleteProperty( _target: object, _key: string ) {
+    throw new ReadOnlyProxyWriteError( "Cannot delete on read-only proxy" )
+  },
+}
+
+function isObject( thing: unknown ) {
+  return thing !== null && typeof thing === "object"
+}
+
+class ReadOnlyProxyWriteError extends Error {
+  override name = "ReadOnlyProxyWriteError"
+}
+
+// Create a read-only proxy over an object.
+// Sub-properties that are objects also return read-only proxies.
+export function readonly<T extends object>( target: T ) {
+  return new Proxy<T>( target, ReadOnlyProxyDescriptor )
+}

package/mod.ts

@@ -0,0 +1,8 @@
+// Run
+export { run } from "./runner.ts"
+
+// Helpers
+export { textHelpers } from "./lib.ts"
+
+// Renderer
+export { Renderer } from "./renderer.ts"

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@codeandmoney/jargal",
+  "version": "0.0.2-RC.3",
+  "private": false,
+  "publishConfig": {
+  "access": "public"
+},
+"description": "Renderer",
+"license": "MIT",
+"author": "Code & Money Team",
+"exports": {
+  ".": "./mod.ts",
+  "./types": "./types.ts",
+  "./actions": "./actions/exports.ts"
+},
+"fmt": {
+  "semiColons": false,
+  "trailingCommas": "onlyMultiLine",
+  "quoteProps": "asNeeded",
+  "indentWidth": 2,
+  "lineWidth": 120,
+  "spaceAround": true
+},
+"devDependencies": {
+  "@types/node": "^24.7.0",
+  "bun-types": "^1.2.23"
+},
+"dependencies": {
+  "change-case": "^5.4.4",
+  "enquirer": "^2.4.1",
+  "es-toolkit": "^1.40.0",
+  "handlebars": "^4.7.8",
+  "title-case": "^4.3.2",
+  "valibot": "^1.1.0"
+}
+}

package/renderer.ts

@@ -0,0 +1,105 @@
+// deno-lint-ignore-file no-explicit-any
+
+import { get, set } from "es-toolkit/compat"
+import handlebars from "handlebars"
+
+import type {
+  GetReturnType,
+  HelperFn,
+  Helpers,
+  MappingScope,
+  Partials,
+  SetOptions,
+  Setter,
+  SetterScope,
+} from "./types.ts"
+import { readonly, textHelpers } from "./lib.ts"
+
+export class Renderer {
+  #partials: Partials = {}
+  #helpers: Helpers = textHelpers
+
+  #mapping: { partial: Partials; helper: Helpers } = { partial: this.#partials, helper: this.#helpers }
+
+  #set<T extends SetterScope>( scope: T, config: Setter<T>, options?: SetOptions ): Renderer {
+    if ( !config.name ) {
+      throw new Error( "Name must be non-empty string" )
+    }
+
+    const target = get( this.#mapping, scope )
+
+    if ( !target ) throw new Error( "No mapping" )
+
+    if ( config.name in target && !options?.override ) {
+      throw new Error( "Can't override" )
+    }
+
+    set( target, config.name, config.target )
+
+    return this
+  }
+
+  public readonly partials: Partials = readonly( this.#partials )
+  public readonly helpers: Helpers = readonly( this.#helpers )
+
+  public get<T extends SetterScope>( scope: T, name: string ): GetReturnType<T> {
+    const target = get( this.#mapping, scope )
+
+    if ( !target ) {
+      throw new Error( "!" )
+    }
+
+    return get( target, name )
+  }
+
+  public list<T extends `${SetterScope}s`, O extends boolean = false>(
+    scope: T,
+    options?: { full?: O },
+  ): O extends true ? MappingScope[T extends `${infer S}s` ? S : T][]
+    : string[] {
+    const target = get( this.#mapping, scope.slice( 0, scope.length - 1 ) )
+
+    if ( !target ) {
+      throw new Error( "No mapping" )
+    }
+
+    if ( !options?.full ) {
+      return Object.keys( target ) as any
+    }
+
+    switch ( scope ) {
+      case "helpers":
+        return Object.entries( target ).map( ( [ name, helper ] ) => ( { name, helper } ) ) as any
+
+      case "partials":
+        return Object.entries( target ).map( ( [ name, partial ] ) => ( { name, partial } ) ) as any
+
+      default:
+        throw new Error( "can't find the scope" )
+    }
+  }
+
+  public setPartial( name: string, partial: string, options?: SetOptions ): Renderer {
+    return this.#set( "partial", { target: partial, name }, options )
+  }
+
+  public setHelper( name: string, helper: HelperFn, options?: SetOptions ): Renderer {
+    return this.#set( "helper", { target: helper, name }, options )
+  }
+
+  public renderString( params: { template: string; data: Record<string, unknown> } ): string {
+    // TODO: do this once
+    for ( const [ name, helper ] of Object.entries( this.#helpers ) ) {
+      handlebars.registerHelper( name, helper )
+    }
+
+    // TODO: do this once
+    for ( const [ name, partial ] of Object.entries( this.#partials ) ) {
+      handlebars.registerPartial( name, partial )
+    }
+
+    const compiled = handlebars.compile( params.template )
+
+    return compiled( params.data )
+  }
+}

package/runner.ts

@@ -0,0 +1,100 @@
+import { assert } from "@std/assert"
+import { Renderer } from "./renderer.ts"
+import * as v from "valibot"
+
+import type { Action, Config, ExecuteActionParams, GeneratorParams } from "./types.ts"
+import { selectGenerator } from "./actions/select_generator.ts"
+
+export async function runGenerator( { context, generator, renderer }: GeneratorParams ): Promise<void> {
+  assert( generator )
+  assert( Array.isArray( generator.actions ) && generator.actions.length > 0 )
+
+  for ( const action of generator.actions ) {
+    await executeAction( { action, context, renderer } )
+  }
+}
+
+export async function executeAction(
+  { action, context, renderer }: ExecuteActionParams,
+): Promise<void | Action | Action[]> {
+  if ( Array.isArray( action ) ) {
+    for ( const action_ of action ) {
+      await executeAction( { action: action_, context, renderer } )
+    }
+  }
+
+  const executed = await action( { context, renderer } )
+
+  if ( !executed ) {
+    return undefined
+  }
+
+  return await execRecursive( executed, { context, renderer } )
+}
+
+async function execRecursive(
+  executed: Action | Action[],
+  { context, renderer }: Omit<ExecuteActionParams, "action">,
+): Promise<Action | Action[] | void> {
+  if ( Array.isArray( executed ) ) {
+    const executionResults: (Action)[] = []
+
+    for ( const action of executed ) {
+      const result = await executeAction( { action, context, renderer } )
+
+      if ( result ) {
+        if ( Array.isArray( result ) ) {
+          executionResults.push( ...result.flat() )
+        } else {
+          executionResults.push( result )
+        }
+      }
+    }
+
+    return executionResults
+  }
+
+  if ( typeof executed === "function" ) {
+    return await executeAction( { action: executed, context, renderer } )
+  }
+
+  assert( !executed )
+
+  return undefined
+}
+
+const ConfigSchema = v.object( {
+  generators: v.pipe(
+    v.array(
+      v.object( {
+        name: v.string(),
+        description: v.optional( v.string() ),
+        actions: v.pipe( v.array( v.any() ), v.minLength( 1 ) ),
+      } ),
+    ),
+    v.minLength( 1 ),
+  ),
+} )
+
+export async function run( config_: Config ): Promise<void> {
+  const config = v.parse( ConfigSchema, config_ )
+
+  if ( config.generators.length === 1 ) {
+    return await runGenerator( {
+      context: { errors: [], answers: {} },
+      renderer: new Renderer(),
+      generator: config.generators[0],
+    } )
+  }
+
+  return await runGenerator( {
+    context: { errors: [], answers: {} },
+    renderer: new Renderer(),
+    generator: {
+      name: "select",
+      actions: [
+        selectGenerator( config ),
+      ],
+    },
+  } )
+}

package/runner_test.ts

@@ -0,0 +1,27 @@
+import { run } from "./runner.ts"
+import { assert } from "@std/assert"
+import { join } from "@std/path"
+import { blank1, blank2 } from "./actions/blank.ts"
+
+import type { Config, GeneratorConfig } from "./types.ts"
+import { loadTemplates } from "./actions/load_templates.ts"
+import { context } from "./actions/context.ts"
+
+Deno.test("simple", async () => {
+  const simple: GeneratorConfig = {
+    name: "simple",
+    description: "description",
+    actions: [
+      blank1,
+      blank2,
+      context( () => ( { kek: Math.random() } ) ),
+      console.log,
+      loadTemplates( join( Deno.cwd(), "actions" ) ),
+    ],
+  }
+
+  const config: Config = { generators: [ simple ] }
+  const result = await run( config )
+
+  assert( typeof result === "undefined" )
+})

package/types.ts

@@ -0,0 +1,97 @@
+// deno-lint-ignore-file
+
+import type { Renderer } from "./renderer.ts"
+
+export interface Config {
+  generators: GeneratorConfig[]
+}
+
+export interface Context extends Record<string, unknown> {
+  answers: Record<string, string | boolean | (string | boolean)[]>
+  errors: Error[]
+}
+
+export type DeepReadonly<T> = {
+  readonly [Key in keyof T]: T[Key] extends any[] ? T[Key]
+    : T[Key] extends object ? DeepReadonly<T[Key]>
+    : T[Key]
+}
+
+export interface GeneratorParams {
+  context: Context
+  renderer: Renderer
+  generator: GeneratorConfig
+  hooks?: ActionHooks
+}
+
+export interface ActionParams {
+  context: Context
+  renderer: Renderer
+  hooks?: ActionHooks
+}
+
+export interface ExecuteActionParams {
+  context: Context
+  renderer: Renderer
+  action: Action
+}
+
+export interface GeneratorConfig {
+  name: string
+  // TODO: implement commented out interface
+  description?: string // | (( params: unknown ) => string)
+  // TODO: implement commented out interface
+  actions: Action[] // | Promise<Action[]>  | (( params: unknown ) => Action[] | Promise<Action[]>)
+}
+
+export type HelperFn = ( str: string ) => string
+
+export interface TextHelpers extends Record<string, HelperFn> {}
+
+export type Action = ( params: ActionParams ) => void | Action | Action[] | Promise<void | Action | Action[]>
+
+export interface ActionHooksFailures {
+  path: string
+  error: string
+  message?: string
+}
+
+export interface ActionHooksChanges {
+  path: string
+}
+
+export interface ActionHooks {
+  onComment?: ( msg: string ) => void
+  onSuccess?: ( change: ActionHooksChanges ) => void
+  onFailure?: ( failure: ActionHooksFailures ) => void
+}
+
+export type SetterScope = "helper" | "partial"
+
+export interface SetOptions {
+  override?: boolean
+}
+
+export interface MappingScope {
+  helper: { name: string; target: HelperFn }
+  partial: { name: string; target: string }
+}
+
+interface Mapping {
+  helper: HelperFn
+  partial: string
+}
+
+type GetSetterType<Key extends SetterScope> = Mapping[Key]
+
+export interface Setter<T extends SetterScope> {
+  target: GetSetterType<T>
+  name: string
+}
+
+export type GetReturnType<T extends SetterScope> = Mapping[T]
+
+export interface Partials extends Record<string, string> {}
+export interface Helpers extends Record<string, any> {}
+
+export type ContextAction = ( context: DeepReadonly<Context> ) => Partial<Context> | Promise<Partial<Context>>