zylaris 1.0.2

package/packages/adapter/src/types.ts

@@ -0,0 +1,191 @@
+/**
+ * Adapter Types - Universal deployment interface
+ * Supports: Static, Node.js, Vercel, Netlify, Cloudflare, Deno, Bun
+ */
+
+import type { BuildOptions } from 'esbuild';
+
+/** Deployment target platforms */
+export type DeploymentTarget = 
+  | 'static'      // GitHub Pages, Surge.sh, etc.
+  | 'node'        // Node.js server
+  | 'vercel'      // Vercel (Serverless + Edge)
+  | 'netlify'     // Netlify (Functions + Edge)
+  | 'cloudflare'  // Cloudflare Pages/Workers
+  | 'deno'        // Deno Deploy
+  | 'bun';        // Bun runtime
+
+/** Output format for generated files */
+export type OutputFormat = 'esm' | 'cjs' | 'iife';
+
+/** Serverless/Edge function config */
+export interface FunctionConfig {
+  /** Function name */
+  name?: string;
+  /** Route pattern */
+  route?: string;
+  /** Memory allocation (MB) */
+  memory?: number;
+  /** Timeout (seconds) */
+  timeout?: number;
+  /** Regions to deploy */
+  regions?: string[];
+  /** Edge function flag */
+  edge?: boolean;
+}
+
+/** Static generation options */
+export interface StaticOptions {
+  /** Routes to pre-render */
+  routes?: string[];
+  /** 404 page path */
+  fallback?: string;
+  /** Crawl dynamic routes */
+  crawl?: boolean;
+  /** Base path for assets */
+  base?: string;
+}
+
+/** Adapter build configuration */
+export interface AdapterConfig {
+  /** Target platform */
+  target: DeploymentTarget;
+  /** Entry point */
+  entry?: string;
+  /** Output directory */
+  outDir?: string;
+  /** Static generation options */
+  static?: StaticOptions;
+  /** Serverless function config */
+  function?: FunctionConfig;
+  /** esbuild options */
+  esbuild?: BuildOptions;
+  /** Environment variables to include */
+  env?: Record<string, string>;
+  /** Headers for HTTP responses */
+  headers?: Record<string, string>;
+  /** Redirects configuration */
+  redirects?: Array<{ from: string; to: string; status?: number }>;
+  /** Rewrites configuration */
+  rewrites?: Array<{ from: string; to: string }>;
+  /** Trailing slash handling */
+  trailingSlash?: 'always' | 'never' | 'ignore';
+  /** Clean URLs (no .html extension) */
+  cleanUrls?: boolean;
+}
+
+/** Build result for any adapter */
+export interface BuildResult {
+  /** Success flag */
+  success: boolean;
+  /** Output directory */
+  outDir: string;
+  /** Generated files */
+  files: string[];
+  /** Warnings */
+  warnings: string[];
+  /** Errors */
+  errors: string[];
+  /** Bundle analysis */
+  analysis?: {
+    /** Total bundle size */
+    totalSize: number;
+    /** Client bundle size */
+    clientSize: number;
+    /** Server bundle size */
+    serverSize?: number;
+    /** Asset sizes */
+    assets: Array<{ file: string; size: number; gzip: number }>;
+  };
+}
+
+/** Server entry point handler */
+export type RequestHandler = (
+  request: Request,
+  context: {
+    params: Record<string, string>;
+    url: URL;
+    headers: Headers;
+    cookies: Map<string, string>;
+  }
+) => Response | Promise<Response>;
+
+/** Adapter interface */
+export interface Adapter {
+  /** Adapter name */
+  readonly name: string;
+  /** Target platform */
+  readonly target: DeploymentTarget;
+  /** Build for target platform */
+  build(config: AdapterConfig): Promise<BuildResult>;
+  /** Preview locally */
+  preview?(config: AdapterConfig, port?: number): Promise<void>;
+  /** Deploy to platform */
+  deploy?(config: AdapterConfig): Promise<void>;
+}
+
+/** Route manifest for static generation */
+export interface RouteManifest {
+  /** Route path */
+  path: string;
+  /** File pattern */
+  file: string;
+  /** Is dynamic route */
+  dynamic?: boolean;
+  /** Required params */
+  params?: string[];
+  /** Preload data */
+  data?: unknown;
+}
+
+/** Manifest for deployment */
+export interface DeploymentManifest {
+  /** Framework version */
+  version: string;
+  /** Build timestamp */
+  timestamp: string;
+  /** Routes */
+  routes: RouteManifest[];
+  /** Assets with hashes */
+  assets: Record<string, string>;
+  /** Entry points */
+  entry: {
+    client: string;
+    server?: string;
+  };
+}
+
+/** Edge runtime context */
+export interface EdgeContext {
+  /** Wait until promise resolves */
+  waitUntil(promise: Promise<unknown>): void;
+  /** Pass-through cache */
+  passThroughOnException(): void;
+  /** Environment bindings */
+  env: Record<string, unknown>;
+  /** Execution context */
+  executionCtx?: {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+  };
+}
+
+/** Platform-specific config files */
+export interface PlatformConfig {
+  vercel?: {
+    buildCommand?: string;
+    outputDirectory?: string;
+    framework?: string | null;
+    installCommand?: string;
+  };
+  netlify?: {
+    buildCommand?: string;
+    publishDirectory?: string;
+    functionsDirectory?: string;
+  };
+  cloudflare?: {
+    buildCommand?: string;
+    destinationDirectory?: string;
+    rootDirectory?: string;
+  };
+}

