@sohan_fahad/wilt 0.1.2

package/dist/lib/bin/wilt.js

@@ -0,0 +1,1151 @@
+#!/usr/bin/env node
+
+// bin/commands/new.ts
+import { mkdirSync, writeFileSync, existsSync } from "fs";
+import { join, resolve } from "path";
+import { execSync } from "child_process";
+function pascal(name) {
+  return name.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+function kebab(name) {
+  return name.replace(/([A-Z])/g, "-$1").replace(/^-/, "").replace(/_/g, "-").toLowerCase();
+}
+function packageJsonTemplate(name) {
+  return JSON.stringify(
+    {
+      name: kebab(name),
+      version: "0.0.1",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "vite dev --host --port 4001",
+        "dev:cf": "wrangler dev --port 4001",
+        build: "vite build",
+        deploy: "vite build && wrangler deploy",
+        "cf-typegen": "wrangler types --env-interface CloudflareBindings",
+        test: "vitest --run",
+        "test:watch": "vitest --watch",
+        "db:gen": "drizzle-kit generate",
+        "db:migrate": "wrangler d1 migrations apply DB --local",
+        "db:migrate:remote": "wrangler d1 migrations apply DB --remote",
+        check: "tsc --noEmit",
+        wilt: "wilt"
+      },
+      dependencies: {
+        hono: "^4.12.0",
+        wilt: "^0.1.0",
+        "reflect-metadata": "^0.2.2",
+        tsyringe: "^4.10.0",
+        zod: "^4.0.0",
+        "drizzle-orm": "^0.45.0",
+        ulid: "^3.0.0"
+      },
+      devDependencies: {
+        "@cloudflare/vite-plugin": "^1.36.0",
+        "@cloudflare/workers-types": "^4.0.0",
+        "@cloudflare/vitest-pool-workers": "^0.16.0",
+        "@sohan_fahad/wilt": "^0.1.0",
+        "@types/node": "^22.0.0",
+        "drizzle-kit": "^0.31.0",
+        typescript: "^5.0.0",
+        vite: "^6.0.0",
+        vitest: "^4.1.0",
+        tsx: "^4.0.0",
+        wrangler: "^4.0.0"
+      }
+    },
+    null,
+    2
+  );
+}
+function wranglerTemplate(name) {
+  return `{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "${kebab(name)}",
+  "main": "./src/index.ts",
+  "compatibility_date": "2025-06-17",
+  "compatibility_flags": ["nodejs_compat"],
+  "vars": {
+    "MODE": "development"
+  },
+  "observability": { "enabled": true },
+  "d1_databases": [
+    {
+      "binding": "DB",
+      "database_name": "REPLACE_WITH_YOUR_D1_NAME",
+      "database_id": "00000000-0000-0000-0000-000000000001",
+      "migrations_dir": "migrations",
+      "preview_database_id": "00000000-0000-0000-0000-000000000002"
+    }
+  ],
+  "dev": { "port": 4001 }
+}
+`;
+}
+function tsconfigTemplate() {
+  return `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "lib": ["ESNext", "DOM"],
+    "types": ["vite/client", "@cloudflare/workers-types"],
+    "baseUrl": ".",
+    "paths": {
+      "@app/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*", "worker-configuration.d.ts"],
+  "exclude": ["node_modules", "dist"]
+}
+`;
+}
+function viteConfigTemplate() {
+  return `import { defineConfig } from "vite";
+import { cloudflare } from "@cloudflare/vite-plugin";
+import { fileURLToPath, URL } from "node:url";
+
+export default defineConfig({
+  plugins: [cloudflare()],
+  resolve: {
+    alias: {
+      "@app": fileURLToPath(new URL("./src", import.meta.url)),
+    },
+  },
+});
+`;
+}
+function workerTypesTemplate() {
+  return `// Generated by \`pnpm cf-typegen\`. Do not edit manually.
+/// <reference types="@cloudflare/vitest-pool-workers/types" />
+interface CloudflareBindings {
+  DB: D1Database;
+  MODE: string;
+}
+
+declare namespace Cloudflare {
+  interface Env extends CloudflareBindings {
+    TEST_MIGRATIONS: string;
+  }
+}
+`;
+}
+function vitestConfigTemplate() {
+  return `import path from "path";
+import { defineConfig } from "vitest/config";
+import { cloudflarePool, cloudflareTest, readD1Migrations } from "@cloudflare/vitest-pool-workers";
+
+export default defineConfig(async () => {
+  const migrations = await readD1Migrations("./migrations");
+  const poolOptions = {
+    wrangler: { configPath: "./wrangler.jsonc" },
+    miniflare: {
+      bindings: { TEST_MIGRATIONS: JSON.stringify(migrations) },
+    },
+  };
+  return {
+    plugins: [cloudflareTest(poolOptions)],
+    resolve: {
+      alias: { "@app": path.resolve("./src") },
+    },
+    test: {
+      pool: cloudflarePool(poolOptions),
+    },
+  };
+});
+`;
+}
+function indexTemplate() {
+  return `import "reflect-metadata";
+import { app } from "./app.module";
+
+export default {
+  async fetch(request: Request, env: CloudflareBindings, ctx: ExecutionContext): Promise<Response> {
+    return app.fetch(request, env, ctx);
+  },
+};
+`;
+}
+function appModuleTemplate(name) {
+  const p = pascal(name);
+  return `import { cors } from "hono/cors";
+import { secureHeaders } from "hono/secure-headers";
+
+import { Module, createModule } from "wilt";
+import { requestLogger } from "wilt/middleware";
+import { HelloModule } from "./modules/app/hello/hello.module";
+
+@Module({
+  imports: [HelloModule],
+})
+export class AppModule {}
+
+const app = createModule(AppModule, {
+  middlewares: [cors(), secureHeaders(), requestLogger],
+});
+
+app.get("/", (c) => c.json({ success: true, status: "healthy", timestamp: new Date().toISOString() }));
+app.get("/health", (c) => c.json({ success: true, status: "healthy", timestamp: new Date().toISOString() }));
+
+export { app };
+`;
+}
+function helloModuleTemplate() {
+  return `import { Module } from "wilt";
+import { HelloController } from "./hello.controller";
+import { HelloService } from "./hello.service";
+
+@Module({
+  controllers: [HelloController],
+  providers: [HelloService],
+})
+export class HelloModule {}
+`;
+}
+function helloControllerTemplate() {
+  return `import type { Context } from "hono";
+import { Controller, Get, Inject } from "wilt";
+import { ResponseUtil } from "wilt";
+import { HelloService } from "./hello.service";
+
+@Controller("/hello")
+export class HelloController {
+  constructor(@Inject(HelloService) private helloService: HelloService) {}
+
+  @Get()
+  async greet(c: Context) {
+    const message = this.helloService.greet();
+    return ResponseUtil.success(c, { message });
+  }
+}
+`;
+}
+function helloServiceTemplate() {
+  return `import { Injectable } from "wilt";
+
+@Injectable()
+export class HelloService {
+  greet() {
+    return "Hello from Wilt!";
+  }
+}
+`;
+}
+function dbSchemaTemplate() {
+  return `// Register all your entity tables here so Drizzle can build relations and
+// drizzle-kit can generate migrations from a single source of truth.
+export const schema = {};
+`;
+}
+function dbConnectionTemplate() {
+  return `import { drizzle } from "drizzle-orm/d1";
+import type { Context } from "hono";
+import { schema } from "./schema";
+export function getDb(c: Context) {
+  return drizzle(c.env.DB, { schema: schema });
+}
+`;
+}
+function gitignoreTemplate() {
+  return `dist/
+node_modules/
+.wrangler
+.env
+.env.production
+.dev.vars
+.DS_Store
+coverage/
+*.log
+`;
+}
+function wiltConfigTemplate() {
+  return `import { defineConfig } from "wilt/config";
+
+export default defineConfig({
+  // Directory where generated modules are placed (relative to project root)
+  modulesDir: "src/modules/app",
+
+  // Default files scaffolded by \`wilt generate module <name>\`
+  // Remove "test" to skip test files, or pass --no-test at the CLI
+  generate: {
+    files: ["module", "controller", "service", "dto", "entity", "test"],
+  },
+});
+`;
+}
+function envExampleTemplate() {
+  return `CLOUDFLARE_ACCOUNT_ID=
+CLOUDFLARE_TOKEN=
+
+CLOUDFLARE_DATABASE_ID=
+`;
+}
+function drizzleConfigTemplate() {
+  return `import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./src/database/schema.ts",
+  out: "./migrations",
+  dialect: "sqlite",
+  driver: "d1-http",
+  dbCredentials: {
+    accountId: process.env.CLOUDFLARE_ACCOUNT_ID!,
+    databaseId: process.env.CLOUDFLARE_DATABASE_ID!,
+    token: process.env.CLOUDFLARE_TOKEN!,
+  },
+  verbose: true,
+  strict: true,
+});
+`;
+}
+function migrationTemplate() {
+  return `-- Initial migration
+-- Add your tables here
+`;
+}
+function migrationMetaTemplate(name) {
+  return JSON.stringify(
+    {
+      version: "5",
+      dialect: "sqlite",
+      entries: [
+        {
+          idx: 0,
+          version: "5",
+          when: Date.now(),
+          tag: "0000_initial",
+          breakpoints: true
+        }
+      ]
+    },
+    null,
+    2
+  );
+}
+function write(path, content) {
+  writeFileSync(path, content, "utf-8");
+  console.log(`  \u2714 ${path.replace(process.cwd() + "/", "")}`);
+}
+function dir(path) {
+  mkdirSync(path, { recursive: true });
+}
+function runNew(args) {
+  const [name] = args;
+  if (!name) {
+    console.error("  \u2717 Usage: wilt new <project-name>");
+    process.exit(1);
+  }
+  const projectDir = resolve(process.cwd(), name);
+  if (existsSync(projectDir)) {
+    console.error(`  \u2717 Directory already exists: ${projectDir}`);
+    process.exit(1);
+  }
+  console.log(`
+  Creating Wilt app "${name}"...
+`);
+  dir(join(projectDir, "src/modules/app/hello"));
+  dir(join(projectDir, "src/database"));
+  dir(join(projectDir, "migrations/meta"));
+  write(join(projectDir, "package.json"), packageJsonTemplate(name));
+  write(join(projectDir, "wrangler.jsonc"), wranglerTemplate(name));
+  write(join(projectDir, "tsconfig.json"), tsconfigTemplate());
+  write(join(projectDir, "vite.config.ts"), viteConfigTemplate());
+  write(join(projectDir, "vitest.config.ts"), vitestConfigTemplate());
+  write(join(projectDir, "worker-configuration.d.ts"), workerTypesTemplate());
+  write(join(projectDir, "wilt.config.ts"), wiltConfigTemplate());
+  write(join(projectDir, ".gitignore"), gitignoreTemplate());
+  write(join(projectDir, ".env.example"), envExampleTemplate());
+  write(join(projectDir, "drizzle.config.ts"), drizzleConfigTemplate());
+  write(join(projectDir, "src/index.ts"), indexTemplate());
+  write(join(projectDir, "src/app.module.ts"), appModuleTemplate(name));
+  write(join(projectDir, "src/modules/app/hello/hello.module.ts"), helloModuleTemplate());
+  write(join(projectDir, "src/modules/app/hello/hello.controller.ts"), helloControllerTemplate());
+  write(join(projectDir, "src/modules/app/hello/hello.service.ts"), helloServiceTemplate());
+  write(join(projectDir, "src/database/schema.ts"), dbSchemaTemplate());
+  write(join(projectDir, "src/database/connection.ts"), dbConnectionTemplate());
+  write(join(projectDir, "migrations/0000_initial.sql"), migrationTemplate());
+  write(join(projectDir, "migrations/meta/_journal.json"), migrationMetaTemplate(name));
+  console.log("\n  Installing dependencies...\n");
+  try {
+    const pm = detectPackageManager();
+    execSync(`${pm} install`, { cwd: projectDir, stdio: "inherit" });
+  } catch {
+    console.log("  \u26A0 Could not auto-install. Run `pnpm install` manually.\n");
+  }
+  console.log(`
+  \u2714 Project created!
+
+  Next steps:
+    cd ${name}
+    cp .env.example .env                   # fill in Cloudflare credentials
+    # Edit wrangler.jsonc: set database_name + database_id
+    pnpm db:migrate                        # apply local D1 migrations
+    pnpm dev                               # http://localhost:4001
+
+  Try it:
+    curl http://localhost:4001/health
+    curl http://localhost:4001/hello
+
+  Generate a new module:
+    pnpm wilt generate module posts
+`);
+}
+function detectPackageManager() {
+  try {
+    execSync("pnpm --version", { stdio: "ignore" });
+    return "pnpm";
+  } catch {
+  }
+  try {
+    execSync("bun --version", { stdio: "ignore" });
+    return "bun";
+  } catch {
+  }
+  return "npm";
+}
+
+// bin/generators/module.generator.ts
+import { writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+
+// bin/utils/paths.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+var PROJECT_ROOT = process.cwd();
+var SRC_DIR = join2(PROJECT_ROOT, "src");
+var MODULES_DIR = join2(SRC_DIR, "modules");
+var APP_MODULES_DIR = join2(MODULES_DIR, "app");
+var WRANGLER_JSONC = join2(PROJECT_ROOT, "wrangler.jsonc");
+var APP_MODULE_FILE = join2(SRC_DIR, "app.module.ts");
+function wiltImportPath() {
+  return "wilt";
+}
+function ensureDir(dir2) {
+  if (!existsSync2(dir2)) {
+    mkdirSync2(dir2, { recursive: true });
+  }
+}
+
+// bin/generators/module.generator.ts
+function toPascalCase(name) {
+  return name.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+function toCamelCase(name) {
+  const pascal2 = toPascalCase(name);
+  return pascal2.charAt(0).toLowerCase() + pascal2.slice(1);
+}
+function toKebabCase(name) {
+  return name.replace(/([A-Z])/g, "-$1").replace(/^-/, "").replace(/_/g, "-").toLowerCase();
+}
+function pluralize(name) {
+  return name.endsWith("s") ? name : name + "s";
+}
+function moduleTemplate(name, wiltPath) {
+  const pascal2 = toPascalCase(name);
+  const kebab2 = toKebabCase(name);
+  return `import { Module } from "${wiltPath}";
+import { ${pascal2}Controller } from "./${kebab2}.controller";
+import { ${pascal2}Service } from "./${kebab2}.service";
+
+@Module({
+  controllers: [${pascal2}Controller],
+  providers: [${pascal2}Service],
+  exports: [${pascal2}Service],
+})
+export class ${pascal2}Module {}
+`;
+}
+function entityTemplate(name) {
+  const camel = toCamelCase(name);
+  const kebab2 = toKebabCase(name);
+  const pascal2 = toPascalCase(name);
+  const entityVar = pluralize(camel);
+  const tableName = pluralize(kebab2);
+  return `import { sqliteTable, integer } from "drizzle-orm/sqlite-core";
+
+export const ${entityVar} = sqliteTable("${tableName}", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .$defaultFn(() => new Date())
+    .notNull(),
+});
+
+export type ${pascal2} = typeof ${entityVar}.$inferSelect;
+export type New${pascal2} = typeof ${entityVar}.$inferInsert;
+`;
+}
+function controllerTemplate(name, wiltPath) {
+  const pascal2 = toPascalCase(name);
+  const camel = toCamelCase(name);
+  const kebab2 = toKebabCase(name);
+  return `import type { Context } from "hono";
+import { Controller, Get, Inject } from "${wiltPath}";
+import { ResponseUtil } from "${wiltPath}";
+import { ${pascal2}Service } from "./${kebab2}.service";
+
+@Controller("/${kebab2}")
+export class ${pascal2}Controller {
+  constructor(@Inject(${pascal2}Service) private ${camel}Service: ${pascal2}Service) {}
+
+  @Get()
+  async getAll(c: Context) {
+    const data = await this.${camel}Service.findAll();
+    return ResponseUtil.success(c, data);
+  }
+}
+`;
+}
+function serviceTemplate(name, wiltPath) {
+  const pascal2 = toPascalCase(name);
+  return `import { Injectable } from "${wiltPath}";
+import { createDatabase } from "../../../database/connection";
+
+@Injectable()
+export class ${pascal2}Service {
+
+  private getDatabase(env: CloudflareBindings) {
+    return createDatabase(env.DB);
+  }
+
+  async findAll() {
+    return [];
+  }
+}
+`;
+}
+function testTemplate(name) {
+  const kebab2 = toKebabCase(name);
+  const pascal2 = toPascalCase(name);
+  const table = pluralize(kebab2.replace(/-/g, "_"));
+  return `import { describe, it, expect, beforeAll, afterEach } from "vitest";
+import { SELF, env, applyD1Migrations } from "cloudflare:test";
+import { ${pascal2}Service } from "./${kebab2}.service";
+
+const BASE = "http://localhost";
+const service = new ${pascal2}Service();
+
+beforeAll(async () => {
+  await applyD1Migrations(env.DB, JSON.parse(env.TEST_MIGRATIONS));
+});
+
+afterEach(async () => {
+  await env.DB.prepare("DELETE FROM ${table}").run();
+});
+
+describe("${pascal2}Service", () => {
+  it("should be defined", () => {
+    expect(service).toBeDefined();
+  });
+});
+
+describe("GET /${kebab2}", () => {
+  it("returns an empty list", async () => {
+    const res = await SELF.fetch(\`\${BASE}/${kebab2}\`);
+    expect(res.status).toBe(200);
+    const { data } = await res.json() as { data: unknown[] };
+    expect(data).toEqual([]);
+  });
+});
+`;
+}
+function dtoTemplate(name) {
+  const pascal2 = toPascalCase(name);
+  return `import { z } from "zod";
+
+export const Create${pascal2}Dto = z.object({
+  // TODO: define your fields
+});
+
+export const Update${pascal2}Dto = Create${pascal2}Dto.partial();
+
+export type Create${pascal2}DtoType = z.infer<typeof Create${pascal2}Dto>;
+export type Update${pascal2}DtoType = z.infer<typeof Update${pascal2}Dto>;
+`;
+}
+function generateModule(name, options = {}) {
+  const kebab2 = toKebabCase(name);
+  const pascal2 = toPascalCase(name);
+  const basedir = options.modulesDir ?? APP_MODULES_DIR;
+  const moduleDir = options.dir ?? join3(basedir, kebab2);
+  let filesToGen = options.files ?? options.defaultFiles ?? ["module", "controller", "service", "dto", "entity", "test"];
+  if (options.noTest) filesToGen = filesToGen.filter((f) => f !== "test");
+  if (existsSync3(moduleDir)) {
+    console.error(`  \u2717 Directory already exists: ${moduleDir}`);
+    process.exit(1);
+  }
+  ensureDir(moduleDir);
+  const wiltPath = wiltImportPath();
+  const hasEntity = filesToGen.includes("entity");
+  const fileMap = {
+    module: moduleTemplate(name, wiltPath),
+    controller: controllerTemplate(name, wiltPath),
+    service: serviceTemplate(name, wiltPath),
+    dto: dtoTemplate(name),
+    entity: entityTemplate(name),
+    test: testTemplate(name)
+  };
+  const extMap = {
+    module: `${kebab2}.module.ts`,
+    controller: `${kebab2}.controller.ts`,
+    service: `${kebab2}.service.ts`,
+    dto: `${kebab2}.dto.ts`,
+    entity: `${kebab2}.entity.ts`,
+    test: `${kebab2}.test.ts`
+  };
+  for (const file of filesToGen) {
+    const filePath = join3(moduleDir, extMap[file]);
+    writeFileSync2(filePath, fileMap[file], "utf-8");
+    console.log(`  \u2714 Created ${filePath.replace(process.cwd() + "/", "")}`);
+  }
+  const relModuleDir = moduleDir.replace(process.cwd() + "/", "");
+  const entityLine = hasEntity ? `
+  2. Add the entity to src/database/schema.ts:
+
+    import { ${pluralize(toCamelCase(name))} } from "@app/${relModuleDir.replace(/^src\//, "")}/${kebab2}.entity";
+
+    export const schema = {
+      ...existing,
+      ${pluralize(toCamelCase(name))},
+    };
+` : "";
+  console.log(`
+  Next steps \u2014
+
+  1. Register the module in src/app.module.ts:
+
+    import { ${pascal2}Module } from "./${relModuleDir.replace(/^src\//, "")}/${kebab2}.module";
+
+    @Module({
+      imports: [..., ${pascal2}Module],
+    })
+    export class AppModule {}
+${entityLine}  Then run \`pnpm db:gen\` to generate a migration.
+`);
+}
+function generateService(name, dir2, modulesDir) {
+  const kebab2 = toKebabCase(name);
+  const basedir = modulesDir ?? APP_MODULES_DIR;
+  const targetDir = dir2 ?? join3(basedir, kebab2);
+  const wiltPath = wiltImportPath();
+  const filePath = join3(targetDir, `${kebab2}.service.ts`);
+  if (existsSync3(filePath)) {
+    console.error(`  \u2717 File already exists: ${filePath}`);
+    process.exit(1);
+  }
+  ensureDir(targetDir);
+  writeFileSync2(filePath, serviceTemplate(name, wiltPath), "utf-8");
+  console.log(`  \u2714 Created ${filePath.replace(process.cwd() + "/", "")}`);
+}
+function generateController(name, dir2, modulesDir) {
+  const kebab2 = toKebabCase(name);
+  const basedir = modulesDir ?? APP_MODULES_DIR;
+  const targetDir = dir2 ?? join3(basedir, kebab2);
+  const wiltPath = wiltImportPath();
+  const filePath = join3(targetDir, `${kebab2}.controller.ts`);
+  if (existsSync3(filePath)) {
+    console.error(`  \u2717 File already exists: ${filePath}`);
+    process.exit(1);
+  }
+  ensureDir(targetDir);
+  writeFileSync2(filePath, controllerTemplate(name, wiltPath), "utf-8");
+  console.log(`  \u2714 Created ${filePath.replace(process.cwd() + "/", "")}`);
+}
+
+// bin/utils/config.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, resolve as resolve2 } from "path";
+import { createJiti } from "jiti";
+async function loadConfig(cwd = process.cwd()) {
+  let userConfig = {};
+  for (const name of ["wilt.config.ts", "wilt.config.js", "wilt.config.mjs"]) {
+    const configPath = join4(cwd, name);
+    if (existsSync4(configPath)) {
+      try {
+        const jiti = createJiti(import.meta.url, { interopDefault: true });
+        const mod = await jiti.import(configPath);
+        userConfig = mod ?? {};
+      } catch {
+      }
+      break;
+    }
+  }
+  return {
+    modulesDir: resolve2(cwd, userConfig.modulesDir ?? "src/modules/app"),
+    srcDir: resolve2(cwd, userConfig.srcDir ?? "src"),
+    generate: {
+      files: userConfig.generate?.files ?? ["module", "controller", "service", "dto", "entity", "test"]
+    }
+  };
+}
+
+// bin/commands/generate.ts
+var USAGE = `
+Usage:
+  pnpm wilt generate module <name> [--path <dir>] [--no-test]
+  pnpm wilt generate service <name> [--path <dir>]
+  pnpm wilt generate controller <name> [--path <dir>]
+
+Aliases:
+  g m  \u2192  generate module
+  g s  \u2192  generate service
+  g c  \u2192  generate controller
+
+Flags:
+  --no-test   Skip generating the .test.ts file for a module
+
+Examples:
+  pnpm wilt generate module payment
+  pnpm wilt g m payment
+  pnpm wilt generate module payment --no-test
+  pnpm wilt generate service payment --path src/modules/app/payment
+`.trim();
+function parsePath(args) {
+  const idx = args.indexOf("--path");
+  if (idx === -1) return { args };
+  const path = args[idx + 1];
+  const cleaned = args.filter((_, i) => i !== idx && i !== idx + 1);
+  return { args: cleaned, path };
+}
+function parseNoTest(args) {
+  const idx = args.indexOf("--no-test");
+  if (idx === -1) return { args, noTest: false };
+  return { args: args.filter((_, i) => i !== idx), noTest: true };
+}
+async function runGenerate(args) {
+  const { args: withoutPath, path: targetPath } = parsePath(args);
+  const { args: cleanArgs, noTest } = parseNoTest(withoutPath);
+  const [subcommand, name] = cleanArgs;
+  if (!subcommand || !name) {
+    console.error(`  \u2717 Missing arguments.
+
+${USAGE}`);
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  const sub = subcommand.toLowerCase();
+  if (sub === "module" || sub === "m") {
+    console.log(`
+  Generating module "${name}"...
+`);
+    generateModule(name, {
+      dir: targetPath,
+      modulesDir: config.modulesDir,
+      defaultFiles: config.generate.files,
+      noTest
+    });
+  } else if (sub === "service" || sub === "s") {
+    console.log(`
+  Generating service "${name}"...
+`);
+    generateService(name, targetPath, config.modulesDir);
+  } else if (sub === "controller" || sub === "c") {
+    console.log(`
+  Generating controller "${name}"...
+`);
+    generateController(name, targetPath, config.modulesDir);
+  } else {
+    console.error(`  \u2717 Unknown generate subcommand: "${subcommand}"
+
+${USAGE}`);
+    process.exit(1);
+  }
+}
+
+// bin/utils/wrangler.ts
+import { readFileSync, writeFileSync as writeFileSync3 } from "fs";
+function stripComments(text) {
+  return text.split("\n").map((line) => line.replace(/\s*\/\/.*$/, "")).join("\n");
+}
+function readWrangler() {
+  const raw = readFileSync(WRANGLER_JSONC, "utf-8");
+  return JSON.parse(stripComments(raw));
+}
+function writeWrangler(config) {
+  const header = `{
+  "$schema": "node_modules/wrangler/config-schema.json",`;
+  const body = JSON.stringify(config, null, 2);
+  const bodyWithoutSchema = body.replace(/^\{/, "").replace(/\s+"?\$schema"?\s*:\s*"[^"]*",?\n/, "\n");
+  writeFileSync3(WRANGLER_JSONC, header + bodyWithoutSchema, "utf-8");
+}
+function addD1(binding, databaseName) {
+  const config = readWrangler();
+  if (!config.d1_databases) config.d1_databases = [];
+  const alreadyExists = config.d1_databases.some(
+    (db) => db.binding === binding
+  );
+  if (alreadyExists) {
+    console.error(`  \u2717 D1 binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+  config.d1_databases.push({
+    binding,
+    database_name: databaseName,
+    database_id: "00000000-0000-0000-0000-000000000000",
+    migrations_dir: "migrations"
+  });
+  writeWrangler(config);
+  console.log(`  \u2714 Added D1 binding "${binding}" (database: ${databaseName})`);
+  console.log(`  ! Remember to replace database_id with your actual D1 database ID.`);
+}
+function addR2(binding, bucketName) {
+  const config = readWrangler();
+  if (!config.r2_buckets) config.r2_buckets = [];
+  if (config.r2_buckets.some((b) => b.binding === binding)) {
+    console.error(`  \u2717 R2 binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+  config.r2_buckets.push({
+    binding,
+    bucket_name: bucketName,
+    preview_bucket_name: `${bucketName}-preview`
+  });
+  writeWrangler(config);
+  console.log(`  \u2714 Added R2 binding "${binding}" (bucket: ${bucketName})`);
+}
+function addKv(binding) {
+  const config = readWrangler();
+  if (!config.kv_namespaces) config.kv_namespaces = [];
+  if (config.kv_namespaces.some((k) => k.binding === binding)) {
+    console.error(`  \u2717 KV binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+  config.kv_namespaces.push({
+    binding,
+    id: "00000000000000000000000000000000"
+  });
+  writeWrangler(config);
+  console.log(`  \u2714 Added KV namespace binding "${binding}"`);
+  console.log(`  ! Remember to replace id with your actual KV namespace ID.`);
+}
+function addQueue(binding, queueName) {
+  const config = readWrangler();
+  if (!config.queues) config.queues = { producers: [], consumers: [] };
+  if (!config.queues.producers) config.queues.producers = [];
+  if (!config.queues.consumers) config.queues.consumers = [];
+  if (config.queues.producers.some((p) => p.binding === binding)) {
+    console.error(`  \u2717 Queue producer binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+  config.queues.producers.push({ binding, queue: queueName });
+  config.queues.consumers.push({
+    queue: queueName,
+    max_batch_size: 10,
+    max_batch_timeout: 10,
+    max_retries: 3
+  });
+  writeWrangler(config);
+  console.log(`  \u2714 Added Queue binding "${binding}" (queue: ${queueName})`);
+}
+function addAi(binding) {
+  const config = readWrangler();
+  if (config.ai) {
+    console.error(`  \u2717 AI binding already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+  config.ai = { binding };
+  writeWrangler(config);
+  console.log(`  \u2714 Added AI binding "${binding}"`);
+}
+function addDurableObject(binding, className) {
+  const config = readWrangler();
+  if (!config.durable_objects) config.durable_objects = { bindings: [] };
+  if (!config.durable_objects.bindings) config.durable_objects.bindings = [];
+  if (config.durable_objects.bindings.some((b) => b.name === binding)) {
+    console.error(`  \u2717 Durable Object binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+  config.durable_objects.bindings.push({
+    name: binding,
+    class_name: className
+  });
+  if (!config.migrations) config.migrations = [];
+  const existingClasses = config.migrations.flatMap(
+    (m) => m.new_sqlite_classes ?? m.new_classes ?? []
+  );
+  if (!existingClasses.includes(className)) {
+    const nextTag = `v${config.migrations.length + 1}`;
+    config.migrations.push({
+      tag: nextTag,
+      new_sqlite_classes: [className]
+    });
+    console.log(`  ! Added migration entry "${nextTag}" for ${className}.`);
+  }
+  writeWrangler(config);
+  console.log(`  \u2714 Added Durable Object binding "${binding}" (class: ${className})`);
+}
+function addVectorize(binding, indexName, dimensions = 1536) {
+  const config = readWrangler();
+  if (!config.vectorize) config.vectorize = [];
+  if (config.vectorize.some((v) => v.binding === binding)) {
+    console.error(`  \u2717 Vectorize binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+  config.vectorize.push({
+    binding,
+    index_name: indexName,
+    dimensions,
+    metric: "cosine"
+  });
+  writeWrangler(config);
+  console.log(`  \u2714 Added Vectorize binding "${binding}" (index: ${indexName}, dimensions: ${dimensions})`);
+  console.log(`  ! Create the index with: wrangler vectorize create ${indexName} --dimensions=${dimensions} --metric=cosine`);
+}
+function addBrowser(binding) {
+  const config = readWrangler();
+  if (config.browser) {
+    console.error(`  \u2717 Browser binding already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+  config.browser = { binding };
+  writeWrangler(config);
+  console.log(`  \u2714 Added Browser rendering binding "${binding}"`);
+}
+function addHyperdrive(binding, connectionString) {
+  const config = readWrangler();
+  if (!config.hyperdrive) config.hyperdrive = [];
+  if (config.hyperdrive.some((h) => h.binding === binding)) {
+    console.error(`  \u2717 Hyperdrive binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+  config.hyperdrive.push({
+    binding,
+    id: "00000000000000000000000000000000",
+    localConnectionString: connectionString
+  });
+  writeWrangler(config);
+  console.log(`  \u2714 Added Hyperdrive binding "${binding}"`);
+  console.log(`  ! Remember to replace id with your actual Hyperdrive config ID.`);
+}
+
+// bin/commands/add.ts
+var USAGE2 = `
+Usage:
+  pnpm wilt add d1 <BINDING_NAME> <database-name>
+  pnpm wilt add r2 <BINDING_NAME> <bucket-name>
+  pnpm wilt add kv <BINDING_NAME>
+  pnpm wilt add queue <BINDING_NAME> <queue-name>
+  pnpm wilt add ai <BINDING_NAME>
+  pnpm wilt add durable-object <BINDING_NAME> <ClassName>
+  pnpm wilt add vectorize <BINDING_NAME> <index-name> [dimensions]
+  pnpm wilt add browser <BINDING_NAME>
+  pnpm wilt add hyperdrive <BINDING_NAME> <connection-string>
+
+Examples:
+  pnpm wilt add d1 PAYMENTS_DB payments-db
+  pnpm wilt add r2 ASSETS_BUCKET my-assets
+  pnpm wilt add kv SESSION_KV
+  pnpm wilt add queue MAIL_QUEUE mailer
+  pnpm wilt add ai AI
+  pnpm wilt add durable-object CHAT_ROOM ChatRoom
+  pnpm wilt add vectorize VECTOR_IDX my-index 1536
+  pnpm wilt add browser BROWSER
+  pnpm wilt add hyperdrive HYPERDRIVE postgres://user:pass@host/db
+`.trim();
+function runAdd(args) {
+  const [service, ...rest] = args;
+  if (!service) {
+    console.error(`  \u2717 Missing service type.
+
+${USAGE2}`);
+    process.exit(1);
+  }
+  const svc = service.toLowerCase();
+  switch (svc) {
+    case "d1": {
+      const [binding, dbName] = rest;
+      if (!binding || !dbName) {
+        console.error(`  \u2717 Usage: pnpm wilt add d1 <BINDING_NAME> <database-name>`);
+        process.exit(1);
+      }
+      console.log(`
+  Adding D1 binding to wrangler.jsonc...
+`);
+      addD1(binding, dbName);
+      break;
+    }
+    case "r2": {
+      const [binding, bucketName] = rest;
+      if (!binding || !bucketName) {
+        console.error(`  \u2717 Usage: pnpm wilt add r2 <BINDING_NAME> <bucket-name>`);
+        process.exit(1);
+      }
+      console.log(`
+  Adding R2 binding to wrangler.jsonc...
+`);
+      addR2(binding, bucketName);
+      break;
+    }
+    case "kv": {
+      const [binding] = rest;
+      if (!binding) {
+        console.error(`  \u2717 Usage: pnpm wilt add kv <BINDING_NAME>`);
+        process.exit(1);
+      }
+      console.log(`
+  Adding KV namespace binding to wrangler.jsonc...
+`);
+      addKv(binding);
+      break;
+    }
+    case "queue": {
+      const [binding, queueName] = rest;
+      if (!binding || !queueName) {
+        console.error(`  \u2717 Usage: pnpm wilt add queue <BINDING_NAME> <queue-name>`);
+        process.exit(1);
+      }
+      console.log(`
+  Adding Queue binding to wrangler.jsonc...
+`);
+      addQueue(binding, queueName);
+      break;
+    }
+    case "ai": {
+      const [binding] = rest;
+      if (!binding) {
+        console.error(`  \u2717 Usage: pnpm wilt add ai <BINDING_NAME>`);
+        process.exit(1);
+      }
+      console.log(`
+  Adding AI binding to wrangler.jsonc...
+`);
+      addAi(binding);
+      break;
+    }
+    case "durable-object":
+    case "do": {
+      const [binding, className] = rest;
+      if (!binding || !className) {
+        console.error(`  \u2717 Usage: pnpm wilt add durable-object <BINDING_NAME> <ClassName>`);
+        process.exit(1);
+      }
+      console.log(`
+  Adding Durable Object binding to wrangler.jsonc...
+`);
+      addDurableObject(binding, className);
+      break;
+    }
+    case "vectorize":
+    case "vector": {
+      const [binding, indexName, rawDimensions] = rest;
+      if (!binding || !indexName) {
+        console.error(`  \u2717 Usage: pnpm wilt add vectorize <BINDING_NAME> <index-name> [dimensions]`);
+        process.exit(1);
+      }
+      const dimensions = rawDimensions ? parseInt(rawDimensions, 10) : 1536;
+      console.log(`
+  Adding Vectorize binding to wrangler.jsonc...
+`);
+      addVectorize(binding, indexName, dimensions);
+      break;
+    }
+    case "browser": {
+      const [binding] = rest;
+      if (!binding) {
+        console.error(`  \u2717 Usage: pnpm wilt add browser <BINDING_NAME>`);
+        process.exit(1);
+      }
+      console.log(`
+  Adding Browser rendering binding to wrangler.jsonc...
+`);
+      addBrowser(binding);
+      break;
+    }
+    case "hyperdrive": {
+      const [binding, connectionString] = rest;
+      if (!binding || !connectionString) {
+        console.error(`  \u2717 Usage: pnpm wilt add hyperdrive <BINDING_NAME> <connection-string>`);
+        process.exit(1);
+      }
+      console.log(`
+  Adding Hyperdrive binding to wrangler.jsonc...
+`);
+      addHyperdrive(binding, connectionString);
+      break;
+    }
+    default: {
+      console.error(`  \u2717 Unknown service type: "${service}"
+
+${USAGE2}`);
+      process.exit(1);
+    }
+  }
+}
+
+// bin/wilt.ts
+var BANNER = `
+  \u2588\u2588\u2557    \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2551    \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551  \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
+  \u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551
+  \u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551
+  \u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551
+   \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D
+  Wilt CLI \u2014 Cloudflare Workers Framework
+`.trim();
+var HELP = `
+${BANNER}
+
+Usage:
+  pnpm wilt <command> [subcommand] [args...]
+
+Commands:
+  new             Create a new Wilt project
+  generate (g)    Scaffold module, service, or controller files
+  add             Add a Cloudflare service binding to wrangler.jsonc
+  help            Show this help message
+
+Generate subcommands:
+  module (m)      Scaffold a full module (module + controller + service + dto)
+  service (s)     Scaffold a service file
+  controller (c)  Scaffold a controller file
+
+Add subcommands:
+  d1              D1 database binding
+  r2              R2 bucket binding
+  kv              KV namespace binding
+  queue           Queue producer + consumer
+  ai              Workers AI binding
+  durable-object  Durable Object binding + migration
+  vectorize       Vectorize index binding
+  browser         Browser rendering binding
+  hyperdrive      Hyperdrive binding
+
+Examples:
+  pnpm wilt new my-app
+  pnpm wilt generate module payment
+  pnpm wilt g m payment
+  pnpm wilt add d1 PAYMENTS_DB payments-db
+  pnpm wilt add r2 ASSETS_BUCKET my-assets
+  pnpm wilt add kv SESSION_KV
+  pnpm wilt add queue MAIL_QUEUE mailer
+  pnpm wilt add ai AI
+  pnpm wilt add durable-object CHAT_ROOM ChatRoom
+`.trim();
+async function main() {
+  const args = process.argv.slice(2);
+  const [command, ...rest] = args;
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    console.log(`
+${HELP}
+`);
+    process.exit(0);
+  }
+  const cmd = command.toLowerCase();
+  if (cmd === "new" || cmd === "n") {
+    runNew(rest);
+  } else if (cmd === "generate" || cmd === "g") {
+    await runGenerate(rest);
+  } else if (cmd === "add") {
+    runAdd(rest);
+  } else {
+    console.error(`  \u2717 Unknown command: "${command}"
+`);
+    console.log(HELP);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=wilt.js.map