@nilejs/cli 0.0.7 → 1.0.1

package/README.md

@@ -2,187 +2,122 @@
 
 [![NPM Version](https://img.shields.io/npm/v/@nilejs/cli.svg)](https://www.npmjs.com/package/@nilejs/cli)
 
-CLI for scaffolding and generating [Nile](https://github.com/nile-js/nile/tree/main/packages/nile) backend projects.
+Create [Nile Js](https://nile-js.github.io/nile/) projects and generate services, actions and schemas.
 
-## Install
-
-```bash
-bun add -g @nilejs/cli
-```
-
-```bash
-npm install -g @nilejs/cli
-```
-
-Or use without installing:
+## Create a project
 
 ```bash
 bunx @nilejs/cli new my-app
+cd my-app
+bun install
+cp .env.example .env
+bun run dev
 ```
 
-```bash
-npx @nilejs/cli new my-app
-```
-
-## Commands
-
-### `nile new <project-name>`
-
-Scaffold a new Nile project. Copies the project template, replaces placeholders with your project name, and prints next steps.
-
-```bash
-nile new my-app
-```
-
-Output:
-
-```
-Creating project: my-app
-
-  Copying project files...
-  Configuring project...
-  Project "my-app" created.
+The server starts on `http://localhost:8000`. The starter stores its data in an embedded PGlite database, so there is no database server to install. The [getting started guide](https://nile-js.github.io/nile/guide/start/getting-started/) walks through the starter step by step.
 
-Next steps:
+The starter includes:
 
-    cd my-app
-    bun install
-    cp .env.example .env
-    bun run dev
-```
+- `src/index.ts`: server entry point on Bun's native HTTP server, with a logger and an `onBoot` schema push
+- `src/db/`: PGlite and Drizzle client, the `tasks` table and a `taskModel` built with `createModel`
+- `src/services/`: an explicit registry and domain entry point for a `tasks` service with create, list, get, update and delete actions
+- `Dockerfile`, `docker-compose.yml` and `docker-compose.dev.yml` for container deployments
+- `drizzle.config.ts`, `.env.example`, `tsconfig.json` and `package.json`
 
-The scaffolded project includes:
+## Generate code
 
-- `src/index.ts`, server entry with PGLite and Drizzle
-- `src/db/`, database client, schema, types, and a `tasks` model using `createModel`
-- `src/services/`, a `tasks` service with five CRUD actions
-- `drizzle.config.ts`, `.env.example`, `tsconfig.json`, `package.json`
+Run the generators from the project root. The starter's `gen` script calls the CLI for you.
 
-### `nile generate service <name>`
+| Command | Description |
+|---|---|
+| `bun run gen service <name>` | Add a service with a sample action |
+| `bun run gen action <service> <name>` | Add an action to an existing service |
+| `bun run gen action <service> <name> --folder` | Add an action in its own folder, for private helper modules |
+| `bun run gen schema` | Generate Zod schemas and TypeScript types from your actions |
 
-Alias: `nile gen service <name>`
+`generate` also has the alias `gen`, so `bunx @nilejs/cli gen service users` works outside the starter.
 
-Generate a new service directory under `src/services/` with a demo action and barrel export. Run this from the project root.
+### Services
 
 ```bash
-nile gen service users
+bun run gen service users
 ```
 
 Creates:
 
-```
+```text
 src/services/users/
-  sample.ts       # Demo action with Zod schema, handler, and createAction
-  index.ts        # Barrel export
+  actions/sample.ts   Sample action with a schema, an input type and a named handler
+  index.ts            Registers the service and its public actions
 ```
 
-After creating the files, the CLI asks whether to auto-register the service in `src/services/services.config.ts`. If you accept, it adds the import and service entry. If you decline, it prints the snippet to add manually.
+The CLI then asks whether to register the service in `src/services/services.config.ts`. If you decline, it prints the lines to add yourself.
 
-### `nile generate action <service-name> <action-name>`
-
-Alias: `nile gen action <service-name> <action-name>`
-
-Generate a new action file in an existing service directory.
+### Actions
 
 ```bash
-nile gen action users get-user
+bun run gen action users get-user
 ```
 
-Creates `src/services/users/get-user.ts` with:
+Creates `src/services/users/actions/get-user.ts`:
 
-```typescript
-import { type Action, createAction } from "@nilejs/nile";
-import { Ok } from "slang-ts";
+```ts
+import { createAction } from "@nilejs/nile";
+import { Ok } from "@nilejs/nile/fp";
 import z from "zod";
 
 const getUserSchema = z.object({
-  // Define your validation schema here
+  // Describe the input this action accepts
 });
 
-const getUserHandler = async (data: Record<string, unknown>) => {
-  // Implement your users.get-user logic here
-  return Ok({ result: data });
+type GetUserInput = z.infer<typeof getUserSchema>;
+
+const getUserHandler = async (input: GetUserInput) => {
+  // Implement users.get-user here
+  return Ok({ result: input });
 };
 
-export const getUserAction: Action = createAction({
+export const getUserAction = createAction<GetUserInput>({
   name: "get-user",
   description: "GetUser action for users",
-  handler: getUserHandler,
   validation: getUserSchema,
+  handler: getUserHandler,
 });
 ```
 
-Kebab-case names are converted to camelCase for variables and PascalCase for types.
-
-### `nile generate schema`
-
-Alias: `nile gen schema`
+Kebab-case names become camelCase variables and PascalCase types. Register the action by importing it in `src/services/users/index.ts` and adding it to the service’s `actions` list. The root registry imports services, not individual actions.
 
-Extract Zod validation schemas from your action definitions and generate TypeScript files with schema exports and inferred types.
+### Schemas and types
 
 ```bash
-nile gen schema
+bun run gen schema
 ```
 
-The command auto-detects `src/services/services.config.ts`. If the file is not found, it prompts for the path. It spawns a `bun` subprocess to import your services config, extracts JSON Schema from each action's validation field, and converts them back to Zod code strings.
-
-Output (default `src/generated/`):
-
-- `schemas.ts` — named Zod schema exports (`tasksCreateSchema`, `tasksUpdateSchema`, etc.)
-- `types.ts` — TypeScript types via `z.infer` (`TasksCreatePayload`, `TasksUpdatePayload`, etc.)
+Reads every action's validation schema from `src/services/services.config.ts` and writes:
 
-Options:
+- `src/generated/schemas.ts`: named Zod schemas, such as `tasksCreateSchema`
+- `src/generated/types.ts`: input types, such as `TasksCreatePayload`
 
 | Flag | Description |
 |---|---|
-| `-e, --entry <path>` | Path to services config (auto-detected by default) |
+| `-e, --entry <path>` | Path to the services config (detected by default) |
 | `-o, --output <path>` | Output directory (default: `src/generated`) |
 
-Actions without a `validation` schema are skipped and listed in the CLI output.
+Actions without a validation schema are skipped and listed in the output. Share the generated files with a frontend to validate forms with the same rules as the server.
 
-Requires [Bun](https://bun.sh) installed for the extraction subprocess.
+## Current starter
 
-### Quick Reference
+CLI 1.0.1 targets Nile `^1.0.4`, Zod 4, TypeScript 7 and the Drizzle model helpers. The generated layout passes Nile’s strict boot checks. Database setup returns a Result and prevents startup on failure; shutdown drains Nile’s work before closing PGlite. Helpers are available as `utils.createModel`, and Result helpers come from `@nilejs/nile/fp`.
 
-| Command | Description |
-|---|---|
-| `nile new <name>` | Scaffold a new project |
-| `nile gen service <name>` | Add a service with a demo action |
-| `nile gen action <service> <name>` | Add an action to an existing service |
-| `nile gen schema` | Generate Zod schemas and TypeScript types |
+Existing apps are not rewritten when the CLI updates. For an older starter, add a service entry point at `src/services/<domain>/index.ts`, register its actions there, and import that service from `services.config.ts`. [Nile’s migration notes](https://github.com/nile-js/nile/blob/main/packages/nile/docs/release-migration.md) describe the current error and startup behavior.
 
-## Generated Project Structure
+## Coding assistants
 
-```
-my-app/
-  package.json
-  tsconfig.json
-  drizzle.config.ts
-  .env.example
-  src/
-    index.ts
-    db/
-      client.ts
-      schema.ts
-      types.ts
-      index.ts
-      models/
-        tasks.ts
-        index.ts
-    services/
-      services.config.ts
-      tasks/
-        create.ts
-        list.ts
-        get.ts
-        update.ts
-        delete.ts
-```
+The starter includes `SKILL.md` with the current Nile action pattern, service layout, Results, access policies and client calls. Ask your assistant to read it before changing the backend. After updating Nile, use the version shipped at `node_modules/@nilejs/nile/SKILL.md`.
 
 ## Requirements
 
-- Node.js 18+ or Bun
-- The scaffolded project uses Bun as its runtime (`Bun.serve`, `bun run`)
+- [Bun](https://bun.sh) 1.4.2 or later. The starter runs on Bun, and `gen schema` imports your services with Bun.
 
 ## License
 

package/dist/index.js

@@ -3,6 +3,8 @@
 // src/index.ts
 import { resolve as resolve6 } from "node:path";
 import { Command } from "commander";
+// package.json
+var version = "1.0.1";
 
 // src/commands/generate-action.ts
 import { resolve } from "node:path";
@@ -87,47 +89,60 @@ var toPascalCase = (str) => {
 var generateActionContent = (actionName, serviceName) => {
   const camel = toCamelCase(actionName);
   const pascal = toPascalCase(actionName);
-  return `import { type Action, createAction } from "@nilejs/nile";
-import { Ok } from "slang-ts";
+  return `import { createAction } from "@nilejs/nile";
+import { Ok } from "@nilejs/nile/fp";
 import z from "zod";
 
 const ${camel}Schema = z.object({
-  // Define your validation schema here
+  // Describe the input this action accepts
 });
 
-const ${camel}Handler = async (data: Record<string, unknown>) => {
-  // Implement your ${serviceName}.${actionName} logic here
-  return Ok({ result: data });
+type ${pascal}Input = z.infer<typeof ${camel}Schema>;
+
+const ${camel}Handler = async (input: ${pascal}Input) => {
+  // Implement ${serviceName}.${actionName} here
+  return Ok({ result: input });
 };
 
-export const ${camel}Action: Action = createAction({
+export const ${camel}Action = createAction<${pascal}Input>({
   name: "${actionName}",
   description: "${pascal} action for ${serviceName}",
-  handler: ${camel}Handler,
   validation: ${camel}Schema,
+  handler: ${camel}Handler,
 });
 `;
 };
-var generateActionCommand = async (serviceName, actionName) => {
+var generateActionCommand = async (serviceName, actionName, options = {}) => {
   const serviceDir = resolve(process.cwd(), "src/services", serviceName);
   if (!pathExists(serviceDir)) {
     error(`Service "${serviceName}" not found at src/services/${serviceName}/`);
     hint(`Create the service first: nile generate service ${serviceName}`);
     process.exit(1);
   }
-  const actionFile = resolve(serviceDir, `${actionName}.ts`);
-  if (pathExists(actionFile)) {
+  const relative = options.folder ? `actions/${actionName}/${actionName}.ts` : `actions/${actionName}.ts`;
+  const actionFile = resolve(serviceDir, relative);
+  const existingEntries = [
+    actionFile,
+    resolve(serviceDir, `${actionName}.ts`),
+    resolve(serviceDir, `actions/${actionName}.ts`),
+    resolve(serviceDir, `actions/${actionName}/${actionName}.ts`)
+  ];
+  if (existingEntries.some(pathExists)) {
     error(`Action file "${actionName}.ts" already exists in src/services/${serviceName}/`);
     process.exit(1);
   }
   brand();
   const spinner = createSpinner(`Creating action ${actionName}...`);
   await writeFileSafe(actionFile, generateActionContent(actionName, serviceName));
-  spinner.stop(`Action created at src/services/${serviceName}/${actionName}.ts`);
+  if (options.folder) {
+    await writeFileSafe(resolve(serviceDir, `actions/${actionName}/index.ts`), `export { ${toCamelCase(actionName)}Action } from "./${actionName}";
+`);
+  }
+  spinner.stop(`Action created at src/services/${serviceName}/${relative}`);
   const camel = toCamelCase(actionName);
   console.log("");
-  hint("Register the action in your service config:");
-  hint(`  import { ${camel}Action } from "./${serviceName}/${actionName}";`);
+  hint("Import the action in your service index.ts and add it to actions:");
+  hint(`  import { ${camel}Action } from "./actions/${actionName}";`);
   outro();
 };
 
@@ -143,15 +158,15 @@ var confirmPrompt = (question, defaultYes = true) => {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     rl.question(`  ${question} ${suffix} `, (answer) => {
       rl.close();
       const trimmed = answer.trim().toLowerCase();
       if (trimmed === "") {
-        resolve2(defaultYes);
+        resolve(defaultYes);
         return;
       }
-      resolve2(trimmed === "y" || trimmed === "yes");
+      resolve(trimmed === "y" || trimmed === "yes");
     });
   });
 };
@@ -160,10 +175,10 @@ var inputPrompt = (question) => {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     rl.question(`  ${question} `, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve(answer.trim());
     });
   });
 };
@@ -171,12 +186,14 @@ var inputPrompt = (question) => {
 // src/utils/schema-codegen.ts
 import { jsonSchemaToZod } from "json-schema-to-zod";
 var toSchemaExportName = (service, action) => {
-  const pascalAction = action.charAt(0).toUpperCase() + action.slice(1);
+  const camelAction = toCamelCase2(action);
+  const pascalAction = camelAction.charAt(0).toUpperCase() + camelAction.slice(1);
   return `${toCamelCase2(service)}${pascalAction}Schema`;
 };
 var toTypeExportName = (service, action) => {
   const pascalService = toCamelCase2(service).charAt(0).toUpperCase() + toCamelCase2(service).slice(1);
-  const pascalAction = action.charAt(0).toUpperCase() + action.slice(1);
+  const camelAction = toCamelCase2(action);
+  const pascalAction = camelAction.charAt(0).toUpperCase() + camelAction.slice(1);
   return `${pascalService}${pascalAction}Payload`;
 };
 var toCamelCase2 = (str) => str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
@@ -243,7 +260,7 @@ var generateTypesFile = (extraction) => {
     ""
   ];
   for (const entry of entries) {
-    lines.push(`export type ${entry.typeName} = z.infer<typeof ${entry.exportName}>;`);
+    lines.push(`export type ${entry.typeName} = z.input<typeof ${entry.exportName}>;`);
   }
   lines.push("");
   lines.push("/** Map of all services and their action payloads for @nilejs/client */");
@@ -290,7 +307,7 @@ for (const service of services) {
     }
 
     try {
-      const jsonSchema = z.toJSONSchema(action.validation, { unrepresentable: "any" });
+      const jsonSchema = z.toJSONSchema(action.validation, { unrepresentable: "any", io: "input" });
       serviceSchemas[action.name] = jsonSchema;
     } catch {
       skipped.push(\`\${service.name}.\${action.name}\`);
@@ -313,7 +330,7 @@ var extractSchemas = (configPath, projectRoot) => {
   const importPath = resolveImportPath(configPath, projectRoot);
   const scriptContent = buildExtractionScript(importPath);
   const tempScriptPath = resolve2(projectRoot, TEMP_SCRIPT_NAME);
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve, reject) => {
     writeFile2(tempScriptPath, scriptContent, "utf-8").then(() => {
       execFile("bun", ["run", TEMP_SCRIPT_NAME], { cwd: projectRoot, timeout: 30000 }, (err, stdout, stderr) => {
         unlink(tempScriptPath).catch(() => {});
@@ -325,7 +342,7 @@ ${message}`));
         }
         try {
           const result = JSON.parse(stdout.trim());
-          resolve3(result);
+          resolve(result);
         } catch {
           reject(new Error(`Failed to parse extraction output. Raw output:
 ${stdout.trim()}`));
@@ -347,12 +364,12 @@ var DEFAULT_OUTPUT_DIR = "src/generated";
 var LEADING_SLASH2 = /^\//;
 var resolveConfigPath = async (projectRoot, entryFlag) => {
   if (entryFlag) {
-    const absolute2 = resolve3(projectRoot, entryFlag);
-    if (!pathExists(absolute2)) {
+    const absolute = resolve3(projectRoot, entryFlag);
+    if (!pathExists(absolute)) {
       error(`Config file not found: ${entryFlag}`);
       return null;
     }
-    return absolute2;
+    return absolute;
   }
   const detected = findServicesConfig(projectRoot);
   if (detected) {
@@ -439,39 +456,45 @@ var toPascalCase2 = (str) => {
 var generateActionContent2 = (serviceName) => {
   const camel = toCamelCase3(serviceName);
   const pascal = toPascalCase2(serviceName);
-  return `import { type Action, createAction } from "@nilejs/nile";
-import { Ok } from "slang-ts";
+  return `import { createAction } from "@nilejs/nile";
+import { Ok } from "@nilejs/nile/fp";
 import z from "zod";
 
 const sample${pascal}Schema = z.object({
   name: z.string().min(1, "Name is required"),
 });
 
-const sample${pascal}Handler = async (data: Record<string, unknown>) => {
-  return Ok({ ${camel}: { name: data.name } });
+type Sample${pascal}Input = z.infer<typeof sample${pascal}Schema>;
+
+const sample${pascal}Handler = async (input: Sample${pascal}Input) => {
+  return Ok({ ${camel}: { name: input.name } });
 };
 
-export const sample${pascal}Action: Action = createAction({
+export const sample${pascal}Action = createAction<Sample${pascal}Input>({
   name: "sample",
   description: "Sample ${serviceName} action",
-  handler: sample${pascal}Handler,
   validation: sample${pascal}Schema,
+  handler: sample${pascal}Handler,
 });
 `;
 };
 var generateBarrelContent = (serviceName) => {
   const pascal = toPascalCase2(serviceName);
-  return `export { sample${pascal}Action } from "./sample";
+  const camel = toCamelCase3(serviceName);
+  return `import { createService } from "@nilejs/nile";
+import { sample${pascal}Action } from "./actions/sample";
+
+export const ${camel}Service = createService({
+  name: "${serviceName}",
+  description: "${pascal} service",
+  actions: [sample${pascal}Action],
+});
 `;
 };
 var generateConfigSnippet = (serviceName) => {
-  const pascal = toPascalCase2(serviceName);
-  const importLine = `import { sample${pascal}Action } from "./${serviceName}/sample";`;
-  const serviceEntry = `  {
-    name: "${serviceName}",
-    description: "${pascal} service",
-    actions: [sample${pascal}Action],
-  },`;
+  const camel = toCamelCase3(serviceName);
+  const importLine = `import { ${camel}Service } from "./${serviceName}";`;
+  const serviceEntry = `  ${camel}Service,`;
   return `${importLine}
 
 // Add to services array:
@@ -480,8 +503,8 @@ ${serviceEntry}`;
 var autoRegisterService = async (configPath, serviceName) => {
   try {
     let content = await readFileContent(configPath);
-    const pascal = toPascalCase2(serviceName);
-    const importLine = `import { sample${pascal}Action } from "./${serviceName}/sample";`;
+    const camel = toCamelCase3(serviceName);
+    const importLine = `import { ${camel}Service } from "./${serviceName}";`;
     const importLines = content.split(`
 `).filter((line) => line.startsWith("import "));
     if (importLines.length === 0) {
@@ -493,17 +516,18 @@ var autoRegisterService = async (configPath, serviceName) => {
     }
     content = content.replace(lastImport, `${lastImport}
 ${importLine}`);
-    const serviceEntry = `  {
-    name: "${serviceName}",
-    description: "${pascal} service",
-    actions: [sample${pascal}Action],
-  },`;
-    const closingIndex = content.lastIndexOf("];");
+    const serviceEntry = `  ${camel}Service,`;
+    const wrappedClosingIndex = content.lastIndexOf("]);");
+    const plainClosingIndex = content.lastIndexOf("];");
+    const closingIndex = Math.max(wrappedClosingIndex, plainClosingIndex);
     if (closingIndex === -1) {
       return false;
     }
-    content = content.slice(0, closingIndex) + serviceEntry + `
-` + content.slice(closingIndex);
+    const prefix = content.slice(0, closingIndex).trimEnd();
+    const separator = prefix.endsWith("[") || prefix.endsWith(",") ? "" : ",";
+    content = `${prefix}${separator}
+${serviceEntry}
+${content.slice(closingIndex)}`;
     await writeFileSafe(configPath, content);
     return true;
   } catch {
@@ -525,7 +549,7 @@ var generateServiceCommand = async (serviceName) => {
   brand();
   const spinner = createSpinner(`Creating service ${serviceName}...`);
   await ensureDir(serviceDir);
-  await writeFileSafe(resolve4(serviceDir, "sample.ts"), generateActionContent2(serviceName));
+  await writeFileSafe(resolve4(serviceDir, "actions/sample.ts"), generateActionContent2(serviceName));
   await writeFileSafe(resolve4(serviceDir, "index.ts"), generateBarrelContent(serviceName));
   spinner.stop(`Service created at src/services/${serviceName}/`);
   const configPath = resolve4(servicesDir, "services.config.ts");
@@ -557,6 +581,7 @@ ${generateConfigSnippet(serviceName)}
 };
 
 // src/commands/new.ts
+import { rename } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
 var __dirname2 = fileURLToPath(new URL(".", import.meta.url));
@@ -581,6 +606,10 @@ var newCommand = async (projectName) => {
   const spinner = createSpinner(`Creating ${projectName}...`);
   const templateDir = resolveTemplateDir();
   await copyDir(templateDir, targetDir);
+  const shippedGitignore = resolve5(targetDir, "gitignore");
+  if (pathExists(shippedGitignore)) {
+    await rename(shippedGitignore, resolve5(targetDir, ".gitignore"));
+  }
   const allFiles = await getFilesRecursive(targetDir);
   const replacements = { "{{projectName}}": projectName };
   for (const filePath of allFiles) {
@@ -597,9 +626,9 @@ var newCommand = async (projectName) => {
   hint("bun run dev");
   console.log("");
   success("Generate with the CLI:");
-  hint("nile g service <name>          Add a new service");
-  hint("nile g action <service> <name> Add an action to a service");
-  hint("nile g schema                  Generate Zod schemas & types");
+  hint("bun run gen service <name>          Add a new service");
+  hint("bun run gen action <service> <name>  Add an action to a service");
+  hint("bun run gen schema                   Generate Zod schemas and types");
   outro();
 };
 
@@ -613,10 +642,10 @@ var ensureDepsInstalled = () => {
   }
 };
 var program = new Command;
-program.name("nile").description("CLI for the Nile backend framework").version("0.0.1");
+program.name("nile").description("CLI for the Nile backend framework").version(version);
 program.command("new").argument("<project-name>", "Name of the project to create").description("Scaffold a new Nile project").action(newCommand);
 var generate = program.command("generate").alias("gen").description("Generate services and actions").hook("preAction", ensureDepsInstalled);
 generate.command("service").argument("<name>", "Service name (kebab-case recommended)").description("Generate a new service with a demo action").action(generateServiceCommand);
-generate.command("action").argument("<service-name>", "Name of the existing service").argument("<action-name>", "Name of the action to create").description("Generate a new action in an existing service").action(generateActionCommand);
+generate.command("action").argument("<service-name>", "Name of the existing service").argument("<action-name>", "Name of the action to create").description("Generate a new action in an existing service").option("--folder", "Create an action folder for private modules").action(generateActionCommand);
 generate.command("schema").option("-e, --entry <path>", "Path to services config file").option("-o, --output <path>", "Output directory for generated files").description("Generate Zod schemas and TypeScript types from action validations").action(generateSchemaCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nilejs/cli",
-  "version": "0.0.7",
+  "version": "1.0.1",
   "description": "CLI for scaffolding and generating Nile backend projects",
   "type": "module",
   "bin": {
@@ -10,10 +10,6 @@
     "dist",
     "template"
   ],
-  "scripts": {
-    "build": "bun run scripts/build.ts",
-    "dev": "bun run src/index.ts"
-  },
   "dependencies": {
     "commander": "^13.1.0",
     "json-schema-to-zod": "^2.7.0",
@@ -22,5 +18,11 @@
   "devDependencies": {
     "@types/node": "^22.8.1",
     "typescript": "^5"
+  },
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "dev": "bun run src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "export": "bun run typecheck && bun run build && node dist/index.js --version"
   }
-}
+}

package/template/Dockerfile

@@ -3,8 +3,7 @@ FROM oven/bun:1-alpine
 WORKDIR /app
 
 # Copy package files
-COPY package.json ./
-COPY bun.lockb ./
+COPY package.json bun.lock ./
 
 # Install production dependencies only
 RUN bun install --frozen-lockfile --production