@richapps/ong 0.1.0

package/README.md

@@ -0,0 +1,166 @@
+<p align="center">
+  <img src="ong-logo.png" alt="ong" width="200">
+</p>
+
+<h1 align="center">@richapps/ong</h1>
+
+<p align="center">
+  Angular CLI powered by <a href="https://vite.dev">Vite</a> + <a href="https://github.com/nicoss/oxc-angular-compiler">OXC</a><br>
+  <em>Blazing fast drop-in replacement for <code>ng serve</code> and <code>ng build</code></em>
+</p>
+
+---
+
+## What is ong?
+
+**ong** uses the Rust-based [OXC Angular compiler](https://github.com/nicoss/oxc-angular-compiler) and [Vite](https://vite.dev) to compile and serve Angular applications — no Webpack, no esbuild, just raw speed.
+
+It reads your existing `angular.json` (or Nx `project.json`) and works with a standard Angular project out of the box. No config files to write, no migration steps.
+
+## Install
+
+```bash
+npm install -D @richapps/ong
+```
+
+If you already have `vite` installed, ong will use your version. Otherwise it will be auto-installed as a peer dependency.
+
+For global usage:
+
+```bash
+npm install -g @richapps/ong
+```
+
+## Usage
+
+```bash
+# Start dev server
+ong serve
+
+# Production build
+ong build
+
+# With options
+ong serve --port 3000 --open
+ong build -c production
+ong serve -p my-app              # specific project
+ong build -p apps/my-app         # nx project path
+```
+
+Or via npm scripts in `package.json`:
+
+```json
+{
+  "scripts": {
+    "start": "ong serve",
+    "build": "ong build"
+  }
+}
+```
+
+## CLI Options
+
+| Option | Alias | Description |
+|---|---|---|
+| `--configuration <name>` | `-c` | Build configuration (default: per-target default) |
+| `--project <name\|path>` | `-p` | Project name (angular.json) or path (nx project.json) |
+| `--port <number>` | | Dev server port (default: 4200) |
+| `--open` | `-o` | Open browser on start |
+| `--host <host>` | | Dev server host |
+| `--watch` | `-w` | Rebuild on file changes (build mode) |
+| `--help` | `-h` | Show help |
+
+## Workspace Support
+
+ong auto-detects your workspace type:
+
+- **angular.json** — Standard Angular CLI workspace
+- **workspace.json** — Older Nx workspace format
+- **project.json** — Per-project Nx monorepo setup
+
+Configurations, file replacements, global styles/scripts, and assets are all read from your existing workspace config.
+
+## Supported angular.json / project.json Properties
+
+### Build target options
+
+| Property | Status | Notes |
+|---|---|---|
+| `browser` / `main` | Supported | Entry point |
+| `tsConfig` | Supported | |
+| `outputPath` | Supported | |
+| `assets` | Supported | String and object (`glob`/`input`/`output`) forms |
+| `styles` | Supported | Global stylesheets, string and `{ input }` forms |
+| `scripts` | Supported | Global scripts |
+| `fileReplacements` | Supported | `replace`/`with` pairs |
+| `sourceMap` | Supported | |
+| `optimization` | Supported | Uses OXC minifier |
+| `outputHashing` | Supported | `none`, `all`, `media`, `bundles` |
+| `configurations` | Supported | Merges base + per-config overrides |
+| `defaultConfiguration` | Supported | |
+| `baseHref` | Supported | Injected into `<base href="...">` and used as Vite `base` |
+| `deployUrl` | Supported | Maps to Vite `base` (takes precedence over `baseHref`) |
+| `polyfills` | Supported | Injected as `<script>` tags (string or array) |
+| `define` | Supported | Maps to Vite `define` for global constant replacements |
+| `externalDependencies` | Supported | Maps to Rollup `external` |
+| `preserveSymlinks` | Supported | Maps to Vite `resolve.preserveSymlinks` |
+| `namedChunks` | Supported | Disables hash-based chunk naming |
+| `crossOrigin` | Supported | Sets attribute on injected `<script>`/`<link>` tags |
+| `stylePreprocessorOptions` | Supported | `includePaths` mapped to Vite `css.preprocessorOptions` |
+| `watch` | Supported | Maps to Vite `build.watch` (also via `--watch` CLI flag) |
+| `poll` | Supported | Maps to Vite `server.watch.usePolling` with interval |
+
+### Serve target options
+
+| Property | Status | Notes |
+|---|---|---|
+| `port` | Supported | |
+| `open` | Supported | |
+| `host` | Supported | |
+| `poll` | Supported | File-watching poll interval |
+| `buildTarget` | Ignored | Configuration is resolved from the build target directly |
+
+### Not yet supported
+
+These `@angular/build:application` properties are **not currently handled** — they are silently ignored:
+
+| Property | Description |
+|---|---|
+| `budgets` | Bundle size budgets and warnings |
+| `extractLicenses` | Extract third-party licenses to a separate file |
+| `subresourceIntegrity` | SRI hashes on `<script>`/`<link>` tags |
+| `allowedCommonJsDependencies` | Suppress CommonJS import warnings |
+| `serviceWorker` / `ngswConfigPath` | PWA service worker generation |
+| `webWorkerTsConfig` | Separate tsconfig for web workers |
+| `i18nMissingTranslation` | i18n missing translation handling |
+| `localize` | i18n locale builds |
+| `inlineStyleLanguage` | Default preprocessor for inline component styles |
+| `loader` | Custom file extension loaders |
+| `progress` | Show build progress indicator |
+| `ssr` / `server` / `prerender` | Server-side rendering / prerendering |
+| `security` | Content Security Policy settings |
+
+> SSR support is not planned — ong focuses on client-side Angular applications.
+
+## Programmatic API
+
+```typescript
+import { resolveWorkspace, createViteConfig } from '@richapps/ong'
+
+const opts = resolveWorkspace(process.cwd(), {
+  command: 'build',
+  configuration: 'production',
+})
+
+const viteConfig = createViteConfig(opts)
+```
+
+## Requirements
+
+- Node.js 18+
+- Angular 17+ (standalone components recommended)
+- Vite 6+
+
+## License
+
+MIT

package/bin/ong.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import('../dist/cli.js').catch(err => {
+  console.error(err.message)
+  process.exit(1)
+})

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,83 @@
+import { createServer, build } from 'vite';
+import { resolveWorkspace } from './workspace.js';
+import { createViteConfig } from './config.js';
+import { banner, printBuildStats, printHelp, error } from './log.js';
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    const command = args[0];
+    if (!command || !['serve', 'build'].includes(command)) {
+        return { command: 'help' };
+    }
+    const result = { command };
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        const next = args[i + 1];
+        if (arg === '--project' || arg === '-p') {
+            result.project = next;
+            i++;
+        }
+        else if (arg === '--configuration' || arg === '-c') {
+            result.configuration = next;
+            i++;
+        }
+        else if (arg.startsWith('--configuration=')) {
+            result.configuration = arg.split('=')[1];
+        }
+        else if (arg === '--port') {
+            result.port = parseInt(next);
+            i++;
+        }
+        else if (arg === '--open' || arg === '-o') {
+            result.open = true;
+        }
+        else if (arg === '--host') {
+            result.host = next;
+            i++;
+        }
+        else if (arg === '--watch' || arg === '-w') {
+            result.watch = true;
+        }
+        else if (arg === '--help' || arg === '-h') {
+            return { command: 'help' };
+        }
+    }
+    return result;
+}
+// ═══════════════════════════════════════════════════════════════
+//  Main
+// ═══════════════════════════════════════════════════════════════
+async function main() {
+    const args = parseArgs(process.argv);
+    if (args.command === 'help') {
+        printHelp();
+        process.exit(0);
+    }
+    const cwd = process.cwd();
+    const resolveOpts = {
+        command: args.command,
+        project: args.project,
+        configuration: args.configuration,
+        port: args.port,
+        open: args.open,
+        host: args.host,
+        watch: args.watch,
+    };
+    const buildOpts = resolveWorkspace(cwd, resolveOpts);
+    banner(args.command, buildOpts.projectName, buildOpts.configName);
+    const viteConfig = createViteConfig(buildOpts);
+    if (args.command === 'serve') {
+        const server = await createServer(viteConfig);
+        await server.listen();
+        server.printUrls();
+        console.log();
+    }
+    if (args.command === 'build') {
+        const start = Date.now();
+        await build(viteConfig);
+        const duration = Date.now() - start;
+        printBuildStats(buildOpts.outputPath, duration);
+    }
+}
+main().catch(err => {
+    error(err.message);
+});

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+import type { InlineConfig } from 'vite';
+import type { ResolvedBuildOptions } from './workspace.js';
+/**
+ * Creates a Vite InlineConfig from resolved Angular build options.
+ */
+export declare function createViteConfig(opts: ResolvedBuildOptions): InlineConfig;