package/packages/adapter/tsconfig.json

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

package/packages/cli/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@zylaris/cli",
+  "version": "1.0.0",
+  "description": "CLI for Zylaris Framework",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "zylaris": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@zylaris/adapter": "workspace:*",
+    "@zylaris/compiler": "workspace:*",
+    "@zylaris/dev-server": "workspace:*",
+    "commander": "^11.1.0",
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.12",
+    "ora": "^8.0.1",
+    "fs-extra": "^11.2.0",
+    "glob": "^10.3.10",
+    "chokidar": "^3.5.3"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "cli",
+    "zylaris"
+  ],
+  "license": "MIT"
+}

package/packages/cli/src/bin.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import { createProject } from './commands/create.js';
+import { devServer } from './commands/dev.js';
+import { buildProject } from './commands/build.js';
+import { deployProject } from './commands/deploy.js';
+
+const version = '1.0.0';
+
+program
+  .name('zylaris')
+  .description('Zylaris Framework CLI')
+  .version(version);
+
+// Create command
+program
+  .command('create <name>')
+  .description('Create a new Zylaris project')
+  .option('-t, --template <template>', 'Project template', 'default')
+  .option('--skip-install', 'Skip package installation')
+  .action(async (name, options) => {
+    console.log(chalk.blue(`Creating Zylaris project: ${name}`));
+    await createProject(name, options);
+  });
+
+// Dev command
+program
+  .command('dev')
+  .description('Start development server')
+  .option('-p, --port <port>', 'Port number', '2727')
+  .option('-h, --host <host>', 'Host address', 'localhost')
+  .option('--turbo', 'Enable turbo mode')
+  .action(async (options) => {
+    console.log(chalk.blue('Starting development server...'));
+    await devServer(options);
+  });
+
+// Build command
+program
+  .command('build')
+  .description('Build for production')
+  .option('-a, --adapter <adapter>', 'Deployment adapter (static, node, vercel, netlify, cloudflare, deno, bun)', 'static')
+  .option('--analyze', 'Analyze bundle size')
+  .option('--static', 'Static export (pre-render pages)')
+  .option('--edge', 'Use Edge runtime (for vercel, netlify, cloudflare)')
+  .option('--outDir <dir>', 'Output directory', 'dist')
+  .option('--memory <mb>', 'Serverless memory (MB)', '1024')
+  .option('--timeout <seconds>', 'Function timeout (seconds)', '10')
+  .option('--regions <regions>', 'Deployment regions (comma-separated)')
+  .action(async (options) => {
+    console.log(chalk.blue(`Building for production with ${options.adapter} adapter...`));
+    await buildProject(options);
+  });
+
+// Adapters command
+program
+  .command('adapters')
+  .description('List available deployment adapters')
+  .action(async () => {
+    const { printAdapters } = await import('./commands/build.js');
+    printAdapters();
+  });
+
+// Deploy command
+program
+  .command('deploy')
+  .description('Deploy project')
+  .option('--vercel', 'Deploy to Vercel')
+  .option('--netlify', 'Deploy to Netlify')
+  .option('--cloudflare', 'Deploy to Cloudflare Pages')
+  .action(async (options) => {
+    console.log(chalk.blue('Deploying...'));
+    await deployProject(options);
+  });
+
+// Test command
+program
+  .command('test')
+  .description('Run tests')
+  .option('--watch', 'Watch mode')
+  .option('--coverage', 'Generate coverage report')
+  .action(async () => {
+    console.log(chalk.blue('Running tests...'));
+    // Delegate to test runner
+  });
+
+// Lint command
+program
+  .command('lint')
+  .description('Run ESLint')
+  .action(async () => {
+    console.log(chalk.blue('Linting...'));
+    // Delegate to ESLint
+  });
+
+// Type check command
+program
+  .command('typecheck')
+  .description('Run TypeScript type checking')
+  .action(async () => {
+    console.log(chalk.blue('Type checking...'));
+    // Delegate to TypeScript
+  });
+
+program.parse();

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

