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

package/dist/index.js

@@ -7,142 +7,68 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
+import chalk11 from "chalk";
 import { Command } from "commander";
 
-// src/start/index.ts
-import colors7 from "colors/safe";
-
-// src/start/runner/index.ts
-import colors from "colors/safe";
-
-// src/helpers/writeFile.ts
-import fs2 from "fs";
-
-// src/helpers/ensureDirectory.ts
-import fs from "fs";
-import path from "path";
-var ensureDirectory = function(filePath) {
-  const dirname = path.dirname(filePath);
-  if (fs.existsSync(dirname)) return true;
-  ensureDirectory(dirname);
-  fs.mkdirSync(dirname);
-};
-var ensureDirectory_default = ensureDirectory;
-
-// src/helpers/writeFile.ts
-async function writeFile_default(path9, content) {
-  ensureDirectory_default(path9);
-  fs2.writeFileSync(path9, content);
-}
-
-// 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");
-  }
-  args.push(".orion/build/index.js");
-  return { startCommand, args };
-}
-
-// src/start/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/build/index.ts
+import chalk2 from "chalk";
 
-// src/start/runner/index.ts
-function getRunner(options) {
-  let appProcess = null;
-  if (options.clean) {
-    console.log(colors.bold("=> Cleaning directory...\n"));
-  }
-  const start = () => {
-    console.log(colors.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
+import { exec } from "child_process";
+async function execute_default(command) {
+  return new Promise((resolve, reject) => {
+    exec(command, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
       } else {
-        console.log(colors.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
+import chalk from "chalk";
 import ts4 from "typescript";
 
-// src/start/watchAndCompile/cleanDirectory.ts
-import fs3 from "fs";
+// src/build/getOptions.ts
 import path2 from "path";
-function rimraf(dir_path) {
-  if (fs3.existsSync(dir_path)) {
-    fs3.readdirSync(dir_path).forEach(function(entry) {
-      var 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 path9 = `${process.cwd()}/.orion/build`;
-    rimraf(path9);
-  } catch {
-  }
-}
-
-// src/start/watchAndCompile/getHost.ts
 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 fs4 from "fs";
+import fs from "fs";
 function readFile(filePath) {
-  if (!fs4.existsSync(filePath)) return null;
-  return fs4.readFileSync(filePath).toString();
+  if (!fs.existsSync(filePath)) return null;
+  return fs.readFileSync(filePath).toString();
+}
+
+// src/helpers/writeFile.ts
+import fs3 from "fs";
+
+// src/helpers/ensureDirectory.ts
+import fs2 from "fs";
+import path from "path";
+var ensureDirectory = (filePath) => {
+  const dirname = path.dirname(filePath);
+  if (fs2.existsSync(dirname)) return true;
+  ensureDirectory(dirname);
+  fs2.mkdirSync(dirname);
+};
+var ensureDirectory_default = ensureDirectory;
+
+// src/helpers/writeFile.ts
+async function writeFile_default(path8, content) {
+  ensureDirectory_default(path8);
+  fs3.writeFileSync(path8, content);
 }
 
 // src/start/watchAndCompile/ensureConfigComplies.ts
-import { parse, stringify } from "comment-json";
 function ensureConfigComplies(configPath) {
   var _a, _b;
   try {
@@ -152,16 +78,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, stringify(newConfig, null, 2));
   } catch (error) {
-    console.log(`Error reading tsconfig ${error.message}`);
+    console.log(`Error reading tsconfig: ${error.message}`);
   }
 }
 
@@ -176,7 +102,7 @@ function getConfigPath() {
   return configPath;
 }
 
-// src/start/watchAndCompile/reports.ts
+// src/build/reports.ts
 import ts2 from "typescript";
 var format = {
   getCanonicalFileName: (fileName) => fileName,
@@ -187,123 +113,86 @@ function reportDiagnostic(diagnostic) {
   console.log(ts2.formatDiagnosticsWithColorAndContext([diagnostic], format));
 }
 
-// src/start/watchAndCompile/getHost.ts
-import colors2 from "colors/safe";
-
-// src/start/watchAndCompile/writeIndex/index.ts
-import fs5 from "fs";
-import path3 from "path";
-function writeIndex_default({ basePath }) {
-  const libPath = `${basePath}/moduleAliasLib.js`;
-  const libContentPath = path3.resolve(__dirname, "../../../../moduleAlias.js.txt");
-  const libContent = fs5.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(colors2.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 = ts3.readConfigFile(filename, ts3.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 = ts3.createEmitAndSemanticDiagnosticsBuilderProgram;
-  const host = ts3.createWatchCompilerHost(
-    configPath,
-    {},
-    ts3.sys,
-    createProgram,
-    reportDiagnostic,
-    reportWatchStatusChanged
-  );
-  return host;
+  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;
 }
 
-// src/start/watchAndCompile/watchDeletes.ts
-import chokidar from "chokidar";
-import path4 from "path";
-import fs6 from "fs";
-async function watchDeletes() {
-  const projectPath = path4.resolve("./app");
-  const watcher = chokidar.watch(projectPath, {
-    ignoreInitial: true
-  });
-  watcher.on("unlink", async (filepath) => {
-    if (!filepath.endsWith(".ts")) return;
-    const relative = path4.relative(process.cwd(), filepath);
-    const atBuildPath = path4.resolve(".orion/build", relative.replace(/.ts$/, ""));
-    try {
-      fs6.unlinkSync(`${atBuildPath}.js`);
-      fs6.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 = 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/start/watchAndCompile/writeEnvFile.ts
-import chokidar2 from "chokidar";
-import colors3 from "colors/safe";
-import { writeDtsFileFromConfigFile } from "@orion-js/env";
-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(colors3.bold(`=> Environment file changed. Restarting...`));
-    writeDtsFileFromConfigFile(envFilePath, dtsFilePath);
-    runner.restart();
-  });
-};
+// 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/start/watchAndCompile/index.ts
-async function watchAndCompile(runner) {
-  await cleanDirectory();
-  const host = getHost(runner);
-  ts4.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
+import chalk8 from "chalk";
+
 // src/start/copyCursorRule/index.ts
-import path5 from "path";
-import fs7 from "fs/promises";
+import fs4 from "fs/promises";
 import https from "https";
-import colors4 from "colors/safe";
+import path3 from "path";
+import chalk3 from "chalk";
 var rules = [
   "orionjs.mdx",
   "orionjs-component.mdx",
@@ -333,73 +222,55 @@ 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 = path5.join(process.cwd(), ".cursor", "rules");
-    await fs7.mkdir(targetDir, { recursive: true });
+    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 = path5.join(targetDir, targetFileName);
+      const targetFile = path3.join(targetDir, targetFileName);
       const sourceUrl = `${baseUrl}/${rule}`;
       const content = await downloadFile(sourceUrl);
-      await fs7.writeFile(targetFile, content, "utf8");
-      console.log(colors4.bold(`=> \u2728 Successfully downloaded ${colors4.cyan(targetFileName)}`));
+      await fs4.writeFile(targetFile, content, "utf8");
+      console.log(chalk3.bold(`=> \u2728 Successfully downloaded ${chalk3.cyan(targetFileName)}`));
     }
-    console.log(colors4.bold("=> \u2728 All rule files have been successfully copied"));
+    console.log(chalk3.bold("=> \u2728 All rule files have been successfully copied"));
   } catch (error) {
-    console.error(colors4.red(`Error copying rule files: ${error.message}`));
+    console.error(chalk3.red(`Error copying rule files: ${error.message}`));
   }
 }
 
 // src/start/copyMCP/index.ts
-import path7 from "path";
-import fs9 from "fs/promises";
-
-// src/helpers/execute.ts
-import { exec } from "child_process";
-async function execute_default(command) {
-  return new Promise(function(resolve, reject) {
-    exec(command, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve({ stdout, stderr });
-      }
-    });
-  });
-}
-
-// src/start/copyMCP/index.ts
-import colors6 from "colors/safe";
-
-// src/start/copyMCP/isValidMCPRepo.ts
-import fs8 from "fs/promises";
-import path6 from "path";
-import colors5 from "colors/safe";
+import fs6 from "fs/promises";
+import path5 from "path";
+import chalk5 from "chalk";
 
 // src/start/copyMCP/consts.ts
 var MCP_VERSION = "v1";
 var VERSION_FILE = "version.txt";
 
 // src/start/copyMCP/isValidMCPRepo.ts
+import fs5 from "fs/promises";
+import path4 from "path";
+import chalk4 from "chalk";
 async function isValidMCPRepository(directoryPath) {
   try {
-    const stats = await fs8.stat(directoryPath);
+    const stats = await fs5.stat(directoryPath);
     if (!stats.isDirectory()) return false;
     const expectedFiles = ["settings.js", "package.json"];
     for (const file of expectedFiles) {
       try {
-        await fs8.access(path6.join(directoryPath, file));
+        await fs5.access(path4.join(directoryPath, file));
       } catch {
         return false;
       }
     }
     try {
-      const versionPath = path6.join(directoryPath, VERSION_FILE);
-      const versionContent = await fs8.readFile(versionPath, "utf-8");
+      const versionPath = path4.join(directoryPath, VERSION_FILE);
+      const versionContent = await fs5.readFile(versionPath, "utf-8");
       if (versionContent.trim() !== MCP_VERSION) {
         console.log(
-          colors5.yellow(
+          chalk4.yellow(
             `=> \u2728 MCP version mismatch: installed=${versionContent.trim()}, required=${MCP_VERSION}`
           )
         );
@@ -417,204 +288,275 @@ async function isValidMCPRepository(directoryPath) {
 // src/start/copyMCP/index.ts
 async function copyMCP() {
   const repoUrl = "https://github.com/orionjs/mcp-docs";
-  const targetDir = path7.join(process.cwd(), ".orion", "mcp");
+  const targetDir = path5.join(process.cwd(), ".orion", "mcp");
   try {
-    await fs9.mkdir(path7.join(process.cwd(), ".orion"), { recursive: true });
+    await fs6.mkdir(path5.join(process.cwd(), ".orion"), { recursive: true });
     if (await isValidMCPRepository(targetDir)) {
-      console.log(colors6.bold(`=> \u2728 MCP documentation already installed`));
+      console.log(chalk5.bold("=> \u2728 MCP documentation already installed"));
       return;
     }
     try {
-      const stats = await fs9.stat(targetDir);
+      const stats = await fs6.stat(targetDir);
       if (stats.isDirectory()) {
-        await fs9.rm(targetDir, { recursive: true, force: true });
+        await fs6.rm(targetDir, { recursive: true, force: true });
         console.log(
-          colors6.bold(
-            `=> \u2728 Removed existing .orion/mcp directory (invalid, incomplete, or outdated)`
+          chalk5.bold(
+            "=> \u2728 Removed existing .orion/mcp directory (invalid, incomplete, or outdated)"
           )
         );
       }
-    } catch (error) {
+    } catch (_) {
     }
-    console.log(colors6.bold(`=> \u2728 Downloading MCP documentation ${MCP_VERSION}...`));
+    console.log(chalk5.bold(`=> \u2728 Downloading MCP documentation ${MCP_VERSION}...`));
     await execute_default(`git clone ${repoUrl} ${targetDir}`);
-    await execute_default(`rm -rf ${path7.join(targetDir, ".git")}`);
-    await fs9.writeFile(path7.join(targetDir, VERSION_FILE), MCP_VERSION, "utf-8");
+    await execute_default(`rm -rf ${path5.join(targetDir, ".git")}`);
+    await fs6.writeFile(path5.join(targetDir, VERSION_FILE), MCP_VERSION, "utf-8");
     console.log(
-      colors6.bold(`=> \u2728 Successfully downloaded MCP documentation v${MCP_VERSION} to .orion/mcp`)
+      chalk5.bold(`=> \u2728 Successfully downloaded MCP documentation v${MCP_VERSION} to .orion/mcp`)
     );
-    console.log(colors6.bold(`=> \u2728 Installing MCP dependencies...`));
+    console.log(chalk5.bold("=> \u2728 Installing MCP dependencies..."));
     await execute_default(`cd ${targetDir} && npm install`);
-    console.log(colors6.bold(`=> \u2728 Successfully installed MCP dependencies`));
+    console.log(chalk5.bold("=> \u2728 Successfully installed MCP dependencies"));
     const mcpServerConfig = {
       mcpServers: {
         "Orionjs documentation search": {
           command: "node",
-          args: [path7.join(targetDir, "src", "index.js")]
+          args: [path5.join(targetDir, "src", "index.js")]
         }
       }
     };
-    const configPath = path7.join(process.cwd(), ".cursor", "mcp.json");
+    const configPath = path5.join(process.cwd(), ".cursor", "mcp.json");
     try {
-      const existingConfig = await fs9.readFile(configPath, "utf-8");
+      const existingConfig = await fs6.readFile(configPath, "utf-8");
       const parsedConfig = JSON.parse(existingConfig);
       parsedConfig.mcpServers = {
         ...parsedConfig.mcpServers,
         ...mcpServerConfig.mcpServers
       };
-      await fs9.writeFile(configPath, JSON.stringify(parsedConfig, null, 2), "utf-8");
-      console.log(colors6.bold(`=> \u2728 Updated MCP server configuration in .cursor/mcp.json`));
-    } catch (error) {
-      await fs9.mkdir(path7.dirname(configPath), { recursive: true });
-      await fs9.writeFile(configPath, JSON.stringify(mcpServerConfig, null, 2), "utf-8");
-      console.log(colors6.bold(`=> \u2728 Created new MCP server configuration in .cursor/mcp.json`));
+      await fs6.writeFile(configPath, JSON.stringify(parsedConfig, null, 2), "utf-8");
+      console.log(chalk5.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"));
     }
   } catch (error) {
-    console.error(colors6.red("=> \u2728 Error copying MCP documentation:"), error);
+    console.error(chalk5.red("=> \u2728 Error copying MCP documentation:"), error);
     throw error;
   }
 }
 
-// src/start/index.ts
-async function start_default(options) {
-  console.log(colors7.bold("\nOrionjs App " + colors7.green(colors7.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(colors7.bold(`=> \u2728 Orionjs AI is ready
-`));
+// 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");
   }
-  const runner = getRunner(options);
-  watchAndCompile(runner);
+  args.push(".orion/build/index.js");
+  return { startCommand, args };
 }
 
-// src/build/index.ts
-import colors9 from "colors/safe";
-
-// src/build/compile.ts
-import ts6 from "typescript";
+// src/start/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/build/getOptions.ts
-import ts5 from "typescript";
-import path8 from "path";
-function getCompilerOptionsJSONFollowExtends(filename) {
-  let compopts = {};
-  const config = ts5.readConfigFile(filename, ts5.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(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 {
-    ...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 } = ts5.convertCompilerOptionsFromJson(config, path8.dirname(configPath));
-  if (errors.length) {
-    errors.forEach(reportDiagnostic);
-    process.exit(1);
-  }
-  return options;
-}
 
-// src/build/compile.ts
-import colors8 from "colors/safe";
-function compile({ output }) {
-  const options = getOptions({ output });
-  const program2 = ts6.createProgram(["./app/index.ts"], options);
-  const preEmitDiagnostics = ts6.getPreEmitDiagnostics(program2);
-  if (preEmitDiagnostics.length > 0) {
-    console.log(colors8.red(`
-==> Error builing Orion app
-`));
-  }
-  preEmitDiagnostics.forEach(reportDiagnostic);
-  if (preEmitDiagnostics.length > 0) {
-    process.exit(1);
+// 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);
   }
-  const emitResult = program2.emit();
-  emitResult.diagnostics.forEach(reportDiagnostic);
-  if (emitResult.emitSkipped) {
-    process.exit(1);
+}
+async function cleanDirectory() {
+  try {
+    const dirPath = path6.join(process.cwd(), ".orion", "build");
+    rimraf(dirPath);
+  } catch (_) {
   }
 }
 
-// src/build/index.ts
-async function build_default({ output }) {
-  if (!output) {
-    output = "./build";
-  }
-  console.log(colors9.bold(`Cleaning directory ${output}...`));
-  await execute_default(`rm -rf ${output}`);
-  console.log(colors9.bold("Compiling your app..."));
-  compile({ output });
-  writeIndex_default({ basePath: output });
-  console.log(colors9.bold("Build created"));
+// 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/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
+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", (_) => {
+    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 (!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(chalk8.bold("=> \u2728 Orionjs AI is ready\n"));
+  }
+  const runner = getRunner(options);
+  watchAndCompile(runner);
 }
 
-// src/index.ts
-import colors12 from "colors/safe";
-
 // src/test/index.ts
-import colors10 from "colors/safe";
+import chalk9 from "chalk";
 function test_default() {
-  console.log(colors10.bold(`To run tests run the following command`));
-  console.log(colors10.bold(`ORION_DEV=LOCAL ORION_TEST=1 jest`));
+  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/handleErrors.ts
-import colors11 from "colors";
+import chalk10 from "chalk";
 process.on("unhandledRejection", (error) => {
   if (error.codeFrame) {
-    console.error(colors11.red(error.message));
+    console.error(chalk10.red(error.message));
     console.log(error.codeFrame);
   } else {
-    console.error(colors11.red(error.message), colors11.red("Unhandled promise rejection"));
+    console.error(chalk10.red(error.message), chalk10.red("Unhandled promise rejection"));
   }
 }).on("uncaughtException", (error) => {
-  console.error(colors11.red(error.message));
+  console.error(chalk10.red(error.message));
   process.exit(1);
 });
 
 // src/version.ts
-var version_default = `3.0`;
+var version_default = "3.0";
 
 // src/index.ts
 import "dotenv/config";
 var program = new Command();
-var run = function(action) {
-  return async function(...args) {
-    try {
-      await action(...args);
-    } catch (e) {
-      console.error(colors12.red("Error: " + e.message));
-    }
-  };
+var run = (action) => async (...args) => {
+  try {
+    await action(...args);
+  } catch (e) {
+    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));