@oyolincc/create 0.2.0 → 0.3.0

package/templates/hono-server/libs/definition/src/configs/defs/log.ts

@@ -0,0 +1,53 @@
+import * as v from 'valibot'
+import { defineSchemaConfig, defineStaticConfig } from '../proto'
+
+export const $S_LogRollSchemaConfig = v.object({
+  loggerDir: v.optional(v.string(), './logs'),
+  loggerFileBase: v.optional(
+    v.pipe(v.string(), v.minLength(1, 'loggerFileBase must be at least 1 character long')),
+    'app',
+  ),
+})
+export type LogRollSchemaConfig = v.InferOutput<typeof $S_LogRollSchemaConfig>
+export const logRollSchemaConfig = defineSchemaConfig($S_LogRollSchemaConfig)
+
+export const $S_LogBaseConfig = v.object({
+  loggerLevel: v.optional(
+    v.picklist(['trace', 'debug', 'info', 'warn', 'error', 'fatal', 'silent']),
+  ),
+})
+export type LogBaseConfig = v.InferOutput<typeof $S_LogBaseConfig>
+export const logBaseConfig = defineSchemaConfig($S_LogBaseConfig)
+
+// https://github.com/mcollina/pino-roll#options
+export interface LogRollRawConfig {
+  frequency: number | string
+  extension: string
+  size: number | string
+  maxFiles: number
+  mkdir: boolean
+  dateFormat: string
+}
+export const logRollRawConfig = defineStaticConfig<LogRollRawConfig>(() => ({
+  frequency: 'daily' as const,
+  extension: '.log',
+  size: '10M',
+  maxFiles: 30,
+  mkdir: true,
+  dateFormat: 'yyyy-MM-dd',
+}))
+
+export interface LogPrettyRawConfig {
+  colorize: boolean
+  singleLine: boolean
+  levelFirst: boolean
+  translateTime: string
+  ignore: string
+}
+export const logPrettyRawConfig = defineStaticConfig<LogPrettyRawConfig>(() => ({
+  colorize: true,
+  singleLine: true,
+  levelFirst: true,
+  translateTime: 'SYS:yyyy-mm-dd HH:MM:ss',
+  ignore: 'pid,hostname',
+}))

package/templates/hono-server/libs/definition/src/configs/defs/middleware.ts

