@rainfw/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rainfw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cli/commands/db.js

@@ -0,0 +1,399 @@
+const path = require("node:path");
+const fs = require("node:fs");
+const { getD1Bindings } = require("../utils/toml-parser");
+const { runCommand, npmInstall } = require("../utils/process");
+const { stripControlChars } = require("../utils/sanitize");
+const { schemaTemplate } = require("../templates/schema");
+const {
+  drizzleConfigTemplate,
+} = require("../templates/drizzle-config");
+
+const SCHEMA_DIR = path.join(process.cwd(), "src", "db");
+const SCHEMA_FILE = path.join(SCHEMA_DIR, "schema.ts");
+const DRIZZLE_CONFIG = path.join(
+  process.cwd(),
+  "drizzle.config.ts",
+);
+const DRIZZLE_DIR = path.join(process.cwd(), "drizzle");
+const SAFE_NAME_RE = /^[\w.\-]+$/;
+
+const DB_SUBCOMMANDS = [
+  "init",
+  "generate",
+  "push",
+  "migrate",
+  "apply-local",
+  "studio",
+];
+
+function printDbHelp() {
+  console.log(`
+  Rain.js DB Commands
+
+  Usage: rainjs db <subcommand>
+
+  Subcommands:
+    init         Set up D1 + Drizzle ORM integration
+    generate     Generate migration SQL from schema changes
+    push         Apply schema directly to D1 (remote)
+    migrate      Run pending migrations (remote)
+    apply-local  Apply migrations to local D1 (wrangler dev)
+    studio       Open Drizzle Studio (DB browser)
+`);
+}
+
+function assertD1Configured() {
+  const d1Bindings = getD1Bindings();
+  if (d1Bindings.length === 0) {
+    console.error(
+      "[Rain] Error: No D1 database bindings found " +
+        "in wrangler.toml.\n\n" +
+        "  \u2192 Add a D1 binding to wrangler.toml:\n\n" +
+        "    [[d1_databases]]\n" +
+        '    binding = "DB"\n' +
+        '    database_name = "my-db"\n' +
+        '    database_id = "your-database-id"\n\n' +
+        "  \u2192 Create a D1 database:\n" +
+        "    npx wrangler d1 create my-db\n\n" +
+        "  \u2192 Then run: npx rainjs db init",
+    );
+    process.exit(1);
+  }
+  return d1Bindings;
+}
+
+function assertDrizzleInstalled() {
+  try {
+    require.resolve("drizzle-kit");
+  } catch {
+    console.error(
+      "[Rain] Error: drizzle-kit is not installed.\n" +
+        "  \u2192 Run: npx rainjs db init",
+    );
+    process.exit(1);
+  }
+}
+
+function dbInit() {
+  const d1Bindings = assertD1Configured();
+  const primary = d1Bindings[0];
+
+  console.log(
+    `\n[Rain] D1 binding "${primary.binding}" ` +
+      "\u3092 wrangler.toml \u304b\u3089\u691c\u51fa\u3057\u307e\u3057\u305f\n",
+  );
+
+  console.log(
+    "1/4  drizzle-orm \u3092\u30a4\u30f3\u30b9\u30c8\u30fc\u30eb\u4e2d...",
+  );
+  const ormStatus = npmInstall(["drizzle-orm"]);
+  if (ormStatus !== 0) {
+    console.error(
+      "[Rain] Error: drizzle-orm \u306e\u30a4\u30f3\u30b9\u30c8\u30fc\u30eb" +
+        "\u306b\u5931\u6557\u3057\u307e\u3057\u305f\u3002\n" +
+        "  \u2192 \u624b\u52d5\u3067\u5b9f\u884c: npm install drizzle-orm",
+    );
+    process.exit(1);
+  }
+
+  console.log(
+    "\n2/4  drizzle-kit \u3092\u30a4\u30f3\u30b9\u30c8\u30fc\u30eb\u4e2d...",
+  );
+  const kitStatus = npmInstall(["drizzle-kit"], true);
+  if (kitStatus !== 0) {
+    console.error(
+      "[Rain] Error: drizzle-kit \u306e\u30a4\u30f3\u30b9\u30c8\u30fc\u30eb" +
+        "\u306b\u5931\u6557\u3057\u307e\u3057\u305f\u3002\n" +
+        "  \u2192 \u624b\u52d5\u3067\u5b9f\u884c: npm install -D drizzle-kit",
+    );
+    process.exit(1);
+  }
+
+  console.log(
+    "\n3/4  \u30d5\u30a1\u30a4\u30eb\u3092\u751f\u6210\u4e2d...",
+  );
+
+  if (!fs.existsSync(SCHEMA_DIR)) {
+    fs.mkdirSync(SCHEMA_DIR, { recursive: true });
+  }
+
+  if (fs.existsSync(SCHEMA_FILE)) {
+    console.log(
+      "     \u2298 src/db/schema.ts " +
+        "\u306f\u65e2\u306b\u5b58\u5728\u3057\u307e\u3059" +
+        "\uff08\u30b9\u30ad\u30c3\u30d7\uff09",
+    );
+  } else {
+    fs.writeFileSync(SCHEMA_FILE, schemaTemplate());
+    console.log("     \u2713 src/db/schema.ts");
+  }
+
+  if (fs.existsSync(DRIZZLE_CONFIG)) {
+    console.log(
+      "     \u2298 drizzle.config.ts " +
+        "\u306f\u65e2\u306b\u5b58\u5728\u3057\u307e\u3059" +
+        "\uff08\u30b9\u30ad\u30c3\u30d7\uff09",
+    );
+  } else {
+    fs.writeFileSync(DRIZZLE_CONFIG, drizzleConfigTemplate());
+    console.log("     \u2713 drizzle.config.ts");
+  }
+
+  console.log(
+    "\n4/4  \u578b\u5b9a\u7fa9\u3092\u66f4\u65b0\u4e2d...",
+  );
+  runCommand("npx", ["wrangler", "types"]);
+
+  console.log(
+    "\n[Rain] D1 \u30bb\u30c3\u30c8\u30a2\u30c3\u30d7\u304c" +
+      "\u5b8c\u4e86\u3057\u307e\u3057\u305f\uff01\n\n" +
+      "  \u6b21\u306e\u30b9\u30c6\u30c3\u30d7:\n" +
+      "    1. src/db/schema.ts " +
+      "\u3067\u30c6\u30fc\u30d6\u30eb\u3092\u5b9a\u7fa9\n" +
+      "    2. npx rainjs db generate " +
+      "\u3067\u30de\u30a4\u30b0\u30ec\u30fc\u30b7\u30e7\u30f3\u751f\u6210\n" +
+      "    3. npx rainjs db push " +
+      "\u3067 D1 \u306b\u9069\u7528\n\n" +
+      "  \u30eb\u30fc\u30c8\u30cf\u30f3\u30c9\u30e9\u3067\u306e" +
+      "\u4f7f\u3044\u65b9:\n\n" +
+      '    import { db } from "../../framework/db";\n' +
+      '    import { todos } from "../../db/schema";\n\n' +
+      "    export const GET: Handler = async (ctx) => {\n" +
+      "      const rows = await db().select().from(todos);\n" +
+      "      return ctx.json(rows);\n" +
+      "    };\n",
+  );
+}
+
+function dbGenerate() {
+  assertD1Configured();
+  assertDrizzleInstalled();
+  console.log(
+    "[Rain] \u30de\u30a4\u30b0\u30ec\u30fc\u30b7\u30e7\u30f3" +
+      "\u3092\u751f\u6210\u4e2d...\n",
+  );
+  const status = runCommand("npx", ["drizzle-kit", "generate"]);
+  if (status !== 0) {
+    console.error(
+      "\n[Rain] Error: \u30de\u30a4\u30b0\u30ec\u30fc\u30b7\u30e7\u30f3" +
+        "\u751f\u6210\u306b\u5931\u6557\u3057\u307e\u3057\u305f\u3002\n" +
+        "  \u2192 src/db/schema.ts \u306e\u30b9\u30ad\u30fc\u30de" +
+        "\u5b9a\u7fa9\u3092\u78ba\u8a8d\u3057\u3066\u304f\u3060\u3055\u3044\n" +
+        "  \u2192 drizzle-kit \u304c\u30a4\u30f3\u30b9\u30c8\u30fc\u30eb" +
+        "\u3055\u308c\u3066\u3044\u308b\u304b\u78ba\u8a8d: " +
+        "npx rainjs db init",
+    );
+    process.exit(1);
+  }
+}
+
+function dbPush() {
+  assertD1Configured();
+  assertDrizzleInstalled();
+  console.log(
+    "[Rain] D1 \u306b\u30b9\u30ad\u30fc\u30de\u3092" +
+      "\u9069\u7528\u4e2d...\n",
+  );
+  const status = runCommand("npx", ["drizzle-kit", "push"]);
+  if (status !== 0) {
+    console.error(
+      "\n[Rain] Error: \u30b9\u30ad\u30fc\u30de\u306e\u9069\u7528\u306b" +
+        "\u5931\u6557\u3057\u307e\u3057\u305f\u3002\n" +
+        "  \u2192 wrangler.toml \u306e D1 \u8a2d\u5b9a\u3092" +
+        "\u78ba\u8a8d\u3057\u3066\u304f\u3060\u3055\u3044\n" +
+        "  \u2192 Cloudflare \u306e\u8a8d\u8a3c\u60c5\u5831\u304c" +
+        "\u8a2d\u5b9a\u3055\u308c\u3066\u3044\u308b\u304b" +
+        "\u78ba\u8a8d\u3057\u3066\u304f\u3060\u3055\u3044",
+    );
+    process.exit(1);
+  }
+}
+
+function dbMigrate() {
+  assertD1Configured();
+  assertDrizzleInstalled();
+  console.log(
+    "[Rain] \u30de\u30a4\u30b0\u30ec\u30fc\u30b7\u30e7\u30f3\u3092" +
+      "\u5b9f\u884c\u4e2d...\n",
+  );
+  const status = runCommand("npx", ["drizzle-kit", "migrate"]);
+  if (status !== 0) {
+    console.error(
+      "\n[Rain] Error: \u30de\u30a4\u30b0\u30ec\u30fc\u30b7\u30e7\u30f3" +
+        "\u306e\u5b9f\u884c\u306b\u5931\u6557\u3057\u307e\u3057\u305f\u3002\n" +
+        "  \u2192 drizzle/ \u30d5\u30a9\u30eb\u30c0\u306b" +
+        "\u30de\u30a4\u30b0\u30ec\u30fc\u30b7\u30e7\u30f3" +
+        "\u30d5\u30a1\u30a4\u30eb\u304c\u3042\u308b\u304b" +
+        "\u78ba\u8a8d\u3057\u3066\u304f\u3060\u3055\u3044\n" +
+        "  \u2192 \u307e\u305a npx rainjs db generate " +
+        "\u3092\u5b9f\u884c\u3057\u3066\u304f\u3060\u3055\u3044",
+    );
+    process.exit(1);
+  }
+}
+
+function dbApplyLocal() {
+  const d1Bindings = assertD1Configured();
+  const dbName = d1Bindings[0].database_name;
+
+  if (!dbName) {
+    console.error(
+      "[Rain] Error: database_name \u304c wrangler.toml " +
+        "\u306b\u898b\u3064\u304b\u308a\u307e\u305b\u3093\u3002\n" +
+        "  \u2192 [[d1_databases]] \u30bb\u30af\u30b7\u30e7\u30f3\u306b " +
+        'database_name = "my-db" \u3092\u8ffd\u52a0' +
+        "\u3057\u3066\u304f\u3060\u3055\u3044",
+    );
+    process.exit(1);
+  }
+
+  if (!SAFE_NAME_RE.test(dbName)) {
+    console.error(
+      "[Rain] Error: database_name \u306b\u4e0d\u6b63\u306a" +
+        "\u6587\u5b57\u304c\u542b\u307e\u308c\u3066\u3044\u307e\u3059: " +
+        dbName + "\n" +
+        "  \u2192 \u82f1\u6570\u5b57\u30fb\u30cf\u30a4\u30d5\u30f3\u30fb" +
+        "\u30a2\u30f3\u30c0\u30fc\u30b9\u30b3\u30a2\u306e\u307f" +
+        "\u4f7f\u7528\u3067\u304d\u307e\u3059",
+    );
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(DRIZZLE_DIR)) {
+    console.error(
+      "[Rain] Error: drizzle/ \u30d5\u30a9\u30eb\u30c0\u304c" +
+        "\u898b\u3064\u304b\u308a\u307e\u305b\u3093\u3002\n" +
+        "  \u2192 \u307e\u305a npx rainjs db generate " +
+        "\u3092\u5b9f\u884c\u3057\u3066\u304f\u3060\u3055\u3044",
+    );
+    process.exit(1);
+  }
+
+  const sqlFiles = fs
+    .readdirSync(DRIZZLE_DIR)
+    .filter((f) => f.endsWith(".sql"))
+    .sort();
+
+  if (sqlFiles.length === 0) {
+    console.log(
+      "[Rain] drizzle/ \u306b SQL \u30d5\u30a1\u30a4\u30eb\u304c" +
+        "\u898b\u3064\u304b\u308a\u307e\u305b\u3093\u3002\n" +
+        "  \u2192 npx rainjs db generate " +
+        "\u3067\u30de\u30a4\u30b0\u30ec\u30fc\u30b7\u30e7\u30f3\u3092" +
+        "\u751f\u6210\u3057\u3066\u304f\u3060\u3055\u3044",
+    );
+    process.exit(0);
+  }
+
+  console.log(
+    `[Rain] Local D1 "${dbName}" ` +
+      "\u306b\u30de\u30a4\u30b0\u30ec\u30fc\u30b7\u30e7\u30f3\u3092" +
+      "\u9069\u7528\u4e2d...\n",
+  );
+
+  let applied = 0;
+  let skipped = 0;
+
+  for (const file of sqlFiles) {
+    if (!SAFE_NAME_RE.test(file)) {
+      console.error(
+        "[Rain] Error: \u4e0d\u6b63\u306a" +
+          "\u30d5\u30a1\u30a4\u30eb\u540d: " +
+          file + "\n" +
+          "  \u2192 \u30d5\u30a1\u30a4\u30eb\u540d\u306b\u306f" +
+          "\u82f1\u6570\u5b57\u30fb\u30cf\u30a4\u30d5\u30f3\u30fb" +
+          "\u30a2\u30f3\u30c0\u30fc\u30b9\u30b3\u30a2\u30fb" +
+          "\u30c9\u30c3\u30c8\u306e\u307f\u4f7f\u7528\u3067\u304d\u307e\u3059",
+      );
+      process.exit(1);
+    }
+    const filePath = path.join("drizzle", file);
+    console.log(`  \u2192 ${file}`);
+    const status = runCommand(
+      "npx",
+      [
+        "wrangler",
+        "d1",
+        "execute",
+        dbName,
+        "--local",
+        `--file=${filePath}`,
+      ],
+      { stdio: "pipe" },
+    );
+    if (status === 0) {
+      applied++;
+    } else {
+      skipped++;
+      console.log(
+        `     \u26a0 ${file} ` +
+          "\u306e\u9069\u7528\u3092\u30b9\u30ad\u30c3\u30d7" +
+          "\uff08\u65e2\u306b\u9069\u7528\u6e08\u307f" +
+          "\u306e\u53ef\u80fd\u6027\uff09",
+      );
+    }
+  }
+
+  console.log(
+    `\n[Rain] \u5b8c\u4e86: ${applied} \u4ef6\u9069\u7528` +
+      (skipped > 0
+        ? `, ${skipped} \u4ef6\u30b9\u30ad\u30c3\u30d7`
+        : ""),
+  );
+}
+
+function dbStudio() {
+  assertD1Configured();
+  assertDrizzleInstalled();
+  console.log(
+    "[Rain] Drizzle Studio " +
+      "\u3092\u8d77\u52d5\u4e2d...\n",
+  );
+  runCommand("npx", ["drizzle-kit", "studio"]);
+}
+
+function handleDbCommand(subcommand) {
+  if (
+    !subcommand ||
+    subcommand === "--help" ||
+    subcommand === "-h"
+  ) {
+    printDbHelp();
+    process.exit(0);
+  }
+
+  if (!DB_SUBCOMMANDS.includes(subcommand)) {
+    console.error(
+      `[Rain] Error: Unknown db subcommand ` +
+        `"${stripControlChars(subcommand)}".\n` +
+        "  \u2192 Available subcommands: " +
+        `${DB_SUBCOMMANDS.join(", ")}\n` +
+        '  \u2192 Run "rainjs db --help" ' +
+        "for usage information.",
+    );
+    process.exit(1);
+  }
+
+  switch (subcommand) {
+    case "init":
+      dbInit();
+      break;
+    case "generate":
+      dbGenerate();
+      break;
+    case "push":
+      dbPush();
+      break;
+    case "migrate":
+      dbMigrate();
+      break;
+    case "apply-local":
+      dbApplyLocal();
+      break;
+    case "studio":
+      dbStudio();
+      break;
+  }
+}
+
+module.exports = { handleDbCommand };

