timonel 2.8.3 → 2.9.1

package/dist/index.d.ts

@@ -3,7 +3,10 @@ export * from './lib/helmChartWriter.js';
 export * from './lib/rutter.js';
 export * from './lib/security.js';
 export * from './lib/umbrella.js';
+export { UmbrellaChartTemplate as UmbrellaChart } from './lib/templates/umbrella-chart.js';
+export { Subchart } from './lib/templates/subchart.js';
+export { BasicChart } from './lib/templates/basic-chart.js';
 export type { AWSALBIngressSpec, AWSEBSStorageClassSpec, AWSEFSStorageClassSpec, AWSIRSAServiceAccountSpec, } from './lib/resources/cloud/aws/awsResources.js';
 export type { KarpenterDisruption, KarpenterDisruptionBudget, KarpenterEC2NodeClassSpec, KarpenterNodeClaimSpec, KarpenterNodePoolSpec, } from './lib/resources/cloud/aws/karpenterResources.js';
 export { DEFAULT_TERMINATION_GRACE_PERIOD, isValidDisruptionBudget, isValidKubernetesDuration, KarpenterVersionUtils, } from './lib/resources/cloud/aws/karpenterResources.js';
-export { AWS_HELPERS, formatHelpers, generateHelpersTemplate, getDefaultHelpers, STANDARD_HELPERS, type HelperDefinition, } from './lib/utils/helmHelpers.js';
+export { AWS_HELPERS, createHelper, FILE_ACCESS_HELPERS, formatHelpers, generateHelpersTemplate, getDefaultHelpers, getHelpersByCategory, KUBERNETES_HELPERS, SPRIG_HELPERS, STANDARD_HELPERS, TEMPLATE_FUNCTION_HELPERS, type HelperDefinition, } from './lib/utils/helmHelpers.js';

package/dist/index.js

@@ -3,5 +3,8 @@ export * from './lib/helmChartWriter.js';
 export * from './lib/rutter.js';
 export * from './lib/security.js';
 export * from './lib/umbrella.js';
+export { UmbrellaChartTemplate as UmbrellaChart } from './lib/templates/umbrella-chart.js';
+export { Subchart } from './lib/templates/subchart.js';
+export { BasicChart } from './lib/templates/basic-chart.js';
 export { DEFAULT_TERMINATION_GRACE_PERIOD, isValidDisruptionBudget, isValidKubernetesDuration, KarpenterVersionUtils, } from './lib/resources/cloud/aws/karpenterResources.js';
-export { AWS_HELPERS, formatHelpers, generateHelpersTemplate, getDefaultHelpers, STANDARD_HELPERS, } from './lib/utils/helmHelpers.js';
+export { AWS_HELPERS, createHelper, FILE_ACCESS_HELPERS, formatHelpers, generateHelpersTemplate, getDefaultHelpers, getHelpersByCategory, KUBERNETES_HELPERS, SPRIG_HELPERS, STANDARD_HELPERS, TEMPLATE_FUNCTION_HELPERS, } from './lib/utils/helmHelpers.js';

package/dist/lib/helmChartWriter.js

