timonel 2.8.0 → 2.8.3

package/dist/cli.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
-import * as cp from 'child_process';
+import { spawnSync, execSync } from 'child_process';
+import { mkdirSync, existsSync, writeFileSync, rmSync, unlinkSync } from 'fs';
+import { join, dirname, isAbsolute, resolve } from 'path';
+import { fileURLToPath } from 'url';
 import * as fs from 'fs';
 import * as path from 'path';
-import { fileURLToPath } from 'url';
 import { SecurityUtils } from './lib/security.js';
-// ES modules equivalent of __dirname
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+const __dirname = dirname(__filename);
 const HELM_INSTALL_URL = 'https://helm.sh/docs/intro/install/';
 const HELM_ENV_VAR_MSG = 'Or set HELM_BIN environment variable to helm binary path.';
 function usageAndExit(msg) {
@@ -50,42 +51,36 @@ function usageAndExit(msg) {
 async function cmdInit(name, silent = false) {
     if (!name)
         usageAndExit('Missing <chart-name>');
-    // Validate chart name for security using centralized validation
-    if (!SecurityUtils.isValidChartName(name)) {
+    const validName = name;
+    if (!SecurityUtils.isValidChartName(validName)) {
         usageAndExit('Invalid chart name: must be RFC 1123 compliant (lowercase alphanumeric with hyphens)');
     }
-    const sanitizedName = name; // Already validated by SecurityUtils
-    const base = SecurityUtils.validatePath(path.join(process.cwd(), 'charts', sanitizedName), process.cwd());
-    const file = path.join(base, 'chart.ts');
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
-    fs.mkdirSync(base, { recursive: true });
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
-    if (fs.existsSync(file)) {
+    const sanitizedName = validName;
+    const base = SecurityUtils.validatePath(join(process.cwd(), 'charts', sanitizedName), process.cwd());
+    const file = join(base, 'chart.ts');
+    mkdirSync(base, { recursive: true });
+    if (existsSync(file)) {
         console.error(`File already exists: ${file}`);
         process.exit(1);
     }
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
-    fs.writeFileSync(file, exampleChartTs(name));
+    writeFileSync(file, exampleChartTs(validName));
     log(SecurityUtils.sanitizeLogMessage(`Scaffold created at ${file}`), silent);
 }
 async function cmdValidate(projectDir, silent = false) {
     if (!projectDir)
         usageAndExit('Missing <projectDir>');
     const proj = projectDir;
-    // Validate and secure the project directory path
-    const basePath = path.isAbsolute(proj) ? path.dirname(proj) : process.cwd();
-    const chartTs = path.isAbsolute(proj)
-        ? SecurityUtils.validatePath(path.join(proj, 'chart.ts'), basePath)
-        : SecurityUtils.validatePath(path.join(process.cwd(), proj, 'chart.ts'), process.cwd());
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
-    if (!fs.existsSync(chartTs)) {
+    const basePath = isAbsolute(proj) ? dirname(proj) : process.cwd();
+    const chartTs = isAbsolute(proj)
+        ? SecurityUtils.validatePath(join(proj, 'chart.ts'), basePath)
+        : SecurityUtils.validatePath(join(process.cwd(), proj, 'chart.ts'), process.cwd());
+    if (!existsSync(chartTs)) {
         console.error(SecurityUtils.sanitizeLogMessage(`chart.ts not found at ${chartTs}`));
         process.exit(1);
     }
-    // Check if helm is available
     const helm = process.env['HELM_BIN'] || 'helm';
     try {
-        cp.execSync(`${helm} version --short`, { stdio: 'ignore' });
+        execSync(`${helm} version --short`, { stdio: 'ignore' });
     }
     catch {
         console.error('✗ Helm not found. Install Helm to enable chart validation.');
@@ -93,12 +88,10 @@ async function cmdValidate(projectDir, silent = false) {
         console.error(`  ${HELM_ENV_VAR_MSG}`);
         process.exit(1);
     }
-    const tempDir = path.join(process.cwd(), '.timonel-validate');
+    const tempDir = join(process.cwd(), '.timonel-validate');
     try {
-        // Generate chart to temp directory for validation
         await cmdSynth(projectDir, tempDir, { dryRun: false, silent: true, set: {} });
-        // Run helm lint on generated chart
-        const lintResult = cp.spawnSync(helm, ['lint', tempDir], {
+        const lintResult = spawnSync(helm, ['lint', tempDir], {
             stdio: silent ? 'pipe' : 'inherit',
             encoding: 'utf8',
         });
@@ -117,19 +110,11 @@ async function cmdValidate(projectDir, silent = false) {
         process.exit(1);
     }
     finally {
-        // Cleanup temp directory
-        if (fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
         }
     }
 }
-/**
- * Execute TypeScript chart using tsx with proper error handling.
- * @param resolvedPath - Resolved path to the TypeScript file
- * @param outDir - Output directory for the chart
- * @param flags - CLI flags
- * @since 2.7.3
- */
 async function executeTypeScriptChart(resolvedPath, outDir, flags) {
     const wrapperScript = `
 import { pathToFileURL } from 'url';
@@ -156,10 +141,10 @@ fs.mkdirSync(outDir, { recursive: true });
 await Promise.resolve(runner(outDir));
 console.log('Chart written to ' + outDir);
 `;
-    const wrapperFile = path.join(process.cwd(), '.timonel-wrapper.mjs');
+    const wrapperFile = join(process.cwd(), '.timonel-wrapper.mjs');
     try {
-        fs.writeFileSync(wrapperFile, wrapperScript);
-        const result = cp.spawnSync('npx', ['tsx', wrapperFile], {
+        writeFileSync(wrapperFile, wrapperScript);
+        const result = spawnSync('npx', ['tsx', wrapperFile], {
             stdio: flags?.silent ? 'pipe' : 'inherit',
             encoding: 'utf8',
         });
@@ -171,9 +156,8 @@ console.log('Chart written to ' + outDir);
         }
     }
     finally {
-        // Cleanup wrapper file
-        if (fs.existsSync(wrapperFile)) {
-            fs.unlinkSync(wrapperFile);
+        if (existsSync(wrapperFile)) {
+            unlinkSync(wrapperFile);
         }
     }
 }
@@ -181,24 +165,20 @@ async function cmdSynth(projectDir, out, flags) {
     if (!projectDir)
         usageAndExit('Missing <projectDir>');
     const proj = projectDir;
-    // Validate and secure the project directory path
-    const basePath = path.isAbsolute(proj) ? path.dirname(proj) : process.cwd();
-    const chartTs = path.isAbsolute(proj)
-        ? SecurityUtils.validatePath(path.join(proj, 'chart.ts'), basePath)
-        : SecurityUtils.validatePath(path.join(process.cwd(), proj, 'chart.ts'), process.cwd());
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
-    if (!fs.existsSync(chartTs)) {
+    const basePath = isAbsolute(proj) ? dirname(proj) : process.cwd();
+    const chartTs = isAbsolute(proj)
+        ? SecurityUtils.validatePath(join(proj, 'chart.ts'), basePath)
+        : SecurityUtils.validatePath(join(process.cwd(), proj, 'chart.ts'), process.cwd());
+    if (!existsSync(chartTs)) {
         console.error(SecurityUtils.sanitizeLogMessage(`chart.ts not found at ${chartTs}`));
         process.exit(1);
     }
-    // Validate TypeScript file extension
     if (!SecurityUtils.isValidTypeScriptFile(chartTs)) {
         console.error('Security: Only TypeScript files (.ts) are allowed');
         process.exit(1);
     }
-    // Additional path validation is already done by SecurityUtils.validatePath above
-    const resolvedPath = path.resolve(chartTs);
-    const outDir = out || path.join(path.dirname(chartTs), 'dist');
+    const resolvedPath = resolve(chartTs);
+    const outDir = out || join(dirname(chartTs), 'dist');
     if (flags?.dryRun) {
         log(`[DRY RUN] Would write chart to ${outDir}`, flags.silent);
         return;
@@ -215,15 +195,17 @@ async function cmdSynth(projectDir, out, flags) {
 async function cmdDiff(projectDir, chartDir, silent = false) {
     if (!projectDir || !chartDir)
         usageAndExit('Missing <projectDir> or <chartDir>');
-    const tempDir = path.join(process.cwd(), '.timonel-temp');
+    const validProjectDir = projectDir;
+    const validChartDir = chartDir;
+    const tempDir = join(process.cwd(), '.timonel-temp');
     try {
-        // Generate chart to temp directory
-        await cmdSynth(projectDir, tempDir);
-        // Compare with existing chart
+        await cmdSynth(validProjectDir, tempDir);
         const diffCmd = process.platform === 'win32' ? 'fc' : 'diff';
-        const args = process.platform === 'win32' ? ['/N', chartDir, tempDir] : ['-r', chartDir, tempDir];
+        const args = process.platform === 'win32'
+            ? ['/N', validChartDir, tempDir]
+            : ['-r', validChartDir, tempDir];
         log(`> ${diffCmd} ${args.join(' ')}`, silent);
-        const res = cp.spawnSync(diffCmd, args, { stdio: 'inherit' });
+        const res = spawnSync(diffCmd, args, { stdio: 'inherit' });
         if (res.status === 0) {
             log('✓ No differences found', silent);
         }
@@ -233,19 +215,19 @@ async function cmdDiff(projectDir, chartDir, silent = false) {
         }
     }
     finally {
-        // Cleanup temp directory
-        if (fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
         }
     }
 }
 async function cmdDeploy(projectDir, releaseName, flags) {
     if (!projectDir || !releaseName)
         usageAndExit('Missing <projectDir> or <release>');
-    // Check if helm is available
+    const validProjectDir = projectDir;
+    const validReleaseName = releaseName;
     const helm = process.env['HELM_BIN'] || 'helm';
     try {
-        cp.execSync(`${helm} version --short`, { stdio: 'ignore' });
+        execSync(`${helm} version --short`, { stdio: 'ignore' });
     }
     catch {
         console.error('✗ Helm not found. Install Helm to enable deployment.');
@@ -253,21 +235,16 @@ async function cmdDeploy(projectDir, releaseName, flags) {
         console.error(`  ${HELM_ENV_VAR_MSG}`);
         process.exit(1);
     }
-    const tempDir = path.join(process.cwd(), '.timonel-deploy');
+    const tempDir = join(process.cwd(), '.timonel-deploy');
     try {
-        // Generate chart
-        await cmdSynth(projectDir, tempDir, flags);
-        // Check if release exists
+        await cmdSynth(validProjectDir, tempDir, flags);
         const checkCmd = `${helm} status ${releaseName}`;
-        const releaseExists = cp.spawnSync('sh', ['-c', checkCmd], { stdio: 'ignore' }).status === 0;
-        // Build helm command
+        const releaseExists = spawnSync('sh', ['-c', checkCmd], { stdio: 'ignore' }).status === 0;
         const action = releaseExists ? 'upgrade' : 'install';
-        const args = [action, releaseName, tempDir];
-        // Add environment-specific values if specified
+        const args = [action, validReleaseName, tempDir];
         if (flags?.env) {
-            const valuesFile = path.join(tempDir, `values-${flags.env}.yaml`);
-            // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
-            if (fs.existsSync(valuesFile)) {
+            const valuesFile = join(tempDir, `values-${flags.env}.yaml`);
+            if (existsSync(valuesFile)) {
                 args.push('-f', valuesFile);
             }
         }
@@ -275,16 +252,15 @@ async function cmdDeploy(projectDir, releaseName, flags) {
             args.push('--dry-run');
         }
         log(`> ${helm} ${args.join(' ')}`, flags?.silent);
-        const res = cp.spawnSync(helm, args, { stdio: 'inherit' });
+        const res = spawnSync(helm, args, { stdio: 'inherit' });
         if (res.status !== 0) {
             process.exit(res.status ?? 1);
         }
-        log(`✓ ${action === 'install' ? 'Deployed' : 'Updated'} release ${releaseName}`, flags?.silent);
+        log(`✓ ${action === 'install' ? 'Deployed' : 'Updated'} release ${validReleaseName}`, flags?.silent);
     }
     finally {
-        // Cleanup temp directory
-        if (fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
         }
     }
 }
@@ -307,65 +283,99 @@ async function cmdUmbrella(subcommand, args, flags) {
     }
 }
 const UMBRELLA_CONFIG_FILE = 'umbrella.config.json';
+const UMBRELLA_FILE_NAME = 'umbrella.ts';
 async function cmdUmbrellaInit(name, silent = false) {
     const MISSING_NAME_MSG = 'Missing umbrella chart name';
     if (!name)
         usageAndExit(MISSING_NAME_MSG);
-    const base = path.join(process.cwd(), name);
-    const umbrellaFile = path.join(base, 'umbrella.ts');
+    const validName = name;
+    const base = path.join(process.cwd(), validName);
+    const umbrellaFile = path.join(base, UMBRELLA_FILE_NAME);
     const configFile = path.join(base, UMBRELLA_CONFIG_FILE);
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
     fs.mkdirSync(base, { recursive: true });
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
     fs.mkdirSync(path.join(base, 'charts'), { recursive: true });
-    // Create umbrella.ts
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
-    fs.writeFileSync(umbrellaFile, exampleUmbrellaTs(name));
-    // Create config file
+    fs.writeFileSync(umbrellaFile, exampleUmbrellaTs(validName));
     const config = {
-        name,
+        name: validName,
         version: '0.1.0',
         description: `${name} umbrella chart`,
         subcharts: [],
     };
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
     fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
     log(`Umbrella chart structure created at ${base}`, silent);
     log(`Add subcharts with: tl umbrella add <subchart-name>`, silent);
 }
-async function cmdUmbrellaAdd(subchartName, silent = false) {
-    const MISSING_SUBCHART_MSG = 'Missing subchart name';
-    if (!subchartName)
+function updateUmbrellaTs(subchartPath, subchartName) {
+    const umbrellaFile = path.join(process.cwd(), UMBRELLA_FILE_NAME);
+    if (!fs.existsSync(umbrellaFile)) {
+        console.error('umbrella.ts not found.');
+        return;
+    }
+    let content = fs.readFileSync(umbrellaFile, 'utf8');
+    const chartName = subchartName || path.basename(subchartPath);
+    const camelCaseName = chartName.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    const importStatement = `import { rutter as ${camelCaseName} } from './charts/${subchartPath}/chart';`;
+    const importRegex = /import\s+.*?from\s+['"].*?['"];?/g;
+    const imports = content.match(importRegex) || [];
+    if (imports.length > 0) {
+        const lastImport = imports[imports.length - 1];
+        if (!lastImport) {
+            throw new Error('No valid import statements found');
+        }
+        const lastImportIndex = content.lastIndexOf(lastImport);
+        const insertIndex = lastImportIndex + lastImport.length;
+        if (!content.includes(importStatement)) {
+            content = content.slice(0, insertIndex) + '\n' + importStatement + content.slice(insertIndex);
+        }
+    }
+    const subchartsRegex = /subcharts:\s*\[([\s\S]*?)\]/;
+    const match = content.match(subchartsRegex);
+    if (match) {
+        const subchartsContent = match[1];
+        if (subchartsContent === undefined) {
+            throw new Error('Unable to parse subcharts content');
+        }
+        if (!subchartsContent.includes(`name: '${chartName}'`)) {
+            let newSubchartsContent;
+            const subchartEntry = `{ name: '${chartName}', rutter: ${camelCaseName} }`;
+            const hasExistingEntries = /\{\s*name:\s*['"]/.test(subchartsContent);
+            if (!hasExistingEntries) {
+                newSubchartsContent = `\n    // Add your subcharts here:\n    ${subchartEntry},\n  `;
+            }
+            else {
+                const trimmedContent = subchartsContent.trimEnd();
+                newSubchartsContent = trimmedContent + `,\n    ${subchartEntry}`;
+            }
+            content = content.replace(subchartsRegex, `subcharts: [${newSubchartsContent}\n  ]`);
+        }
+    }
+    fs.writeFileSync(umbrellaFile, content);
+}
+async function cmdUmbrellaAdd(subchartPath, silent = false) {
+    const MISSING_SUBCHART_MSG = 'Missing subchart name or path';
+    if (!subchartPath)
         usageAndExit(MISSING_SUBCHART_MSG);
+    const validSubchartPath = subchartPath;
     const configFile = path.join(process.cwd(), UMBRELLA_CONFIG_FILE);
     if (!fs.existsSync(configFile)) {
         console.error(`${UMBRELLA_CONFIG_FILE} not found. Run \`tl umbrella init\` first.`);
         process.exit(1);
     }
     const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
-    // Create subchart directory and scaffold
-    const subchartDir = path.join(process.cwd(), 'charts', subchartName);
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
+    const subchartName = path.basename(validSubchartPath);
+    const subchartDir = path.join(process.cwd(), 'charts', validSubchartPath);
     fs.mkdirSync(subchartDir, { recursive: true });
     const chartFile = path.join(subchartDir, 'chart.ts');
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
     fs.writeFileSync(chartFile, exampleSubchartTs(subchartName));
-    // Update config
     config.subcharts.push({
         name: subchartName,
         version: '0.1.0',
-        path: `./charts/${subchartName}/chart.ts`,
+        path: `./charts/${validSubchartPath}/chart.ts`,
     });
     fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
-    log(`Subchart ${subchartName} added to umbrella`, silent);
+    updateUmbrellaTs(validSubchartPath, subchartName);
+    log(`Subchart ${subchartName} added to umbrella at path '${validSubchartPath}'`, silent);
 }
-/**
- * Execute TypeScript umbrella chart using tsx with proper error handling.
- * @param resolvedPath - Resolved path to the TypeScript file
- * @param outDir - Output directory for the chart
- * @param flags - CLI flags
- * @since 2.7.3
- */
 async function executeTypeScriptUmbrella(resolvedPath, outDir, flags) {
     const wrapperScript = `
 import { pathToFileURL } from 'url';
@@ -386,7 +396,7 @@ console.log('Umbrella chart written to ' + output);
     const wrapperFile = path.join(process.cwd(), '.timonel-umbrella-wrapper.mjs');
     try {
         fs.writeFileSync(wrapperFile, wrapperScript);
-        const result = cp.spawnSync('npx', ['tsx', wrapperFile], {
+        const result = spawnSync('npx', ['tsx', wrapperFile], {
             stdio: flags?.silent ? 'pipe' : 'inherit',
             encoding: 'utf8',
         });
@@ -398,7 +408,6 @@ console.log('Umbrella chart written to ' + output);
         }
     }
     finally {
-        // Cleanup wrapper file
         if (fs.existsSync(wrapperFile)) {
             fs.unlinkSync(wrapperFile);
         }
@@ -410,17 +419,15 @@ async function cmdUmbrellaSynth(outDir, flags) {
         console.error(`${UMBRELLA_CONFIG_FILE} not found. Run \`tl umbrella init\` first.`);
         process.exit(1);
     }
-    const umbrellaFile = path.join(process.cwd(), 'umbrella.ts');
+    const umbrellaFile = path.join(process.cwd(), UMBRELLA_FILE_NAME);
     if (!fs.existsSync(umbrellaFile)) {
         console.error('umbrella.ts not found.');
         process.exit(1);
     }
-    // Validate TypeScript file extension
     if (!SecurityUtils.isValidTypeScriptFile(umbrellaFile)) {
         console.error('Security: Only TypeScript files (.ts) are allowed');
         process.exit(1);
     }
-    // Validate path to prevent traversal attacks
     const validatedPath = SecurityUtils.validatePath(umbrellaFile, process.cwd());
     const resolvedPath = path.resolve(validatedPath);
     const output = outDir || path.join(process.cwd(), 'dist');
@@ -440,20 +447,21 @@ async function cmdUmbrellaSynth(outDir, flags) {
 async function cmdPackage(chartDir, out, silent = false) {
     if (!chartDir)
         usageAndExit('Missing <chartDir>');
-    const src = path.isAbsolute(chartDir) ? chartDir : path.join(process.cwd(), chartDir);
+    const validChartDir = chartDir;
+    const src = path.isAbsolute(validChartDir)
+        ? validChartDir
+        : path.join(process.cwd(), validChartDir);
     const chartYaml = path.join(src, 'Chart.yaml');
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
     if (!fs.existsSync(chartYaml)) {
         console.error(`Chart.yaml not found in ${src}`);
         process.exit(1);
     }
     const outDir = out ? (path.isAbsolute(out) ? out : path.join(process.cwd(), out)) : src;
-    // eslint-disable-next-line security/detect-non-literal-fs-filename -- CLI tool needs dynamic paths
     fs.mkdirSync(outDir, { recursive: true });
     const helm = process.env['HELM_BIN'] || 'helm';
     const args = ['package', src, '-d', outDir];
     log(`> ${helm} ${args.join(' ')}`, silent);
-    const res = cp.spawnSync(helm, args, { stdio: 'inherit' });
+    const res = spawnSync(helm, args, { stdio: 'inherit' });
     if (res.error) {
         console.error(`✗ Failed to execute Helm: ${res.error.message}`);
         console.error(`  Install: ${HELM_INSTALL_URL}`);
@@ -505,18 +513,11 @@ export default function run(outDir: string) {
 }
 `;
 }
-/**
- * Generate TypeScript code for a subchart with correct package imports.
- * Uses published package imports instead of relative development paths.
- * @param name - The name of the subchart
- * @returns TypeScript code string for the subchart
- * @since 2.7.3
- */
 function exampleSubchartTs(name) {
     return `import { Rutter } from 'timonel';
-import { valuesRef } from 'timonel/lib/helm';
+import { valuesRef, helm } from 'timonel/lib/helm';
 
-// Define subchart
+// Create a new Rutter instance
 const rutter = new Rutter({
   meta: {
     name: '${name}',
@@ -531,19 +532,73 @@ const rutter = new Rutter({
   },
 });
 
-// Add resources
-rutter.addDeployment({
-  name: '${name}-deployment',
-  image: String(valuesRef('image.repository')) + ':' + String(valuesRef('image.tag')),
-  replicas: 1,
-  containerPort: 80,
-});
+// Add Deployment using addManifest with native Kubernetes object
+rutter.addManifest({
+    apiVersion: 'apps/v1',
+    kind: 'Deployment',
+    metadata: {
+      name: '${name}',
+      labels: {
+        app: '${name}'
+      }
+    },
+    spec: {
+      replicas: valuesRef('replicas'),
+      selector: {
+        matchLabels: {
+          app: '${name}'
+        }
+      },
+      template: {
+        metadata: {
+          labels: {
+            app: '${name}'
+          }
+        },
+        spec: {
+          containers: [
+            {
+              name: '${name}',
+              image: String(valuesRef('image.repository')) + ':' + String(valuesRef('image.tag')),
+              ports: [
+                {
+                  name: 'http',
+                  containerPort: 80,
+                  protocol: 'TCP'
+                }
+              ]
+            }
+          ]
+        }
+      }
+    }
+  }, '${name}-deployment');
 
-rutter.addService({
-  name: '${name}-service',
-  ports: [{ port: 80, targetPort: 80 }],
-  selector: { app: '${name}' },
-});
+// Add Service using addManifest with native Kubernetes object
+rutter.addManifest({
+    apiVersion: 'v1',
+    kind: 'Service',
+    metadata: {
+      name: '${name}',
+      labels: {
+        app: '${name}'
+      }
+    },
+    spec: {
+      type: 'ClusterIP',
+      ports: [
+        {
+          port: valuesRef('service.port'),
+          targetPort: 'http',
+          protocol: 'TCP',
+          name: 'http'
+        }
+      ],
+      selector: {
+        app: '${name}'
+      }
+    }
+  }, '${name}-service');
 
 export default function run(outDir: string) {
   rutter.write(outDir);
@@ -553,13 +608,6 @@ export default function run(outDir: string) {
 export { rutter };
 `;
 }
-/**
- * Generate TypeScript code for a main chart with correct package imports.
- * Uses published package imports instead of relative development paths.
- * @param name - The name of the chart
- * @returns TypeScript code string for the chart
- * @since 2.7.3
- */
 function exampleChartTs(name) {
     return `import { Rutter } from 'timonel';
 import { valuesRef, helm } from 'timonel/lib/helm';
@@ -577,6 +625,7 @@ const rutter = new Rutter({
     replicas: 1,
     service: { port: 80 },
     ingress: { enabled: false, host: 'example.com', className: 'nginx' },
+    namespace: { create: false, name: '${name}' },
   },
   envValues: {
     dev: { replicas: 1 },
@@ -584,54 +633,140 @@ const rutter = new Rutter({
   },
 });
 
-// Use Helm placeholders in strings passed to cdk8s constructs
-rutter.addDeployment({
-  name: '${name}-deployment',
-  image: String(valuesRef('image.repository')) + ':' + String(valuesRef('image.tag')),
-  replicas: valuesRef('replicas'),
-  containerPort: 80,
-  env: {
-    APP_NAME: '${name}',
-    RELEASE: helm.releaseName,
+// Add Deployment using addManifest with native Kubernetes object
+rutter.addManifest({
+  apiVersion: 'apps/v1',
+  kind: 'Deployment',
+  metadata: {
+    name: '${name}',
+    labels: {
+      app: '${name}'
+    }
   },
-});
+  spec: {
+    replicas: valuesRef('replicas'),
+    selector: {
+      matchLabels: {
+        app: '${name}'
+      }
+    },
+    template: {
+      metadata: {
+        labels: {
+          app: '${name}'
+        }
+      },
+      spec: {
+        containers: [
+          {
+            name: '${name}',
+            image: String(valuesRef('image.repository')) + ':' + String(valuesRef('image.tag')),
+            ports: [
+              {
+                name: 'http',
+                containerPort: 80,
+                protocol: 'TCP'
+              }
+            ],
+            env: [
+              {
+                name: 'APP_NAME',
+                value: '${name}'
+              },
+              {
+                name: 'RELEASE',
+                value: helm.releaseName
+              }
+            ]
+          }
+        ]
+      }
+    }
+  }
+}, '${name}-deployment');
 
-rutter.addService({
-  name: '${name}-service',
-  ports: [{ port: valuesRef('service.port'), targetPort: 80 }],
-  type: 'ClusterIP',
-  selector: { app: '${name}' },
-});
+// Add Service using addManifest with native Kubernetes object
+rutter.addManifest({
+  apiVersion: 'v1',
+  kind: 'Service',
+  metadata: {
+    name: '${name}',
+    labels: {
+      app: '${name}'
+    }
+  },
+  spec: {
+    type: 'ClusterIP',
+    ports: [
+      {
+        port: valuesRef('service.port'),
+        targetPort: 'http',
+        protocol: 'TCP',
+        name: 'http'
+      }
+    ],
+    selector: {
+      app: '${name}'
+    }
+  }
+}, '${name}-service');
 
-// Optional ingress with advanced path routing and TLS support
-// Helm conditionals can be embedded as comments; template users can wrap templates with if blocks
-// Here we just generate an ingress; for real conditional generation you could split assets yourself.
-rutter.addIngress({
-  name: '${name}-ingress',
-  ingressClassName: String(valuesRef('ingress.className')),
-  rules: [{
-    host: String(valuesRef('ingress.host')),
-    paths: [{
-      path: '/',
-      pathType: 'Prefix',
-      backend: {
-        service: {
-          name: '${name}',
-          port: { number: valuesRef('service.port') },
-        },
-      },
-    }],
-  }],
-});
+// Add Ingress using addConditionalManifest with native Kubernetes object
+rutter.addConditionalManifest({
+  apiVersion: 'networking.k8s.io/v1',
+  kind: 'Ingress',
+  metadata: {
+    name: '${name}',
+    labels: {
+      app: '${name}'
+    }
+  },
+  spec: {
+    ingressClassName: String(valuesRef('ingress.className')),
+    rules: [
+      {
+        host: String(valuesRef('ingress.host')),
+        http: {
+          paths: [
+            {
+              path: '/',
+              pathType: 'Prefix',
+              backend: {
+                service: {
+                  name: '${name}',
+                  port: {
+                    number: valuesRef('service.port')
+                  }
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}, valuesRef('ingress.enabled'), '${name}-ingress');
+
+// Add Namespace using addConditionalManifest
+rutter.addConditionalManifest({
+  apiVersion: 'v1',
+  kind: 'Namespace',
+  metadata: {
+    name: String(valuesRef('namespace.name')),
+    labels: {
+      app: '${name}',
+      'app.kubernetes.io/name': '${name}',
+      'app.kubernetes.io/instance': helm.releaseName
+    }
+  }
+}, valuesRef('namespace.create'), '${name}-namespace');
 
 export default function run(outDir: string) {
   rutter.write(outDir);
 }
 `;
 }
-// eslint-disable-next-line sonarjs/cognitive-complexity -- CLI argument parsing requires multiple conditions
 function parseArgs() {
-    /* eslint-disable security/detect-object-injection */
     const argv = process.argv.slice(2);
     const flags = { dryRun: false, silent: false, set: {} };
     const args = [];
@@ -679,14 +814,8 @@ function parseArgs() {
             }
         }
     }
-    /* eslint-enable security/detect-object-injection */
     return { cmd, args, flags };
 }
-/**
- * Display the current version of Timonel CLI.
- * Reads version from package.json using ES modules compatible path resolution.
- * @since 2.7.3
- */
 function showVersion() {
     const packagePath = path.join(__dirname, '..', 'package.json');
     try {
@@ -734,4 +863,3 @@ main().catch((err) => {
     console.error(err);
     process.exit(1);
 });
-//# sourceMappingURL=cli.js.map