@orion-js/core 4.0.0-next.6 → 4.0.0

package/dist/index.js

@@ -1,18 +1,9 @@
 #!/usr/bin/env node
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 
 // src/index.ts
 import chalk11 from "chalk";
 import { Command } from "commander";
 
-// src/build/index.ts
-import chalk2 from "chalk";
-
 // src/helpers/execute.ts
 import { exec } from "child_process";
 async function execute_default(command) {
@@ -27,48 +18,153 @@ async function execute_default(command) {
   });
 }
 
-// src/build/compile.ts
-import chalk from "chalk";
-import ts4 from "typescript";
-
-// src/build/getOptions.ts
-import path2 from "path";
-import ts3 from "typescript";
-
-// src/start/watchAndCompile/getConfigPath.ts
-import ts from "typescript";
-
-// src/start/watchAndCompile/ensureConfigComplies.ts
-import { parse, stringify } from "comment-json";
-
-// src/helpers/getFileContents.ts
-import fs from "fs";
-function readFile(filePath) {
-  if (!fs.existsSync(filePath)) return null;
-  return fs.readFileSync(filePath).toString();
+// src/create/index.ts
+async function create_default({ name, kit }) {
+  if (!name) {
+    throw new Error("Please set the name of the app");
+  }
+  if (!kit) {
+    throw new Error("Please select which kit to use");
+  }
+  const repo = `https://github.com/siturra/boilerplate-orionjs-${kit}`;
+  console.log("Downloading starter kit...");
+  await execute_default(`git clone ${repo} ${name}`);
+  await execute_default(`cd ${name} && rm -rf .git`);
+  console.log("Your starter kit is ready");
 }
 
+// src/dev/runner/index.ts
+import chalk from "chalk";
+
 // src/helpers/writeFile.ts
-import fs3 from "fs";
+import fs2 from "fs";
 
 // src/helpers/ensureDirectory.ts
-import fs2 from "fs";
+import fs from "fs";
 import path from "path";
 var ensureDirectory = (filePath) => {
   const dirname = path.dirname(filePath);
-  if (fs2.existsSync(dirname)) return true;
+  if (fs.existsSync(dirname)) return true;
   ensureDirectory(dirname);
-  fs2.mkdirSync(dirname);
+  fs.mkdirSync(dirname);
 };
 var ensureDirectory_default = ensureDirectory;
 
 // src/helpers/writeFile.ts
-async function writeFile_default(path8, content) {
-  ensureDirectory_default(path8);
-  fs3.writeFileSync(path8, content);
+async function writeFile_default(path7, content) {
+  ensureDirectory_default(path7);
+  fs2.writeFileSync(path7, content);
+}
+
+// src/dev/runner/startProcess.ts
+import { spawn } from "child_process";
+
+// src/dev/runner/getArgs.ts
+function getArgs(options) {
+  let startCommand = process.env.START_COMMAND || "./node_modules/@orion-js/core/node_modules/.bin/tsx";
+  const args = [];
+  if (process.env.START_COMMAND) {
+    const [first, ...otherArgs] = process.env.START_COMMAND.split(" ");
+    startCommand = first;
+    args.push(...otherArgs);
+    console.log(`Using custom command: ${[startCommand, ...args].join(" ")}`);
+  } else if (options.shell) {
+    args.push("--inspect");
+  }
+  args.push("./app/index.ts");
+  return { startCommand, args };
+}
+
+// src/dev/runner/startProcess.ts
+function startProcess(options) {
+  const { startCommand, args } = getArgs(options);
+  return spawn(startCommand, args, {
+    env: {
+      ORION_DEV: "local",
+      ...process.env
+    },
+    cwd: process.cwd(),
+    stdio: "inherit",
+    detached: false
+  });
 }
 
-// src/start/watchAndCompile/ensureConfigComplies.ts
+// src/dev/runner/index.ts
+function getRunner(options) {
+  let appProcess = null;
+  if (options.clean) {
+    console.log(chalk.bold("=> Cleaning directory...\n"));
+  }
+  const start = () => {
+    console.log(chalk.bold("=> Starting app...\n"));
+    appProcess = startProcess(options);
+    appProcess.on("exit", (code, signal) => {
+      if (!code || code === 143 || code === 0 || signal === "SIGTERM" || signal === "SIGINT") {
+      } else {
+        console.log(chalk.bold(`=> Error running app. Exit code: ${code}`));
+      }
+    });
+    writeFile_default(".orion/process", `${appProcess.pid}`);
+  };
+  const stop = () => {
+    if (appProcess) {
+      appProcess.kill();
+    }
+  };
+  const restart = () => {
+    stop();
+    start();
+  };
+  return {
+    restart,
+    stop
+  };
+}
+
+// src/dev/watchAndCompile/index.ts
+import ts4 from "typescript";
+
+// src/dev/watchAndCompile/cleanDirectory.ts
+import fs3 from "fs";
+import path2 from "path";
+function rimraf(dir_path) {
+  if (fs3.existsSync(dir_path)) {
+    fs3.readdirSync(dir_path).map((entry) => {
+      const entry_path = path2.join(dir_path, entry);
+      if (fs3.lstatSync(entry_path).isDirectory()) {
+        rimraf(entry_path);
+      } else {
+        fs3.unlinkSync(entry_path);
+      }
+    });
+    fs3.rmdirSync(dir_path);
+  }
+}
+async function cleanDirectory() {
+  try {
+    const dirPath = path2.join(process.cwd(), ".orion", "build");
+    rimraf(dirPath);
+  } catch (_) {
+  }
+}
+
+// src/dev/watchAndCompile/getHost.ts
+import ts3 from "typescript";
+
+// src/dev/watchAndCompile/getConfigPath.ts
+import ts from "typescript";
+
+// src/dev/watchAndCompile/ensureConfigComplies.ts
+import { parse, stringify } from "comment-json";
+
+// src/helpers/getFileContents.ts
+import fs4 from "fs";
+function readFile(filePath) {
+  if (!fs4.existsSync(filePath)) return null;
+  return fs4.readFileSync(filePath).toString();
+}
+
+// src/dev/watchAndCompile/ensureConfigComplies.ts
 function ensureConfigComplies(configPath) {
   var _a, _b;
   try {
@@ -78,8 +174,8 @@ function ensureConfigComplies(configPath) {
       ...config,
       compilerOptions: {
         ...config.compilerOptions,
-        outDir: "./.orion/build/app",
-        baseUrl: "./"
+        baseUrl: "./",
+        noEmit: true
       }
     };
     if (!((_a = config.compilerOptions) == null ? void 0 : _a.rootDir) && !((_b = config.compilerOptions) == null ? void 0 : _b.rootDirs)) {
@@ -91,7 +187,7 @@ function ensureConfigComplies(configPath) {
   }
 }
 
-// src/start/watchAndCompile/getConfigPath.ts
+// src/dev/watchAndCompile/getConfigPath.ts
 function getConfigPath() {
   const appBasePath = process.cwd();
   const configPath = ts.findConfigFile(appBasePath, ts.sys.fileExists, "tsconfig.server.json") || ts.findConfigFile(appBasePath, ts.sys.fileExists, "tsconfig.json");
@@ -102,7 +198,7 @@ function getConfigPath() {
   return configPath;
 }
 
-// src/build/reports.ts
+// src/dev/watchAndCompile/reports.ts
 import ts2 from "typescript";
 var format = {
   getCanonicalFileName: (fileName) => fileName,
@@ -113,86 +209,91 @@ function reportDiagnostic(diagnostic) {
   console.log(ts2.formatDiagnosticsWithColorAndContext([diagnostic], format));
 }
 
-// src/build/getOptions.ts
-function getCompilerOptionsJSONFollowExtends(filename) {
-  let compopts = {};
-  const config = ts3.readConfigFile(filename, ts3.sys.readFile).config;
-  if (config.extends) {
-    const rqrpath = __require.resolve(config.extends);
-    compopts = getCompilerOptionsJSONFollowExtends(rqrpath);
-  }
-  return {
-    ...compopts,
-    ...config.compilerOptions
+// src/dev/watchAndCompile/getHost.ts
+import chalk2 from "chalk";
+function getHost(runner) {
+  const reportWatchStatusChanged = (diagnostic) => {
+    if (diagnostic.category !== 3) return;
+    if (diagnostic.code === 6032 || diagnostic.code === 6031) {
+      runner.stop();
+    }
+    console.log(chalk2.bold(`=> ${diagnostic.messageText}`));
+    if (diagnostic.code === 6194) {
+      if (/^Found .+ errors?/.test(diagnostic.messageText.toString())) {
+        if (!diagnostic.messageText.toString().includes("Found 0 errors.")) {
+          return;
+        }
+      }
+      runner.restart();
+    }
   };
-}
-function getOptions({ output }) {
   const configPath = getConfigPath();
-  const config = getCompilerOptionsJSONFollowExtends(configPath);
-  config.outDir = `${output}/app`;
-  config.incremental = false;
-  const { options, errors } = ts3.convertCompilerOptionsFromJson(config, path2.dirname(configPath));
-  if (errors.length) {
-    errors.forEach(reportDiagnostic);
-    process.exit(1);
-  }
-  return options;
+  const createProgram = ts3.createEmitAndSemanticDiagnosticsBuilderProgram;
+  const host = ts3.createWatchCompilerHost(
+    configPath,
+    {},
+    ts3.sys,
+    createProgram,
+    reportDiagnostic,
+    reportWatchStatusChanged
+  );
+  return host;
 }
 
-// src/build/compile.ts
-function compile({ output }) {
-  const options = getOptions({ output });
-  const program2 = ts4.createProgram(["./app/index.ts"], options);
-  const preEmitDiagnostics = ts4.getPreEmitDiagnostics(program2);
-  if (preEmitDiagnostics.length > 0) {
-    console.log(chalk.red("\n==> Error builing Orion app\n"));
-  }
-  preEmitDiagnostics.forEach(reportDiagnostic);
-  if (preEmitDiagnostics.length > 0) {
-    process.exit(1);
-  }
-  const emitResult = program2.emit();
-  emitResult.diagnostics.forEach(reportDiagnostic);
-  if (emitResult.emitSkipped) {
-    process.exit(1);
-  }
+// src/dev/watchAndCompile/watchDeletes.ts
+import fs5 from "fs";
+import path3 from "path";
+import chokidar from "chokidar";
+async function watchDeletes() {
+  const projectPath = path3.resolve("./app");
+  const watcher = chokidar.watch(projectPath, {
+    ignoreInitial: true
+  });
+  watcher.on("unlink", async (filepath) => {
+    if (!filepath.endsWith(".ts")) return;
+    const relative = path3.relative(process.cwd(), filepath);
+    const atBuildPath = path3.resolve(".orion/build", relative.replace(/.ts$/, ""));
+    try {
+      fs5.unlinkSync(`${atBuildPath}.js`);
+      fs5.unlinkSync(`${atBuildPath}.d.ts`);
+    } catch (error) {
+      console.log(
+        `Error cleaning ${atBuildPath}. Restar project is suggested. Error: ${error.message}`
+      );
+    }
+  });
 }
 
-// src/build/index.ts
-async function build_default({ output }) {
-  if (!output) {
-    output = "./build";
-  }
-  console.log(chalk2.bold(`Cleaning directory ${output}...`));
-  await execute_default(`rm -rf ${output}`);
-  console.log(chalk2.bold("Compiling your app..."));
-  compile({ output });
-  console.log(chalk2.bold("Build created"));
-}
+// src/dev/watchAndCompile/writeEnvFile.ts
+import { writeDtsFileFromConfigFile } from "@orion-js/env";
+import chalk3 from "chalk";
+import chokidar2 from "chokidar";
+var envFilePath = process.env.ORION_ENV_FILE_PATH;
+var dtsFilePath = "./app/env.d.ts";
+var watchEnvFile = async (runner) => {
+  if (!envFilePath) return;
+  writeDtsFileFromConfigFile(envFilePath, dtsFilePath);
+  chokidar2.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
+    console.log(chalk3.bold("=> Environment file changed. Restarting..."));
+    writeDtsFileFromConfigFile(envFilePath, dtsFilePath);
+    runner.restart();
+  });
+};
 
-// src/create/index.ts
-async function create_default({ name, kit }) {
-  if (!name) {
-    throw new Error("Please set the name of the app");
-  }
-  if (!kit) {
-    throw new Error("Please select which kit to use");
-  }
-  const repo = `https://github.com/siturra/boilerplate-orionjs-${kit}`;
-  console.log("Downloading starter kit...");
-  await execute_default(`git clone ${repo} ${name}`);
-  await execute_default(`cd ${name} && rm -rf .git`);
-  console.log("Your starter kit is ready");
+// src/dev/watchAndCompile/index.ts
+async function watchAndCompile(runner) {
+  await cleanDirectory();
+  const host = getHost(runner);
+  ts4.createWatchProgram(host);
+  watchDeletes();
+  watchEnvFile(runner);
 }
 
-// src/start/index.ts
-import chalk8 from "chalk";
-
-// src/start/copyCursorRule/index.ts
-import fs4 from "fs/promises";
+// src/dev/copyCursorRule/index.ts
+import fs6 from "fs/promises";
 import https from "https";
-import path3 from "path";
-import chalk3 from "chalk";
+import path4 from "path";
+import chalk4 from "chalk";
 var rules = [
   "orionjs.mdx",
   "orionjs-component.mdx",
@@ -224,53 +325,55 @@ var downloadFile = (url) => {
 async function copyCursorRule() {
   const baseUrl = "https://raw.githubusercontent.com/orionjs/orionjs/refs/heads/master/mdc";
   try {
-    const targetDir = path3.join(process.cwd(), ".cursor", "rules");
-    await fs4.mkdir(targetDir, { recursive: true });
-    for (const rule of rules) {
-      const targetFileName = rule.replace(".mdx", ".mdc");
-      const targetFile = path3.join(targetDir, targetFileName);
-      const sourceUrl = `${baseUrl}/${rule}`;
-      const content = await downloadFile(sourceUrl);
-      await fs4.writeFile(targetFile, content, "utf8");
-      console.log(chalk3.bold(`=> \u2728 Successfully downloaded ${chalk3.cyan(targetFileName)}`));
-    }
-    console.log(chalk3.bold("=> \u2728 All rule files have been successfully copied"));
+    const targetDir = path4.join(process.cwd(), ".cursor", "rules");
+    await fs6.mkdir(targetDir, { recursive: true });
+    await Promise.all(
+      rules.map(async (rule) => {
+        const targetFileName = rule.replace(".mdx", ".mdc");
+        const targetFile = path4.join(targetDir, targetFileName);
+        const sourceUrl = `${baseUrl}/${rule}`;
+        const content = await downloadFile(sourceUrl);
+        await fs6.writeFile(targetFile, content, "utf8");
+        console.log(chalk4.bold(`=> \u2728 Successfully downloaded ${chalk4.cyan(targetFileName)}`));
+      })
+    );
+    console.log(chalk4.bold("=> \u2728 All rule files have been successfully copied"));
   } catch (error) {
-    console.error(chalk3.red(`Error copying rule files: ${error.message}`));
+    console.error(chalk4.red(`Error copying rule files: ${error.message}`));
   }
 }
 
-// src/start/copyMCP/index.ts
-import fs6 from "fs/promises";
-import path5 from "path";
-import chalk5 from "chalk";
+// src/dev/copyMCP/index.ts
+import fs8 from "fs/promises";
+import path6 from "path";
+import chalk6 from "chalk";
 
-// src/start/copyMCP/consts.ts
-var MCP_VERSION = "v1";
+// src/dev/copyMCP/consts.ts
+var MCP_VERSION = "v4";
 var VERSION_FILE = "version.txt";
 
-// src/start/copyMCP/isValidMCPRepo.ts
-import fs5 from "fs/promises";
-import path4 from "path";
-import chalk4 from "chalk";
+// src/dev/copyMCP/isValidMCPRepo.ts
+import fs7 from "fs/promises";
+import path5 from "path";
+import chalk5 from "chalk";
 async function isValidMCPRepository(directoryPath) {
   try {
-    const stats = await fs5.stat(directoryPath);
+    const stats = await fs7.stat(directoryPath);
     if (!stats.isDirectory()) return false;
     const expectedFiles = ["settings.js", "package.json"];
     for (const file of expectedFiles) {
       try {
-        await fs5.access(path4.join(directoryPath, file));
+        await fs7.access(path5.join(directoryPath, file));
       } catch {
         return false;
       }
     }
     try {
-      const versionPath = path4.join(directoryPath, VERSION_FILE);
-      const versionContent = await fs5.readFile(versionPath, "utf-8");
+      const versionPath = path5.join(directoryPath, VERSION_FILE);
+      const versionContent = await fs7.readFile(versionPath, "utf-8");
       if (versionContent.trim() !== MCP_VERSION) {
         console.log(
-          chalk4.yellow(
+          chalk5.yellow(
             `=> \u2728 MCP version mismatch: installed=${versionContent.trim()}, required=${MCP_VERSION}`
           )
         );
@@ -285,250 +388,134 @@ async function isValidMCPRepository(directoryPath) {
   }
 }
 
-// src/start/copyMCP/index.ts
+// src/dev/copyMCP/index.ts
 async function copyMCP() {
   const repoUrl = "https://github.com/orionjs/mcp-docs";
-  const targetDir = path5.join(process.cwd(), ".orion", "mcp");
+  const targetDir = path6.join(process.cwd(), ".orion", "mcp");
   try {
-    await fs6.mkdir(path5.join(process.cwd(), ".orion"), { recursive: true });
+    await fs8.mkdir(path6.join(process.cwd(), ".orion"), { recursive: true });
     if (await isValidMCPRepository(targetDir)) {
-      console.log(chalk5.bold("=> \u2728 MCP documentation already installed"));
+      console.log(chalk6.bold("=> \u2728 MCP documentation already installed"));
       return;
     }
     try {
-      const stats = await fs6.stat(targetDir);
+      const stats = await fs8.stat(targetDir);
       if (stats.isDirectory()) {
-        await fs6.rm(targetDir, { recursive: true, force: true });
+        await fs8.rm(targetDir, { recursive: true, force: true });
         console.log(
-          chalk5.bold(
+          chalk6.bold(
             "=> \u2728 Removed existing .orion/mcp directory (invalid, incomplete, or outdated)"
           )
         );
       }
     } catch (_) {
     }
-    console.log(chalk5.bold(`=> \u2728 Downloading MCP documentation ${MCP_VERSION}...`));
+    console.log(chalk6.bold(`=> \u2728 Downloading MCP documentation ${MCP_VERSION}...`));
     await execute_default(`git clone ${repoUrl} ${targetDir}`);
-    await execute_default(`rm -rf ${path5.join(targetDir, ".git")}`);
-    await fs6.writeFile(path5.join(targetDir, VERSION_FILE), MCP_VERSION, "utf-8");
+    await execute_default(`rm -rf ${path6.join(targetDir, ".git")}`);
+    await fs8.writeFile(path6.join(targetDir, VERSION_FILE), MCP_VERSION, "utf-8");
     console.log(
-      chalk5.bold(`=> \u2728 Successfully downloaded MCP documentation v${MCP_VERSION} to .orion/mcp`)
+      chalk6.bold(`=> \u2728 Successfully downloaded MCP documentation v${MCP_VERSION} to .orion/mcp`)
     );
-    console.log(chalk5.bold("=> \u2728 Installing MCP dependencies..."));
+    console.log(chalk6.bold("=> \u2728 Installing MCP dependencies..."));
     await execute_default(`cd ${targetDir} && npm install`);
-    console.log(chalk5.bold("=> \u2728 Successfully installed MCP dependencies"));
+    console.log(chalk6.bold("=> \u2728 Successfully installed MCP dependencies"));
+    const relativePath = path6.relative(process.cwd(), targetDir);
+    console.log(relativePath);
     const mcpServerConfig = {
       mcpServers: {
         "Orionjs documentation search": {
           command: "node",
-          args: [path5.join(targetDir, "src", "index.js")]
+          args: [`./${path6.join(relativePath, "src", "index.js")}`]
         }
       }
     };
-    const configPath = path5.join(process.cwd(), ".cursor", "mcp.json");
+    const configPath = path6.join(process.cwd(), ".cursor", "mcp.json");
     try {
-      const existingConfig = await fs6.readFile(configPath, "utf-8");
+      const existingConfig = await fs8.readFile(configPath, "utf-8");
       const parsedConfig = JSON.parse(existingConfig);
       parsedConfig.mcpServers = {
         ...parsedConfig.mcpServers,
         ...mcpServerConfig.mcpServers
       };
-      await fs6.writeFile(configPath, JSON.stringify(parsedConfig, null, 2), "utf-8");
-      console.log(chalk5.bold("=> \u2728 Updated MCP server configuration in .cursor/mcp.json"));
+      await fs8.writeFile(configPath, JSON.stringify(parsedConfig, null, 2), "utf-8");
+      console.log(chalk6.bold("=> \u2728 Updated MCP server configuration in .cursor/mcp.json"));
     } catch (_) {
-      await fs6.mkdir(path5.dirname(configPath), { recursive: true });
-      await fs6.writeFile(configPath, JSON.stringify(mcpServerConfig, null, 2), "utf-8");
-      console.log(chalk5.bold("=> \u2728 Created new MCP server configuration in .cursor/mcp.json"));
+      await fs8.mkdir(path6.dirname(configPath), { recursive: true });
+      await fs8.writeFile(configPath, JSON.stringify(mcpServerConfig, null, 2), "utf-8");
+      console.log(chalk6.bold("=> \u2728 Created new MCP server configuration in .cursor/mcp.json"));
     }
   } catch (error) {
-    console.error(chalk5.red("=> \u2728 Error copying MCP documentation:"), error);
+    console.error(chalk6.red("=> \u2728 Error copying MCP documentation:"), error);
     throw error;
   }
 }
 
-// src/start/runner/index.ts
-import chalk6 from "chalk";
-
-// src/start/runner/startProcess.ts
-import { spawn } from "child_process";
-
-// src/start/runner/getArgs.ts
-function getArgs(options) {
-  let startCommand = process.env.START_COMMAND || "node";
-  const args = [];
-  if (process.env.START_COMMAND) {
-    const [first, ...otherArgs] = process.env.START_COMMAND.split(" ");
-    startCommand = first;
-    args.push(...otherArgs);
-    console.log(`Using custom command: ${[startCommand, ...args].join(" ")}`);
-  } else if (options.shell) {
-    args.push("--inspect");
+// src/dev/index.ts
+import chalk7 from "chalk";
+async function dev_default(options) {
+  console.log(chalk7.bold(`
+Orionjs App ${chalk7.green(chalk7.bold("V4"))} Dev mode 
+`));
+  if (!options.omitCursorRule) {
+    await copyCursorRule().catch(console.error);
   }
-  args.push(".orion/build/index.js");
-  return { startCommand, args };
+  if (!options.omitMcpServer) {
+    await copyMCP().catch(console.error);
+  }
+  if (!options.omitMcpServer && !options.omitCursorRule) {
+    console.log(chalk7.bold("=> \u2728 Orionjs AI is ready\n"));
+  }
+  const runner = getRunner(options);
+  watchAndCompile(runner);
 }
 
-// src/start/runner/startProcess.ts
-function startProcess(options) {
-  const { startCommand, args } = getArgs(options);
-  return spawn(startCommand, args, {
+// src/prod/index.ts
+import chalk9 from "chalk";
+
+// src/prod/runProd.ts
+import { spawn as spawn2 } from "child_process";
+function runProd() {
+  spawn2("./node_modules/@orion-js/core/node_modules/.bin/tsx", ["./app/index.ts"], {
     env: {
-      ORION_DEV: "local",
+      NODE_ENV: "production",
       ...process.env
     },
     cwd: process.cwd(),
     stdio: "inherit",
+    gid: process.getgid(),
+    uid: process.getuid(),
     detached: false
   });
 }
 
-// src/start/runner/index.ts
-function getRunner(options) {
-  let appProcess = null;
-  if (options.clean) {
-    console.log(chalk6.bold("=> Cleaning directory...\n"));
-  }
-  const start = () => {
-    console.log(chalk6.bold("=> Starting app...\n"));
-    appProcess = startProcess(options);
-    appProcess.on("exit", (code, signal) => {
-      if (!code || code === 143 || code === 0 || signal === "SIGTERM" || signal === "SIGINT") {
-      } else {
-        console.log(chalk6.bold(`=> Error running app. Exit code: ${code}`));
-      }
-    });
-    writeFile_default(".orion/process", `${appProcess.pid}`);
-  };
-  const stop = () => {
-    if (appProcess) {
-      appProcess.kill();
-    }
-  };
-  const restart = () => {
-    stop();
-    start();
-  };
-  return {
-    restart,
-    stop,
-    basePath: `${process.cwd()}/.orion/build`
-  };
-}
-
-// src/start/watchAndCompile/index.ts
-import { spawn as spawn2 } from "child_process";
-
-// src/start/watchAndCompile/cleanDirectory.ts
-import fs7 from "fs";
-import path6 from "path";
-function rimraf(dir_path) {
-  if (fs7.existsSync(dir_path)) {
-    fs7.readdirSync(dir_path).forEach((entry) => {
-      const entry_path = path6.join(dir_path, entry);
-      if (fs7.lstatSync(entry_path).isDirectory()) {
-        rimraf(entry_path);
-      } else {
-        fs7.unlinkSync(entry_path);
-      }
-    });
-    fs7.rmdirSync(dir_path);
-  }
-}
-async function cleanDirectory() {
+// src/prod/checkTs.ts
+import chalk8 from "chalk";
+import { execSync } from "child_process";
+function checkTs() {
   try {
-    const dirPath = path6.join(process.cwd(), ".orion", "build");
-    rimraf(dirPath);
-  } catch (_) {
-  }
-}
-
-// src/start/watchAndCompile/watchDeletes.ts
-import fs8 from "fs";
-import path7 from "path";
-import chokidar from "chokidar";
-async function watchDeletes() {
-  const projectPath = path7.resolve("./app");
-  const watcher = chokidar.watch(projectPath, {
-    ignoreInitial: true
-  });
-  watcher.on("unlink", async (filepath) => {
-    if (!filepath.endsWith(".ts")) return;
-    const relative = path7.relative(process.cwd(), filepath);
-    const atBuildPath = path7.resolve(".orion/build", relative.replace(/.ts$/, ""));
-    try {
-      fs8.unlinkSync(`${atBuildPath}.js`);
-      fs8.unlinkSync(`${atBuildPath}.d.ts`);
-    } catch (error) {
-      console.log(
-        `Error cleaning ${atBuildPath}. Restar project is suggested. Error: ${error.message}`
-      );
-    }
-  });
-}
-
-// src/start/watchAndCompile/writeEnvFile.ts
-import { writeDtsFileFromConfigFile } from "@orion-js/env";
-import chalk7 from "chalk";
-import chokidar2 from "chokidar";
-var envFilePath = process.env.ORION_ENV_FILE_PATH;
-var dtsFilePath = "./app/env.d.ts";
-var watchEnvFile = async (runner) => {
-  if (!envFilePath) return;
-  writeDtsFileFromConfigFile(envFilePath, dtsFilePath);
-  chokidar2.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
-    console.log(chalk7.bold("=> Environment file changed. Restarting..."));
-    writeDtsFileFromConfigFile(envFilePath, dtsFilePath);
-    runner.restart();
-  });
-};
-
-// src/start/watchAndCompile/index.ts
-async function watchAndCompile(runner) {
-  const configPath = getConfigPath();
-  ensureConfigComplies(configPath);
-  await cleanDirectory();
-  watchDeletes();
-  watchEnvFile(runner);
-  const child = spawn2("tsx", ["watch", "app/index.ts"], {
-    cwd: process.cwd(),
-    env: process.env,
-    gid: process.getgid(),
-    uid: process.getuid(),
-    stdio: "inherit"
-  });
-  child.on("error", (_) => {
+    execSync("tsc --noEmit", {
+      cwd: process.cwd(),
+      env: {
+        ...process.env
+      },
+      gid: process.getgid(),
+      uid: process.getuid(),
+      stdio: "inherit"
+    });
+  } catch {
+    console.log(chalk8.red.bold("TypeScript compilation failed"));
     process.exit(1);
-  });
-  child.on("exit", (code) => {
-    if (code !== 0) {
-      process.exit(code || 1);
-    }
-  });
-}
-
-// src/start/index.ts
-async function start_default(options) {
-  console.log(chalk8.bold(`
-Orionjs App ${chalk8.green(chalk8.bold("V4\n"))}`));
-  if (!options.omitCursorRule) {
-    await copyCursorRule().catch(console.error);
-  }
-  if (!options.omitMcpServer) {
-    await copyMCP().catch(console.error);
-  }
-  if (!options.omitMcpServer && !options.omitCursorRule) {
-    console.log(chalk8.bold("=> \u2728 Orionjs AI is ready\n"));
   }
-  const runner = getRunner(options);
-  watchAndCompile(runner);
 }
 
-// src/test/index.ts
-import chalk9 from "chalk";
-function test_default() {
-  console.log(chalk9.bold("To run tests run the following command"));
-  console.log(chalk9.bold("ORION_DEV=LOCAL ORION_TEST=1 jest"));
-  process.exit(1);
+// src/prod/index.ts
+async function prod_default() {
+  console.log(chalk9.bold(`
+Orionjs App ${chalk9.green(chalk9.bold("V4"))} Prod mode
+`));
+  checkTs();
+  runProd();
 }
 
 // src/handleErrors.ts
@@ -558,9 +545,8 @@ var run = (action) => async (...args) => {
     console.error(chalk11.red(`Error: ${e.message}`));
   }
 };
-program.command("start").description("Run the Orionjs app").option("--shell", "Opens a shell in Chrome developer tools").option("--clean", "Build the typescript project from scratch").option("--omit-cursor-rule", "Omit the creation of the Orionjs Cursor rule").option("--omit-mcp-server", "Omit the creation of the Orionjs MCP server").action(run(start_default));
-program.command("test").allowUnknownOption().description("Deprecated command").action(run(test_default));
-program.command("build").description("Compiles an Orionjs app and exports it to a simple nodejs app").option("-o, --output [output]", "Output directory").action(run(build_default));
+program.command("dev").description("Run the Orionjs app in development mode").option("--shell", "Opens a shell in Chrome developer tools").option("--omit-cursor-rule", "Omit the creation of the Orionjs Cursor rule").option("--omit-mcp-server", "Omit the creation of the Orionjs MCP server").action(run(dev_default));
+program.command("prod").description("Run the Orionjs app in production mode").action(run(prod_default));
 program.command("create").description("Creates a new Orionjs project").option("--name [name]", "Name of the project").option("--kit [kit]", "Which starter kit to use").action(run(create_default));
 program.version(version_default, "-v --version");
 program.parse(process.argv);