@@ -0,0 +1,16 @@
+import * as v from 'valibot'
+import { defineSchemaConfig } from '../proto'
+
+export const $S_CORSConfig = v.object({
+  domains: v.pipe(
+    v.optional(v.string()),
+    v.transform((val) =>
+      String(val || '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean),
+    ),
+  ) as v.GenericSchema<string | undefined, string[]>,
+})
+export type CORSConfig = v.InferOutput<typeof $S_CORSConfig>
+export const corsConfig = defineSchemaConfig($S_CORSConfig)

package/templates/hono-server/libs/definition/src/configs/defs/runtime.ts

@@ -0,0 +1,12 @@
+import * as v from 'valibot'
+import { defineSchemaConfig } from '../proto'
+
+export const $S_RuntimeConfig = v.object({
+  serverBasePath: v.optional(v.string(), '/'),
+  serverEnv: v.optional(
+    v.union([v.literal('local'), v.literal('test'), v.literal('staging'), v.literal('main')]),
+    'local',
+  ),
+})
+export type RuntimeConfig = v.InferOutput<typeof $S_RuntimeConfig>
+export const runtimeConfig = defineSchemaConfig($S_RuntimeConfig)

package/templates/hono-server/libs/definition/src/configs/defs/sqlite.ts

@@ -0,0 +1,26 @@
+import path from 'node:path'
+import * as v from 'valibot'
+import { defineSchemaConfig } from '../proto'
+import { $S_NonEmptyString } from '../schema'
+
+function defaultSqliteDbPath(): string {
+  const workspaceRoot = path.join(import.meta.dirname, '../../..')
+  return path.join(workspaceRoot, 'db-data', 'repo.sqlite')
+}
+
+export const $S_SqliteSchemaConfig = v.object({
+  dbPath: v.pipe(
+    v.optional($S_NonEmptyString),
+    v.transform((dbPath) => dbPath || defaultSqliteDbPath()),
+  ) as v.GenericSchema<string | undefined, string>,
+})
+export type SqliteSchemaConfig = v.InferOutput<typeof $S_SqliteSchemaConfig>
+export const sqliteSchemaConfig = defineSchemaConfig($S_SqliteSchemaConfig)
+
+export const $S_D1SchemaConfig = v.object({
+  cloudflareAccountId: $S_NonEmptyString,
+  cloudflareDatabaseId: $S_NonEmptyString,
+  cloudflareToken: $S_NonEmptyString,
+})
+export type D1SchemaConfig = v.InferOutput<typeof $S_D1SchemaConfig>
+export const d1SchemaConfig = defineSchemaConfig($S_D1SchemaConfig)

package/templates/hono-server/libs/definition/src/configs/defs/worker.ts

@@ -0,0 +1,29 @@
+import * as v from 'valibot'
+import { defineSchemaConfig } from '../proto'
+import { availableParallelism } from 'node:os'
+
+const workerNumber = (minimum: number, name: string) =>
+  v.pipe(
+    v.union([v.string(), v.number()]),
+    v.transform((value) => Number(value)),
+    v.integer(`${name} must be an integer`),
+    v.minValue(minimum, `${name} must be at least ${minimum}`),
+  )
+
+export const $S_WorkerConfig = v.object({
+  /** Worker 池启动时至少保留的 Worker 数量。 */
+  minThreads: v.optional(workerNumber(1, 'minThreads'), 1),
+  /** Worker 池允许创建的最大 Worker 数量。 */
+  maxThreads: v.optional(workerNumber(1, 'maxThreads'), Math.max(2, availableParallelism() + 1)),
+  /** 每个 Worker 可同时执行的任务数量。 */
+  concurrentTasksPerWorker: v.optional(workerNumber(1, 'concurrentTasksPerWorker'), 1),
+  /** Runner 等待队列允许容纳的最大任务数量。 */
+  maxQueue: v.optional(workerNumber(0, 'maxQueue'), 12),
+
+  /** 非 Piscina 官方配置，任务从提交到完成的最长时间，0 表示不限制。 */
+  workerTaskTimeoutMs: v.optional(workerNumber(0, 'workerTaskTimeoutMs'), 30_000),
+})
+
+export type WorkerConfig = v.InferOutput<typeof $S_WorkerConfig>
+
+export const workerConfig = defineSchemaConfig($S_WorkerConfig)

package/templates/hono-server/libs/definition/src/configs/index.ts

@@ -0,0 +1,5 @@
+export * from './defs/runtime'
+export * from './defs/log'
+export * from './defs/middleware'
+export * from './defs/worker'
+export * from './defs/sqlite'

package/templates/hono-server/libs/definition/src/configs/proto.ts

@@ -0,0 +1,81 @@
+import { camelCase, constantCase, kebabCase, snakeCase } from 'change-case'
+import { type ObjectEntries, type ObjectSchema, type InferOutput, parse } from 'valibot'
+
+export type ConfigType = 'static' | 'schema'
+export type ContextCase = 'kebab' | 'camel' | 'env' | 'constantCase' | 'snake' | 'raw'
+
+const rawCaser = (str: string) => str || ''
+
+const caserMap: Record<ContextCase, (str: string) => string> = {
+  kebab: kebabCase,
+  camel: camelCase,
+  env: constantCase,
+  constantCase: constantCase,
+  snake: snakeCase,
+  raw: rawCaser,
+}
+
+export interface ConfigResolver<TParams, TValue> {
+  (...args: undefined extends TParams ? [params?: TParams] : [params: TParams]): TValue
+}
+
+export interface SchemaConfigResolverParams {
+  context: Record<string, any>
+  matchContextKey?: ContextCase | ((str: string) => string)
+}
+export type SchemaConfigResolver<TSchema extends ObjectSchema<ObjectEntries, any>> = ConfigResolver<
+  SchemaConfigResolverParams,
+  InferOutput<TSchema>
+>
+
+export interface AppConfig<TKind extends ConfigType, R extends ConfigResolver<any, any>> {
+  kind: TKind
+  resolve: R
+}
+
+export type StaticAppConfig<TValue> = AppConfig<'static', ConfigResolver<undefined, TValue>>
+
+export type SchemaAppConfig<TSchema extends ObjectSchema<ObjectEntries, any>> = AppConfig<
+  'schema',
+  SchemaConfigResolver<TSchema>
+> & {
+  schema: TSchema
+}
+
+export const createSchemaResolver = <TSchema extends ObjectSchema<ObjectEntries, any>>(
+  schema: TSchema,
+): SchemaConfigResolver<TSchema> => {
+  return ({ context, matchContextKey }) => {
+    const caser =
+      typeof matchContextKey === 'function'
+        ? matchContextKey
+        : (matchContextKey && caserMap[matchContextKey]) || rawCaser
+
+    const depKeys = Object.keys(schema.entries)
+    const filteredInput: Record<string, any> = {}
+    for (const key of depKeys) {
+      const fromKey = caser(key)
+      if (fromKey) filteredInput[key] = context[fromKey]
+    }
+
+    const parsed = parse(schema, filteredInput)
+    return parsed
+  }
+}
+
+export const defineStaticConfig = <TValue>(resolver: () => TValue): StaticAppConfig<TValue> => {
+  return {
+    kind: 'static',
+    resolve: resolver,
+  }
+}
+
+export const defineSchemaConfig = <TSchema extends ObjectSchema<ObjectEntries, any>>(
+  schema: TSchema,
+): SchemaAppConfig<TSchema> => {
+  return {
+    kind: 'schema',
+    schema: schema,
+    resolve: createSchemaResolver(schema),
+  }
+}

package/templates/hono-server/libs/definition/src/configs/schema.ts

@@ -0,0 +1,23 @@
+import * as v from 'valibot'
+
+export const $S_NonEmptyString = v.pipe(v.string(), v.minLength(1))
+
+export const $S_BooleanString = v.pipe(
+  v.optional(
+    v.pipe(
+      v.string(),
+      v.check((value) => value === 'true' || value === 'false', 'Expected true or false'),
+    ),
+  ),
+  v.transform((value) => value !== 'false'),
+)
+
+export const $S_NumberString = (defaultValue: number) =>
+  v.optional(
+    v.pipe(
+      v.string(),
+      v.check((value) => Number.isFinite(Number(value)), 'Expected a numeric string'),
+      v.transform(Number),
+    ),
+    String(defaultValue),
+  )

package/templates/hono-server/libs/definition/src/modules/example/index.ts

@@ -0,0 +1,16 @@
+export type Example = {
+  id: string
+  message: string
+  createdAt: string
+  updatedAt: string
+}
+
+export type CreateExampleInput = Pick<Example, 'message'>
+
+export type ProcessExampleInput = Pick<Example, 'message'>
+
+export type ProcessExampleOutput = {
+  original: string
+  normalized: string
+  length: number
+}

package/templates/hono-server/libs/definition/src/modules/index.ts

@@ -0,0 +1 @@
+export * from './example'

package/templates/hono-server/libs/definition/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "@oyolincc/dev-config/tsconfig.bundler.json",
+  "files": [],
+  "include": ["src", "./*.ts", "./*.mts"]
+}

