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

package/dist/index.cjs

@@ -23,142 +23,68 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
+var import_chalk11 = __toESM(require("chalk"), 1);
 var import_commander = require("commander");
 
-// src/start/index.ts
-var import_safe7 = __toESM(require("colors/safe"), 1);
-
-// src/start/runner/index.ts
-var import_safe = __toESM(require("colors/safe"), 1);
-
-// src/helpers/writeFile.ts
-var import_fs2 = __toESM(require("fs"), 1);
-
-// src/helpers/ensureDirectory.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-var ensureDirectory = function(filePath) {
-  const dirname = import_path.default.dirname(filePath);
-  if (import_fs.default.existsSync(dirname)) return true;
-  ensureDirectory(dirname);
-  import_fs.default.mkdirSync(dirname);
-};
-var ensureDirectory_default = ensureDirectory;
-
-// src/helpers/writeFile.ts
-async function writeFile_default(path9, content) {
-  ensureDirectory_default(path9);
-  import_fs2.default.writeFileSync(path9, content);
-}
-
-// src/start/runner/startProcess.ts
-var import_child_process = require("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");
-  }
-  args.push(".orion/build/index.js");
-  return { startCommand, args };
-}
-
-// src/start/runner/startProcess.ts
-function startProcess(options) {
-  const { startCommand, args } = getArgs(options);
-  return (0, import_child_process.spawn)(startCommand, args, {
-    env: {
-      ORION_DEV: "local",
-      ...process.env
-    },
-    cwd: process.cwd(),
-    stdio: "inherit",
-    detached: false
-  });
-}
+// src/build/index.ts
+var import_chalk2 = __toESM(require("chalk"), 1);
 