package/cli/index.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+const path = require("node:path");
+const fs = require("node:fs");
+const { spawn } = require("node:child_process");
+
+const { stripControlChars } = require("./utils/sanitize");
+
+const PACKAGE_JSON = path.join(__dirname, "..", "package.json");
+const pkg = JSON.parse(fs.readFileSync(PACKAGE_JSON, "utf-8"));
+
+const command = process.argv[2];
+const VALID_COMMANDS = ["dev", "build", "routes", "db"];
+
+function printHelp() {
+  console.log(`
+  Rain.js v${pkg.version}
+
+  Usage: rainjs <command>
+
+  Commands:
+    dev      Start development server (codegen + watch + wrangler dev)
+    build    Run code generation only
+    routes   Display registered routes
+    db       D1 database management (init, generate, push, migrate, apply-local, studio)
+
+  Options:
+    --help, -h     Show this help message
+    --version, -v  Show version number
+`);
+}
+
+function printVersion() {
+  console.log(`@rainfw/core v${pkg.version}`);
+}
+
+if (!command || command === "--help" || command === "-h") {
+  printHelp();
+  process.exit(0);
+}
+
+if (command === "--version" || command === "-v") {
+  printVersion();
+  process.exit(0);
+}
+
+if (!VALID_COMMANDS.includes(command)) {
+  console.error(
+    `[Rain] Error: Unknown command "${stripControlChars(command)}".\n` +
+      `  → Available commands: ${VALID_COMMANDS.join(", ")}\n` +
+      "  → Run \"rainjs --help\" for usage information.",
+  );
+  process.exit(1);
+}
+
+if (command === "db") {
+  const { handleDbCommand } = require("./commands/db");
+  handleDbCommand(process.argv[3]);
+  process.exit(0);
+}
+
+if (command === "build") {
+  const { generate } = require("../scripts/generate");
+  generate();
+}
+
+if (command === "routes") {
+  const {
+    getRouteFiles,
+    getMiddlewareFiles,
+    getMiddlewaresForRoute,
+    filePathToUrlPath,
+    detectExportedMethods,
+    middlewareImportName,
+    ROUTES_DIR,
+  } = require("../scripts/generate");
+
+  if (!fs.existsSync(ROUTES_DIR)) {
+    console.error(
+      "[Rain] Error: src/routes/ directory not found.\n" +
+        `  → Current directory: ${process.cwd()}\n` +
+        "  → Ensure you are running this command from a Rain.js project root.\n" +
+        "  → Or create the directory: mkdir -p src/routes",
+    );
+    process.exit(1);
+  }
+
+  const files = getRouteFiles(ROUTES_DIR);
+  const middlewareFiles = getMiddlewareFiles(ROUTES_DIR);
+
+  if (files.length === 0) {
+    console.log("[Rain] No routes found in src/routes/.");
+    console.log("  → Add a route file, e.g.: src/routes/route.ts");
+    process.exit(0);
+  }
+
+  console.log("\n  Rain.js Routes\n");
+
+  const rows = [];
+  for (const file of files) {
+    const urlPath = filePathToUrlPath(file);
+    const fullPath = path.join(ROUTES_DIR, file);
+    const methods = detectExportedMethods(fullPath);
+    const applicableMw = getMiddlewaresForRoute(file, middlewareFiles);
+    const mwNames = applicableMw.map((mf) => middlewareImportName(mf));
+
+    rows.push({
+      method: methods.join(", ") || "(none)",
+      path: urlPath,
+      file: `src/routes/${file.replace(/\\/g, "/")}`,
+      middleware: mwNames.length > 0 ? mwNames.join(" → ") : "-",
+    });
+  }
+
+  const maxMethod = Math.max(6, ...rows.map((r) => r.method.length));
+  const maxPath = Math.max(4, ...rows.map((r) => r.path.length));
+  const maxFile = Math.max(4, ...rows.map((r) => r.file.length));
+  const maxMw = Math.max(10, ...rows.map((r) => r.middleware.length));
+
+  const header = `  ${"METHOD".padEnd(maxMethod)}  ${"PATH".padEnd(maxPath)}  ${"FILE".padEnd(maxFile)}  ${"MIDDLEWARE".padEnd(maxMw)}`;
+  const separator = `  ${"─".repeat(maxMethod)}  ${"─".repeat(maxPath)}  ${"─".repeat(maxFile)}  ${"─".repeat(maxMw)}`;
+
+  console.log(header);
+  console.log(separator);
+
+  for (const row of rows) {
+    console.log(
+      `  ${row.method.padEnd(maxMethod)}  ${row.path.padEnd(maxPath)}  ${row.file.padEnd(maxFile)}  ${row.middleware.padEnd(maxMw)}`,
+    );
+  }
+
+  console.log(`\n  Total: ${rows.length} route(s)\n`);
+}
+
+if (command === "dev") {
+  const { generate, ROUTES_DIR } = require("../scripts/generate");
+
+  generate();
+
+  let debounceTimer = null;
+  try {
+    const watcher = fs.watch(
+      ROUTES_DIR,
+      { recursive: true },
+      (eventType, filename) => {
+        if (
+          !(
+            filename?.endsWith(".ts") ||
+            filename?.endsWith(".tsx")
+          )
+        )
+          return;
+        clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+          console.log(`[watch] ${eventType}: ${filename}`);
+          generate();
+        }, 100);
+      },
+    );
+
+    watcher.on("error", (err) => {
+      console.error(
+        "[Rain] Error: File watcher encountered an error.\n" +
+          `  \u2192 ${err.message}\n` +
+          "  \u2192 The dev server will continue running, " +
+          "but route changes won't be detected " +
+          "automatically.\n" +
+          '  \u2192 Run "rainjs build" manually after ' +
+          "making route changes.",
+      );
+    });
+  } catch (watchError) {
+    console.error(
+      "[Rain] Error: Failed to start file watcher on src/routes/.\n" +
+        `  → ${watchError.message}\n` +
+        "  → The dev server will still run, but route changes won't be detected automatically.\n" +
+        '  → Run "rainjs build" manually after making route changes.',
+    );
+  }
+  console.log("[watch] Watching src/routes/ for changes...");
+
+  const wrangler = spawn("npx", ["wrangler", "dev"], {
+    stdio: "inherit",
+    shell: true,
+    cwd: process.cwd(),
+  });
+
+  wrangler.on("error", (err) => {
+    console.error(
+      "[Rain] Error: Failed to start wrangler dev.\n" +
+        `  → ${err.message}\n` +
+        '  → Ensure wrangler is installed: npm install -D wrangler\n' +
+        '  → Try running "npx wrangler dev" directly to debug.',
+    );
+    process.exit(1);
+  });
+
+  process.on("SIGINT", () => {
+    wrangler.kill();
+    process.exit(0);
+  });
+
+  wrangler.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+}