package/templates/hono-server/libs/definition/vite.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite-plus'
+import { packConfig } from '@oyolincc/dev-config'
+
+export default defineConfig({
+  test: {
+    clearMocks: false,
+  },
+  pack: {
+    ...packConfig,
+    entry: {
+      backend: 'src/backend.ts',
+    },
+    exports: false,
+  },
+})

package/templates/hono-server/oyo.config.json

@@ -0,0 +1,13 @@
+{
+  "env": {
+    "dir": "./envs/",
+    "presets": {
+      "server": [".env.server", ".env.sqlite"],
+      "sqlite": [".env.sqlite"],
+      "sqlite-d1": [".env.sqlite-d1"]
+    }
+  },
+  "codeGenerator": {
+    "root": "."
+  }
+}

package/templates/hono-server/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "repo",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "prepare": "vp config",
+    "changeset": "vp exec changeset",
+    "build": "turbo build",
+    "build:libs": "turbo build --filter=!@repo/stack --filter=!@repo/server"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "catalog:",
+    "@changesets/cli": "catalog:",
+    "@oyolincc/cli": "catalog:",
+    "@oyolincc/dev-config": "catalog:",
+    "@types/node": "catalog:",
+    "tsx": "catalog:",
+    "turbo": "catalog:",
+    "vite-plus": "catalog:"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "packageManager": "pnpm@11.25.0"
+}

package/templates/hono-server/pnpm-workspace.yaml