-// src/start/runner/index.ts
-function getRunner(options) {
-  let appProcess = null;
-  if (options.clean) {
-    console.log(import_safe.default.bold("=> Cleaning directory...\n"));
-  }
-  const start = () => {
-    console.log(import_safe.default.bold("=> Starting app...\n"));
-    appProcess = startProcess(options);
-    appProcess.on("exit", function(code, signal) {
-      if (!code || code === 143 || code === 0 || signal === "SIGTERM" || signal === "SIGINT") {
+// src/helpers/execute.ts
+var import_node_child_process = require("child_process");
+async function execute_default(command) {
+  return new Promise((resolve, reject) => {
+    (0, import_node_child_process.exec)(command, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
       } else {
-        console.log(import_safe.default.bold(`=> Error running app. Exit code: ${code}`));
+        resolve({ stdout, stderr });
       }
     });
-    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
+// src/build/compile.ts
+var import_chalk = __toESM(require("chalk"), 1);
 var import_typescript4 = __toESM(require("typescript"), 1);
 
-// src/start/watchAndCompile/cleanDirectory.ts
-var import_fs3 = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
-function rimraf(dir_path) {
-  if (import_fs3.default.existsSync(dir_path)) {
-    import_fs3.default.readdirSync(dir_path).forEach(function(entry) {
-      var entry_path = import_path2.default.join(dir_path, entry);
-      if (import_fs3.default.lstatSync(entry_path).isDirectory()) {
-        rimraf(entry_path);
-      } else {
-        import_fs3.default.unlinkSync(entry_path);
-      }
-    });
-    import_fs3.default.rmdirSync(dir_path);
-  }
-}
-async function cleanDirectory() {
-  try {
-    const path9 = `${process.cwd()}/.orion/build`;
-    rimraf(path9);
-  } catch {
-  }
-}
-
-// src/start/watchAndCompile/getHost.ts
+// src/build/getOptions.ts
+var import_node_path2 = __toESM(require("path"), 1);
 var import_typescript3 = __toESM(require("typescript"), 1);
 
 // src/start/watchAndCompile/getConfigPath.ts
 var import_typescript = __toESM(require("typescript"), 1);
 
+// src/start/watchAndCompile/ensureConfigComplies.ts
+var import_comment_json = require("comment-json");
+
 // src/helpers/getFileContents.ts
-var import_fs4 = __toESM(require("fs"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
 function readFile(filePath) {
-  if (!import_fs4.default.existsSync(filePath)) return null;
-  return import_fs4.default.readFileSync(filePath).toString();
+  if (!import_node_fs.default.existsSync(filePath)) return null;
+  return import_node_fs.default.readFileSync(filePath).toString();
+}
+
+// src/helpers/writeFile.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+
+// src/helpers/ensureDirectory.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var ensureDirectory = (filePath) => {
+  const dirname = import_node_path.default.dirname(filePath);
+  if (import_node_fs2.default.existsSync(dirname)) return true;
+  ensureDirectory(dirname);
+  import_node_fs2.default.mkdirSync(dirname);
+};
+var ensureDirectory_default = ensureDirectory;
+
+// src/helpers/writeFile.ts
+async function writeFile_default(path8, content) {
+  ensureDirectory_default(path8);
+  import_node_fs3.default.writeFileSync(path8, content);
 }
 
 // src/start/watchAndCompile/ensureConfigComplies.ts
-var import_comment_json = require("comment-json");
 function ensureConfigComplies(configPath) {
   var _a, _b;
   try {
@@ -168,16 +94,16 @@ function ensureConfigComplies(configPath) {
       ...config,
       compilerOptions: {
         ...config.compilerOptions,
-        outDir: `./.orion/build/app`,
-        baseUrl: `./`
+        outDir: "./.orion/build/app",
+        baseUrl: "./"
       }
     };
     if (!((_a = config.compilerOptions) == null ? void 0 : _a.rootDir) && !((_b = config.compilerOptions) == null ? void 0 : _b.rootDirs)) {
-      newConfig.compilerOptions.rootDir = `./app`;
+      newConfig.compilerOptions.rootDir = "./app";
     }
     writeFile_default(configPath, (0, import_comment_json.stringify)(newConfig, null, 2));
   } catch (error) {
-    console.log(`Error reading tsconfig ${error.message}`);
+    console.log(`Error reading tsconfig: ${error.message}`);
   }
 }
 
@@ -192,7 +118,7 @@ function getConfigPath() {
   return configPath;
 }
 
-// src/start/watchAndCompile/reports.ts
+// src/build/reports.ts
 var import_typescript2 = __toESM(require("typescript"), 1);
 var format = {
   getCanonicalFileName: (fileName) => fileName,
@@ -203,123 +129,86 @@ function reportDiagnostic(diagnostic) {
   console.log(import_typescript2.default.formatDiagnosticsWithColorAndContext([diagnostic], format));
 }
 
-// src/start/watchAndCompile/getHost.ts
-var import_safe2 = __toESM(require("colors/safe"), 1);
-
-// src/start/watchAndCompile/writeIndex/index.ts
-var import_fs5 = __toESM(require("fs"), 1);
-var import_path3 = __toESM(require("path"), 1);
-function writeIndex_default({ basePath }) {
-  const libPath = `${basePath}/moduleAliasLib.js`;
-  const libContentPath = import_path3.default.resolve(__dirname, "../../../../moduleAlias.js.txt");
-  const libContent = import_fs5.default.readFileSync(libContentPath).toString();
-  writeFile_default(libPath, libContent);
-  const aliasPath = `${basePath}/moduleAlias.js`;
-  writeFile_default(
-    aliasPath,
-    `"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const moduleAlias = require('./moduleAliasLib')
-const path =  __dirname + '/app'
-moduleAlias.addAlias('app', path)
-  `
-  );
-  const indexPath = `${basePath}/index.js`;
-  writeFile_default(
-    indexPath,
-    `"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("./moduleAlias");
-require("./app");
-  `
-  );
-}
-
-// src/start/watchAndCompile/getHost.ts
-function getHost(runner) {
-  const reportWatchStatusChanged = (diagnostic) => {
-    if (diagnostic.category !== 3) return;
-    if (diagnostic.code === 6032 || diagnostic.code === 6031) {
-      runner.stop();
-    }
-    console.log(import_safe2.default.bold(`=> ${diagnostic.messageText}`));
-    if (diagnostic.code === 6194) {
-      if (/^Found .+ errors?/.test(diagnostic.messageText.toString())) {
-        if (!diagnostic.messageText.toString().includes("Found 0 errors.")) {
-          return;
-        }
-      }
-      writeIndex_default({ basePath: runner.basePath });
-      runner.restart();
-    }
+// src/build/getOptions.ts
+function getCompilerOptionsJSONFollowExtends(filename) {
+  let compopts = {};
+  const config = import_typescript3.default.readConfigFile(filename, import_typescript3.default.sys.readFile).config;
+  if (config.extends) {
+    const rqrpath = require.resolve(config.extends);
+    compopts = getCompilerOptionsJSONFollowExtends(rqrpath);
+  }
+  return {
+    ...compopts,
+    ...config.compilerOptions
   };
+}
+function getOptions({ output }) {
   const configPath = getConfigPath();
-  const createProgram = import_typescript3.default.createEmitAndSemanticDiagnosticsBuilderProgram;
-  const host = import_typescript3.default.createWatchCompilerHost(
-    configPath,
-    {},
-    import_typescript3.default.sys,
-    createProgram,
-    reportDiagnostic,
-    reportWatchStatusChanged
-  );
-  return host;
+  const config = getCompilerOptionsJSONFollowExtends(configPath);
+  config.outDir = `${output}/app`;
+  config.incremental = false;
+  const { options, errors } = import_typescript3.default.convertCompilerOptionsFromJson(config, import_node_path2.default.dirname(configPath));
+  if (errors.length) {
+    errors.forEach(reportDiagnostic);
+    process.exit(1);
+  }
+  return options;
 }
 
-// src/start/watchAndCompile/watchDeletes.ts
-var import_chokidar = __toESM(require("chokidar"), 1);
-var import_path4 = __toESM(require("path"), 1);
-var import_fs6 = __toESM(require("fs"), 1);
-async function watchDeletes() {
-  const projectPath = import_path4.default.resolve("./app");
-  const watcher = import_chokidar.default.watch(projectPath, {
-    ignoreInitial: true
-  });
-  watcher.on("unlink", async (filepath) => {
-    if (!filepath.endsWith(".ts")) return;
-    const relative = import_path4.default.relative(process.cwd(), filepath);
-    const atBuildPath = import_path4.default.resolve(".orion/build", relative.replace(/.ts$/, ""));
-    try {
-      import_fs6.default.unlinkSync(`${atBuildPath}.js`);
-      import_fs6.default.unlinkSync(`${atBuildPath}.d.ts`);
-    } catch (error) {
-      console.log(
-        `Error cleaning ${atBuildPath}. Restar project is suggested. Error: ${error.message}`
-      );
-    }
-  });
+// src/build/compile.ts
+function compile({ output }) {
+  const options = getOptions({ output });
+  const program2 = import_typescript4.default.createProgram(["./app/index.ts"], options);
+  const preEmitDiagnostics = import_typescript4.default.getPreEmitDiagnostics(program2);
+  if (preEmitDiagnostics.length > 0) {
+    console.log(import_chalk.default.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/start/watchAndCompile/writeEnvFile.ts
-var import_chokidar2 = __toESM(require("chokidar"), 1);
-var import_safe3 = __toESM(require("colors/safe"), 1);
-var import_env = require("@orion-js/env");
-var envFilePath = process.env.ORION_ENV_FILE_PATH;
-var dtsFilePath = "./app/env.d.ts";
-var watchEnvFile = async (runner) => {
-  if (!envFilePath) return;
-  (0, import_env.writeDtsFileFromConfigFile)(envFilePath, dtsFilePath);
-  import_chokidar2.default.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
-    console.log(import_safe3.default.bold(`=> Environment file changed. Restarting...`));
-    (0, import_env.writeDtsFileFromConfigFile)(envFilePath, dtsFilePath);
-    runner.restart();
-  });
-};
+// src/build/index.ts
+async function build_default({ output }) {
+  if (!output) {
+    output = "./build";
+  }
+  console.log(import_chalk2.default.bold(`Cleaning directory ${output}...`));
+  await execute_default(`rm -rf ${output}`);
+  console.log(import_chalk2.default.bold("Compiling your app..."));
+  compile({ output });
+  console.log(import_chalk2.default.bold("Build created"));
+}
 
-// src/start/watchAndCompile/index.ts
-async function watchAndCompile(runner) {
-  await cleanDirectory();
-  const host = getHost(runner);
-  import_typescript4.default.createWatchProgram(host);
-  watchDeletes();
-  watchEnvFile(runner);
+// 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/start/index.ts
+var import_chalk8 = __toESM(require("chalk"), 1);
+
 // src/start/copyCursorRule/index.ts
-var import_path5 = __toESM(require("path"), 1);
 var import_promises = __toESM(require("fs/promises"), 1);
-var import_https = __toESM(require("https"), 1);
-var import_safe4 = __toESM(require("colors/safe"), 1);
+var import_node_https = __toESM(require("https"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
 var rules = [
   "orionjs.mdx",
   "orionjs-component.mdx",
@@ -330,7 +219,7 @@ var rules = [
 ];
 var downloadFile = (url) => {
   return new Promise((resolve, reject) => {
-    import_https.default.get(url, (response) => {
+    import_node_https.default.get(url, (response) => {
       if (response.statusCode !== 200) {
         reject(new Error(`Failed to download, status code: ${response.statusCode}`));
         return;
@@ -349,55 +238,37 @@ var downloadFile = (url) => {
   });
 };
 async function copyCursorRule() {
-  const baseUrl = `https://raw.githubusercontent.com/orionjs/orionjs/refs/heads/master/mdc`;
+  const baseUrl = "https://raw.githubusercontent.com/orionjs/orionjs/refs/heads/master/mdc";
   try {
-    const targetDir = import_path5.default.join(process.cwd(), ".cursor", "rules");
+    const targetDir = import_node_path3.default.join(process.cwd(), ".cursor", "rules");
     await import_promises.default.mkdir(targetDir, { recursive: true });
     for (const rule of rules) {
       const targetFileName = rule.replace(".mdx", ".mdc");
-      const targetFile = import_path5.default.join(targetDir, targetFileName);
+      const targetFile = import_node_path3.default.join(targetDir, targetFileName);
       const sourceUrl = `${baseUrl}/${rule}`;
       const content = await downloadFile(sourceUrl);
       await import_promises.default.writeFile(targetFile, content, "utf8");
-      console.log(import_safe4.default.bold(`=> \u2728 Successfully downloaded ${import_safe4.default.cyan(targetFileName)}`));
+      console.log(import_chalk3.default.bold(`=> \u2728 Successfully downloaded ${import_chalk3.default.cyan(targetFileName)}`));
     }
-    console.log(import_safe4.default.bold("=> \u2728 All rule files have been successfully copied"));
+    console.log(import_chalk3.default.bold("=> \u2728 All rule files have been successfully copied"));
   } catch (error) {
-    console.error(import_safe4.default.red(`Error copying rule files: ${error.message}`));
+    console.error(import_chalk3.default.red(`Error copying rule files: ${error.message}`));
   }
 }
 
 // src/start/copyMCP/index.ts
-var import_path7 = __toESM(require("path"), 1);
 var import_promises3 = __toESM(require("fs/promises"), 1);
-
-// src/helpers/execute.ts
-var import_child_process2 = require("child_process");
-async function execute_default(command) {
-  return new Promise(function(resolve, reject) {
-    (0, import_child_process2.exec)(command, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve({ stdout, stderr });
-      }
-    });
-  });
-}
-
-// src/start/copyMCP/index.ts
-var import_safe6 = __toESM(require("colors/safe"), 1);
-
-// src/start/copyMCP/isValidMCPRepo.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_path6 = __toESM(require("path"), 1);
-var import_safe5 = __toESM(require("colors/safe"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_chalk5 = __toESM(require("chalk"), 1);
 
 // src/start/copyMCP/consts.ts
 var MCP_VERSION = "v1";
 var VERSION_FILE = "version.txt";
 
 // src/start/copyMCP/isValidMCPRepo.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_chalk4 = __toESM(require("chalk"), 1);
 async function isValidMCPRepository(directoryPath) {
   try {
     const stats = await import_promises2.default.stat(directoryPath);
@@ -405,17 +276,17 @@ async function isValidMCPRepository(directoryPath) {
     const expectedFiles = ["settings.js", "package.json"];
     for (const file of expectedFiles) {
       try {
-        await import_promises2.default.access(import_path6.default.join(directoryPath, file));
+        await import_promises2.default.access(import_node_path4.default.join(directoryPath, file));
       } catch {
         return false;
       }
     }
     try {
-      const versionPath = import_path6.default.join(directoryPath, VERSION_FILE);
+      const versionPath = import_node_path4.default.join(directoryPath, VERSION_FILE);
       const versionContent = await import_promises2.default.readFile(versionPath, "utf-8");
       if (versionContent.trim() !== MCP_VERSION) {
         console.log(
-          import_safe5.default.yellow(
+          import_chalk4.default.yellow(
             `=> \u2728 MCP version mismatch: installed=${versionContent.trim()}, required=${MCP_VERSION}`
           )
         );
@@ -433,11 +304,11 @@ async function isValidMCPRepository(directoryPath) {
 // src/start/copyMCP/index.ts
 async function copyMCP() {
   const repoUrl = "https://github.com/orionjs/mcp-docs";
-  const targetDir = import_path7.default.join(process.cwd(), ".orion", "mcp");
+  const targetDir = import_node_path5.default.join(process.cwd(), ".orion", "mcp");
   try {
-    await import_promises3.default.mkdir(import_path7.default.join(process.cwd(), ".orion"), { recursive: true });
+    await import_promises3.default.mkdir(import_node_path5.default.join(process.cwd(), ".orion"), { recursive: true });
     if (await isValidMCPRepository(targetDir)) {
-      console.log(import_safe6.default.bold(`=> \u2728 MCP documentation already installed`));
+      console.log(import_chalk5.default.bold("=> \u2728 MCP documentation already installed"));
       return;
     }
     try {
@@ -445,32 +316,32 @@ async function copyMCP() {
       if (stats.isDirectory()) {
         await import_promises3.default.rm(targetDir, { recursive: true, force: true });
         console.log(
-          import_safe6.default.bold(
-            `=> \u2728 Removed existing .orion/mcp directory (invalid, incomplete, or outdated)`
+          import_chalk5.default.bold(
+            "=> \u2728 Removed existing .orion/mcp directory (invalid, incomplete, or outdated)"
           )
         );
       }
-    } catch (error) {
+    } catch (_) {
     }
-    console.log(import_safe6.default.bold(`=> \u2728 Downloading MCP documentation ${MCP_VERSION}...`));
+    console.log(import_chalk5.default.bold(`=> \u2728 Downloading MCP documentation ${MCP_VERSION}...`));
     await execute_default(`git clone ${repoUrl} ${targetDir}`);
-    await execute_default(`rm -rf ${import_path7.default.join(targetDir, ".git")}`);
-    await import_promises3.default.writeFile(import_path7.default.join(targetDir, VERSION_FILE), MCP_VERSION, "utf-8");
+    await execute_default(`rm -rf ${import_node_path5.default.join(targetDir, ".git")}`);
+    await import_promises3.default.writeFile(import_node_path5.default.join(targetDir, VERSION_FILE), MCP_VERSION, "utf-8");
     console.log(
-      import_safe6.default.bold(`=> \u2728 Successfully downloaded MCP documentation v${MCP_VERSION} to .orion/mcp`)
+      import_chalk5.default.bold(`=> \u2728 Successfully downloaded MCP documentation v${MCP_VERSION} to .orion/mcp`)
     );
-    console.log(import_safe6.default.bold(`=> \u2728 Installing MCP dependencies...`));
+    console.log(import_chalk5.default.bold("=> \u2728 Installing MCP dependencies..."));
     await execute_default(`cd ${targetDir} && npm install`);
-    console.log(import_safe6.default.bold(`=> \u2728 Successfully installed MCP dependencies`));
+    console.log(import_chalk5.default.bold("=> \u2728 Successfully installed MCP dependencies"));
     const mcpServerConfig = {
       mcpServers: {
         "Orionjs documentation search": {
           command: "node",
-          args: [import_path7.default.join(targetDir, "src", "index.js")]
+          args: [import_node_path5.default.join(targetDir, "src", "index.js")]
         }
       }
     };
-    const configPath = import_path7.default.join(process.cwd(), ".cursor", "mcp.json");
+    const configPath = import_node_path5.default.join(process.cwd(), ".cursor", "mcp.json");
     try {
       const existingConfig = await import_promises3.default.readFile(configPath, "utf-8");
       const parsedConfig = JSON.parse(existingConfig);
@@ -479,158 +350,229 @@ async function copyMCP() {
         ...mcpServerConfig.mcpServers
       };
       await import_promises3.default.writeFile(configPath, JSON.stringify(parsedConfig, null, 2), "utf-8");
-      console.log(import_safe6.default.bold(`=> \u2728 Updated MCP server configuration in .cursor/mcp.json`));
-    } catch (error) {
-      await import_promises3.default.mkdir(import_path7.default.dirname(configPath), { recursive: true });
+      console.log(import_chalk5.default.bold("=> \u2728 Updated MCP server configuration in .cursor/mcp.json"));
+    } catch (_) {
+      await import_promises3.default.mkdir(import_node_path5.default.dirname(configPath), { recursive: true });
       await import_promises3.default.writeFile(configPath, JSON.stringify(mcpServerConfig, null, 2), "utf-8");
-      console.log(import_safe6.default.bold(`=> \u2728 Created new MCP server configuration in .cursor/mcp.json`));
+      console.log(import_chalk5.default.bold("=> \u2728 Created new MCP server configuration in .cursor/mcp.json"));
     }
   } catch (error) {
-    console.error(import_safe6.default.red("=> \u2728 Error copying MCP documentation:"), error);
+    console.error(import_chalk5.default.red("=> \u2728 Error copying MCP documentation:"), error);
     throw error;
   }
 }
 
-// src/start/index.ts
-async function start_default(options) {
-  console.log(import_safe7.default.bold("\nOrionjs App " + import_safe7.default.green(import_safe7.default.bold("V3\n"))));
-  if (!options.omitCursorRule) {
-    await copyCursorRule().catch(console.error);
-  }
-  if (!options.omitMcpServer) {
-    await copyMCP().catch(console.error);
-  }
-  if (!options.omitMcpServer && !options.omitCursorRule) {
-    console.log(import_safe7.default.bold(`=> \u2728 Orionjs AI is ready
-`));
+// src/start/runner/index.ts
+var import_chalk6 = __toESM(require("chalk"), 1);
+
+// src/start/runner/startProcess.ts
+var import_node_child_process2 = require("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");
   }
-  const runner = getRunner(options);
-  watchAndCompile(runner);
+  args.push(".orion/build/index.js");
+  return { startCommand, args };
 }
 
-// src/build/index.ts
-var import_safe9 = __toESM(require("colors/safe"), 1);
-
-// src/build/compile.ts
-var import_typescript6 = __toESM(require("typescript"), 1);
+// src/start/runner/startProcess.ts
+function startProcess(options) {
+  const { startCommand, args } = getArgs(options);
+  return (0, import_node_child_process2.spawn)(startCommand, args, {
+    env: {
+      ORION_DEV: "local",
+      ...process.env
+    },
+    cwd: process.cwd(),
+    stdio: "inherit",
+    detached: false
+  });
+}
 
-// src/build/getOptions.ts
-var import_typescript5 = __toESM(require("typescript"), 1);
-var import_path8 = __toESM(require("path"), 1);
-function getCompilerOptionsJSONFollowExtends(filename) {
-  let compopts = {};
-  const config = import_typescript5.default.readConfigFile(filename, import_typescript5.default.sys.readFile).config;
-  if (config.extends) {
-    const rqrpath = require.resolve(config.extends);
-    compopts = getCompilerOptionsJSONFollowExtends(rqrpath);
+// src/start/runner/index.ts
+function getRunner(options) {
+  let appProcess = null;
+  if (options.clean) {
+    console.log(import_chalk6.default.bold("=> Cleaning directory...\n"));
   }
+  const start = () => {
+    console.log(import_chalk6.default.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(import_chalk6.default.bold(`=> Error running app. Exit code: ${code}`));
+      }
+    });
+    writeFile_default(".orion/process", `${appProcess.pid}`);
+  };
+  const stop = () => {
+    if (appProcess) {
+      appProcess.kill();
+    }
+  };
+  const restart = () => {
+    stop();
+    start();
+  };
   return {
-    ...compopts,
-    ...config.compilerOptions
+    restart,
+    stop,
+    basePath: `${process.cwd()}/.orion/build`
   };
 }
-function getOptions({ output }) {
-  const configPath = getConfigPath();
-  const config = getCompilerOptionsJSONFollowExtends(configPath);
-  config.outDir = `${output}/app`;
-  config.incremental = false;
-  const { options, errors } = import_typescript5.default.convertCompilerOptionsFromJson(config, import_path8.default.dirname(configPath));
-  if (errors.length) {
-    errors.forEach(reportDiagnostic);
-    process.exit(1);
-  }
-  return options;
-}
 
-// src/build/compile.ts
-var import_safe8 = __toESM(require("colors/safe"), 1);
-function compile({ output }) {
-  const options = getOptions({ output });
-  const program2 = import_typescript6.default.createProgram(["./app/index.ts"], options);
-  const preEmitDiagnostics = import_typescript6.default.getPreEmitDiagnostics(program2);
-  if (preEmitDiagnostics.length > 0) {
-    console.log(import_safe8.default.red(`
-==> Error builing Orion app
-`));
-  }
-  preEmitDiagnostics.forEach(reportDiagnostic);
-  if (preEmitDiagnostics.length > 0) {
-    process.exit(1);
+// src/start/watchAndCompile/index.ts
+var import_node_child_process3 = require("child_process");
+
+// src/start/watchAndCompile/cleanDirectory.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+function rimraf(dir_path) {
+  if (import_node_fs4.default.existsSync(dir_path)) {
+    import_node_fs4.default.readdirSync(dir_path).forEach((entry) => {
+      const entry_path = import_node_path6.default.join(dir_path, entry);
+      if (import_node_fs4.default.lstatSync(entry_path).isDirectory()) {
+        rimraf(entry_path);
+      } else {
+        import_node_fs4.default.unlinkSync(entry_path);
+      }
+    });
+    import_node_fs4.default.rmdirSync(dir_path);
   }
-  const emitResult = program2.emit();
-  emitResult.diagnostics.forEach(reportDiagnostic);
-  if (emitResult.emitSkipped) {
-    process.exit(1);
+}
+async function cleanDirectory() {
+  try {
+    const dirPath = import_node_path6.default.join(process.cwd(), ".orion", "build");
+    rimraf(dirPath);
+  } catch (_) {
   }
 }
 
-// src/build/index.ts
-async function build_default({ output }) {
-  if (!output) {
-    output = "./build";
-  }
-  console.log(import_safe9.default.bold(`Cleaning directory ${output}...`));
-  await execute_default(`rm -rf ${output}`);
-  console.log(import_safe9.default.bold("Compiling your app..."));
-  compile({ output });
-  writeIndex_default({ basePath: output });
-  console.log(import_safe9.default.bold("Build created"));
+// src/start/watchAndCompile/watchDeletes.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+var import_chokidar = __toESM(require("chokidar"), 1);
+async function watchDeletes() {
+  const projectPath = import_node_path7.default.resolve("./app");
+  const watcher = import_chokidar.default.watch(projectPath, {
+    ignoreInitial: true
+  });
+  watcher.on("unlink", async (filepath) => {
+    if (!filepath.endsWith(".ts")) return;
+    const relative = import_node_path7.default.relative(process.cwd(), filepath);
+    const atBuildPath = import_node_path7.default.resolve(".orion/build", relative.replace(/.ts$/, ""));
+    try {
+      import_node_fs5.default.unlinkSync(`${atBuildPath}.js`);
+      import_node_fs5.default.unlinkSync(`${atBuildPath}.d.ts`);
+    } catch (error) {
+      console.log(
+        `Error cleaning ${atBuildPath}. Restar project is suggested. Error: ${error.message}`
+      );
+    }
+  });
 }
 
-// src/create/index.ts
-async function create_default({ name, kit }) {
-  if (!name) {
-    throw new Error("Please set the name of the app");
+// src/start/watchAndCompile/writeEnvFile.ts
+var import_env = require("@orion-js/env");
+var import_chalk7 = __toESM(require("chalk"), 1);
+var import_chokidar2 = __toESM(require("chokidar"), 1);
+var envFilePath = process.env.ORION_ENV_FILE_PATH;
+var dtsFilePath = "./app/env.d.ts";
+var watchEnvFile = async (runner) => {
+  if (!envFilePath) return;
+  (0, import_env.writeDtsFileFromConfigFile)(envFilePath, dtsFilePath);
+  import_chokidar2.default.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
+    console.log(import_chalk7.default.bold("=> Environment file changed. Restarting..."));
+    (0, import_env.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 = (0, import_node_child_process3.spawn)("tsx", ["watch", "app/index.ts"], {
+    cwd: process.cwd(),
+    env: process.env,
+    gid: process.getgid(),
+    uid: process.getuid(),
+    stdio: "inherit"
+  });
+  child.on("error", (_) => {
+    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(import_chalk8.default.bold(`
+Orionjs App ${import_chalk8.default.green(import_chalk8.default.bold("V4\n"))}`));
+  if (!options.omitCursorRule) {
+    await copyCursorRule().catch(console.error);
   }
-  if (!kit) {
-    throw new Error("Please select which kit to use");
+  if (!options.omitMcpServer) {
+    await copyMCP().catch(console.error);
   }
-  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");
+  if (!options.omitMcpServer && !options.omitCursorRule) {
+    console.log(import_chalk8.default.bold("=> \u2728 Orionjs AI is ready\n"));
+  }
+  const runner = getRunner(options);
+  watchAndCompile(runner);
 }
 
-// src/index.ts
-var import_safe11 = __toESM(require("colors/safe"), 1);
-
 // src/test/index.ts
-var import_safe10 = __toESM(require("colors/safe"), 1);
+var import_chalk9 = __toESM(require("chalk"), 1);
 function test_default() {
-  console.log(import_safe10.default.bold(`To run tests run the following command`));
-  console.log(import_safe10.default.bold(`ORION_DEV=LOCAL ORION_TEST=1 jest`));
+  console.log(import_chalk9.default.bold("To run tests run the following command"));
+  console.log(import_chalk9.default.bold("ORION_DEV=LOCAL ORION_TEST=1 jest"));
   process.exit(1);
 }
 
 // src/handleErrors.ts
-var import_colors = __toESM(require("colors"), 1);
+var import_chalk10 = __toESM(require("chalk"), 1);
 process.on("unhandledRejection", (error) => {
   if (error.codeFrame) {
-    console.error(import_colors.default.red(error.message));
+    console.error(import_chalk10.default.red(error.message));
     console.log(error.codeFrame);
   } else {
-    console.error(import_colors.default.red(error.message), import_colors.default.red("Unhandled promise rejection"));
+    console.error(import_chalk10.default.red(error.message), import_chalk10.default.red("Unhandled promise rejection"));
   }
 }).on("uncaughtException", (error) => {
-  console.error(import_colors.default.red(error.message));
+  console.error(import_chalk10.default.red(error.message));
   process.exit(1);
 });
 
 // src/version.ts
-var version_default = `3.0`;
+var version_default = "3.0";
 
 // src/index.ts
 var import_config = require("dotenv/config");
 var program = new import_commander.Command();
-var run = function(action) {
-  return async function(...args) {
-    try {
-      await action(...args);
-    } catch (e) {
-      console.error(import_safe11.default.red("Error: " + e.message));
-    }
-  };
+var run = (action) => async (...args) => {
+  try {
+    await action(...args);
+  } catch (e) {
+    console.error(import_chalk11.default.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));