package/dist/config.js

@@ -0,0 +1,89 @@
+import { resolve } from 'node:path';
+import { angular } from '@oxc-angular/vite';
+import { htmlInjectPlugin, assetCopyPlugin } from './plugins.js';
+/**
+ * Creates a Vite InlineConfig from resolved Angular build options.
+ */
+export function createViteConfig(opts) {
+    const { workspaceRoot, sourceRoot } = opts;
+    // Output naming based on hashing config
+    const hash = (scope) => {
+        if (opts.outputHashing === 'all')
+            return true;
+        if (opts.outputHashing === 'none')
+            return false;
+        if (opts.outputHashing === 'media' && scope === 'asset')
+            return true;
+        if (opts.outputHashing === 'bundles' && scope === 'chunk')
+            return true;
+        return false;
+    };
+    // namedChunks overrides hash-based naming for JS chunks
+    const useChunkHash = !opts.namedChunks && hash('chunk');
+    const assetNames = hash('asset') ? 'assets/[name]-[hash].[ext]' : 'assets/[name].[ext]';
+    const chunkNames = useChunkHash ? 'assets/[name]-[hash].js' : 'assets/[name].js';
+    const entryNames = useChunkHash ? '[name]-[hash].js' : '[name].js';
+    // deployUrl takes precedence over baseHref for Vite's base
+    const base = opts.deployUrl || opts.baseHref || '/';
+    // Sass/Less includePaths → Vite css.preprocessorOptions
+    const cssPreprocessorOptions = {};
+    if (opts.stylePreprocessorOptions.includePaths.length) {
+        const paths = opts.stylePreprocessorOptions.includePaths;
+        cssPreprocessorOptions.scss = { includePaths: paths };
+        cssPreprocessorOptions.sass = { includePaths: paths };
+        cssPreprocessorOptions.less = { paths };
+    }
+    return {
+        root: resolve(workspaceRoot, sourceRoot),
+        base,
+        publicDir: resolve(workspaceRoot, 'public'),
+        logLevel: 'info',
+        plugins: [
+            htmlInjectPlugin(opts),
+            ...angular({
+                tsconfig: opts.tsconfig,
+                sourceMap: opts.sourceMap,
+                liveReload: !opts.optimization,
+                workspaceRoot,
+                ...(opts.fileReplacements.length ? { fileReplacements: opts.fileReplacements } : {}),
+            }),
+            assetCopyPlugin(opts.assets, workspaceRoot, sourceRoot),
+        ],
+        // Global constant replacements (angular.json "define")
+        ...(Object.keys(opts.define).length ? { define: opts.define } : {}),
+        resolve: {
+            preserveSymlinks: opts.preserveSymlinks,
+        },
+        css: Object.keys(cssPreprocessorOptions).length
+            ? { preprocessorOptions: cssPreprocessorOptions }
+            : undefined,
+        build: {
+            outDir: opts.outputPath,
+            emptyOutDir: true,
+            sourcemap: opts.sourceMap,
+            minify: opts.optimization ? 'oxc' : false,
+            modulePreload: { polyfill: false },
+            watch: opts.watch ? {} : null,
+            rollupOptions: {
+                // Use index.html as entry so Vite processes HTML transforms (script/style injection)
+                input: resolve(workspaceRoot, sourceRoot, 'index.html'),
+                external: opts.externalDependencies.length ? opts.externalDependencies : undefined,
+            },
+            assetsInlineLimit: 0,
+            rolldownOptions: {
+                tsconfig: opts.tsconfig,
+                output: {
+                    assetFileNames: assetNames,
+                    chunkFileNames: chunkNames,
+                    entryFileNames: entryNames,
+                },
+            },
+        },
+        server: {
+            port: opts.serve.port,
+            open: opts.serve.open,
+            host: opts.serve.host ?? false,
+            watch: opts.poll ? { usePolling: true, interval: opts.poll } : undefined,
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Programmatic API for @richapps/ong
+ *
+ * Usage:
+ *   import { resolveWorkspace, createViteConfig } from '@richapps/ong'
+ *
+ *   const opts = resolveWorkspace(process.cwd(), { command: 'build', configuration: 'production' })
+ *   const viteConfig = createViteConfig(opts)
+ */
+export { resolveWorkspace, detectWorkspace } from './workspace.js';
+export type { ResolvedBuildOptions, ResolveOptions, AssetConfig } from './workspace.js';
+export { createViteConfig } from './config.js';
+export { htmlInjectPlugin, assetCopyPlugin } from './plugins.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * Programmatic API for @richapps/ong
+ *
+ * Usage:
+ *   import { resolveWorkspace, createViteConfig } from '@richapps/ong'
+ *
+ *   const opts = resolveWorkspace(process.cwd(), { command: 'build', configuration: 'production' })
+ *   const viteConfig = createViteConfig(opts)
+ */
+export { resolveWorkspace, detectWorkspace } from './workspace.js';
+export { createViteConfig } from './config.js';
+export { htmlInjectPlugin, assetCopyPlugin } from './plugins.js';

package/dist/log.d.ts

@@ -0,0 +1,16 @@
+declare const c: {
+    reset: string;
+    bold: string;
+    dim: string;
+    green: string;
+    cyan: string;
+    yellow: string;
+    red: string;
+    gray: string;
+};
+export declare function banner(command: string, projectName: string, configName: string): void;
+export declare function error(msg: string): never;
+export declare function formatBytes(bytes: number): string;
+export declare function printBuildStats(outDir: string, durationMs: number): void;
+export declare function printHelp(): void;
+export { c };

package/dist/log.js

@@ -0,0 +1,96 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    cyan: '\x1b[36m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    gray: '\x1b[90m',
+};
+export function banner(command, projectName, configName) {
+    console.log();
+    console.log(`  ${c.green}${c.bold}ong${c.reset} ${c.dim}— Angular + OXC + Vite${c.reset}`);
+    console.log();
+    console.log(`  ${c.dim}Command:${c.reset}        ${command}`);
+    console.log(`  ${c.dim}Project:${c.reset}        ${projectName}`);
+    console.log(`  ${c.dim}Configuration:${c.reset}  ${configName}`);
+    console.log();
+}
+export function error(msg) {
+    console.error(`\n  ${c.red}${c.bold}Error:${c.reset} ${msg}\n`);
+    process.exit(1);
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return bytes + ' B';
+    if (bytes < 1024 * 1024)
+        return (bytes / 1024).toFixed(1) + ' kB';
+    return (bytes / (1024 * 1024)).toFixed(2) + ' MB';
+}
+export function printBuildStats(outDir, durationMs) {
+    console.log();
+    console.log(`  ${c.green}${c.bold}Build complete${c.reset} in ${c.bold}${durationMs}ms${c.reset}`);
+    console.log(`  ${c.dim}Output:${c.reset} ${relative(process.cwd(), outDir)}`);
+    console.log();
+    try {
+        const files = readdirSync(outDir, { recursive: true, withFileTypes: true });
+        const entries = [];
+        for (const f of files) {
+            if (f.isFile()) {
+                const fullPath = join(f.parentPath ?? f.path, f.name);
+                const stat = statSync(fullPath);
+                entries.push({ path: relative(outDir, fullPath), size: stat.size });
+            }
+        }
+        entries.sort((a, b) => b.size - a.size);
+        const totalSize = entries.reduce((sum, e) => sum + e.size, 0);
+        for (const entry of entries.slice(0, 15)) {
+            const sizeStr = formatBytes(entry.size).padStart(10);
+            const isJs = entry.path.endsWith('.js');
+            const isCss = entry.path.endsWith('.css');
+            const color = isJs ? c.yellow : isCss ? c.cyan : c.dim;
+            console.log(`  ${color}${sizeStr}${c.reset}  ${entry.path}`);
+        }
+        if (entries.length > 15) {
+            console.log(`  ${c.dim}... and ${entries.length - 15} more files${c.reset}`);
+        }
+        console.log();
+        console.log(`  ${c.bold}Total: ${formatBytes(totalSize)}${c.reset}`);
+    }
+    catch {
+        // ignore
+    }
+    console.log();
+}
+export function printHelp() {
+    console.log(`
+  ${c.green}${c.bold}ong${c.reset} ${c.dim}— Angular CLI powered by Vite + OXC${c.reset}
+
+  ${c.bold}Commands:${c.reset}
+    serve                       Start dev server
+    build                       Build for production
+
+  ${c.bold}Options:${c.reset}
+    -c, --configuration <name>  Build configuration (default: per-target default)
+    -p, --project <name>        Project name (angular.json) or path (nx project.json)
+        --port <number>         Dev server port (default: 4200)
+    -o, --open                  Open browser on start
+        --host <host>           Dev server host
+    -w, --watch                 Rebuild on file changes (build mode)
+
+  ${c.bold}Workspace support:${c.reset}
+    angular.json                Standard Angular CLI workspace
+    project.json                Nx monorepo (auto-detected)
+
+  ${c.bold}Examples:${c.reset}
+    ong serve
+    ong build -c production
+    ong serve --port 3000 --open
+    ong build -p my-app -c production
+    ong serve -p apps/my-app                ${c.dim}# nx project path${c.reset}
+`);
+}
+export { c };

package/dist/plugins.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+import type { ResolvedBuildOptions, AssetConfig } from './workspace.js';
+/**
+ * Injects global styles, scripts, polyfills, and the entry point into index.html.
+ * This makes a standard Angular index.html work with Vite without modifications.
+ */
+export declare function htmlInjectPlugin(opts: ResolvedBuildOptions): Plugin;
+/**
+ * Copies static assets from angular.json config to build output.
+ */
+export declare function assetCopyPlugin(assets: AssetConfig[], workspaceRoot: string, sourceRoot: string): Plugin;

package/dist/plugins.js

@@ -0,0 +1,97 @@
+import { existsSync, cpSync, mkdirSync } from 'node:fs';
+import { resolve, relative, join } from 'node:path';
+/**
+ * Injects global styles, scripts, polyfills, and the entry point into index.html.
+ * This makes a standard Angular index.html work with Vite without modifications.
+ */
+export function htmlInjectPlugin(opts) {
+    const viteRoot = resolve(opts.workspaceRoot, opts.sourceRoot);
+    const browserRelative = '/' + relative(viteRoot, opts.browser);
+    const styleRefs = opts.styles.map(s => '/' + relative(viteRoot, s));
+    const scriptRefs = opts.scripts.map(s => '/' + relative(viteRoot, s));
+    const crossOriginAttr = opts.crossOrigin !== 'none'
+        ? ` crossorigin="${opts.crossOrigin}"`
+        : '';
+    return {
+        name: 'ong:html-inject',
+        transformIndexHtml: {
+            order: 'pre',
+            handler(html) {
+                let result = html;
+                // Inject/update base href if not default
+                if (opts.baseHref && opts.baseHref !== '/') {
+                    if (result.includes('<base href=')) {
+                        result = result.replace(/<base href="[^"]*">/, `<base href="${opts.baseHref}">`);
+                    }
+                    else {
+                        result = result.replace('<head>', `<head>\n  <base href="${opts.baseHref}">`);
+                    }
+                }
+                // Inject global stylesheets
+                if (styleRefs.length) {
+                    const tags = styleRefs
+                        .map(s => `  <link rel="stylesheet" href="${s}"${crossOriginAttr}>`)
+                        .join('\n');
+                    result = result.replace('</head>', `${tags}\n</head>`);
+                }
+                // Inject global scripts
+                if (scriptRefs.length) {
+                    const tags = scriptRefs
+                        .map(s => `  <script type="module" src="${s}"${crossOriginAttr}></script>`)
+                        .join('\n');
+                    result = result.replace('</head>', `${tags}\n</head>`);
+                }
+                // Inject polyfills before the entry point
+                if (opts.polyfills.length) {
+                    const tags = opts.polyfills
+                        .map(p => {
+                        // Bare specifiers (e.g. "zone.js") become imports, paths become src refs
+                        if (p.startsWith('.') || p.startsWith('/')) {
+                            const ref = '/' + relative(viteRoot, resolve(opts.workspaceRoot, p));
+                            return `  <script type="module" src="${ref}"${crossOriginAttr}></script>`;
+                        }
+                        return `  <script type="module">import '${p}';</script>`;
+                    })
+                        .join('\n');
+                    result = result.replace('</body>', `${tags}\n</body>`);
+                }
+                // Inject entry point if not already present
+                const hasEntry = html.includes(`src="${browserRelative}"`) ||
+                    html.includes('src="/main.ts"') ||
+                    html.includes('src="main.ts"');
+                if (!hasEntry) {
+                    result = result.replace('</body>', `  <script type="module" src="${browserRelative}"${crossOriginAttr}></script>\n</body>`);
+                }
+                return result;
+            },
+        },
+    };
+}
+/**
+ * Copies static assets from angular.json config to build output.
+ */
+export function assetCopyPlugin(assets, workspaceRoot, sourceRoot) {
+    return {
+        name: 'ong:assets',
+        writeBundle(bundleOpts) {
+            const outDir = bundleOpts.dir || resolve(workspaceRoot, 'dist');
+            for (const asset of assets) {
+                if (typeof asset === 'string') {
+                    const src = resolve(workspaceRoot, asset);
+                    if (existsSync(src)) {
+                        const dest = join(outDir, asset.replace(sourceRoot + '/', ''));
+                        cpSync(src, dest, { recursive: true });
+                    }
+                }
+                else if (asset?.input) {
+                    const inputDir = resolve(workspaceRoot, asset.input);
+                    if (existsSync(inputDir)) {
+                        const outputDir = join(outDir, asset.output || '');
+                        mkdirSync(outputDir, { recursive: true });
+                        cpSync(inputDir, outputDir, { recursive: true });
+                    }
+                }
+            }
+        },
+    };
+}

package/dist/workspace.d.ts

@@ -0,0 +1,125 @@
+export interface ResolvedBuildOptions {
+    /** Absolute path to workspace root */
+    workspaceRoot: string;
+    /** Project name */
+    projectName: string;
+    /** Configuration name */
+    configName: string;
+    /** Source root relative to workspace (e.g. "src" or "apps/my-app/src") */
+    sourceRoot: string;
+    /** Absolute path to tsconfig */
+    tsconfig: string;
+    /** Absolute path to browser entry (e.g. src/main.ts) */
+    browser: string;
+    /** Absolute paths to global style files */
+    styles: string[];
+    /** Absolute paths to global script files */
+    scripts: string[];
+    /** Asset configs from angular.json */
+    assets: AssetConfig[];
+    /** File replacement pairs */
+    fileReplacements: {
+        replace: string;
+        with: string;
+    }[];
+    /** Whether to generate source maps */
+    sourceMap: boolean;
+    /** Whether to optimize (minify, tree-shake) */
+    optimization: boolean;
+    /** Output hashing mode */
+    outputHashing: 'none' | 'all' | 'media' | 'bundles';
+    /** Absolute path to output directory */
+    outputPath: string;
+    /** Base href for the application */
+    baseHref: string;
+    /** Deploy URL prefix for assets */
+    deployUrl: string;
+    /** Polyfill entries (e.g. ["zone.js"]) */
+    polyfills: string[];
+    /** Global constant replacements */
+    define: Record<string, string>;
+    /** Dependencies to treat as external */
+    externalDependencies: string[];
+    /** Preserve symlinks in module resolution */
+    preserveSymlinks: boolean;
+    /** Use human-readable chunk names */
+    namedChunks: boolean;
+    /** Cross-origin attribute for script/link tags */
+    crossOrigin: 'none' | 'anonymous' | 'use-credentials';
+    /** Sass/Less preprocessor options */
+    stylePreprocessorOptions: {
+        includePaths: string[];
+    };
+    /** Watch mode for build */
+    watch: boolean;
+    /** File-watching poll interval in ms (0 = no polling) */
+    poll: number;
+    /** Serve options */
+    serve: {
+        port?: number;
+        open?: boolean;
+        host?: string;
+    };
+}
+export type AssetConfig = string | {
+    glob: string;
+    input: string;
+    output?: string;
+};
+export interface ResolveOptions {
+    /** Project name or path */
+    project?: string;
+    /** Configuration name */
+    configuration?: string;
+    /** Command being run */
+    command: 'serve' | 'build';
+    /** Dev server port override */
+    port?: number;
+    /** Open browser on start */
+    open?: boolean;
+    /** Dev server host override */
+    host?: string;
+    /** Watch mode override for build */
+    watch?: boolean;
+}
+interface Target {
+    builder?: string;
+    executor?: string;
+    options?: Record<string, any>;
+    configurations?: Record<string, Record<string, any>>;
+    defaultConfiguration?: string;
+}
+interface Project {
+    name?: string;
+    root?: string;
+    sourceRoot?: string;
+    prefix?: string;
+    architect?: Record<string, Target>;
+    targets?: Record<string, Target>;
+}
+interface WorkspaceJson {
+    projects?: Record<string, Project>;
+    defaultProject?: string;
+}
+type WorkspaceType = 'angular' | 'nx-project';
+interface DetectedWorkspace {
+    type: WorkspaceType;
+    root: string;
+    data: WorkspaceJson | Project;
+    projectJsonPath?: string;
+}
+/**
+ * Detect and read the workspace configuration.
+ *
+ * Supports:
+ * - angular.json (standard Angular CLI)
+ * - workspace.json (older Nx format)
+ * - project.json (per-project Nx)
+ * - Auto-detection via --project pointing to an Nx app directory
+ */
+export declare function detectWorkspace(cwd: string, projectHint?: string): DetectedWorkspace;
+/**
+ * Main entry: detect workspace type and resolve all build options.
+ */
+export declare function resolveWorkspace(cwd: string, opts: ResolveOptions): ResolvedBuildOptions;
+export {};

package/dist/workspace.js

@@ -0,0 +1,232 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, join, dirname, basename } from 'node:path';
+// ═══════════════════════════════════════════════════════════════
+//  Detection
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Detect and read the workspace configuration.
+ *
+ * Supports:
+ * - angular.json (standard Angular CLI)
+ * - workspace.json (older Nx format)
+ * - project.json (per-project Nx)
+ * - Auto-detection via --project pointing to an Nx app directory
+ */
+export function detectWorkspace(cwd, projectHint) {
+    // If projectHint points to a specific project.json or directory
+    if (projectHint) {
+        const hintPath = resolve(cwd, projectHint);
+        // Direct path to project.json
+        if (hintPath.endsWith('project.json') && existsSync(hintPath)) {
+            return {
+                type: 'nx-project',
+                root: findWorkspaceRoot(dirname(hintPath)) ?? cwd,
+                data: JSON.parse(readFileSync(hintPath, 'utf-8')),
+                projectJsonPath: hintPath,
+            };
+        }
+        // Directory containing project.json
+        const dirProjectJson = join(hintPath, 'project.json');
+        if (existsSync(dirProjectJson)) {
+            return {
+                type: 'nx-project',
+                root: findWorkspaceRoot(hintPath) ?? cwd,
+                data: JSON.parse(readFileSync(dirProjectJson, 'utf-8')),
+                projectJsonPath: dirProjectJson,
+            };
+        }
+    }
+    // angular.json in cwd
+    const angularJson = resolve(cwd, 'angular.json');
+    if (existsSync(angularJson)) {
+        return {
+            type: 'angular',
+            root: cwd,
+            data: JSON.parse(readFileSync(angularJson, 'utf-8')),
+        };
+    }
+    // workspace.json (some Nx workspaces)
+    const workspaceJson = resolve(cwd, 'workspace.json');
+    if (existsSync(workspaceJson)) {
+        return {
+            type: 'angular',
+            root: cwd,
+            data: JSON.parse(readFileSync(workspaceJson, 'utf-8')),
+        };
+    }
+    // project.json in cwd (standalone Nx project or running from project dir)
+    const projectJson = resolve(cwd, 'project.json');
+    if (existsSync(projectJson)) {
+        return {
+            type: 'nx-project',
+            root: findWorkspaceRoot(cwd) ?? cwd,
+            data: JSON.parse(readFileSync(projectJson, 'utf-8')),
+            projectJsonPath: projectJson,
+        };
+    }
+    throw new Error('No angular.json or project.json found.\n' +
+        '  Run from an Angular/Nx workspace root, or use --project <path>.');
+}
+/**
+ * Walk up directories to find the workspace root (has nx.json or angular.json).
+ */
+function findWorkspaceRoot(from) {
+    let dir = resolve(from);
+    while (true) {
+        if (existsSync(join(dir, 'nx.json')))
+            return dir;
+        if (existsSync(join(dir, 'angular.json')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+// ═══════════════════════════════════════════════════════════════
+//  Resolve
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Main entry: detect workspace type and resolve all build options.
+ */
+export function resolveWorkspace(cwd, opts) {
+    const ws = detectWorkspace(cwd, opts.project);
+    if (ws.type === 'nx-project') {
+        return resolveNxProject(ws, opts);
+    }
+    return resolveAngularWorkspace(ws, opts);
+}
+function resolveAngularWorkspace(ws, opts) {
+    const workspace = ws.data;
+    const projects = workspace.projects ?? {};
+    let projectName;
+    let project;
+    if (opts.project && projects[opts.project]) {
+        projectName = opts.project;
+        project = projects[opts.project];
+    }
+    else if (workspace.defaultProject && projects[workspace.defaultProject]) {
+        projectName = workspace.defaultProject;
+        project = projects[workspace.defaultProject];
+    }
+    else {
+        const entries = Object.entries(projects);
+        if (entries.length === 0)
+            throw new Error('No projects found in angular.json');
+        [projectName, project] = entries[0];
+    }
+    return resolveProjectOptions(ws.root, projectName, project, opts);
+}
+function resolveNxProject(ws, opts) {
+    const project = ws.data;
+    const projectName = project.name ?? basename(dirname(ws.projectJsonPath));
+    const projectDir = dirname(ws.projectJsonPath);
+    // Resolve root relative to workspace
+    const projectRoot = project.root ?? relPath(ws.root, projectDir);
+    const resolved = {
+        ...project,
+        root: projectRoot,
+        sourceRoot: project.sourceRoot ?? join(projectRoot, 'src'),
+    };
+    return resolveProjectOptions(ws.root, projectName, resolved, opts);
+}
+function relPath(base, target) {
+    const resolved = resolve(target);
+    const baseResolved = resolve(base);
+    if (resolved.startsWith(baseResolved)) {
+        return resolved.slice(baseResolved.length + 1) || '.';
+    }
+    return resolved;
+}
+function resolveProjectOptions(workspaceRoot, projectName, project, opts) {
+    // Nx uses "targets", Angular CLI uses "architect"
+    const targets = project.targets ?? project.architect ?? {};
+    const buildTarget = targets['build'];
+    if (!buildTarget) {
+        throw new Error(`No "build" target found for project "${projectName}"`);
+    }
+    const serveTarget = targets['serve'];
+    // Resolve configuration name
+    let configName;
+    if (opts.configuration) {
+        configName = opts.configuration;
+    }
+    else if (opts.command === 'serve') {
+        configName = serveTarget?.defaultConfiguration ?? 'development';
+    }
+    else {
+        configName = buildTarget.defaultConfiguration ?? 'production';
+    }
+    // Merge base + config overrides
+    const base = buildTarget.options ?? {};
+    const overrides = buildTarget.configurations?.[configName];
+    const merged = overrides ? { ...base, ...overrides } : { ...base };
+    // Serve target options
+    const serveBase = serveTarget?.options ?? {};
+    const serveOverrides = serveTarget?.configurations?.[configName];
+    const serveOpts = serveOverrides ? { ...serveBase, ...serveOverrides } : { ...serveBase };
+    const projectRoot = project.root ?? '';
+    const sourceRoot = project.sourceRoot ?? join(projectRoot, 'src');
+    const abs = (p) => resolve(workspaceRoot, p);
+    const tsconfig = abs(merged.tsConfig ?? join(projectRoot, 'tsconfig.app.json'));
+    const browser = abs(merged.browser ?? merged.main ?? join(sourceRoot, 'main.ts'));
+    const styles = (merged.styles ?? []).map((s) => abs(typeof s === 'string' ? s : s.input));
+    const scripts = (merged.scripts ?? []).map((s) => abs(typeof s === 'string' ? s : s.input));
+    const assets = merged.assets ?? [];
+    const fileReplacements = (merged.fileReplacements ?? []).map((fr) => ({
+        replace: abs(fr.replace),
+        with: abs(fr.with),
+    }));
+    const sourceMap = merged.sourceMap ?? (configName !== 'production');
+    const optimization = merged.optimization ?? (configName === 'production');
+    const outputHashing = merged.outputHashing ?? (configName === 'production' ? 'all' : 'none');
+    const outputPath = abs(merged.outputPath ?? join('dist', projectRoot || projectName));
+    const baseHref = merged.baseHref ?? '/';
+    const deployUrl = merged.deployUrl ?? '';
+    const crossOrigin = merged.crossOrigin ?? 'none';
+    const namedChunks = merged.namedChunks ?? false;
+    const preserveSymlinks = merged.preserveSymlinks ?? false;
+    const watch = opts.watch ?? merged.watch ?? false;
+    const poll = serveOpts.poll ?? merged.poll ?? 0;
+    const polyfills = Array.isArray(merged.polyfills)
+        ? merged.polyfills
+        : merged.polyfills ? [merged.polyfills] : [];
+    const define = merged.define ?? {};
+    const externalDependencies = merged.externalDependencies ?? [];
+    const rawIncludePaths = merged.stylePreprocessorOptions?.includePaths ?? [];
+    const stylePreprocessorOptions = {
+        includePaths: rawIncludePaths.map((p) => abs(p)),
+    };
+    return {
+        workspaceRoot,
+        projectName,
+        configName,
+        sourceRoot,
+        tsconfig,
+        browser,
+        styles,
+        scripts,
+        assets,
+        fileReplacements,
+        sourceMap,
+        optimization,
+        outputHashing,
+        outputPath,
+        baseHref,
+        deployUrl,
+        polyfills,
+        define,
+        externalDependencies,
+        preserveSymlinks,
+        namedChunks,
+        crossOrigin,
+        stylePreprocessorOptions,
+        watch,
+        poll,
+        serve: {
+            port: opts.port ?? serveOpts.port ?? merged.port ?? 4200,
+            open: opts.open ?? serveOpts.open ?? merged.open ?? false,
+            host: opts.host ?? serveOpts.host,
+        },
+    };
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@richapps/ong",
+  "version": "0.1.0",
+  "description": "Angular CLI powered by Vite + OXC — blazing fast drop-in replacement for ng serve/build",
+  "keywords": [
+    "angular",
+    "vite",
+    "oxc",
+    "cli",
+    "compiler",
+    "nx",
+    "build",
+    "dev-server"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "ong": "./bin/ong.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@oxc-angular/vite": "^0.0.15"
+  },
+  "peerDependencies": {
+    "vite": ">=6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "~5.9.2",
+    "vite": "^8.0.0-beta.16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nicoss/ong"
+  }
+}