@@ -0,0 +1,197 @@
+import { resolve } from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import ora from 'ora';
+import type { AdapterConfig, DeploymentTarget } from '@zylaris/adapter';
+import { getAdapter, listAdapters } from '@zylaris/adapter';
+
+interface BuildOptions {
+  analyze?: boolean;
+  static?: boolean;
+  adapter?: DeploymentTarget;
+  outDir?: string;
+  edge?: boolean;
+  memory?: number;
+  timeout?: number;
+  regions?: string;
+}
+
+export async function buildProject(options: BuildOptions): Promise<void> {
+  const spinner = ora('Building for production...').start();
+  const startTime = Date.now();
+
+  try {
+    const cwd = process.cwd();
+
+    // Determine adapter/target
+    const target = options.adapter || 'static';
+    const adapter = getAdapter(target);
+
+    spinner.text = `Building with ${adapter.name} adapter...`;
+
+    // Load config if exists
+    const configPath = resolve(cwd, 'zylaris.config.ts');
+    let userConfig: Partial<AdapterConfig> = {};
+
+    if (await fs.pathExists(configPath)) {
+      try {
+        const configModule = await import(configPath);
+        userConfig = configModule.default || configModule;
+      } catch {
+        // Config is optional
+      }
+    }
+
+    // Build adapter config
+    const config: AdapterConfig = {
+      target,
+      outDir: options.outDir || userConfig.outDir || 'dist',
+      static: options.static || userConfig.static ? {
+        routes: ['/', '/about', '/contact'], // Auto-detect in real implementation
+        ...userConfig.static,
+      } : undefined,
+      function: {
+        edge: options.edge ?? userConfig.function?.edge ?? false,
+        memory: options.memory ?? userConfig.function?.memory ?? 1024,
+        timeout: options.timeout ?? userConfig.function?.timeout ?? 10,
+        regions: options.regions?.split(',') ?? userConfig.function?.regions ?? ['iad1'],
+        ...userConfig.function,
+      },
+      esbuild: userConfig.esbuild,
+      env: userConfig.env,
+      headers: {
+        '/*': 'X-Frame-Options: DENY\n  X-Content-Type-Options: nosniff',
+        ...userConfig.headers,
+      },
+      redirects: userConfig.redirects,
+      rewrites: userConfig.rewrites,
+      trailingSlash: userConfig.trailingSlash ?? 'ignore',
+      cleanUrls: userConfig.cleanUrls ?? true,
+    };
+
+    // Run build
+    const result = await adapter.build(config);
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+
+    if (!result.success) {
+      spinner.fail(chalk.red('Build failed'));
+      for (const error of result.errors) {
+        console.error(chalk.red(`  ✗ ${error}`));
+      }
+      process.exit(1);
+    }
+
+    spinner.succeed(chalk.green(`Build completed in ${duration}s`));
+
+    // Print summary
+    console.log('\n' + chalk.bold('Output:'));
+    console.log(chalk.cyan(`  ${result.outDir}/`));
+    
+    if (result.files.length > 0) {
+      console.log(chalk.gray(`  (${result.files.length} files generated)`));
+    }
+
+    // Print bundle analysis
+    if (result.analysis && options.analyze) {
+      console.log('\n' + chalk.bold('Bundle Analysis:'));
+      console.log(`  Total: ${formatSize(result.analysis.totalSize)}`);
+      console.log(`  Client: ${formatSize(result.analysis.clientSize)}`);
+      if (result.analysis.serverSize) {
+        console.log(`  Server: ${formatSize(result.analysis.serverSize)}`);
+      }
+      
+      console.log('\n  Top Assets:');
+      for (const asset of result.analysis.assets.slice(0, 5)) {
+        console.log(`    ${asset.file}`);
+        console.log(`      Size: ${formatSize(asset.size)} | Gzipped: ${formatSize(asset.gzip)}`);
+      }
+    }
+
+    // Print deployment info
+    console.log('\n' + chalk.bold('Deploy:'));
+    printDeployInstructions(target, result.outDir);
+
+    if (result.warnings.length > 0) {
+      console.log('\n' + chalk.yellow('Warnings:'));
+      for (const warning of result.warnings) {
+        console.log(chalk.yellow(`  ⚠ ${warning}`));
+      }
+    }
+
+  } catch (error) {
+    spinner.fail(chalk.red('Build failed'));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+/** Print deployment instructions */
+function printDeployInstructions(target: DeploymentTarget, outDir: string): void {
+  const instructions: Record<DeploymentTarget, string[]> = {
+    static: [
+      '  Upload to any static hosting:',
+      chalk.gray(`    - GitHub Pages: push to gh-pages branch`),
+      chalk.gray(`    - Netlify: npx netlify deploy --prod --dir=${outDir}`),
+      chalk.gray(`    - Vercel: npx vercel --prod`),
+      chalk.gray(`    - Cloudflare Pages: npx wrangler pages deploy ${outDir}`),
+    ],
+    node: [
+      '  Run the server:',
+      chalk.gray(`    cd ${outDir}`),
+      chalk.gray(`    npm install`),
+      chalk.gray(`    npm start`),
+      '',
+      '  Or with Docker:',
+      chalk.gray(`    docker build -t zylaris-app .`),
+      chalk.gray(`    docker run -p 3000:3000 zylaris-app`),
+    ],
+    vercel: [
+      '  Deploy to Vercel:',
+      chalk.gray(`    npx vercel --prod`),
+    ],
+    netlify: [
+      '  Deploy to Netlify:',
+      chalk.gray(`    npx netlify deploy --prod`),
+    ],
+    cloudflare: [
+      '  Deploy to Cloudflare:',
+      chalk.gray(`    npx wrangler pages deploy ${outDir}`),
+      chalk.gray(`    # or for Workers:`),
+      chalk.gray(`    npx wrangler deploy`),
+    ],
+    deno: [
+      '  Deploy to Deno Deploy:',
+      chalk.gray(`    npx deployctl deploy --project=zylaris-app ${outDir}/server.ts`),
+    ],
+    bun: [
+      '  Run with Bun:',
+      chalk.gray(`    bun ${outDir}/server.js`),
+      '',
+      '  Or use Docker for deployment',
+    ],
+  };
+
+  console.log(instructions[target].join('\n'));
+}
+
+/** Format bytes to human readable */
+function formatSize(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/** List available adapters */
+export function printAdapters(): void {
+  console.log(chalk.bold('\nAvailable Adapters:\n'));
+  
+  for (const { target, name, description } of listAdapters()) {
+    console.log(`  ${chalk.cyan(target.padEnd(12))} ${chalk.bold(name)}`);
+    console.log(`  ${''.padEnd(12)} ${chalk.gray(description)}\n`);
+  }
+  
+  console.log(`Usage: ${chalk.yellow('zylaris build --adapter <target>')}\n`);
+}