zylaris 1.0.2

package/packages/cli/src/commands/create.ts

@@ -0,0 +1,222 @@
+import { resolve, join } from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+
+const TEMPLATES = ['default', 'api', 'docs', 'blog', 'ecommerce'];
+
+interface CreateOptions {
+  template?: string;
+  skipInstall?: boolean;
+}
+
+export async function createProject(name: string, options: CreateOptions): Promise<void> {
+  const targetDir = resolve(process.cwd(), name);
+
+  // Check if directory exists
+  if (await fs.pathExists(targetDir)) {
+    const { overwrite } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'overwrite',
+      message: `Directory ${name} already exists. Overwrite?`,
+      default: false,
+    }]);
+
+    if (!overwrite) {
+      console.log(chalk.yellow('Cancelled.'));
+      return;
+    }
+
+    await fs.remove(targetDir);
+  }
+
+  // Validate template
+  let template = options.template || 'default';
+  if (!TEMPLATES.includes(template)) {
+    const { selectedTemplate } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selectedTemplate',
+      message: 'Select a template:',
+      choices: TEMPLATES,
+    }]);
+    template = selectedTemplate;
+  }
+
+  const spinner = ora('Creating project...').start();
+
+  try {
+    // Create directory structure
+    await fs.ensureDir(targetDir);
+
+    // Create package.json
+    await createPackageJson(targetDir, name, template);
+
+    // Create tsconfig.json
+    await createTsConfig(targetDir);
+
+    // Create zylaris.config.ts
+    await createConfig(targetDir, template);
+
+    // Create source files
+    await createSourceFiles(targetDir, template);
+
+    // Create public folder
+    await fs.ensureDir(join(targetDir, 'public'));
+
+    // Install dependencies
+    if (!options.skipInstall) {
+      spinner.text = 'Installing dependencies...';
+      // In real implementation, run npm/pnpm install
+    }
+
+    spinner.succeed(chalk.green(`Project ${name} created successfully!`));
+
+    console.log('\nNext steps:');
+    console.log(chalk.cyan(`  cd ${name}`));
+    console.log(chalk.cyan('  npm run dev'));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to create project'));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+async function createPackageJson(targetDir: string, name: string, _template: string): Promise<void> {
+  const packageJson = {
+    name,
+    version: '0.1.0',
+    private: true,
+    type: 'module',
+    scripts: {
+      dev: 'zylaris dev',
+      build: 'zylaris build',
+      start: 'node .zylaris/server.js',
+      test: 'zylaris test',
+      lint: 'zylaris lint',
+      typecheck: 'zylaris typecheck',
+    },
+    dependencies: {
+      zylaris: '^1.0.0',
+      react: '^18.2.0',
+      'react-dom': '^18.2.0',
+    },
+    devDependencies: {
+      '@types/react': '^18.2.0',
+      '@types/react-dom': '^18.2.0',
+      typescript: '^5.3.3',
+    },
+  };
+
+  await fs.writeJson(join(targetDir, 'package.json'), packageJson, { spaces: 2 });
+}
+
+async function createTsConfig(targetDir: string): Promise<void> {
+  const tsConfig = {
+    compilerOptions: {
+      target: 'ES2022',
+      lib: ['ES2022', 'DOM', 'DOM.Iterable'],
+      module: 'ESNext',
+      moduleResolution: 'bundler',
+      resolveJsonModule: true,
+      allowJs: true,
+      checkJs: false,
+      declaration: true,
+      sourceMap: true,
+      strict: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      noFallthroughCasesInSwitch: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      jsx: 'react-jsx',
+      jsxImportSource: 'zylaris',
+      baseUrl: '.',
+      paths: {
+        '@/*': ['./src/*'],
+      },
+    },
+    include: ['src/**/*'],
+    exclude: ['node_modules', 'dist', '.zylaris'],
+  };
+
+  await fs.writeJson(join(targetDir, 'tsconfig.json'), tsConfig, { spaces: 2 });
+}
+
+async function createConfig(targetDir: string, _template: string): Promise<void> {
+  const config = `import { defineConfig } from 'zylaris';
+
+export default defineConfig({
+  runtime: 'node',
+  rendering: {
+    default: 'ssr',
+  },
+  islands: {
+    mode: 'auto',
+  },
+  compiler: {
+    target: 'es2022',
+    minify: true,
+  },
+  server: {
+    port: 3000,
+  },
+  styling: {
+    tailwind: true,
+  },
+  typescript: {
+    strict: true,
+  },
+});
+`;
+
+  await fs.writeFile(join(targetDir, 'zylaris.config.ts'), config);
+}
+
+async function createSourceFiles(targetDir: string, _template: string): Promise<void> {
+  const srcDir = join(targetDir, 'src');
+  const appDir = join(srcDir, 'app');
+
+  await fs.ensureDir(appDir);
+
+  // Create layout.tsx
+  const layout = `export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en">
+      <body>
+        {children}
+      </body>
+    </html>
+  );
+}
+`;
+  await fs.writeFile(join(appDir, 'layout.tsx'), layout);
+
+  // Create page.tsx
+  const page = `export default function HomePage() {
+  return (
+    <main>
+      <h1>Welcome to Zylaris!</h1>
+      <p>Get started by editing src/app/page.tsx</p>
+    </main>
+  );
+}
+`;
+  await fs.writeFile(join(appDir, 'page.tsx'), page);
+
+  // Create global.css
+  const globalCss = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+body {
+  font-family: system-ui, -apple-system, sans-serif;
+}
+`;
+  await fs.writeFile(join(appDir, 'global.css'), globalCss);
+}

package/packages/cli/src/commands/deploy.ts

@@ -0,0 +1,90 @@
+import { resolve } from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import ora from 'ora';
+// import { execa } from 'execa';
+async function execa(_cmd: string, _args: string[], _options: { cwd?: string; stdio?: string }): Promise<unknown> {
+  throw new Error('execa not implemented');
+}
+
+interface DeployOptions {
+  vercel?: boolean;
+  netlify?: boolean;
+  cloudflare?: boolean;
+}
+
+export async function deployProject(options: DeployOptions): Promise<void> {
+  const spinner = ora('Deploying...').start();
+
+  try {
+    const cwd = process.cwd();
+
+    // Check if build exists
+    const distPath = resolve(cwd, 'dist');
+    if (!(await fs.pathExists(distPath))) {
+      spinner.text = 'Building first...';
+      // await buildProject({});
+    }
+
+    if (options.vercel) {
+      spinner.text = 'Deploying to Vercel...';
+      await deployToVercel(cwd);
+    } else if (options.netlify) {
+      spinner.text = 'Deploying to Netlify...';
+      await deployToNetlify(cwd);
+    } else if (options.cloudflare) {
+      spinner.text = 'Deploying to Cloudflare Pages...';
+      await deployToCloudflare(cwd);
+    } else {
+      // Default: Zylaris Cloud
+      spinner.text = 'Deploying to Zylaris Cloud...';
+      await deployToZylarisCloud(cwd);
+    }
+
+    spinner.succeed(chalk.green('Deployment complete!'));
+  } catch (error) {
+    spinner.fail(chalk.red('Deployment failed'));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+async function deployToVercel(cwd: string): Promise<void> {
+  // Check if vercel CLI is installed
+  try {
+    await execa('vercel', ['--version'], { cwd });
+  } catch {
+    console.log(chalk.yellow('Vercel CLI not found. Installing...'));
+    await execa('npm', ['install', '-g', 'vercel'], { cwd });
+  }
+
+  await execa('vercel', ['--prod'], { cwd, stdio: 'inherit' });
+}
+
+async function deployToNetlify(cwd: string): Promise<void> {
+  try {
+    await execa('netlify', ['--version'], { cwd });
+  } catch {
+    console.log(chalk.yellow('Netlify CLI not found. Installing...'));
+    await execa('npm', ['install', '-g', 'netlify-cli'], { cwd });
+  }
+
+  await execa('netlify', ['deploy', '--prod', '--dir=dist'], { cwd, stdio: 'inherit' });
+}
+
+async function deployToCloudflare(cwd: string): Promise<void> {
+  try {
+    await execa('wrangler', ['--version'], { cwd });
+  } catch {
+    console.log(chalk.yellow('Wrangler not found. Installing...'));
+    await execa('npm', ['install', '-g', 'wrangler'], { cwd });
+  }
+
+  await execa('wrangler', ['pages', 'deploy', 'dist'], { cwd, stdio: 'inherit' });
+}
+
+async function deployToZylarisCloud(_cwd: string): Promise<void> {
+  // In real implementation, deploy to Zylaris Cloud
+  console.log(chalk.blue('Deploying to Zylaris Cloud...'));
+  console.log(chalk.yellow('Coming soon!'));
+}

package/packages/cli/src/commands/dev.ts

@@ -0,0 +1,108 @@
+import { createServer } from '@zylaris/dev-server';
+import chalk from 'chalk';
+import net from 'net';
+
+interface DevOptions {
+  port?: string;
+  host?: string;
+  turbo?: boolean;
+}
+
+// Check if port is available
+function isPortAvailable(port: number, host: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => {
+      resolve(false);
+    });
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port, host);
+  });
+}
+
+// Find available port starting from preferred port
+async function findAvailablePort(preferredPort: number, host: string): Promise<number> {
+  let port = preferredPort;
+  while (port < preferredPort + 10) {
+    if (await isPortAvailable(port, host)) {
+      return port;
+    }
+    port++;
+  }
+  throw new Error(`No available port found between ${preferredPort} and ${preferredPort + 10}`);
+}
+
+// Print banner
+function printBanner(port: number, host: string, wsPort: number) {
+  const box = `
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃                                                    ┃
+┃   🚀 ${chalk.bold('Zylaris Dev Server')}                            ┃
+┃                                                    ┃
+┃   ${chalk.cyan('➜')}  Local:   ${chalk.cyan(`http://${host}:${port}`)}                ┃
+┃   ${chalk.magenta('➜')}  WebSocket: ${chalk.magenta(`ws://${host}:${wsPort}`)}               ┃
+┃                                                    ┃
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+`;
+  console.log(box);
+}
+
+export async function devServer(options: DevOptions): Promise<void> {
+  const preferredPort = parseInt(options.port || '2727');
+  const host = options.host || 'localhost';
+
+  // Clear console for clean output
+  console.clear();
+  
+  console.log(chalk.gray('Starting development server...\n'));
+
+  try {
+    // Find available port
+    const port = await findAvailablePort(preferredPort, host);
+    
+    if (port !== preferredPort) {
+      console.log(chalk.yellow(`⚠ Port ${preferredPort} is in use, using port ${port} instead\n`));
+    }
+
+    const server = await createServer({
+      port,
+      host,
+      turbo: options.turbo,
+    });
+
+    // Print prominent banner
+    const wsPort = port + 1;
+    printBanner(port, host, wsPort);
+
+    // Handle graceful shutdown
+    const shutdown = () => {
+      console.log(chalk.yellow('\n🛑 Shutting down server...'));
+      server.close(() => {
+        console.log(chalk.green('✓ Server closed'));
+        process.exit(0);
+      });
+      
+      // Force exit after 3 seconds
+      setTimeout(() => {
+        console.log(chalk.red('Force exit after timeout'));
+        process.exit(1);
+      }, 3000);
+    };
+    
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    
+    // Handle uncaught errors
+    process.on('uncaughtException', (err) => {
+      console.error(chalk.red('\n✗ Uncaught exception:'), err);
+      shutdown();
+    });
+    
+  } catch (error) {
+    console.error(chalk.red('\n✗ Failed to start dev server:'), error);
+    process.exit(1);
+  }
+}

package/packages/cli/src/index.ts

@@ -0,0 +1,6 @@
+// Zylaris CLI
+
+export { createProject } from './commands/create.js';
+export { devServer } from './commands/dev.js';
+export { buildProject } from './commands/build.js';
+export { deployProject } from './commands/deploy.js';

package/packages/cli/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules"]
+}

package/packages/compiler/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@zylaris/compiler",
+  "version": "1.0.0",
+  "description": "Compiler for Zylaris Framework",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@swc/core": "^1.3.100",
+    "@swc/helpers": "^0.5.3",
+    "esbuild": "^0.19.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "compiler",
+    "transform",
+    "zylaris"
+  ],
+  "license": "MIT"
+}

package/packages/compiler/src/index.ts

@@ -0,0 +1,210 @@
+// Zylaris Compiler
+// Transforms JSX and TypeScript for production
+
+import { transform as swcTransform } from '@swc/core';
+import * as esbuild from 'esbuild';
+import path from 'path';
+
+export interface CompileOptions {
+  target?: 'es2020' | 'es2022' | 'esnext';
+  minify?: boolean;
+  sourceMap?: boolean;
+  jsx?: {
+    runtime?: 'automatic' | 'classic';
+    importSource?: string;
+  };
+}
+
+export interface CompileResult {
+  code: string;
+  map?: string;
+  errors: CompileError[];
+}
+
+export interface CompileError {
+  message: string;
+  location?: {
+    line: number;
+    column: number;
+  };
+}
+
+export async function compile(
+  source: string,
+  filename: string,
+  options: CompileOptions = {}
+): Promise<CompileResult> {
+  const ext = path.extname(filename);
+
+  if (ext === '.tsx' || ext === '.jsx') {
+    return compileJSX(source, filename, options);
+  }
+
+  if (ext === '.ts') {
+    return compileTypeScript(source, filename, options);
+  }
+
+  return {
+    code: source,
+    errors: [],
+  };
+}
+
+async function compileJSX(
+  source: string,
+  filename: string,
+  options: CompileOptions
+): Promise<CompileResult> {
+  try {
+    const result = await swcTransform(source, {
+      filename,
+      jsc: {
+        parser: {
+          syntax: 'typescript',
+          tsx: true,
+        },
+        transform: {
+          react: {
+            runtime: options.jsx?.runtime || 'automatic',
+            importSource: options.jsx?.importSource || 'zylaris',
+          },
+        },
+        target: options.target || 'es2022',
+        minify: {
+          compress: options.minify,
+          mangle: options.minify,
+        },
+      },
+      sourceMaps: options.sourceMap,
+      minify: options.minify,
+    });
+
+    return {
+      code: result.code,
+      map: result.map,
+      errors: [],
+    };
+  } catch (error) {
+    return {
+      code: '',
+      errors: [
+        {
+          message: error instanceof Error ? error.message : 'Unknown error',
+        },
+      ],
+    };
+  }
+}
+
+async function compileTypeScript(
+  source: string,
+  filename: string,
+  options: CompileOptions
+): Promise<CompileResult> {
+  try {
+    const result = await swcTransform(source, {
+      filename,
+      jsc: {
+        parser: {
+          syntax: 'typescript',
+        },
+        target: options.target || 'es2022',
+        minify: {
+          compress: options.minify,
+          mangle: options.minify,
+        },
+      },
+      sourceMaps: options.sourceMap,
+      minify: options.minify,
+    });
+
+    return {
+      code: result.code,
+      map: result.map,
+      errors: [],
+    };
+  } catch (error) {
+    return {
+      code: '',
+      errors: [
+        {
+          message: error instanceof Error ? error.message : 'Unknown error',
+        },
+      ],
+    };
+  }
+}
+
+// Bundle with esbuild
+export async function bundle(
+  entryPoints: string[],
+  outdir: string,
+  options: CompileOptions = {}
+): Promise<void> {
+  await esbuild.build({
+    entryPoints,
+    outdir,
+    bundle: true,
+    splitting: true,
+    format: 'esm',
+    target: options.target || 'es2022',
+    minify: options.minify,
+    sourcemap: options.sourceMap,
+    jsx: 'automatic',
+    jsxImportSource: options.jsx?.importSource || 'zylaris',
+    metafile: true,
+  });
+}
+
+// Transform JSX for client-side hydration
+export async function transformJSXForClient(
+  source: string,
+  filename: string
+): Promise<string> {
+  const result = await swcTransform(source, {
+    filename,
+    jsc: {
+      parser: {
+        syntax: 'typescript',
+        tsx: true,
+      },
+      transform: {
+        react: {
+          runtime: 'automatic',
+          importSource: 'zylaris',
+        },
+      },
+      target: 'es2022',
+    },
+  });
+
+  return result.code;
+}
+
+// Export JIT compiler for development
+export * from './jit.js';
+
+// Transform JSX for server-side rendering
+export async function transformJSXForServer(
+  source: string,
+  filename: string
+): Promise<string> {
+  const result = await swcTransform(source, {
+    filename,
+    jsc: {
+      parser: {
+        syntax: 'typescript',
+        tsx: true,
+      },
+      transform: {
+        react: {
+          runtime: 'automatic',
+          importSource: 'zylaris',
+        },
+      },
+      target: 'es2022',
+    },
+  });
+
+  return result.code;
+}