speexjs 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,1017 @@
+#!/usr/bin/env node
+
+// src/native/args.ts
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const result = {
+    command: "",
+    args: [],
+    options: {}
+  };
+  if (args.length === 0) return result;
+  const first = args[0];
+  if (first.includes(":")) {
+    result.command = first;
+    parseOptions(args.slice(1), result);
+    return result;
+  }
+  result.command = first;
+  if (args.length > 1) {
+    const second = args[1];
+    if (!second.startsWith("-")) {
+      result.subcommand = second;
+      result.args.push(second);
+      parseOptions(args.slice(2), result);
+      return result;
+    }
+  }
+  parseOptions(args.slice(1), result);
+  return result;
+}
+function parseOptions(argv, result) {
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--") {
+      for (let j = i + 1; j < argv.length; j++) {
+        result.args.push(argv[j]);
+      }
+      break;
+    }
+    if (arg.startsWith("--no-")) {
+      const key = arg.slice(5);
+      if (key) {
+        result.options[key] = false;
+      }
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+        const val = argv[i + 1];
+        const existing = result.options[key];
+        if (existing !== void 0) {
+          result.options[key] = Array.isArray(existing) ? [...existing, val] : [existing, val];
+        } else {
+          result.options[key] = val;
+        }
+        i += 2;
+      } else {
+        result.options[key] = true;
+        i++;
+      }
+      continue;
+    }
+    if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+        const val = argv[i + 1];
+        result.options[key] = val;
+        i += 2;
+      } else {
+        result.options[key] = true;
+        i++;
+      }
+      continue;
+    }
+    result.args.push(arg);
+    i++;
+  }
+}
+
+// src/native/colors.ts
+var RESET = "\x1B[0m";
+var codes = {
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m"
+};
+var colors = {
+  red: (s) => `${codes.red}${s}${RESET}`,
+  green: (s) => `${codes.green}${s}${RESET}`,
+  yellow: (s) => `${codes.yellow}${s}${RESET}`,
+  blue: (s) => `${codes.blue}${s}${RESET}`,
+  magenta: (s) => `${codes.magenta}${s}${RESET}`,
+  cyan: (s) => `${codes.cyan}${s}${RESET}`,
+  gray: (s) => `${codes.gray}${s}${RESET}`,
+  white: (s) => `${codes.white}${s}${RESET}`,
+  bold: (s) => `${codes.bold}${s}${RESET}`,
+  dim: (s) => `${codes.dim}${s}${RESET}`,
+  italic: (s) => `${codes.italic}${s}${RESET}`,
+  underline: (s) => `${codes.underline}${s}${RESET}`
+};
+function isColorSupported() {
+  if (typeof process === "undefined") return false;
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return true;
+  if (!process.stdout) return false;
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+
+// src/cli/commands/init.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+var TEMPLATES = {
+  blank: {
+    dirs: ["src"],
+    files: {
+      "package.json": (name) => JSON.stringify(
+        {
+          name,
+          version: "0.1.0",
+          type: "module",
+          private: true,
+          scripts: {
+            dev: "SpeedX serve",
+            build: "SpeedX build",
+            start: "node dist/index.js"
+          },
+          dependencies: {
+            SpeedX: "latest"
+          },
+          devDependencies: {
+            "@types/node": "^26.0.1",
+            typescript: "^5.7.0"
+          }
+        },
+        null,
+        2
+      ),
+      "tsconfig.json": JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            strict: true,
+            declaration: true,
+            sourceMap: true,
+            esModuleInterop: true,
+            isolatedModules: true,
+            resolveJsonModule: true,
+            outDir: "./dist",
+            rootDir: "./src"
+          },
+          include: ["src/**/*.ts"],
+          exclude: ["node_modules", "dist"]
+        },
+        null,
+        2
+      ),
+      "src/index.ts": `import { SpeedX } from 'speedx/server'
+
+const app = SpeedX()
+
+const PORT = Number(process.env.PORT) || 3000
+
+app.get('/', async ({ response }) => {
+  return response.html('<h1>SpeedX \u{1F680}</h1>')
+})
+
+app.listen(PORT, () => {
+  console.log(\`SpeedX running on http://localhost:\${PORT}\`)
+})
+`,
+      "src/app.ts": `import { SpeedX } from 'speedx/server'
+
+export function createApp() {
+  const app = SpeedX()
+  return app
+}
+`,
+      ".env.example": `PORT=3000
+NODE_ENV=development
+`,
+      ".gitignore": `node_modules/
+dist/
+.env
+*.log
+`
+    }
+  },
+  fullstack: {
+    dirs: [
+      "src/server",
+      "src/server/controllers",
+      "src/server/middleware",
+      "src/client",
+      "src/client/components",
+      "src/client/pages",
+      "src/shared",
+      "public"
+    ],
+    files: {
+      "package.json": (name) => JSON.stringify(
+        {
+          name,
+          version: "0.1.0",
+          type: "module",
+          private: true,
+          scripts: {
+            dev: "SpeedX serve",
+            build: "tsc",
+            start: "node dist/server/index.js"
+          },
+          dependencies: {
+            SpeedX: "latest"
+          },
+          devDependencies: {
+            "@types/node": "^26.0.1",
+            typescript: "^5.7.0"
+          }
+        },
+        null,
+        2
+      ),
+      "tsconfig.json": JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            strict: true,
+            declaration: true,
+            sourceMap: true,
+            esModuleInterop: true,
+            isolatedModules: true,
+            resolveJsonModule: true,
+            jsx: "react-jsx",
+            jsxImportSource: "@SpeedX/vdom",
+            outDir: "./dist",
+            rootDir: "./src"
+          },
+          include: ["src/**/*.ts", "src/**/*.tsx"],
+          exclude: ["node_modules", "dist"]
+        },
+        null,
+        2
+      ),
+      "src/server/index.ts": `import { SpeedX } from 'speedx/server'
+import { UserController } from './controllers/user.controller.js'
+
+const PORT = Number(process.env.PORT) || 3000
+
+const app = SpeedX()
+
+app.controller(UserController)
+
+app.get('/', async ({ response }) => {
+  return response.html(\`
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+      <meta charset="UTF-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+      <title>SpeedX Fullstack</title>
+    </head>
+    <body>
+      <div id="root"></div>
+      <script type="module" src="/client/index.js"></script>
+    </body>
+    </html>
+  \`)
+})
+
+app.listen(PORT, () => {
+  console.log(\`SpeedX running on http://localhost:\${PORT}\`)
+})
+`,
+      "src/server/controllers/user.controller.ts": `import { Controller, get, post } from 'speedx/server'
+
+export class UserController extends Controller {
+  @get('/users')
+  async index({ response }) {
+    return response.json({ data: [] })
+  }
+
+  @post('/users')
+  async store({ request, response }) {
+    const body = await request.body()
+    return response.json({ data: body }, 201)
+  }
+}
+`,
+      "src/client/index.ts": `import { createApp } from './app.js'
+
+document.addEventListener('DOMContentLoaded', () => {
+  createApp().mount('#root')
+})
+`,
+      "src/client/app.ts": `export function createApp() {
+  function mount(selector: string) {
+    const root = document.querySelector(selector)
+    if (!root) {
+      console.error('Root element not found:', selector)
+      return
+    }
+    root.innerHTML = \`
+      <div style="text-align:center;padding:2rem">
+        <h1>SpeedX Fullstack</h1>
+        <p>Welcome to SpeedX!</p>
+      </div>
+    \`
+  }
+
+  return { mount }
+}
+`,
+      "public/style.css": `* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  background: #0f172a;
+  color: #e2e8f0;
+  min-height: 100vh;
+}
+
+#root {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+}
+`,
+      "src/shared/types.ts": `export interface ApiResponse<T = unknown> {
+  success: boolean
+  data: T
+  message?: string
+}
+`,
+      ".env.example": `PORT=3000
+NODE_ENV=development
+`,
+      ".gitignore": `node_modules/
+dist/
+.env
+*.log
+`
+    }
+  },
+  "api-only": {
+    dirs: ["src", "src/controllers", "src/middleware"],
+    files: {
+      "package.json": (name) => JSON.stringify(
+        {
+          name,
+          version: "0.1.0",
+          type: "module",
+          private: true,
+          scripts: {
+            dev: "SpeedX serve",
+            build: "tsc",
+            start: "node dist/index.js"
+          },
+          dependencies: {
+            SpeedX: "latest"
+          },
+          devDependencies: {
+            "@types/node": "^26.0.1",
+            typescript: "^5.7.0"
+          }
+        },
+        null,
+        2
+      ),
+      "tsconfig.json": JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            strict: true,
+            declaration: true,
+            sourceMap: true,
+            esModuleInterop: true,
+            isolatedModules: true,
+            resolveJsonModule: true,
+            outDir: "./dist",
+            rootDir: "./src"
+          },
+          include: ["src/**/*.ts"],
+          exclude: ["node_modules", "dist"]
+        },
+        null,
+        2
+      ),
+      "src/index.ts": `import { SpeedX } from 'speedx/server'
+
+const PORT = Number(process.env.PORT) || 3000
+
+const app = SpeedX()
+
+app.get('/api/health', async ({ response }) => {
+  return response.json({ status: 'ok', timestamp: new Date().toISOString() })
+})
+
+app.listen(PORT, () => {
+  console.log(\`SpeedX API running on http://localhost:\${PORT}\`)
+})
+`,
+      "src/controllers/health.controller.ts": `import { Controller, get } from 'speedx/server'
+
+export class HealthController extends Controller {
+  @get('/health')
+  async check({ response }) {
+    return response.json({
+      status: 'ok',
+      uptime: process.uptime(),
+    })
+  }
+}
+`,
+      "src/middleware/auth.ts": `import type { RouteContext } from 'speedx/server/router'
+
+export function auth() {
+  return async (ctx: RouteContext, next: () => Promise<void>) => {
+    const token = ctx.request.headers.get('authorization')
+
+    if (!token) {
+      ctx.response.status(401).json({
+        error: 'Unauthorized',
+        message: 'Missing authorization header',
+      })
+      return
+    }
+
+    await next()
+  }
+}
+`,
+      ".env.example": `PORT=3000
+NODE_ENV=development
+`,
+      ".gitignore": `node_modules/
+dist/
+.env
+*.log
+`
+    }
+  }
+};
+var TEMPLATE_ALIASES = {
+  api: "api-only",
+  full: "fullstack"
+};
+function getTemplate(name) {
+  return TEMPLATE_ALIASES[name] ?? name;
+}
+function toPascalCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => (c ?? "").toUpperCase()).replace(/^(.)/, (c) => c.toUpperCase());
+}
+async function initProject(name, options) {
+  const targetDir = resolve(process.cwd(), name);
+  if (existsSync(targetDir)) {
+    console.error(colors.red(`Directory '${name}' sudah ada!`));
+    process.exit(1);
+  }
+  const templateName = getTemplate(String(options.template || "blank"));
+  const template = TEMPLATES[templateName];
+  if (!template) {
+    console.error(
+      colors.red(
+        `Template '${options.template}' tidak dikenal. Gunakan: blank, fullstack, api-only`
+      )
+    );
+    process.exit(1);
+  }
+  mkdirSync(targetDir, { recursive: true });
+  for (const dir of template.dirs) {
+    mkdirSync(resolve(targetDir, dir), { recursive: true });
+  }
+  for (const [filePath, content] of Object.entries(template.files)) {
+    const fullPath = resolve(targetDir, filePath);
+    mkdirSync(dirname(fullPath), { recursive: true });
+    const resolvedContent = typeof content === "function" ? content(name) : content;
+    writeFileSync(fullPath, resolvedContent, "utf-8");
+  }
+  if (options.git !== false) {
+    try {
+      const { execSync } = await import("child_process");
+      execSync("git init", { cwd: targetDir, stdio: "ignore" });
+    } catch {
+    }
+  }
+  if (options.install !== false) {
+    const pm = String(options["package-manager"] || options.packageManager || "npm");
+    try {
+      const { execSync } = await import("child_process");
+      console.log(`  ${colors.cyan("\u2192")} Installing dependencies with ${pm}...`);
+      execSync(`${pm} install`, { cwd: targetDir, stdio: "inherit" });
+    } catch {
+      console.log(
+        `  ${colors.yellow("!")} Dependency install skipped. Run '${pm} install' manually.`
+      );
+    }
+  }
+  const packageManager = String(options["package-manager"] || options.packageManager || "npm");
+  console.log();
+  console.log(`${colors.bold("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}`);
+  console.log(`${colors.bold("\u2551")}        ${colors.green("SpeedX \u{1F680} Project Created")}${colors.bold("       \u2551")}`);
+  console.log(`${colors.bold("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}`);
+  console.log();
+  console.log(`  ${colors.bold("Name:")}     ${toPascalCase(name)}`);
+  console.log(`  ${colors.bold("Template:")} ${templateName}`);
+  console.log(`  ${colors.bold("Dir:")}      ${targetDir}`);
+  console.log();
+  console.log(`  ${colors.cyan("$")} cd ${name}`);
+  console.log(`  ${colors.cyan("$")} ${packageManager} run dev`);
+  console.log();
+}
+
+// src/cli/commands/make-controller.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+function toPascalCase2(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => (c ?? "").toUpperCase()).replace(/^(.)/, (c) => c.toUpperCase());
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function toCamelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => (c ?? "").toUpperCase()).replace(/^(.)/, (c) => c.toLowerCase());
+}
+function makeController(name) {
+  const className = `${toPascalCase2(name)}Controller`;
+  const fileName = `${toKebabCase(name)}.controller.ts`;
+  const targetDir = resolve2(process.cwd(), "src/server/controllers");
+  const fullPath = resolve2(targetDir, fileName);
+  const varName = toCamelCase(name);
+  if (existsSync2(fullPath)) {
+    console.error(colors.red(`File ${fileName} sudah ada!`));
+    process.exit(1);
+  }
+  mkdirSync2(targetDir, { recursive: true });
+  const content = `import { Controller, get, post, put, del } from 'speedx/server'
+import type { RouteContext } from 'speedx/server/router'
+
+export class ${className} extends Controller {
+  @get('/')
+  async index({ response }: RouteContext) {
+    return response.json({ data: [] })
+  }
+
+  @get('/:id')
+  async show({ response, params }: RouteContext) {
+    return response.json({ data: { id: params.id } })
+  }
+
+  @post('/')
+  async store({ request, response }: RouteContext) {
+    const body = await request.body()
+    return response.json({ data: body }, 201)
+  }
+
+  @put('/:id')
+  async update({ request, response, params }: RouteContext) {
+    const body = await request.body()
+    return response.json({ data: { id: params.id, ...body } })
+  }
+
+  @del('/:id')
+  async destroy({ response, params }: RouteContext) {
+    return response.json({ message: \`${className} deleted \${params.id}\` })
+  }
+}
+
+export const ${varName}Controller = ${className}
+`;
+  writeFileSync2(fullPath, content, "utf-8");
+  console.log(
+    `${colors.green("\u2705")} Controller ${colors.bold(className)} dibuat di ${colors.cyan(fileName)}`
+  );
+}
+
+// src/cli/commands/make-middleware.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+function toPascalCase3(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => (c ?? "").toUpperCase()).replace(/^(.)/, (c) => c.toUpperCase());
+}
+function toKebabCase2(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function toCamelCase2(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => (c ?? "").toUpperCase()).replace(/^(.)/, (c) => c.toLowerCase());
+}
+function makeMiddleware(name) {
+  const functionName = toCamelCase2(name);
+  const className = toPascalCase3(name);
+  const fileName = `${toKebabCase2(name)}.middleware.ts`;
+  const targetDir = resolve3(process.cwd(), "src/server/middleware");
+  const fullPath = resolve3(targetDir, fileName);
+  if (existsSync3(fullPath)) {
+    console.error(colors.red(`File ${fileName} sudah ada!`));
+    process.exit(1);
+  }
+  mkdirSync3(targetDir, { recursive: true });
+  const content = `import type { RouteContext } from 'speedx/server/router'
+
+export function ${functionName}(options?: Record<string, unknown>) {
+  return async (ctx: RouteContext, next: () => Promise<void>) => {
+    const start = Date.now()
+
+    await next()
+
+    const duration = Date.now() - start
+    console.log(\`[${className}Middleware] \${ctx.request.method} \${ctx.request.url} \${duration}ms\`)
+  }
+}
+`;
+  writeFileSync3(fullPath, content, "utf-8");
+  console.log(
+    `${colors.green("\u2705")} Middleware ${colors.bold(functionName)} dibuat di ${colors.cyan(fileName)}`
+  );
+}
+
+// src/cli/commands/make-schema.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+function toPascalCase4(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => (c ?? "").toUpperCase()).replace(/^(.)/, (c) => c.toUpperCase());
+}
+function toKebabCase3(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function makeSchema(name) {
+  const schemaName = `${toPascalCase4(name)}Schema`;
+  const typeName = toPascalCase4(name);
+  const fileName = `${toKebabCase3(name)}.schema.ts`;
+  const targetDir = resolve4(process.cwd(), "src/schemas");
+  const fullPath = resolve4(targetDir, fileName);
+  if (existsSync4(fullPath)) {
+    console.error(colors.red(`File ${fileName} sudah ada!`));
+    process.exit(1);
+  }
+  mkdirSync4(targetDir, { recursive: true });
+  const content = `import { s, type Infer } from 'speedx/schema'
+
+export const ${schemaName} = s.object({
+  id: s.string().uuid(),
+  name: s.string().min(1).max(255),
+  createdAt: s.string().datetime(),
+  updatedAt: s.string().datetime().optional(),
+})
+
+export type ${typeName} = Infer<typeof ${schemaName}>
+
+export const create${typeName}Schema = s.object({
+  name: s.string().min(1).max(255),
+})
+
+export type Create${typeName} = Infer<typeof create${typeName}Schema>
+`;
+  writeFileSync4(fullPath, content, "utf-8");
+  console.log(
+    `${colors.green("\u2705")} Schema ${colors.bold(schemaName)} dibuat di ${colors.cyan(fileName)}`
+  );
+}
+
+// src/cli/commands/list-routes.ts
+import { existsSync as existsSync5, readdirSync, readFileSync } from "fs";
+import { resolve as resolve5 } from "path";
+function extractDecorators(content) {
+  const pattern = /@(get|post|put|patch|del|delete)\s*\(\s*'([^']+)'\s*\)/g;
+  const results = [];
+  let match = pattern.exec(content);
+  while (match !== null) {
+    const method = match[1] === "del" ? "DELETE" : match[1].toUpperCase();
+    const path = match[2];
+    results.push({ method, path });
+    match = pattern.exec(content);
+  }
+  return results;
+}
+function listRoutes() {
+  const routesDir = resolve5(process.cwd(), "src/server/controllers");
+  if (!existsSync5(routesDir)) {
+    console.log(
+      `  ${colors.yellow("!")} Tidak ada route terdaftar. Buat controller dulu:`
+    );
+    console.log(`    ${colors.cyan("speedx make:controller <name>")}`);
+    return;
+  }
+  const files = readdirSync(routesDir).filter((f) => f.endsWith(".ts"));
+  if (files.length === 0) {
+    console.log(
+      `  ${colors.yellow("!")} Tidak ada route terdaftar. Buat controller dulu:`
+    );
+    console.log(`    ${colors.cyan("speedx make:controller <name>")}`);
+    return;
+  }
+  let total = 0;
+  console.log();
+  console.log(`  ${colors.bold("\u{1F4CB} Daftar Route:")}`);
+  console.log();
+  for (const file of files) {
+    const content = readFileSync(resolve5(routesDir, file), "utf-8");
+    const routes = extractDecorators(content);
+    if (routes.length > 0) {
+      console.log(`  ${colors.cyan("\u2500\u2500")} ${colors.bold(file.replace(".controller.ts", ""))} ${colors.cyan("\u2500\u2500")}`);
+      for (const { method, path } of routes) {
+        const coloredMethod = method === "GET" ? colors.green(method.padEnd(8)) : method === "POST" ? colors.blue(method.padEnd(8)) : method === "PUT" || method === "PATCH" ? colors.yellow(method.padEnd(8)) : colors.red(method.padEnd(8));
+        console.log(`    ${coloredMethod} ${path}`);
+        total++;
+      }
+      console.log();
+    }
+  }
+  console.log(`  ${colors.dim(`${total} route${total !== 1 ? "s" : ""} ditemukan`)}`);
+  console.log();
+}
+
+// src/cli/commands/serve.ts
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve6 } from "path";
+
+// src/native/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var TIMEZONE_OFFSETS = {
+  WIB: 7,
+  WITA: 8,
+  WIT: 9,
+  UTC: 0
+};
+function pad(n) {
+  return n.toString().padStart(2, "0");
+}
+function formatTimestamp(tz) {
+  const offset = TIMEZONE_OFFSETS[tz ?? ""] ?? 7;
+  const now = /* @__PURE__ */ new Date();
+  const utc = now.getTime() + now.getTimezoneOffset() * 6e4;
+  const local = new Date(utc + offset * 36e5);
+  const y = local.getFullYear();
+  const M = pad(local.getMonth() + 1);
+  const d = pad(local.getDate());
+  const h = pad(local.getHours());
+  const m = pad(local.getMinutes());
+  const s = pad(local.getSeconds());
+  return `${y}-${M}-${d} ${h}:${m}:${s} ${tz ?? "WIB"}`;
+}
+var LEVEL_PREFIX = {
+  debug: "DEBUG",
+  info: "INFO",
+  warn: "WARN",
+  error: "ERROR"
+};
+var LEVEL_COLOR = {
+  debug: colors.gray,
+  info: colors.cyan,
+  warn: colors.yellow,
+  error: colors.red
+};
+var Logger = class _Logger {
+  _level;
+  _name;
+  _useColors;
+  _useTimestamps;
+  _timezone;
+  constructor(options) {
+    this._level = options?.level ?? "info";
+    this._name = options?.name ?? "";
+    this._useColors = options?.colors ?? isColorSupported();
+    this._useTimestamps = options?.timestamps ?? true;
+    this._timezone = options?.timezone ?? "WIB";
+  }
+  _format(level, msg, meta) {
+    const parts = [];
+    if (this._useTimestamps) {
+      parts.push(formatTimestamp(this._timezone));
+    }
+    if (this._useColors) {
+      parts.push(LEVEL_COLOR[level](LEVEL_PREFIX[level]));
+    } else {
+      parts.push(LEVEL_PREFIX[level]);
+    }
+    if (this._name) {
+      parts.push(this._useColors ? colors.dim(`[${this._name}]`) : `[${this._name}]`);
+    }
+    if (this._useColors) {
+      parts.push(LEVEL_COLOR[level](msg));
+    } else {
+      parts.push(msg);
+    }
+    if (meta && Object.keys(meta).length > 0) {
+      parts.push(JSON.stringify(meta));
+    }
+    return parts.join(" ");
+  }
+  debug(msg, meta) {
+    if (LOG_LEVELS[this._level] > LOG_LEVELS.debug) return;
+    console.debug(this._format("debug", msg, meta));
+  }
+  info(msg, meta) {
+    if (LOG_LEVELS[this._level] > LOG_LEVELS.info) return;
+    console.info(this._format("info", msg, meta));
+  }
+  warn(msg, meta) {
+    if (LOG_LEVELS[this._level] > LOG_LEVELS.warn) return;
+    console.warn(this._format("warn", msg, meta));
+  }
+  error(msg, meta) {
+    if (LOG_LEVELS[this._level] > LOG_LEVELS.error) return;
+    console.error(this._format("error", msg, meta));
+  }
+  child(name) {
+    const childName = this._name ? `${this._name}:${name}` : name;
+    return new _Logger({
+      level: this._level,
+      name: childName,
+      colors: this._useColors,
+      timestamps: this._useTimestamps,
+      timezone: this._timezone
+    });
+  }
+  setLevel(level) {
+    this._level = level;
+  }
+};
+var logger = new Logger();
+
+// src/cli/commands/serve.ts
+async function serve(options) {
+  const opts = {
+    port: options.port || options.p || 3e3,
+    host: options.host || options.H || "localhost",
+    dev: options.dev !== false
+  };
+  const port = parseInt(String(opts.port), 10);
+  const host = String(opts.host);
+  const serverEntry = resolve6(process.cwd(), "src/app.ts");
+  const serverEntryAlt = resolve6(process.cwd(), "src/server/index.ts");
+  const serverEntryIndex = resolve6(process.cwd(), "src/index.ts");
+  let entryPath = null;
+  if (existsSync6(serverEntry)) entryPath = serverEntry;
+  else if (existsSync6(serverEntryAlt)) entryPath = serverEntryAlt;
+  else if (existsSync6(serverEntryIndex)) entryPath = serverEntryIndex;
+  if (!entryPath) {
+    console.error(
+      colors.red(
+        "Tidak ditemukan file entry point. Buat src/app.ts atau src/index.ts"
+      )
+    );
+    process.exit(1);
+  }
+  if (opts.dev) {
+    logger.info(
+      `Development server starting at ${colors.cyan(`http://${host}:${port}`)}`
+    );
+    try {
+      const { app } = await import(entryPath);
+      if (!app || typeof app.listen !== "function") {
+        console.error(
+          colors.red(
+            "Entry point harus export { app } dengan method .listen()"
+          )
+        );
+        process.exit(1);
+      }
+      app.listen(port, host, () => {
+        console.log();
+        console.log(`  ${colors.bold("SpeedX")} ${colors.green("running")}`);
+        console.log(`  ${colors.dim("\u2192")}  ${colors.cyan(`http://${host}:${port}`)}`);
+        console.log();
+      });
+    } catch (err) {
+      console.error(colors.red(`Gagal menjalankan server: ${err.message}`));
+      process.exit(1);
+    }
+  } else {
+    try {
+      const { app } = await import(entryPath);
+      if (!app || typeof app.listen !== "function") {
+        console.error(
+          colors.red(
+            "Entry point harus export { app } dengan method .listen()"
+          )
+        );
+        process.exit(1);
+      }
+      app.listen(port, host, () => {
+        console.log();
+        console.log(`  ${colors.bold("SpeedX")} ${colors.green("running")}`);
+        console.log(`  ${colors.dim("\u2192")}  ${colors.cyan(`http://${host}:${port}`)}`);
+        console.log();
+      });
+    } catch (err) {
+      console.error(colors.red(`Gagal menjalankan server: ${err.message}`));
+      process.exit(1);
+    }
+  }
+}
+
+// src/cli/index.ts
+function showHelp() {
+  console.log(`${colors.bold("SpeedX")} ${colors.cyan("v0.2.0")}`);
+  console.log("Fullstack JavaScript/TypeScript Framework");
+  console.log();
+  console.log(`${colors.bold("Usage:")}`);
+  console.log("  SpeedX init [name] [options]        Buat project baru");
+  console.log("  SpeedX make:controller <name>        Generate controller");
+  console.log("  SpeedX make:middleware <name>        Generate middleware");
+  console.log("  SpeedX make:schema <name>            Generate schema");
+  console.log("  SpeedX list-routes                   Lihat semua route");
+  console.log("  SpeedX serve [options]               Jalankan server");
+  console.log("  SpeedX --help                        Bantuan ini");
+  console.log();
+  console.log(`${colors.bold("Aliases:")}`);
+  console.log("  SpeedX -v, --version                 Lihat versi");
+  console.log();
+  console.log(`${colors.bold("Options:")}`);
+  console.log("  --template <type>    blank, fullstack, api-only");
+  console.log("  --frontend <fe>      super, react, vue");
+  console.log("  --port <number>      Port server (default: 3000)");
+  console.log("  --host <string>      Host address (default: localhost)");
+}
+async function main() {
+  const parsed = parseArgs(process.argv);
+  const command = parsed.command;
+  switch (command) {
+    case "init": {
+      await initProject(parsed.args[0] || "my-app", parsed.options);
+      break;
+    }
+    case "make:controller": {
+      if (!parsed.args[0]) {
+        console.error(colors.red("Nama controller diperlukan"));
+        console.log(`  ${colors.cyan("SpeedX make:controller <name>")}`);
+        process.exit(1);
+      }
+      await makeController(parsed.args[0]);
+      break;
+    }
+    case "make:middleware": {
+      if (!parsed.args[0]) {
+        console.error(colors.red("Nama middleware diperlukan"));
+        console.log(`  ${colors.cyan("SpeedX make:middleware <name>")}`);
+        process.exit(1);
+      }
+      await makeMiddleware(parsed.args[0]);
+      break;
+    }
+    case "make:schema": {
+      if (!parsed.args[0]) {
+        console.error(colors.red("Nama schema diperlukan"));
+        console.log(`  ${colors.cyan("SpeedX make:schema <name>")}`);
+        process.exit(1);
+      }
+      await makeSchema(parsed.args[0]);
+      break;
+    }
+    case "list-routes":
+    case "routes":
+    case "lr": {
+      await listRoutes();
+      break;
+    }
+    case "serve":
+    case "dev": {
+      await serve(parsed.options);
+      break;
+    }
+    case "help":
+    case "--help":
+    case "-h": {
+      showHelp();
+      break;
+    }
+    case "version":
+    case "--version":
+    case "-v": {
+      console.log("SpeedX v0.2.0");
+      break;
+    }
+    default: {
+      if (command) {
+        console.error(`${colors.red(`Command '${command}' tidak dikenal`)}`);
+        console.log();
+      }
+      showHelp();
+      if (command) process.exit(1);
+    }
+  }
+}
+main().catch((err) => {
+  console.error(colors.red(`Error: ${err.message}`));
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map