create-routa-ts 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,649 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { dirname as dirname2, join as join2, relative, resolve as resolve2, sep } from "node:path";
+import { createInterface } from "node:readline/promises";
+
+// src/create-project.ts
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { builtinModules } from "node:module";
+import { basename, dirname, join, resolve } from "node:path";
+function createProject(targetDir, cwd = process.cwd(), options = {}) {
+  const projectDir = resolve(cwd, targetDir);
+  const projectName = basename(projectDir);
+  if (existsSync(projectDir)) {
+    throw new Error(`Target directory already exists: ${targetDir}`);
+  }
+  if (!isValidPackageName(projectName)) {
+    throw new Error(`Invalid package name from target directory: ${projectName}`);
+  }
+  const statusRoute = statusRouteSource();
+  const statusSchemas = statusSchemasSource();
+  const openApi = openApiYaml();
+  const routesMetadata = routesMetadataSource();
+  const openApiBaseline = openApiBaselineJson();
+  const manifest = manifestJson({
+    route: statusRoute,
+    schema: statusSchemas,
+    routesMetadata,
+    baseline: openApiBaseline
+  });
+  const files = /* @__PURE__ */ new Map([
+    [".gitignore", gitignore()],
+    [".vscode/settings.json", vscodeSettings()],
+    ["README.md", readme(projectName, options.openApi ?? true)],
+    ["biome.json", biomeJson()],
+    [
+      "package.json",
+      packageJson(projectName, options.routaVersion ?? "latest", options.openApi ?? true)
+    ],
+    ["src/routa.ts", routaSource()],
+    ["tsconfig.json", tsconfigJson()],
+    ["src/routes/status/route.ts", statusRoute],
+    ["src/routes/status/schemas.ts", statusSchemas]
+  ]);
+  if (options.openApi ?? true) {
+    files.set("openapi.yaml", openApi);
+    files.set(".routa/openapi-baseline.json", openApiBaseline);
+    files.set(".routa/manifest.json", manifest);
+    files.set(".routa/routes.gen.ts", routesMetadata);
+  }
+  for (const [path, content] of files) {
+    const absolutePath = join(projectDir, path);
+    mkdirSync(dirname(absolutePath), { recursive: true });
+    writeFileSync(absolutePath, content);
+  }
+  return { projectDir, files: Array.from(files.keys()) };
+}
+function isValidPackageName(name) {
+  const reservedNames = /* @__PURE__ */ new Set([
+    "node_modules",
+    "favicon.ico",
+    ...builtinModules.map((moduleName) => moduleName.replace(/^node:/, ""))
+  ]);
+  return name.length <= 214 && !reservedNames.has(name) && /^[a-z0-9][a-z0-9._-]*$/.test(name) && encodeURIComponent(name) === name;
+}
+function generatedHeader(source) {
+  return `// Generated by Routa.
+// Safe to edit, but regeneration may update this file after preview.
+// Source: ${source}
+
+`;
+}
+function routesMetadataSource() {
+  const routes = [
+    {
+      file: ["src", "routes", "status", "route.ts"].join("/"),
+      path: "/status",
+      methods: ["GET"],
+      responses: { get: [200] },
+      inputs: { get: { params: false, query: false, body: false } },
+      middleware: [],
+      methodMiddleware: { get: [] },
+      ctx: [],
+      groups: [],
+      segments: ["status"]
+    }
+  ];
+  const emptyCtx = "{ readonly __empty?: never }";
+  const methodCtxMap = `{
+${["get", "post", "put", "patch", "delete", "head", "options"].map((method) => `		${method}: ${emptyCtx};`).join("\n")}
+	}`;
+  return `${generatedHeader("src/routes directory")}export const routaRoutes = ${JSON.stringify(routes, null, "	")} as const;
+
+export type StatusCtx = {
+	readonly __empty?: never;
+};
+
+export type RoutaRouteCtxByPath = {
+	"/status": ${methodCtxMap};
+};
+
+export type RoutaCtxByKey = ${emptyCtx};
+
+declare module "@routa-ts/core" {
+	export interface Register {
+		routeCtxByPath: RoutaRouteCtxByPath;
+		ctxByKey: RoutaCtxByKey;
+	}
+}
+`;
+}
+function openApiBaselineJson() {
+  return `${JSON.stringify(
+    {
+      openapi: "3.1.0",
+      info: {
+        title: "Routa API",
+        version: "0.0.0"
+      },
+      paths: {
+        "/status": {
+          get: {
+            operationId: "getStatus",
+            responses: {
+              "200": {
+                description: "Service status",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      required: ["ok"],
+                      properties: {
+                        ok: {
+                          type: "boolean"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function manifestJson(content) {
+  return `${JSON.stringify(
+    {
+      version: 1,
+      openapi: {
+        baseline: ".routa/openapi-baseline.json"
+      },
+      generated: [
+        {
+          path: "src/routes/status/route.ts",
+          source: "openapi.yaml",
+          operationIds: ["getStatus"],
+          kind: "route",
+          sha256: sha256(content.route)
+        },
+        {
+          path: "src/routes/status/schemas.ts",
+          source: "openapi.yaml",
+          operationIds: ["getStatus"],
+          kind: "schema",
+          sha256: sha256(content.schema)
+        },
+        {
+          path: ".routa/routes.gen.ts",
+          source: "openapi.yaml",
+          kind: "route-metadata",
+          sha256: sha256(content.routesMetadata)
+        },
+        {
+          path: ".routa/openapi-baseline.json",
+          source: "openapi.yaml",
+          kind: "openapi-baseline",
+          sha256: sha256(content.baseline)
+        }
+      ]
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function packageJson(name, routaVersion, openApi) {
+  return `${JSON.stringify(
+    {
+      name,
+      version: "0.0.0",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "routa dev",
+        start: "routa start",
+        check: "routa check",
+        build: "routa build",
+        lint: "biome check .",
+        format: "biome check --write .",
+        ...openApi ? {
+          scaffold: "routa scaffold openapi.yaml",
+          "openapi:check": "routa openapi check"
+        } : {}
+      },
+      dependencies: {
+        "@routa-ts/cli": routaVersion,
+        "@routa-ts/core": routaVersion,
+        hono: "^4.12.27",
+        tsx: "^4.22.4",
+        zod: "^4.4.3"
+      },
+      devDependencies: {
+        "@biomejs/biome": "^2.5.1",
+        "@types/node": "^24.0.4",
+        typescript: "^5.8.3"
+      }
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function tsconfigJson() {
+  return `{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"strict": true,
+		"skipLibCheck": true,
+		"noEmitOnError": true,
+		"outDir": "dist",
+		"types": ["node"]
+	},
+	"include": ["src/**/*.ts", ".routa/**/*.ts"]
+}
+`;
+}
+function gitignore() {
+  return `node_modules/
+dist/
+.env
+.env.local
+coverage/
+`;
+}
+function vscodeSettings() {
+  return `${JSON.stringify(
+    {
+      "files.watcherExclude": {
+        "**/.routa/routes.gen.ts": true
+      },
+      "search.exclude": {
+        "**/.routa/routes.gen.ts": true
+      },
+      "files.readonlyInclude": {
+        "**/.routa/routes.gen.ts": true
+      },
+      "[typescript]": {
+        "editor.defaultFormatter": "biomejs.biome"
+      },
+      "[json]": {
+        "editor.defaultFormatter": "biomejs.biome"
+      },
+      "[jsonc]": {
+        "editor.defaultFormatter": "biomejs.biome"
+      },
+      "editor.codeActionsOnSave": {
+        "source.organizeImports.biome": "explicit"
+      }
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function readme(name, openApi) {
+  return `# ${name}
+
+Routa API generated with \`pnpm create routa-ts@latest\`.
+
+## Development
+
+\`\`\`sh
+pnpm install
+pnpm dev
+\`\`\`
+
+\`pnpm dev\` runs \`routa dev\`, which validates the route graph, generates Routa metadata, typechecks, and starts the internal development server.
+
+## Scripts
+
+\`\`\`sh
+pnpm dev
+pnpm start
+pnpm check
+pnpm build
+pnpm lint
+pnpm format
+${openApi ? "pnpm openapi:check\n" : ""}\`\`\`
+
+## Routes
+
+\`src/routa.ts\` is the user-owned Routa entry point. Routes live in \`src/routes\`.
+
+\`\`\`txt
+src/routa.ts
+src/routes/status/route.ts
+src/routes/status/schemas.ts
+\`\`\`
+
+${openApi ? "Routa owns generated project metadata in `.routa/`. Commit those files so OpenAPI drift and regeneration safety work across machines." : "This starter was created without OpenAPI files. Add `openapi.yaml` later and run `routa scaffold openapi.yaml` if you want generated route metadata."}
+`;
+}
+function biomeJson() {
+  return `${JSON.stringify(
+    {
+      $schema: "./node_modules/@biomejs/biome/configuration_schema.json",
+      root: false,
+      vcs: {
+        enabled: true,
+        clientKind: "git",
+        useIgnoreFile: true
+      },
+      files: {
+        ignoreUnknown: true,
+        includes: ["**", "!node_modules", "!dist", "!coverage", "!.routa"]
+      },
+      formatter: {
+        enabled: true,
+        indentStyle: "tab",
+        lineWidth: 100
+      },
+      linter: {
+        enabled: true,
+        rules: {
+          preset: "recommended",
+          correctness: {
+            useImportExtensions: "off"
+          },
+          suspicious: {
+            noConsole: "off",
+            noExplicitAny: "off"
+          }
+        }
+      },
+      assist: {
+        enabled: true,
+        actions: {
+          source: {
+            recommended: true
+          }
+        }
+      }
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function routaSource() {
+  return `import { createRouta } from "@routa-ts/core";
+
+export default createRouta({
+	port: 3000,
+});
+`;
+}
+function openApiYaml() {
+  return `openapi: 3.1.0
+info:
+  title: Routa API
+  version: 0.0.0
+paths:
+  /status:
+    get:
+      operationId: getStatus
+      responses:
+        "200":
+          description: Service status
+          content:
+            application/json:
+              schema:
+                type: object
+                required:
+                  - ok
+                properties:
+                  ok:
+                    type: boolean
+`;
+}
+function statusRouteSource() {
+  return `import { createRoute, defineRoute } from "@routa-ts/core";
+import { GetStatusResponse } from "./schemas.js";
+
+export default defineRoute({
+	get: createRoute({
+		responses: {
+			success: {
+				status: 200,
+				schema: GetStatusResponse,
+			},
+		},
+		run: () => ({ type: "success", data: { ok: true } }),
+	}),
+});
+`;
+}
+function statusSchemasSource() {
+  return `import { z } from "zod";
+
+export const GetStatusResponse = z.object({
+	ok: z.boolean(),
+});
+`;
+}
+
+// src/ui.ts
+function shouldUseColor() {
+  if ("FORCE_COLOR" in process.env) {
+    return process.env.FORCE_COLOR !== "0";
+  }
+  if ("NO_COLOR" in process.env || process.env.CI) {
+    return false;
+  }
+  return Boolean(process.stdout.isTTY);
+}
+function createUi(color = false) {
+  return {
+    heading: style(color, "1;36"),
+    command: style(color, "36"),
+    success: style(color, "32"),
+    warn: style(color, "33"),
+    error: style(color, "31"),
+    muted: style(color, "2")
+  };
+}
+function style(color, code) {
+  return (value) => color ? `\x1B[${code}m${value}\x1B[0m` : value;
+}
+
+// src/index.ts
+async function runCreate(argv = process.argv.slice(2), cwd = process.cwd()) {
+  const config = await resolveCreateConfig(argv, cwd);
+  const ui = createUi(shouldUseColor());
+  try {
+    printSummary(config, ui);
+    if (config.interactive && config.prompted && !config.yes && !await confirm("Continue with these settings?", true)) {
+      process.stdout.write(`${ui.muted("Creation cancelled.")}
+`);
+      return 0;
+    }
+    const result = createProject(config.targetDir, cwd, {
+      openApi: config.openApi,
+      routaVersion: resolveRoutaVersion(config.cwd, config.targetDir)
+    });
+    if (config.git) {
+      const git = spawnSync("git", ["init"], {
+        cwd: result.projectDir,
+        encoding: "utf8"
+      });
+      if (git.status === 0) {
+        process.stdout.write(`${ui.success("Initialized git repository.")}
+`);
+      } else {
+        process.stderr.write(`${ui.error("git init failed.")} ${git.stderr ?? ""}
+`);
+      }
+    }
+    if (config.install) {
+      const install = spawnSync("pnpm", ["install"], {
+        cwd: result.projectDir,
+        encoding: "utf8",
+        stdio: "inherit"
+      });
+      if (install.status !== 0) {
+        process.stderr.write(
+          `${ui.error('Command "pnpm install" did not run successfully.')} Please run this manually in your project.
+`
+        );
+      }
+    }
+    process.stdout.write(
+      `
+${ui.success(`Your Routa app is ready in '${config.targetDir}'.`)}
+
+`
+    );
+    process.stdout.write("Use the following commands to start your app:\n");
+    process.stdout.write(`${ui.command(`cd ${config.targetDir}`)}
+`);
+    if (!config.install) {
+      process.stdout.write(`${ui.command("pnpm install")}
+`);
+    }
+    process.stdout.write(`${ui.command("pnpm dev")}
+`);
+    return 0;
+  } catch (error) {
+    process.stderr.write(
+      `${ui.error("Error:")} ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    return 1;
+  }
+}
+function resolveRoutaVersion(cwd, targetDir) {
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  if (!workspaceRoot) {
+    return "latest";
+  }
+  const workspaceConfig = readFileSync(join2(workspaceRoot, "pnpm-workspace.yaml"), "utf8");
+  const projectPath = resolve2(cwd, targetDir);
+  const projectRelativePath = relative(workspaceRoot, projectPath).split(sep).join("/");
+  if (workspaceConfig.includes("examples/*") && projectRelativePath.startsWith("examples/")) {
+    return "workspace:*";
+  }
+  return "latest";
+}
+function findWorkspaceRoot(cwd) {
+  let current = resolve2(cwd);
+  while (true) {
+    if (existsSync2(join2(current, "pnpm-workspace.yaml"))) {
+      return current;
+    }
+    const parent = dirname2(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+async function resolveCreateConfig(argv, cwd) {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const targetArg = argv.find((item) => !item.startsWith("-"));
+  let targetDir = targetArg ?? "routa-app";
+  let prompted = false;
+  if (interactive && !targetArg) {
+    const answer = await question("Project name (leave empty to use routa-app)");
+    prompted = true;
+    targetDir = answer.trim() || targetDir;
+  }
+  const openApi = await flagOrPrompt(
+    argv,
+    "--openapi",
+    "--no-openapi",
+    "Include a starter OpenAPI file?",
+    true
+  );
+  const git = await flagOrPrompt(
+    argv,
+    "--git",
+    "--no-git",
+    "Initialize a new git repository?",
+    interactive
+  );
+  const install = await flagOrPrompt(
+    argv,
+    "--install",
+    "--no-install",
+    "Install dependencies?",
+    interactive
+  );
+  prompted = prompted || openApi.prompted || git.prompted || install.prompted;
+  return {
+    targetDir,
+    openApi: openApi.value,
+    git: git.value,
+    install: install.value,
+    interactive,
+    prompted,
+    yes: argv.includes("--yes") || argv.includes("-y"),
+    cwd
+  };
+}
+async function flagOrPrompt(argv, enabledFlag, disabledFlag, label, defaultValue) {
+  if (argv.includes(enabledFlag)) {
+    return { value: true, prompted: false };
+  }
+  if (argv.includes(disabledFlag)) {
+    return { value: false, prompted: false };
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return { value: defaultValue, prompted: false };
+  }
+  return { value: await confirm(label, defaultValue), prompted: true };
+}
+async function question(label) {
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    return await prompt.question(`${label}
+> `);
+  } finally {
+    prompt.close();
+  }
+}
+async function confirm(label, defaultValue) {
+  const suffix = defaultValue ? "Y/n" : "y/N";
+  const answer = (await question(`${label} (${suffix})`)).trim().toLowerCase();
+  if (!answer) {
+    return defaultValue;
+  }
+  return ["y", "yes"].includes(answer);
+}
+function printSummary(config, ui) {
+  process.stdout.write(`${ui.heading("Let's configure your Routa API")}
+
+`);
+  process.stdout.write(`${ui.muted("About to create:")}
+
+`);
+  process.stdout.write(`  Project:         ${config.targetDir}
+`);
+  process.stdout.write(`  Location:        ${config.cwd}/${config.targetDir}
+`);
+  process.stdout.write("  Package manager: pnpm\n");
+  process.stdout.write("  Toolchain:       TypeScript, Biome\n");
+  process.stdout.write(`  OpenAPI starter: ${config.openApi ? "yes" : "no"}
+`);
+  process.stdout.write(`  Initialize git:  ${config.git ? "yes" : "no"}
+`);
+  process.stdout.write(`  Install deps:    ${config.install ? "yes" : "no"}
+
+`);
+}
+
+// src/cli.ts
+runCreate().then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 1;
+});

package/dist/create-project.d.ts

@@ -0,0 +1,18 @@
+export type CreateProjectResult = {
+    projectDir: string;
+    files: string[];
+};
+export type CreateProjectOptions = {
+    openApi?: boolean;
+    routaVersion?: string;
+};
+/**
+ * Creates a new Routa project scaffold in the target directory.
+ *
+ * @param targetDir - Directory for the new project, resolved relative to `cwd`
+ * @param cwd - Base directory used to resolve `targetDir`
+ * @param options - Project generation options
+ * @returns The absolute project directory and the list of generated file paths
+ * @throws Error if the target directory already exists
+ */
+export declare function createProject(targetDir: string, cwd?: string, options?: CreateProjectOptions): CreateProjectResult;

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+export { createProject } from "./create-project.js";
+export { createUi, shouldUseColor, type Ui } from "./ui.js";
+/**
+ * Prepends the create subcommand to an argument list.
+ *
+ * @param argv - The original command-line arguments
+ * @returns The arguments with `"create"` inserted at the beginning
+ */
+export declare function createCommandArgs(argv: readonly string[]): string[];
+/**
+ * Creates a new Routa app from the provided command-line arguments.
+ *
+ * @param argv - Command-line arguments to parse
+ * @param cwd - Current working directory used to resolve paths
+ * @returns `0` on success or cancellation, `1` if project creation fails
+ */
+export declare function runCreate(argv?: string[], cwd?: string): Promise<number>;
+/**
+ * Resolves the Routa package version for a new project.
+ *
+ * @param cwd - The current working directory used to locate a pnpm workspace
+ * @param targetDir - The target project directory
+ * @returns `"workspace:*"` for example projects in matching workspaces, `"latest"` otherwise
+ */
+export declare function resolveRoutaVersion(cwd: string, targetDir: string): "latest" | "workspace:*";

package/dist/index.js

@@ -0,0 +1,651 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { dirname as dirname2, join as join2, relative, resolve as resolve2, sep } from "node:path";
+import { createInterface } from "node:readline/promises";
+
+// src/create-project.ts
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { builtinModules } from "node:module";
+import { basename, dirname, join, resolve } from "node:path";
+function createProject(targetDir, cwd = process.cwd(), options = {}) {
+  const projectDir = resolve(cwd, targetDir);
+  const projectName = basename(projectDir);
+  if (existsSync(projectDir)) {
+    throw new Error(`Target directory already exists: ${targetDir}`);
+  }
+  if (!isValidPackageName(projectName)) {
+    throw new Error(`Invalid package name from target directory: ${projectName}`);
+  }
+  const statusRoute = statusRouteSource();
+  const statusSchemas = statusSchemasSource();
+  const openApi = openApiYaml();
+  const routesMetadata = routesMetadataSource();
+  const openApiBaseline = openApiBaselineJson();
+  const manifest = manifestJson({
+    route: statusRoute,
+    schema: statusSchemas,
+    routesMetadata,
+    baseline: openApiBaseline
+  });
+  const files = /* @__PURE__ */ new Map([
+    [".gitignore", gitignore()],
+    [".vscode/settings.json", vscodeSettings()],
+    ["README.md", readme(projectName, options.openApi ?? true)],
+    ["biome.json", biomeJson()],
+    [
+      "package.json",
+      packageJson(projectName, options.routaVersion ?? "latest", options.openApi ?? true)
+    ],
+    ["src/routa.ts", routaSource()],
+    ["tsconfig.json", tsconfigJson()],
+    ["src/routes/status/route.ts", statusRoute],
+    ["src/routes/status/schemas.ts", statusSchemas]
+  ]);
+  if (options.openApi ?? true) {
+    files.set("openapi.yaml", openApi);
+    files.set(".routa/openapi-baseline.json", openApiBaseline);
+    files.set(".routa/manifest.json", manifest);
+    files.set(".routa/routes.gen.ts", routesMetadata);
+  }
+  for (const [path, content] of files) {
+    const absolutePath = join(projectDir, path);
+    mkdirSync(dirname(absolutePath), { recursive: true });
+    writeFileSync(absolutePath, content);
+  }
+  return { projectDir, files: Array.from(files.keys()) };
+}
+function isValidPackageName(name) {
+  const reservedNames = /* @__PURE__ */ new Set([
+    "node_modules",
+    "favicon.ico",
+    ...builtinModules.map((moduleName) => moduleName.replace(/^node:/, ""))
+  ]);
+  return name.length <= 214 && !reservedNames.has(name) && /^[a-z0-9][a-z0-9._-]*$/.test(name) && encodeURIComponent(name) === name;
+}
+function generatedHeader(source) {
+  return `// Generated by Routa.
+// Safe to edit, but regeneration may update this file after preview.
+// Source: ${source}
+
+`;
+}
+function routesMetadataSource() {
+  const routes = [
+    {
+      file: ["src", "routes", "status", "route.ts"].join("/"),
+      path: "/status",
+      methods: ["GET"],
+      responses: { get: [200] },
+      inputs: { get: { params: false, query: false, body: false } },
+      middleware: [],
+      methodMiddleware: { get: [] },
+      ctx: [],
+      groups: [],
+      segments: ["status"]
+    }
+  ];
+  const emptyCtx = "{ readonly __empty?: never }";
+  const methodCtxMap = `{
+${["get", "post", "put", "patch", "delete", "head", "options"].map((method) => `		${method}: ${emptyCtx};`).join("\n")}
+	}`;
+  return `${generatedHeader("src/routes directory")}export const routaRoutes = ${JSON.stringify(routes, null, "	")} as const;
+
+export type StatusCtx = {
+	readonly __empty?: never;
+};
+
+export type RoutaRouteCtxByPath = {
+	"/status": ${methodCtxMap};
+};
+
+export type RoutaCtxByKey = ${emptyCtx};
+
+declare module "@routa-ts/core" {
+	export interface Register {
+		routeCtxByPath: RoutaRouteCtxByPath;
+		ctxByKey: RoutaCtxByKey;
+	}
+}
+`;
+}
+function openApiBaselineJson() {
+  return `${JSON.stringify(
+    {
+      openapi: "3.1.0",
+      info: {
+        title: "Routa API",
+        version: "0.0.0"
+      },
+      paths: {
+        "/status": {
+          get: {
+            operationId: "getStatus",
+            responses: {
+              "200": {
+                description: "Service status",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      required: ["ok"],
+                      properties: {
+                        ok: {
+                          type: "boolean"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function manifestJson(content) {
+  return `${JSON.stringify(
+    {
+      version: 1,
+      openapi: {
+        baseline: ".routa/openapi-baseline.json"
+      },
+      generated: [
+        {
+          path: "src/routes/status/route.ts",
+          source: "openapi.yaml",
+          operationIds: ["getStatus"],
+          kind: "route",
+          sha256: sha256(content.route)
+        },
+        {
+          path: "src/routes/status/schemas.ts",
+          source: "openapi.yaml",
+          operationIds: ["getStatus"],
+          kind: "schema",
+          sha256: sha256(content.schema)
+        },
+        {
+          path: ".routa/routes.gen.ts",
+          source: "openapi.yaml",
+          kind: "route-metadata",
+          sha256: sha256(content.routesMetadata)
+        },
+        {
+          path: ".routa/openapi-baseline.json",
+          source: "openapi.yaml",
+          kind: "openapi-baseline",
+          sha256: sha256(content.baseline)
+        }
+      ]
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function packageJson(name, routaVersion, openApi) {
+  return `${JSON.stringify(
+    {
+      name,
+      version: "0.0.0",
+      private: true,
+      type: "module",
+      scripts: {
+        dev: "routa dev",
+        start: "routa start",
+        check: "routa check",
+        build: "routa build",
+        lint: "biome check .",
+        format: "biome check --write .",
+        ...openApi ? {
+          scaffold: "routa scaffold openapi.yaml",
+          "openapi:check": "routa openapi check"
+        } : {}
+      },
+      dependencies: {
+        "@routa-ts/cli": routaVersion,
+        "@routa-ts/core": routaVersion,
+        hono: "^4.12.27",
+        tsx: "^4.22.4",
+        zod: "^4.4.3"
+      },
+      devDependencies: {
+        "@biomejs/biome": "^2.5.1",
+        "@types/node": "^24.0.4",
+        typescript: "^5.8.3"
+      }
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function tsconfigJson() {
+  return `{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"strict": true,
+		"skipLibCheck": true,
+		"noEmitOnError": true,
+		"outDir": "dist",
+		"types": ["node"]
+	},
+	"include": ["src/**/*.ts", ".routa/**/*.ts"]
+}
+`;
+}
+function gitignore() {
+  return `node_modules/
+dist/
+.env
+.env.local
+coverage/
+`;
+}
+function vscodeSettings() {
+  return `${JSON.stringify(
+    {
+      "files.watcherExclude": {
+        "**/.routa/routes.gen.ts": true
+      },
+      "search.exclude": {
+        "**/.routa/routes.gen.ts": true
+      },
+      "files.readonlyInclude": {
+        "**/.routa/routes.gen.ts": true
+      },
+      "[typescript]": {
+        "editor.defaultFormatter": "biomejs.biome"
+      },
+      "[json]": {
+        "editor.defaultFormatter": "biomejs.biome"
+      },
+      "[jsonc]": {
+        "editor.defaultFormatter": "biomejs.biome"
+      },
+      "editor.codeActionsOnSave": {
+        "source.organizeImports.biome": "explicit"
+      }
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function readme(name, openApi) {
+  return `# ${name}
+
+Routa API generated with \`pnpm create routa-ts@latest\`.
+
+## Development
+
+\`\`\`sh
+pnpm install
+pnpm dev
+\`\`\`
+
+\`pnpm dev\` runs \`routa dev\`, which validates the route graph, generates Routa metadata, typechecks, and starts the internal development server.
+
+## Scripts
+
+\`\`\`sh
+pnpm dev
+pnpm start
+pnpm check
+pnpm build
+pnpm lint
+pnpm format
+${openApi ? "pnpm openapi:check\n" : ""}\`\`\`
+
+## Routes
+
+\`src/routa.ts\` is the user-owned Routa entry point. Routes live in \`src/routes\`.
+
+\`\`\`txt
+src/routa.ts
+src/routes/status/route.ts
+src/routes/status/schemas.ts
+\`\`\`
+
+${openApi ? "Routa owns generated project metadata in `.routa/`. Commit those files so OpenAPI drift and regeneration safety work across machines." : "This starter was created without OpenAPI files. Add `openapi.yaml` later and run `routa scaffold openapi.yaml` if you want generated route metadata."}
+`;
+}
+function biomeJson() {
+  return `${JSON.stringify(
+    {
+      $schema: "./node_modules/@biomejs/biome/configuration_schema.json",
+      root: false,
+      vcs: {
+        enabled: true,
+        clientKind: "git",
+        useIgnoreFile: true
+      },
+      files: {
+        ignoreUnknown: true,
+        includes: ["**", "!node_modules", "!dist", "!coverage", "!.routa"]
+      },
+      formatter: {
+        enabled: true,
+        indentStyle: "tab",
+        lineWidth: 100
+      },
+      linter: {
+        enabled: true,
+        rules: {
+          preset: "recommended",
+          correctness: {
+            useImportExtensions: "off"
+          },
+          suspicious: {
+            noConsole: "off",
+            noExplicitAny: "off"
+          }
+        }
+      },
+      assist: {
+        enabled: true,
+        actions: {
+          source: {
+            recommended: true
+          }
+        }
+      }
+    },
+    null,
+    "	"
+  )}
+`;
+}
+function routaSource() {
+  return `import { createRouta } from "@routa-ts/core";
+
+export default createRouta({
+	port: 3000,
+});
+`;
+}
+function openApiYaml() {
+  return `openapi: 3.1.0
+info:
+  title: Routa API
+  version: 0.0.0
+paths:
+  /status:
+    get:
+      operationId: getStatus
+      responses:
+        "200":
+          description: Service status
+          content:
+            application/json:
+              schema:
+                type: object
+                required:
+                  - ok
+                properties:
+                  ok:
+                    type: boolean
+`;
+}
+function statusRouteSource() {
+  return `import { createRoute, defineRoute } from "@routa-ts/core";
+import { GetStatusResponse } from "./schemas.js";
+
+export default defineRoute({
+	get: createRoute({
+		responses: {
+			success: {
+				status: 200,
+				schema: GetStatusResponse,
+			},
+		},
+		run: () => ({ type: "success", data: { ok: true } }),
+	}),
+});
+`;
+}
+function statusSchemasSource() {
+  return `import { z } from "zod";
+
+export const GetStatusResponse = z.object({
+	ok: z.boolean(),
+});
+`;
+}
+
+// src/ui.ts
+function shouldUseColor() {
+  if ("FORCE_COLOR" in process.env) {
+    return process.env.FORCE_COLOR !== "0";
+  }
+  if ("NO_COLOR" in process.env || process.env.CI) {
+    return false;
+  }
+  return Boolean(process.stdout.isTTY);
+}
+function createUi(color = false) {
+  return {
+    heading: style(color, "1;36"),
+    command: style(color, "36"),
+    success: style(color, "32"),
+    warn: style(color, "33"),
+    error: style(color, "31"),
+    muted: style(color, "2")
+  };
+}
+function style(color, code) {
+  return (value) => color ? `\x1B[${code}m${value}\x1B[0m` : value;
+}
+
+// src/index.ts
+function createCommandArgs(argv) {
+  return ["create", ...argv];
+}
+async function runCreate(argv = process.argv.slice(2), cwd = process.cwd()) {
+  const config = await resolveCreateConfig(argv, cwd);
+  const ui = createUi(shouldUseColor());
+  try {
+    printSummary(config, ui);
+    if (config.interactive && config.prompted && !config.yes && !await confirm("Continue with these settings?", true)) {
+      process.stdout.write(`${ui.muted("Creation cancelled.")}
+`);
+      return 0;
+    }
+    const result = createProject(config.targetDir, cwd, {
+      openApi: config.openApi,
+      routaVersion: resolveRoutaVersion(config.cwd, config.targetDir)
+    });
+    if (config.git) {
+      const git = spawnSync("git", ["init"], {
+        cwd: result.projectDir,
+        encoding: "utf8"
+      });
+      if (git.status === 0) {
+        process.stdout.write(`${ui.success("Initialized git repository.")}
+`);
+      } else {
+        process.stderr.write(`${ui.error("git init failed.")} ${git.stderr ?? ""}
+`);
+      }
+    }
+    if (config.install) {
+      const install = spawnSync("pnpm", ["install"], {
+        cwd: result.projectDir,
+        encoding: "utf8",
+        stdio: "inherit"
+      });
+      if (install.status !== 0) {
+        process.stderr.write(
+          `${ui.error('Command "pnpm install" did not run successfully.')} Please run this manually in your project.
+`
+        );
+      }
+    }
+    process.stdout.write(
+      `
+${ui.success(`Your Routa app is ready in '${config.targetDir}'.`)}
+
+`
+    );
+    process.stdout.write("Use the following commands to start your app:\n");
+    process.stdout.write(`${ui.command(`cd ${config.targetDir}`)}
+`);
+    if (!config.install) {
+      process.stdout.write(`${ui.command("pnpm install")}
+`);
+    }
+    process.stdout.write(`${ui.command("pnpm dev")}
+`);
+    return 0;
+  } catch (error) {
+    process.stderr.write(
+      `${ui.error("Error:")} ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    return 1;
+  }
+}
+function resolveRoutaVersion(cwd, targetDir) {
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  if (!workspaceRoot) {
+    return "latest";
+  }
+  const workspaceConfig = readFileSync(join2(workspaceRoot, "pnpm-workspace.yaml"), "utf8");
+  const projectPath = resolve2(cwd, targetDir);
+  const projectRelativePath = relative(workspaceRoot, projectPath).split(sep).join("/");
+  if (workspaceConfig.includes("examples/*") && projectRelativePath.startsWith("examples/")) {
+    return "workspace:*";
+  }
+  return "latest";
+}
+function findWorkspaceRoot(cwd) {
+  let current = resolve2(cwd);
+  while (true) {
+    if (existsSync2(join2(current, "pnpm-workspace.yaml"))) {
+      return current;
+    }
+    const parent = dirname2(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+async function resolveCreateConfig(argv, cwd) {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const targetArg = argv.find((item) => !item.startsWith("-"));
+  let targetDir = targetArg ?? "routa-app";
+  let prompted = false;
+  if (interactive && !targetArg) {
+    const answer = await question("Project name (leave empty to use routa-app)");
+    prompted = true;
+    targetDir = answer.trim() || targetDir;
+  }
+  const openApi = await flagOrPrompt(
+    argv,
+    "--openapi",
+    "--no-openapi",
+    "Include a starter OpenAPI file?",
+    true
+  );
+  const git = await flagOrPrompt(
+    argv,
+    "--git",
+    "--no-git",
+    "Initialize a new git repository?",
+    interactive
+  );
+  const install = await flagOrPrompt(
+    argv,
+    "--install",
+    "--no-install",
+    "Install dependencies?",
+    interactive
+  );
+  prompted = prompted || openApi.prompted || git.prompted || install.prompted;
+  return {
+    targetDir,
+    openApi: openApi.value,
+    git: git.value,
+    install: install.value,
+    interactive,
+    prompted,
+    yes: argv.includes("--yes") || argv.includes("-y"),
+    cwd
+  };
+}
+async function flagOrPrompt(argv, enabledFlag, disabledFlag, label, defaultValue) {
+  if (argv.includes(enabledFlag)) {
+    return { value: true, prompted: false };
+  }
+  if (argv.includes(disabledFlag)) {
+    return { value: false, prompted: false };
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return { value: defaultValue, prompted: false };
+  }
+  return { value: await confirm(label, defaultValue), prompted: true };
+}
+async function question(label) {
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    return await prompt.question(`${label}
+> `);
+  } finally {
+    prompt.close();
+  }
+}
+async function confirm(label, defaultValue) {
+  const suffix = defaultValue ? "Y/n" : "y/N";
+  const answer = (await question(`${label} (${suffix})`)).trim().toLowerCase();
+  if (!answer) {
+    return defaultValue;
+  }
+  return ["y", "yes"].includes(answer);
+}
+function printSummary(config, ui) {
+  process.stdout.write(`${ui.heading("Let's configure your Routa API")}
+
+`);
+  process.stdout.write(`${ui.muted("About to create:")}
+
+`);
+  process.stdout.write(`  Project:         ${config.targetDir}
+`);
+  process.stdout.write(`  Location:        ${config.cwd}/${config.targetDir}
+`);
+  process.stdout.write("  Package manager: pnpm\n");
+  process.stdout.write("  Toolchain:       TypeScript, Biome\n");
+  process.stdout.write(`  OpenAPI starter: ${config.openApi ? "yes" : "no"}
+`);
+  process.stdout.write(`  Initialize git:  ${config.git ? "yes" : "no"}
+`);
+  process.stdout.write(`  Install deps:    ${config.install ? "yes" : "no"}
+
+`);
+}
+export {
+  createCommandArgs,
+  createProject,
+  createUi,
+  resolveRoutaVersion,
+  runCreate,
+  shouldUseColor
+};

package/dist/ui.d.ts

@@ -0,0 +1,10 @@
+export type Ui = {
+    heading: (value: string) => string;
+    command: (value: string) => string;
+    success: (value: string) => string;
+    warn: (value: string) => string;
+    error: (value: string) => string;
+    muted: (value: string) => string;
+};
+export declare function shouldUseColor(): boolean;
+export declare function createUi(color?: boolean): Ui;

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "create-routa-ts",
+	"version": "0.1.0",
+	"description": "Scaffold a new Routa API project",
+	"private": false,
+	"type": "module",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/joseAcevesG/Routa.git",
+		"directory": "packages/create-routa-ts"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"bin": {
+		"create-routa-ts": "./dist/cli.js"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "node ../../scripts/build-package.mjs create-routa-ts",
+		"typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+		"lint": "biome lint src",
+		"test": "vitest run"
+	}
+}