package/cli/templates/drizzle-config.js

@@ -0,0 +1,15 @@
+function drizzleConfigTemplate() {
+  return [
+    'import { defineConfig } from "drizzle-kit";',
+    "",
+    "export default defineConfig({",
+    '  out: "./drizzle",',
+    '  schema: "./src/db/schema.ts",',
+    '  dialect: "sqlite",',
+    '  driver: "d1-http",',
+    "});",
+    "",
+  ].join("\n");
+}
+
+module.exports = { drizzleConfigTemplate };

package/cli/templates/schema.js

@@ -0,0 +1,16 @@
+function schemaTemplate() {
+  return [
+    'import { int, sqliteTable, text } from "drizzle-orm/sqlite-core";',
+    "",
+    'export const example = sqliteTable("example", {',
+    "  id: int().primaryKey({ autoIncrement: true }),",
+    "  name: text().notNull(),",
+    '  createdAt: int({ mode: "timestamp" })',
+    "    .notNull()",
+    "    .$defaultFn(() => new Date()),",
+    "});",
+    "",
+  ].join("\n");
+}
+
+module.exports = { schemaTemplate };

package/cli/utils/process.js

@@ -0,0 +1,23 @@
+const { spawnSync } = require("node:child_process");
+
+function runCommand(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    stdio: "inherit",
+    shell: true,
+    cwd: process.cwd(),
+    ...options,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return result.status;
+}
+
+function npmInstall(packages, isDev = false) {
+  const args = ["install", ...(isDev ? ["-D"] : []), ...packages];
+  return runCommand("npm", args);
+}
+
+module.exports = { runCommand, npmInstall };

package/cli/utils/sanitize.d.ts

@@ -0,0 +1 @@
+export function stripControlChars(input: unknown): string;

package/cli/utils/sanitize.js

@@ -0,0 +1,8 @@
+const CONTROL_CHARS_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
+
+function stripControlChars(input) {
+  if (typeof input !== "string") return "";
+  return input.replace(CONTROL_CHARS_RE, "");
+}
+
+module.exports = { stripControlChars };