@@ -0,0 +1,66 @@
+packages:
+  - apps/*
+  - libs/*
+
+catalogMode: prefer
+catalogPrune: true
+
+catalog:
+  '@changesets/changelog-github': '0.5.0'
+  '@changesets/cli': '2.27.12'
+  '@cloudflare/vite-plugin': '1.62.5'
+  '@oyolincc/cli': '2.1.3'
+  '@oyolincc/dev-config': '0.1.1'
+  '@oyolincc/env-loader': '^0.2.0'
+  '@types/node': '^24'
+  'concurrently': '^10.0.5'
+  'dotenv': '17.2.3'
+  'tsx': '4.21.0'
+  'turbo': '^2.9.14'
+  'typescript': '7.0.2'
+  'vite': 'npm:@voidzero-dev/vite-plus-core@1.0.0'
+  'vite-plus': '1.0.0'
+  'wrangler': '4.147.0'
+
+catalogs:
+  shared:
+    '@types/string-template': '^1.0.7'
+    'change-case': '^5.4.4'
+    'defu': '^6.1.7'
+    'ky': '^2.0.2'
+    'string-template': '^1.0.0'
+    'valibot': '^1.4.2'
+    'yaml': '^2.8.1'
+  server:
+    '@hono/node-server': '^2.1.0'
+    '@hono/standard-validator': '^0.4.0'
+    '@hono/swagger-ui': '^0.6.1'
+    '@hono/vite-dev-server': '^0.26.1'
+    '@valibot/to-json-schema': '^1.7.1'
+    'hono': '^4.13.1'
+    'hono-openapi': '^1.3.3'
+    'hono-pino': '^0.10.3'
+    'hono-problem-details': '^0.11.0'
+    'pino': '^10.3.1'
+    'pino-pretty': '^13.1.3'
+    'pino-roll': '^4.0.0'
+    'piscina': '^5.3.0'
+  db:
+    '@types/better-sqlite3': '^7.6.13'
+    'better-sqlite3': '^12.11.1'
+    'drizzle-kit': '1.0.0-rc.4'
+    'drizzle-orm': '1.0.0-rc.4'
+
+overrides:
+  'vite@*': 'catalog:'
+
+peerDependencyRules:
+  allowAny:
+    - 'vite'
+  allowedVersions:
+    'vite': '*'
+
+allowBuilds:
+  'better-sqlite3': true
+  'esbuild': true
+  'workerd': true

package/templates/hono-server/scripts/.env.example.docker

@@ -0,0 +1,4 @@
+BUILD_TAG=local
+SERVER_IMAGE=repo/hono-server
+DOCKER_PLATFORM=linux/amd64
+

package/templates/hono-server/scripts/build-docker-server.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+source "${SCRIPT_DIR}/common.sh"
+if [ -f "${SCRIPT_DIR}/.env.docker" ]; then read_env "${SCRIPT_DIR}/.env.docker"; fi
+BUILD_TAG=${INLINE_BUILD_TAG:-${BUILD_TAG:-local}}
+SERVER_IMAGE=${SERVER_IMAGE:-repo/hono-server}
+docker buildx build --platform "${DOCKER_PLATFORM:-linux/amd64}" --load \
+  -t "${SERVER_IMAGE}:${BUILD_TAG}" \
+  -f "${REPO_ROOT}/docker/server.Dockerfile" \
+  "${REPO_ROOT}"
+

package/templates/hono-server/scripts/common.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+read_env() {
+  local env_path=$1
+  if [ -z "$env_path" ] || [ ! -f "$env_path" ]; then
+    echo "Environment file not found: $env_path" >&2
+    return 1
+  fi
+  set -a
+  . "$env_path"
+  set +a
+}
+
+require_env() {
+  local name=$1
+  local value
+  eval "value=\${${name}:-}"
+  if [ -z "$value" ]; then echo "${name} is required" >&2; return 1; fi
+}
+

package/templates/hono-server/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@oyolincc/dev-config/tsconfig.bundler.json",
+  "include": ["./*.ts"]
+}

package/templates/hono-server/turbo.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "tasks": {
+    "dev": {
+      "dependsOn": ["^build"],
+      "cache": false,
+      "persistent": true
+    },
+    "dev:node": {
+      "dependsOn": ["^build"],
+      "env": ["DEPLOY_TARGET"],
+      "cache": false,
+      "persistent": true
+    },
+    "dev:cloudflare": {
+      "dependsOn": ["^build"],
+      "env": ["DEPLOY_TARGET"],
+      "cache": false,
+      "persistent": true
+    },
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": ["dist/**", ".output/**"]
+    },
+    "build:node": {
+      "dependsOn": ["^build"],
+      "env": ["DEPLOY_TARGET"],
+      "outputs": ["dist/**", ".output/**"]
+    },
+    "build:cloudflare": {
+      "dependsOn": ["^build"],
+      "env": ["DEPLOY_TARGET"],
+      "outputs": ["dist/**", ".output/**"]
+    }
+  }
+}

package/templates/hono-server/vite.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vite-plus'
+import { lintConfig, fmtConfig } from '@oyolincc/dev-config'
+
+export default defineConfig({
+  create: { defaultTemplate: '@oyolincc' },
+  staged: {
+    '*': 'vp check --fix',
+  },
+  fmt: fmtConfig,
+  lint: lintConfig,
+  run: {
+    cache: false,
+  },
+})

package/templates/monorepo/.agents/skills/ask-matt/PHASE-BOUNDARIES.md

@@ -0,0 +1,55 @@
+# Phase boundaries
+
+A **phase** is a chunk of work inside a session — the grilling, the implementation, the QA. The definition is fuzzy on purpose: a phase ends when you think *"ok, we're done with that"*.
+
+The **phase boundary** is the gap between two phases, and it is the only place this decision belongs. Mid-phase there is no decision to make — continue, or split the work that's left into subagents. Compacting mid-phase makes the agent lose the thread.
+
+## The five options
+
+| Option       | What it does                                                    |
+| ------------ | --------------------------------------------------------------- |
+| **Continue** | Stay in the session. No context switch at all.                    |
+| **`/clear`** | Empty the context window and start from nothing.                  |
+| **`/handoff`** | Write a portable markdown file and seed a session anywhere with it. |
+| **Subagent** | Send the task to its own context window and get a report back.     |
+| **`/compact`** | Compress this context and seed a fresh session with the summary.  |
+
+## The tree
+
+Work top to bottom at the boundary. The first **yes** wins.
+
+**1. Can you continue in this session?** Two things make the answer yes: the next phase needs this phase as a **primary source**, or you have enough [smart zone](https://www.aihero.dev/ai-coding-dictionary/smart-zone) left (~150k tokens) for the next phase to fit. Grilling → implementation is the standard yes: the implementation wants the reasoning verbatim, not a summary of it. Continue costs nothing and loses nothing, so rule it out before anything else.
+
+**2. Is the context irrelevant to what comes next?** Is everything in this session — the exploration, the decisions, the dead ends — disposable? If so, **`/clear`**. It is the cheapest move on the board: it takes no time and hands back the whole window. `/clear` also isn't terminal — the old session stays resumable.
+
+The cost of getting this wrong is one-way. Clear a *relevant* context and you lose the **why** behind what you built, and no amount of reading the diff back gets it returned.
+
+**3. Do you need to hand off?** `/handoff` is narrow. You need it only when you are:
+
+- swapping to a **new harness** (Claude → Codex),
+- moving to a **new directory** or repo,
+- sending the work to a **colleague**,
+- or forking a side task you found **mid-phase** without derailing what you're doing.
+
+That list is the whole clause. What `/handoff` buys is **portability** — a file that travels. If nothing is travelling, you don't need it.
+
+**4. Can the task be done AFK?** Is it scoped tightly enough to run with you away from the keyboard, no steering? Then send it to a **subagent** and leave this session untouched. Automated review is the standard case: the agent reads the diff and reports, and you aren't needed while it does.
+
+**5. Otherwise, `/compact`.** Relevant context, same harness, same directory, and you need to stay in the loop — this is where the tree lands, and it lands here often. Pass it an instruction (`/compact we're going to QA this area`) so the summary keeps what the next phase needs.
+
+`/compact` is the **default, not the first reach**. It sits at the bottom because the four questions above it are all cheaper or more precise. The failure mode when people start here is a fresh session that is confidently wrong about a decision the summary flattened.
+
+## Primary and secondary sources
+
+Every move except **Continue** turns a **primary source** into a **secondary source** — the session as it happened, replaced by a summary of it. The trade is always the same shape:
+
+| Source                            | Information | Noise | Room to move |
+| --------------------------------- | ----------- | ----- | ------------ |
+| Primary (Continue)                | Full        | Lots  | Little       |
+| Secondary (`/compact`, `/handoff`) | Lossy       | Less  | Lots         |
+
+This is why question 1 comes first. You only pay the lossiness when staying costs more than it saves.
+
+## These are judgement calls
+
+The questions are not objective — each has taste in it, and the same boundary can go two ways on two days. The value is in asking them **in order**, at the boundary rather than in the middle of the work.