@@ -5,6 +5,7 @@ import { SecurityUtils } from './security.js';
 export class HelmChartWriter {
     static write(opts) {
         const { outDir, meta, defaultValues = {}, envValues = {}, assets, helpersTpl, notesTpl, valuesSchema, } = opts;
+        console.log(`📝 Writing Helm chart: ${meta.name} v${meta.version} to ${outDir}`);
         const validatedOutDir = SecurityUtils.validatePath(outDir, process.cwd());
         this.createDirectories(validatedOutDir);
         this.writeChartYaml(validatedOutDir, meta);
@@ -14,6 +15,7 @@ export class HelmChartWriter {
         this.writeNotes(validatedOutDir, notesTpl);
         this.writeSchema(validatedOutDir, valuesSchema);
         this.writeHelmIgnore(validatedOutDir);
+        console.log(`✅ Helm chart written successfully to ${validatedOutDir}`);
     }
     static createDirectories(outDir) {
         fs.mkdirSync(path.join(outDir, 'templates'), { recursive: true });
@@ -109,14 +111,21 @@ function writeAssets(outDir, assets) {
     for (const asset of assets) {
         const sanitizedId = asset.id.replace(/[^a-zA-Z0-9-_]/g, '');
         if (sanitizedId !== asset.id) {
+            console.error(`❌ Invalid asset ID detected: ${SecurityUtils.sanitizeLogMessage(asset.id)}`);
             throw new Error(`Invalid asset ID: ${SecurityUtils.sanitizeLogMessage(asset.id)}`);
         }
         const targetDir = getTargetDirectory(asset.target);
-        if (asset.singleFile) {
-            writeSingleAssetFile(outDir, targetDir, sanitizedId, asset.yaml);
+        try {
+            if (asset.singleFile) {
+                writeSingleAssetFile(outDir, targetDir, sanitizedId, asset.yaml);
+            }
+            else {
+                writeMultipleAssetFiles(outDir, targetDir, sanitizedId, asset.yaml);
+            }
         }
-        else {
-            writeMultipleAssetFiles(outDir, targetDir, sanitizedId, asset.yaml);
+        catch (error) {
+            console.error(`❌ Failed to write asset ${asset.id}:`, error);
+            throw error;
         }
     }
 }
@@ -124,14 +133,27 @@ function getTargetDirectory(target) {
     return target === 'crds' ? 'crds' : 'templates';
 }
 function writeSingleAssetFile(outDir, targetDir, assetId, yaml) {
+    if (assetId === 'ingress' && yaml.includes('number:')) {
+        console.log('🔍 Writing ingress file with content:');
+        const numberLines = yaml.split('\n').filter((line) => line.includes('number:'));
+        console.log('Number lines:', numberLines);
+    }
     const filename = `${assetId}.yaml`;
     fs.mkdirSync(path.join(outDir, targetDir), { recursive: true });
     fs.writeFileSync(path.join(outDir, targetDir, filename), yaml + '\n');
 }
 function writeMultipleAssetFiles(outDir, targetDir, assetId, yaml) {
+    if (assetId === 'ingress' && yaml.includes('number:')) {
+        console.log('🔍 Writing ingress file (multiple) with content:');
+        const numberLines = yaml.split('\n').filter((line) => line.includes('number:'));
+        console.log('Number lines:', numberLines);
+    }
     const parts = splitDocs(yaml);
     parts.forEach((doc, index) => {
         const filename = `${assetId}${parts.length > 1 ? `-${index + 1}` : ''}.yaml`;
+        if (assetId === 'ingress' && doc.includes('number:')) {
+            console.log(`🔍 Writing document ${index + 1} for ingress:`, doc.split('\n').filter((line) => line.includes('number:')));
+        }
         fs.mkdirSync(path.join(outDir, targetDir), { recursive: true });
         fs.writeFileSync(path.join(outDir, targetDir, filename), doc + '\n');
     });

package/dist/lib/rutter.d.ts

@@ -1,21 +1,21 @@
 import { ApiObject } from 'cdk8s';
 import type { ChartProps } from 'cdk8s';
+import type { Ingress, ServiceAccount } from 'cdk8s-plus-33';
 import type { Construct } from 'constructs';
-import type { ServiceAccount, Ingress } from 'cdk8s-plus-33';
 import type { AWSALBIngressSpec, AWSEBSStorageClassSpec, AWSECRServiceAccountSpec, AWSEFSStorageClassSpec, AWSIRSAServiceAccountSpec } from './resources/cloud/aws/awsResources.js';
 import type { KarpenterEC2NodeClassSpec, KarpenterNodeClaimSpec, KarpenterNodePoolSpec } from './resources/cloud/aws/karpenterResources.js';
 import type { HelperDefinition } from './utils/helmHelpers.js';
 export declare class Rutter {
     private static readonly HELPER_NAME;
     private readonly app;
-    private readonly chart;
+    private readonly assets;
     private readonly awsResources;
-    private readonly karpenterResources;
-    private readonly meta;
+    private readonly chart;
     private readonly defaultValues;
     private readonly envValues;
+    private readonly karpenterResources;
+    private readonly meta;
     private readonly props;
-    private readonly assets;
     constructor(props: RutterProps);
     addAWSEBSStorageClass(spec: AWSEBSStorageClassSpec): ApiObject;
     addAWSEFSStorageClass(spec: AWSEFSStorageClassSpec): ApiObject;
@@ -79,6 +79,7 @@ export declare class Rutter {
     }): ApiObject;
     addAWSECRServiceAccount(spec: AWSECRServiceAccountSpec): ServiceAccount;
     addManifest(yamlOrObject: string | Record<string, unknown>, id: string): ApiObject;
+    addTemplateManifest(yamlTemplate: string, id: string): ApiObject;
     addConditionalManifest(manifestObject: Record<string, unknown>, condition: string, id: string): ApiObject;
     private validateManifestStructure;
     getMeta(): ChartMetadata;
@@ -91,31 +92,42 @@ export declare class Rutter {
     }>;
     private toSynthArray;
     private processHelmTemplates;
+    private fixCharacterMappingIssues;
+    private processCharacterMapping;
+    private applyHelmTemplateReplacements;
+    private fixIncludeStatements;
+    private fixFunctionCalls;
+    private fixChartReferences;
+    private removeHelmExpressionQuotes;
+    private fixConditionalBlocks;
+    private fixPipeExpressions;
+    private fixNestedQuotes;
+    private cleanupArtifacts;
     write(outDir: string): void;
 }
 export interface ChartMetadata {
-    name: string;
-    version: string;
     description?: string;
-    keywords?: string[];
     home?: string;
-    sources?: string[];
+    keywords?: string[];
     maintainers?: Array<{
-        name: string;
         email?: string;
+        name: string;
         url?: string;
     }>;
+    name: string;
+    sources?: string[];
+    version: string;
 }
 export interface RutterProps {
-    scope?: Construct;
-    meta: ChartMetadata;
+    chartProps?: ChartProps;
+    cloudProvider?: 'aws';
     defaultValues?: Record<string, unknown>;
     envValues?: Record<string, Record<string, unknown>>;
-    namespace?: string;
-    chartProps?: ChartProps;
     helpersTpl?: string | HelperDefinition[];
-    cloudProvider?: 'aws';
     manifestPrefix?: string;
+    meta: ChartMetadata;
+    namespace?: string;
+    scope?: Construct;
     singleManifestFile?: boolean;
 }
-export type { AWSEBSStorageClassSpec, AWSEFSStorageClassSpec, AWSIRSAServiceAccountSpec, AWSALBIngressSpec, } from './resources/cloud/aws/awsResources.js';
+export type { AWSALBIngressSpec, AWSEBSStorageClassSpec, AWSEFSStorageClassSpec, AWSIRSAServiceAccountSpec, } from './resources/cloud/aws/awsResources.js';

package/dist/lib/rutter.js

@@ -1,6 +1,7 @@
 import { ApiObject, App, Chart, Testing } from 'cdk8s';
+import Handlebars from 'handlebars';
 import YAML from 'yaml';
-import { helm, include } from './helm.js';
+import { include } from './helm.js';
 import { HelmChartWriter } from './helmChartWriter.js';
 import { AWSResources } from './resources/cloud/aws/awsResources.js';
 import { KarpenterResources } from './resources/cloud/aws/karpenterResources.js';
@@ -8,10 +9,11 @@ import { generateHelpersTemplate } from './utils/helmHelpers.js';
 export class Rutter {
     constructor(props) {
         this.assets = [];
-        this.props = props;
-        this.meta = props.meta;
+        console.log(`🚀 Initializing Rutter chart: ${props.meta.name} v${props.meta.version}`);
         this.defaultValues = props.defaultValues ?? {};
         this.envValues = props.envValues ?? {};
+        this.meta = props.meta;
+        this.props = props;
         this.app = new App();
         this.chart = new Chart(this.app, props.meta.name, {
             ...props.chartProps,
@@ -74,6 +76,19 @@ export class Rutter {
             spec: manifestObject['spec'],
         });
     }
+    addTemplateManifest(yamlTemplate, id) {
+        const templateAsset = {
+            id,
+            yaml: yamlTemplate,
+            target: 'templates',
+        };
+        this.assets.push(templateAsset);
+        return new ApiObject(this.chart, id, {
+            apiVersion: 'v1',
+            kind: 'ConfigMap',
+            metadata: { name: id },
+        });
+    }
     addConditionalManifest(manifestObject, condition, id) {
         if (!condition || typeof condition !== 'string') {
             throw new Error('Condition must be a non-empty string');
@@ -86,13 +101,32 @@ export class Rutter {
         else {
             helmCondition = `.Values.${condition}`;
         }
-        const conditionalAsset = {
-            id,
-            yaml: `{{- if ${helmCondition} }}\n${YAML.stringify(manifestObject)}{{- end }}`,
-            target: 'templates',
-        };
-        this.assets.push(conditionalAsset);
-        return new ApiObject(this.chart, id, {
+        try {
+            const yamlContent = YAML.stringify(manifestObject, {
+                lineWidth: 0,
+                doubleQuotedAsJSON: false,
+                simpleKeys: true,
+            });
+            const conditionalTemplate = `\\{{- if ${helmCondition} }}
+{{{manifestYaml}}}
+\\{{- end }}`;
+            const template = Handlebars.compile(conditionalTemplate, {
+                noEscape: true,
+            });
+            const conditionalYaml = template({
+                manifestYaml: yamlContent.trim(),
+            });
+            const conditionalAsset = {
+                id,
+                yaml: conditionalYaml,
+                target: 'templates',
+            };
+            this.assets.push(conditionalAsset);
+        }
+        catch (error) {
+            throw new Error(`Failed to compile Handlebars template for manifest '${id}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        return new ApiObject(this.chart, `${id}-placeholder`, {
             apiVersion: manifestObject['apiVersion'],
             kind: manifestObject['kind'],
             metadata: {
@@ -100,39 +134,33 @@ export class Rutter {
                 annotations: {
                     ...(manifestObject['metadata']?.['annotations'] || {}),
                     'timonel.sh/conditional': condition,
+                    'timonel.sh/placeholder': 'true',
                 },
             },
             spec: manifestObject['spec'],
         });
     }
     validateManifestStructure(manifest) {
-        if (!manifest['apiVersion'] || typeof manifest['apiVersion'] !== 'string') {
-            throw new Error('Kubernetes manifest must have a valid apiVersion');
+        if (!manifest.apiVersion) {
+            console.error('❌ Manifest validation failed: Missing apiVersion');
+            throw new Error('Manifest must have an apiVersion');
         }
-        if (!manifest['kind'] || typeof manifest['kind'] !== 'string') {
-            throw new Error('Kubernetes manifest must have a valid kind');
+        if (!manifest.kind) {
+            console.error('❌ Manifest validation failed: Missing kind');
+            throw new Error('Manifest must have a kind');
         }
-        if (!manifest['metadata'] ||
-            typeof manifest['metadata'] !== 'object' ||
-            manifest['metadata'] === null) {
-            throw new Error('Kubernetes manifest must have valid metadata');
+        if (!manifest.metadata) {
+            console.error('❌ Manifest validation failed: Missing metadata');
+            throw new Error('Manifest must have metadata');
         }
-        const metadata = manifest['metadata'];
-        if (!metadata['name'] || typeof metadata['name'] !== 'string') {
-            throw new Error('Kubernetes manifest metadata must have a valid name');
+        const metadata = manifest.metadata;
+        if (!metadata.name) {
+            console.error('❌ Manifest validation failed: Missing metadata.name');
+            throw new Error('Manifest metadata must have a name');
         }
-        const kind = manifest['kind'];
-        if (kind === 'CustomResourceDefinition') {
-            if (!manifest['spec'] || typeof manifest['spec'] !== 'object' || manifest['spec'] === null) {
-                throw new Error('CustomResourceDefinition must have a valid spec');
-            }
-            const spec = manifest['spec'];
-            if (!spec['group'] || typeof spec['group'] !== 'string') {
-                throw new Error('CustomResourceDefinition spec must have a valid group');
-            }
-            if (!Array.isArray(spec['versions']) || spec['versions'].length === 0) {
-                throw new Error('CustomResourceDefinition must have at least one version in spec.versions');
-            }
+        if (typeof metadata.name !== 'string') {
+            console.error('❌ Manifest validation failed: metadata.name must be a string');
+            throw new Error('Manifest metadata.name must be a string');
         }
     }
     getMeta() {
@@ -148,13 +176,23 @@ export class Rutter {
         return [...this.assets];
     }
     toSynthArray() {
+        console.log(`📦 Synthesizing chart assets for: ${this.meta.name}`);
         const apiObjectIds = [];
         for (const child of this.chart.node.children) {
-            if (child instanceof ApiObject) {
+            if (child instanceof ApiObject && !child.node.id.endsWith('-placeholder')) {
                 apiObjectIds.push(child.node.id);
             }
         }
-        const manifestObjs = Testing.synth(this.chart);
+        const allManifestObjs = Testing.synth(this.chart);
+        const manifestObjs = allManifestObjs.filter((obj) => {
+            if (obj && typeof obj === 'object') {
+                const o = obj;
+                const annotations = o.metadata?.annotations || {};
+                return annotations['timonel.sh/placeholder'] !== 'true';
+            }
+            return true;
+        });
+        console.log(`📋 Found ${manifestObjs.length} manifest objects to process`);
         const enriched = manifestObjs.map((obj) => {
             if (obj && typeof obj === 'object') {
                 const o = obj;
@@ -162,12 +200,12 @@ export class Rutter {
                 o.metadata.labels = o.metadata.labels ?? {};
                 const labels = o.metadata.labels;
                 const defaults = {
-                    'helm.sh/chart': '{{ .Chart.Name }}-{{ .Chart.Version }}',
-                    'app.kubernetes.io/name': include(Rutter.HELPER_NAME),
-                    'app.kubernetes.io/instance': helm.releaseName,
-                    'app.kubernetes.io/version': helm.chartVersion,
+                    'helm.sh/chart': `{{ .Chart.Name }}-{{ .Chart.Version }}`,
+                    'app.kubernetes.io/name': `{{ ${include} "${Rutter.HELPER_NAME}" . }}`,
+                    'app.kubernetes.io/instance': '{{ .Release.Name }}',
+                    'app.kubernetes.io/version': '{{ .Chart.Version }}',
                     'app.kubernetes.io/managed-by': '{{ .Release.Service }}',
-                    'app.kubernetes.io/part-of': helm.chartName,
+                    'app.kubernetes.io/part-of': '{{ .Chart.Name }}',
                 };
                 for (const [key, value] of Object.entries(defaults)) {
                     if (!(key in labels)) {
@@ -188,10 +226,10 @@ export class Rutter {
         }
         else {
             enriched.forEach((obj, index) => {
+                const apiObjectId = apiObjectIds[index];
+                const manifestId = apiObjectId || `manifest-${index + 1}`;
                 const yaml = this.processHelmTemplates(YAML.stringify(obj).trim());
                 if (yaml) {
-                    const apiObjectId = apiObjectIds[index];
-                    const manifestId = apiObjectId || `manifest-${index + 1}`;
                     synthAssets.push({ id: manifestId, yaml });
                 }
             });
@@ -202,13 +240,174 @@ export class Rutter {
         return synthAssets;
     }
     processHelmTemplates(yaml) {
-        return yaml
-            .replace(/": "\{\{([^}]+)\}\}"/g, ': {{ $1 }}')
-            .replace(/: "\{\{([^}]+)\}\}"/g, ': {{ $1 }}')
-            .replace(/"\{\{([^}]+)\}\}"/g, '{{ $1 }}')
-            .replace(/": "\.nan"/g, ': .nan');
+        let processed = this.fixCharacterMappingIssues(yaml);
+        processed = this.applyHelmTemplateReplacements(processed);
+        return processed;
+    }
+    fixCharacterMappingIssues(yaml) {
+        const lines = yaml.split('\n');
+        const fixedLines = [];
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            if (!line) {
+                i++;
+                continue;
+            }
+            const charKeyMatch = line.match(/^(\s*)"(\d+)":\s*(.+)$/);
+            if (charKeyMatch && charKeyMatch[2] && parseInt(charKeyMatch[2]) === 0) {
+                const indent = charKeyMatch[1] || '';
+                const result = this.processCharacterMapping(lines, i, indent);
+                if (result.reconstructed) {
+                    fixedLines.push(result.reconstructed);
+                    i = result.nextIndex;
+                    continue;
+                }
+            }
+            if (line) {
+                fixedLines.push(line);
+            }
+            i++;
+        }
+        return fixedLines.join('\n');
+    }
+    processCharacterMapping(lines, startIndex, indent) {
+        const charMappings = [];
+        let j = startIndex;
+        while (j < lines.length) {
+            const currentLine = lines[j];
+            if (!currentLine) {
+                break;
+            }
+            const currentMatch = currentLine.match(/^(\s*)"(\d+)":\s*(.+)$/);
+            if (currentMatch && currentMatch[1] === indent && currentMatch[2] && currentMatch[3]) {
+                const index = parseInt(currentMatch[2]);
+                let char = currentMatch[3];
+                if (char && char.startsWith('"') && char.endsWith('"')) {
+                    char = char.slice(1, -1);
+                }
+                charMappings.push({ index, char });
+                j++;
+            }
+            else {
+                break;
+            }
+        }
+        if (charMappings.length > 3) {
+            charMappings.sort((a, b) => a.index - b.index);
+            const reconstructed = charMappings.map((m) => m.char).join('');
+            if (reconstructed.includes('{{') && reconstructed.includes('}}')) {
+                return { reconstructed: `${indent}${reconstructed}`, nextIndex: j };
+            }
+        }
+        return { nextIndex: j };
+    }
+    applyHelmTemplateReplacements(processed) {
+        processed = this.fixConditionalBlocks(processed);
+        processed = this.fixPipeExpressions(processed);
+        processed = this.fixNestedQuotes(processed);
+        processed = this.cleanupArtifacts(processed);
+        processed = this.removeHelmExpressionQuotes(processed);
+        return processed;
+    }
+    fixIncludeStatements(processed) {
+        processed = processed.replace(/\{\{ include \\"([^"]+)\\" \. \| nindent (\d+) \}\}/g, '{{ include "$1" . | nindent $2 }}');
+        processed = processed.replace(/\{\{ include \\"([^"]+)\\" \. \}\}/g, '{{ include "$1" . }}');
+        return processed;
+    }
+    fixFunctionCalls(processed) {
+        return processed.replace(/\{\{ (\w+) \\"([^"]*)\\" ([^}]*) \}\}/g, '{{ $1 "$2" $3 }}');
+    }
+    fixChartReferences(processed) {
+        return processed.replace(/\{\{ \.Chart\.(\w+) \| replace \\"([^"]*)\\" \\"([^"]*)\\" ([^}]*) \}\}/g, '{{ .Chart.$1 | replace "$2" "$3" $4 }}');
+    }
+    removeHelmExpressionQuotes(processed) {
+        const HELM_EXPRESSION_REPLACEMENT = '$1$2: {{$3}}';
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\|\s*(?:int|float|bool|number)[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(port\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(service\.port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(backend\.service\.port\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(spec\.port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]*\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(replicas):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(targetPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(nodePort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(containerPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(hostPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(weight):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(priority):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(timeoutSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(periodSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(successThreshold):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(failureThreshold):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(initialDelaySeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(terminationGracePeriodSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(activeDeadlineSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(backoffLimit):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(parallelism):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(completions):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(revisionHistoryLimit):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(progressDeadlineSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(minReadySeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(maxUnavailable):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(maxSurge):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(cpu):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(memory):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(enabled):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(create):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(allow):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(disable):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(force):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(required):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(optional):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(readOnly):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(runAsNonRoot):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(privileged):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(allowPrivilegeEscalation):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(readOnlyRootFilesystem):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*true[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*false[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\d+[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\beq\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bne\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\blt\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\ble\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bgt\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bge\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\band\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bor\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bnot\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[+][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[-][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[*][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/:\s*"([^"]*\{\{[^}]+\}\}[^"]*)"/g, ': $1');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(true|false)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+\.\d+)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+\.?\d*[eE][+-]?\d+)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/"\{\{([^}]*)\}\}"/g, '{{$1}}');
+        processed = processed.replace(/^(\s*)-\s*"\{\{([^}]*)\}\}"/gm, '$1- {{$2}}');
+        return processed;
+    }
+    fixConditionalBlocks(processed) {
+        return processed.replace(/"\{\{-\s*(if|with|range)([^}]*)\}\}([^"]*)\{\{-\s*end\s*\}\}"/g, '{{- $1$2}}$3{{- end }}');
+    }
+    fixPipeExpressions(processed) {
+        return processed.replace(/"\{\{([^}]*\|[^}]*)\}\}"/g, '{{$1}}');
+    }
+    fixNestedQuotes(processed) {
+        return processed.replace(/\{\{([^}]*)\\"([^"]*)\\"([^}]*)\}\}/g, '{{$1"$2"$3}}');
+    }
+    cleanupArtifacts(processed) {
+        processed = processed.replace(/": "\.nan"/g, ': .nan');
+        processed = processed.replace(/: \{\{([^}]+)\}\}$/gm, ': {{$1}}');
+        return processed;
     }
     write(outDir) {
+        console.log(`✍️  Writing Helm chart '${this.meta.name}' to: ${outDir}`);
         let helpersContent;
         if (this.props.helpersTpl) {
             if (typeof this.props.helpersTpl === 'string') {
@@ -228,14 +427,17 @@ ${helper.template}
         else {
             helpersContent = generateHelpersTemplate(this.props.cloudProvider);
         }
+        const synthAssets = this.toSynthArray();
+        console.log(`📄 Generated ${synthAssets.length} assets for chart`);
         HelmChartWriter.write({
             outDir,
             meta: this.meta,
             defaultValues: this.defaultValues,
             envValues: this.envValues,
-            assets: this.toSynthArray(),
+            assets: synthAssets,
             helpersTpl: helpersContent,
         });
+        console.log(`✅ Helm chart '${this.meta.name}' written successfully`);
     }
 }
 Rutter.HELPER_NAME = 'chart.name';

package/dist/lib/templates/basic-chart.d.ts

@@ -0,0 +1,19 @@
+import { Chart } from 'cdk8s';
+import type { ChartProps } from 'cdk8s';
+import type { Construct } from 'constructs';
+export interface BasicChartProps extends ChartProps {
+    appName?: string;
+    image?: string;
+    port?: number;
+    replicas?: number;
+    createNamespace?: boolean;
+}
+export declare class BasicChart extends Chart {
+    private rutter;
+    private props;
+    constructor(scope: Construct, id: string, props?: BasicChartProps);
+    private initializeRutter;
+    writeHelmChart(outDir: string): void;
+    private generateKubernetesManifests;
+}
+export declare function generateBasicChart(appName?: string): string;