@sansavision/aurora 0.1.0-alpha.20260212.4

package/src/create.ts

@@ -0,0 +1,425 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+import { type CommandContext, type CommandResult } from "./registry";
+
+type TemplateId =
+  | "basic"
+  | "saas"
+  | "blog"
+  | "dashboard"
+  | "monorepo"
+  | "desktop"
+  | "mobile";
+
+interface CreateOptions {
+  projectName: string;
+  template: TemplateId;
+  initializeGit: boolean;
+}
+
+interface TemplateScaffold {
+  id: TemplateId;
+  summary: string;
+  targets: ReadonlyArray<"node" | "edge" | "static">;
+  files: ReadonlyArray<{ path: string; content: string }>;
+}
+
+interface CreateBootstrapReport {
+  mode: "create";
+  cwd: string;
+  projectName: string;
+  projectRoot: string;
+  template: TemplateId;
+  templateSummary: string;
+  targets: ReadonlyArray<"node" | "edge" | "static">;
+  initializeGit: boolean;
+  createdFileCount: number;
+}
+
+const TEMPLATE_CATALOG: Record<TemplateId, Omit<TemplateScaffold, "files">> = {
+  basic: {
+    id: "basic",
+    summary: "Basic web app starter with query/action examples.",
+    targets: ["node", "edge"],
+  },
+  saas: {
+    id: "saas",
+    summary: "SaaS starter with auth, billing seam, and team management shape.",
+    targets: ["node"],
+  },
+  blog: {
+    id: "blog",
+    summary: "Content/blog starter optimized for static generation and SEO.",
+    targets: ["static", "node"],
+  },
+  dashboard: {
+    id: "dashboard",
+    summary: "Dashboard starter with data-grid/realtime oriented structure.",
+    targets: ["node"],
+  },
+  monorepo: {
+    id: "monorepo",
+    summary: "Workspace starter with app + shared packages layout.",
+    targets: ["node"],
+  },
+  desktop: {
+    id: "desktop",
+    summary: "Desktop starter with Tauri integration seams.",
+    targets: ["node"],
+  },
+  mobile: {
+    id: "mobile",
+    summary: "Mobile companion starter with typed client SDK usage.",
+    targets: ["node"],
+  },
+};
+
+const TEMPLATE_IDS = Object.keys(TEMPLATE_CATALOG) as ReadonlyArray<TemplateId>;
+const APP_NAME_PLACEHOLDER = "__AURORA_APP_NAME__";
+
+function parseTemplate(rawValue: string | undefined): TemplateId | CommandResult {
+  if (!rawValue) {
+    return {
+      exitCode: 2,
+      stderr: `aurora create: --template requires one of ${TEMPLATE_IDS.map((item) => `'${item}'`).join(", ")}`,
+    };
+  }
+
+  if (TEMPLATE_IDS.includes(rawValue as TemplateId)) {
+    return rawValue as TemplateId;
+  }
+
+  return {
+    exitCode: 2,
+    stderr: `aurora create: invalid template '${rawValue}'. Expected ${TEMPLATE_IDS.join(", ")}`,
+  };
+}
+
+function parseCreateOptions(args: ReadonlyArray<string>): CreateOptions | CommandResult {
+  if (args.length === 0) {
+    return {
+      exitCode: 2,
+      stderr: "aurora create: project name is required",
+    };
+  }
+
+  const firstArg = args[0];
+  if (firstArg.startsWith("-")) {
+    return {
+      exitCode: 2,
+      stderr: "aurora create: project name must be provided before options",
+    };
+  }
+
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9-_]*$/.test(firstArg)) {
+    return {
+      exitCode: 2,
+      stderr:
+        "aurora create: project name must match ^[a-zA-Z0-9][a-zA-Z0-9-_]*$",
+    };
+  }
+
+  const options: CreateOptions = {
+    projectName: firstArg,
+    template: "basic",
+    initializeGit: false,
+  };
+
+  for (let i = 1; i < args.length; i += 1) {
+    const arg = args[i];
+
+    if (arg === "--template") {
+      const parsedTemplate = parseTemplate(args[i + 1]);
+      if (typeof parsedTemplate !== "string") {
+        return parsedTemplate;
+      }
+
+      options.template = parsedTemplate;
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--git") {
+      options.initializeGit = true;
+      continue;
+    }
+
+    return {
+      exitCode: 2,
+      stderr: `aurora create: unknown option '${arg}'`,
+    };
+  }
+
+  return options;
+}
+
+function isNonEmptyDirectory(path: string): boolean {
+  if (!existsSync(path)) {
+    return false;
+  }
+
+  try {
+    return readdirSync(path).length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function loadTemplateFilesFromDisk(
+  template: TemplateId,
+  projectName: string,
+): ReadonlyArray<{ path: string; content: string }> {
+  const templateRoot = resolve(import.meta.dir, "../templates", template);
+  if (!existsSync(templateRoot)) {
+    return [];
+  }
+
+  return collectTemplateFiles(templateRoot, templateRoot, projectName);
+}
+
+function collectTemplateFiles(
+  templateRoot: string,
+  currentDirectory: string,
+  projectName: string,
+): ReadonlyArray<{ path: string; content: string }> {
+  const collected: Array<{ path: string; content: string }> = [];
+  const entries = readdirSync(currentDirectory, { withFileTypes: true }).sort((left, right) =>
+    left.name.localeCompare(right.name),
+  );
+
+  for (const entry of entries) {
+    const absolutePath = join(currentDirectory, entry.name);
+    if (entry.isDirectory()) {
+      collected.push(...collectTemplateFiles(templateRoot, absolutePath, projectName));
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const relativePath = absolutePath
+      .slice(templateRoot.length + 1)
+      .replaceAll("\\", "/");
+    const source = readFileSync(absolutePath, "utf8");
+    collected.push({
+      path: relativePath,
+      content: source.split(APP_NAME_PLACEHOLDER).join(projectName),
+    });
+  }
+
+  return collected;
+}
+
+function buildScaffoldFiles(projectName: string, template: TemplateId): TemplateScaffold {
+  const templateMeta = TEMPLATE_CATALOG[template];
+  const files: Array<{ path: string; content: string }> = [];
+  const diskTemplateFiles = loadTemplateFilesFromDisk(template, projectName);
+
+  if (diskTemplateFiles.length > 0) {
+    files.push(...diskTemplateFiles);
+  }
+
+  if (template === "monorepo" && diskTemplateFiles.length === 0) {
+    files.push({
+      path: "package.json",
+      content: JSON.stringify(
+        {
+          name: projectName,
+          private: true,
+          workspaces: ["apps/*", "packages/*"],
+          scripts: {
+            dev: "bun run --cwd apps/web aurora dev",
+            build: "bun run --cwd apps/web aurora build",
+            start: "bun run --cwd apps/web aurora start",
+          },
+        },
+        null,
+        2,
+      ),
+    });
+    files.push({
+      path: "apps/web/package.json",
+      content: JSON.stringify(
+        {
+          name: `${projectName}-web`,
+          private: true,
+          scripts: {
+            dev: "aurora dev",
+            build: "aurora build",
+            start: "aurora start",
+          },
+        },
+        null,
+        2,
+      ),
+    });
+    files.push({
+      path: "apps/web/src/routes/index.tsx",
+      content:
+        "export const HomePage = () => <main>Welcome to Aurora monorepo starter.</main>;\n",
+    });
+    files.push({
+      path: "packages/ui/README.md",
+      content: "# UI Package\n\nShared UI components for Aurora apps.\n",
+    });
+    files.push({
+      path: "packages/shared/README.md",
+      content: "# Shared Package\n\nShared types and utilities.\n",
+    });
+  } else if (diskTemplateFiles.length === 0) {
+    files.push({
+      path: "package.json",
+      content: JSON.stringify(
+        {
+          name: projectName,
+          private: true,
+          scripts: {
+            dev: "aurora dev",
+            build: "aurora build",
+            start: "aurora start",
+            test: "aurora test",
+          },
+        },
+        null,
+        2,
+      ),
+    });
+    files.push({
+      path: "src/routes/index.tsx",
+      content: `export const HomePage = () => <main>${templateMeta.summary}</main>;\n`,
+    });
+    files.push({
+      path: "src/actions/health.action.server.ts",
+      content:
+        "export const health = async () => ({ ok: true, source: \"aurora-template\" });\n",
+    });
+  }
+
+  files.push({
+    path: "aurora.template.json",
+    content: JSON.stringify(
+      {
+        template: templateMeta.id,
+        summary: templateMeta.summary,
+        targets: templateMeta.targets,
+      },
+      null,
+      2,
+    ),
+  });
+
+  if (!files.some((file) => file.path === "README.md")) {
+    files.push({
+      path: "README.md",
+      content: [
+        `# ${projectName}`,
+        "",
+        `Template: ${templateMeta.id}`,
+        "",
+        templateMeta.summary,
+        "",
+        "## Commands",
+        "",
+        "- `aurora dev`",
+        "- `aurora build`",
+        "- `aurora start`",
+      ].join("\n"),
+    });
+  }
+
+  return {
+    ...templateMeta,
+    files,
+  };
+}
+
+function ensureParentDirectory(filePath: string): void {
+  mkdirSync(dirname(filePath), { recursive: true });
+}
+
+function scaffoldProject(
+  options: CreateOptions,
+  context: CommandContext,
+): CreateBootstrapReport | CommandResult {
+  const projectRoot = resolve(context.cwd, options.projectName);
+
+  if (isNonEmptyDirectory(projectRoot)) {
+    return {
+      exitCode: 2,
+      stderr: `aurora create: target directory already exists and is not empty: ${projectRoot}`,
+    };
+  }
+
+  try {
+    mkdirSync(projectRoot, { recursive: true });
+
+    const scaffold = buildScaffoldFiles(options.projectName, options.template);
+    for (const file of scaffold.files) {
+      const absolutePath = join(projectRoot, file.path);
+      ensureParentDirectory(absolutePath);
+      writeFileSync(absolutePath, `${file.content}\n`, "utf8");
+    }
+
+    if (options.initializeGit) {
+      writeFileSync(join(projectRoot, ".gitignore"), "node_modules\n.aurora\n", "utf8");
+    }
+
+    return {
+      mode: "create",
+      cwd: context.cwd,
+      projectName: options.projectName,
+      projectRoot,
+      template: scaffold.id,
+      templateSummary: scaffold.summary,
+      targets: scaffold.targets,
+      initializeGit: options.initializeGit,
+      createdFileCount: scaffold.files.length + (options.initializeGit ? 1 : 0),
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      exitCode: 1,
+      stderr: `aurora create: failed to scaffold project at ${projectRoot}: ${message}`,
+    };
+  }
+}
+
+function renderCreateBootstrapReport(report: CreateBootstrapReport): string {
+  return [
+    "aurora create bootstrap",
+    `cwd: ${report.cwd}`,
+    `project: ${report.projectName}`,
+    `project_root: ${report.projectRoot}`,
+    `template: ${report.template}`,
+    `template_summary: ${report.templateSummary}`,
+    `targets: ${report.targets.join(", ")}`,
+    `git: ${report.initializeGit ? "enabled" : "disabled"}`,
+    `created_files: ${report.createdFileCount}`,
+    "next_steps:",
+    `  cd ${report.projectName}`,
+    "  bun install",
+    "  aurora dev",
+  ].join("\n");
+}
+
+export function runCreateCommand(
+  args: ReadonlyArray<string>,
+  context: CommandContext,
+): CommandResult {
+  const options = parseCreateOptions(args);
+  if ("exitCode" in options) {
+    return options;
+  }
+
+  const report = scaffoldProject(options, context);
+  if ("exitCode" in report) {
+    return report;
+  }
+
+  return {
+    exitCode: 0,
+    stdout: renderCreateBootstrapReport(report),
+  };
+}

package/src/dev.ts

@@ -0,0 +1,126 @@
+import { resolve } from "node:path";
+
+import { type CommandContext, type CommandResult } from "./registry";
+
+interface DevOptions {
+  port: number;
+  openBrowser: boolean;
+  https: boolean;
+}
+
+interface DevBootstrapReport {
+  mode: "dev";
+  cwd: string;
+  url: string;
+  hmrBridgeUrl: string;
+  compilerManifestPath: string;
+  openBrowser: boolean;
+  https: boolean;
+}
+
+function parsePort(rawValue: string | undefined): number | CommandResult {
+  if (!rawValue) {
+    return {
+      exitCode: 2,
+      stderr: "aurora dev: --port requires a numeric value",
+    };
+  }
+
+  const value = Number(rawValue);
+  if (!Number.isInteger(value) || value < 1 || value > 65535) {
+    return {
+      exitCode: 2,
+      stderr: "aurora dev: --port must be an integer between 1 and 65535",
+    };
+  }
+
+  return value;
+}
+
+function parseDevOptions(args: ReadonlyArray<string>): DevOptions | CommandResult {
+  const options: DevOptions = {
+    port: 3000,
+    openBrowser: false,
+    https: false,
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+
+    if (arg === "--port") {
+      const parsedPort = parsePort(args[i + 1]);
+      if (typeof parsedPort !== "number") {
+        return parsedPort;
+      }
+
+      options.port = parsedPort;
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--open") {
+      options.openBrowser = true;
+      continue;
+    }
+
+    if (arg === "--https") {
+      options.https = true;
+      continue;
+    }
+
+    return {
+      exitCode: 2,
+      stderr: `aurora dev: unknown option '${arg}'`,
+    };
+  }
+
+  return options;
+}
+
+function buildDevBootstrapReport(
+  options: DevOptions,
+  context: CommandContext,
+): DevBootstrapReport {
+  const protocol = options.https ? "https" : "http";
+  const wsProtocol = options.https ? "wss" : "ws";
+  const host = "localhost";
+  const baseUrl = `${protocol}://${host}:${options.port}`;
+
+  return {
+    mode: "dev",
+    cwd: context.cwd,
+    url: baseUrl,
+    hmrBridgeUrl: `${wsProtocol}://${host}:${options.port}/__aurora_hmr`,
+    compilerManifestPath: resolve(context.cwd, ".aurora/compiler/manifest.json"),
+    openBrowser: options.openBrowser,
+    https: options.https,
+  };
+}
+
+function renderDevBootstrapReport(report: DevBootstrapReport): string {
+  return [
+    "aurora dev bootstrap",
+    `cwd: ${report.cwd}`,
+    `url: ${report.url}`,
+    `hmr_bridge: ${report.hmrBridgeUrl}`,
+    `compiler_manifest: ${report.compilerManifestPath}`,
+    `open_browser: ${report.openBrowser ? "enabled" : "disabled"}`,
+    `https: ${report.https ? "enabled" : "disabled"}`,
+  ].join("\n");
+}
+
+export function runDevCommand(
+  args: ReadonlyArray<string>,
+  context: CommandContext,
+): CommandResult {
+  const options = parseDevOptions(args);
+  if ("exitCode" in options) {
+    return options;
+  }
+
+  const report = buildDevBootstrapReport(options, context);
+  return {
+    exitCode: 0,
+    stdout: renderDevBootstrapReport(report),
+  };
+}