@kustodian/cli 1.0.0

package/src/commands/init.ts

@@ -0,0 +1,299 @@
+import * as path from 'node:path';
+import { success } from '@kustodian/core';
+import { file_exists, write_file, write_yaml_file } from '@kustodian/loader';
+
+import { define_command } from '../command.js';
+
+/**
+ * Init command - initializes a new Kustodian project.
+ */
+export const init_command = define_command({
+  name: 'init',
+  description: 'Initialize a new Kustodian project',
+  arguments: [
+    {
+      name: 'name',
+      description: 'Project name (creates directory)',
+      required: true,
+    },
+  ],
+  options: [
+    {
+      name: 'force',
+      short: 'f',
+      description: 'Overwrite existing files',
+      type: 'boolean',
+      default_value: false,
+    },
+  ],
+  handler: async (ctx) => {
+    const project_name = ctx.args[0];
+    const force = ctx.options['force'] as boolean;
+
+    if (!project_name) {
+      console.error('Error: Project name is required');
+      return {
+        success: false as const,
+        error: { code: 'INVALID_ARGS', message: 'Project name is required' },
+      };
+    }
+
+    const project_dir = path.resolve(project_name);
+
+    // Check if directory exists
+    if (!force && (await file_exists(project_dir))) {
+      console.error(`Error: Directory '${project_name}' already exists. Use --force to overwrite.`);
+      return {
+        success: false as const,
+        error: { code: 'ALREADY_EXISTS', message: `Directory '${project_name}' already exists` },
+      };
+    }
+
+    console.log(`Creating project: ${project_name}`);
+
+    // Create kustodian.yaml
+    const kustodian_config = {
+      apiVersion: 'kustodian.io/v1',
+      kind: 'Project',
+      metadata: {
+        name: project_name,
+      },
+      spec: {
+        flux_namespace: 'flux-system',
+        oci_repository: 'flux-system',
+      },
+    };
+
+    let result = await write_yaml_file(path.join(project_dir, 'kustodian.yaml'), kustodian_config);
+    if (!result.success) {
+      console.error(`Error creating kustodian.yaml: ${result.error.message}`);
+      return result;
+    }
+    console.log('  Created kustodian.yaml');
+
+    // Create example template
+    const example_template = {
+      apiVersion: 'kustodian.io/v1',
+      kind: 'Template',
+      metadata: {
+        name: 'example',
+      },
+      spec: {
+        kustomizations: [
+          {
+            name: 'app',
+            path: './app',
+            namespace: {
+              default: 'example',
+            },
+            substitutions: [
+              {
+                name: 'replicas',
+                default: '1',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    result = await write_yaml_file(
+      path.join(project_dir, 'templates', 'example', 'template.yaml'),
+      example_template,
+    );
+    if (!result.success) {
+      console.error(`Error creating template: ${result.error.message}`);
+      return result;
+    }
+    console.log('  Created templates/example/template.yaml');
+
+    // Create example kustomization.yaml
+    const example_kustomization = `apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+resources:
+  - deployment.yaml
+`;
+
+    result = await write_file(
+      path.join(project_dir, 'templates', 'example', 'app', 'kustomization.yaml'),
+      example_kustomization,
+    );
+    if (!result.success) {
+      console.error(`Error creating kustomization.yaml: ${result.error.message}`);
+      return result;
+    }
+    console.log('  Created templates/example/app/kustomization.yaml');
+
+    // Create example deployment
+    const example_deployment = `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: example
+spec:
+  replicas: \${replicas}
+  selector:
+    matchLabels:
+      app: example
+  template:
+    metadata:
+      labels:
+        app: example
+    spec:
+      containers:
+        - name: example
+          image: nginx:latest
+          ports:
+            - containerPort: 80
+`;
+
+    result = await write_file(
+      path.join(project_dir, 'templates', 'example', 'app', 'deployment.yaml'),
+      example_deployment,
+    );
+    if (!result.success) {
+      console.error(`Error creating deployment.yaml: ${result.error.message}`);
+      return result;
+    }
+    console.log('  Created templates/example/app/deployment.yaml');
+
+    // Create example cluster
+    const example_cluster = {
+      apiVersion: 'kustodian.io/v1',
+      kind: 'Cluster',
+      metadata: {
+        name: 'local',
+      },
+      spec: {
+        domain: 'local.example.com',
+        oci: {
+          registry: 'ghcr.io',
+          repository: `your-org/${project_name}`,
+          tag_strategy: 'git-sha',
+          secret_ref: 'ghcr-auth',
+        },
+        templates: [
+          {
+            name: 'example',
+            enabled: true,
+            values: {
+              replicas: '2',
+            },
+          },
+        ],
+      },
+    };
+
+    result = await write_yaml_file(
+      path.join(project_dir, 'clusters', 'local', 'cluster.yaml'),
+      example_cluster,
+    );
+    if (!result.success) {
+      console.error(`Error creating cluster: ${result.error.message}`);
+      return result;
+    }
+    console.log('  Created clusters/local/cluster.yaml');
+
+    // Create .gitignore
+    const gitignore = `# Output
+output/
+
+# Dependencies
+node_modules/
+
+# Build artifacts
+dist/
+*.tsbuildinfo
+
+# OS files
+.DS_Store
+`;
+
+    result = await write_file(path.join(project_dir, '.gitignore'), gitignore);
+    if (!result.success) {
+      console.error(`Error creating .gitignore: ${result.error.message}`);
+      return result;
+    }
+    console.log('  Created .gitignore');
+
+    // Create GitHub Actions workflow
+    const workflow_yaml = `name: Deploy
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Flux CLI
+        uses: fluxcd/flux2/action@main
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: \${{ github.actor }}
+          password: \${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install kustodian
+        run: |
+          # TODO: Replace with actual installation method
+          # npm install -g @kustodian/cli
+          echo "Install kustodian CLI here"
+
+      - name: Validate configuration
+        run: |
+          # TODO: Run validation once kustodian is installed
+          echo "Validation step"
+
+      - name: Push artifacts (on main branch)
+        if: github.ref == 'refs/heads/main'
+        run: |
+          # TODO: Replace with actual push command once kustodian is installed
+          # for cluster in clusters/*/cluster.yaml; do
+          #   cluster_name=$(basename $(dirname $cluster))
+          #   echo "Pushing $cluster_name..."
+          #   kustodian push --cluster $cluster_name
+          # done
+          echo "Push step (configure after installing kustodian)"
+`;
+
+    result = await write_file(
+      path.join(project_dir, '.github', 'workflows', 'deploy.yaml'),
+      workflow_yaml,
+    );
+    if (!result.success) {
+      console.error(`Error creating workflow: ${result.error.message}`);
+      return result;
+    }
+    console.log('  Created .github/workflows/deploy.yaml');
+
+    console.log(`\n✓ Project '${project_name}' created successfully`);
+    console.log('\nNext steps:');
+    console.log(`  1. cd ${project_name}`);
+    console.log(
+      '  2. Initialize git repository: git init && git add . && git commit -m "Initial commit"',
+    );
+    console.log('  3. Update clusters/local/cluster.yaml with your OCI registry details');
+    console.log('  4. Create registry authentication secret in your cluster:');
+    console.log('     kubectl create secret docker-registry ghcr-auth \\');
+    console.log('       --docker-server=ghcr.io \\');
+    console.log('       --docker-username=<your-username> \\');
+    console.log('       --docker-password=<your-token>');
+    console.log('  5. Generate and push: kustodian push --cluster local --dry-run');
+    console.log('  6. Review output, then: kustodian push --cluster local');
+    console.log('  7. Apply Flux resources: kubectl apply -f output/local/');
+
+    return success(undefined);
+  },
+});

package/src/commands/update.ts

@@ -0,0 +1,274 @@
+import * as path from 'node:path';
+
+import { failure, is_success, success } from '@kustodian/core';
+import { read_yaml_file, write_yaml_file } from '@kustodian/loader';
+import { find_project_root, load_project } from '@kustodian/loader';
+import {
+  check_version_update,
+  create_client_for_image,
+  filter_semver_tags,
+  parse_image_reference,
+} from '@kustodian/registry';
+import { type VersionSubstitutionType, is_version_substitution } from '@kustodian/schema';
+
+import { define_command } from '../command.js';
+
+/**
+ * Update result for a single substitution.
+ */
+interface UpdateResultType {
+  cluster: string;
+  template: string;
+  substitution: string;
+  image: string;
+  current: string;
+  latest: string;
+  constraint?: string | undefined;
+  updated: boolean;
+}
+
+/**
+ * Update command - checks and updates version substitutions.
+ */
+export const update_command = define_command({
+  name: 'update',
+  description: 'Check and update image version substitutions',
+  options: [
+    {
+      name: 'cluster',
+      short: 'c',
+      description: 'Cluster to update values for',
+      type: 'string',
+      required: true,
+    },
+    {
+      name: 'project',
+      short: 'p',
+      description: 'Path to project root',
+      type: 'string',
+    },
+    {
+      name: 'dry-run',
+      short: 'd',
+      description: 'Show what would be updated without making changes',
+      type: 'boolean',
+      default_value: false,
+    },
+    {
+      name: 'json',
+      description: 'Output results as JSON',
+      type: 'boolean',
+      default_value: false,
+    },
+    {
+      name: 'substitution',
+      short: 's',
+      description: 'Only update specific substitution(s)',
+      type: 'string',
+    },
+  ],
+  handler: async (ctx) => {
+    const cluster_name = ctx.options['cluster'] as string;
+    const project_path = (ctx.options['project'] as string) || process.cwd();
+    const dry_run = ctx.options['dry-run'] as boolean;
+    const json_output = ctx.options['json'] as boolean;
+    const substitution_filter = ctx.options['substitution'] as string | undefined;
+
+    // Load project
+    const root_result = await find_project_root(project_path);
+    if (!is_success(root_result)) {
+      return root_result;
+    }
+
+    const project_result = await load_project(root_result.value);
+    if (!is_success(project_result)) {
+      return project_result;
+    }
+
+    const project = project_result.value;
+    const loaded_cluster = project.clusters.find((c) => c.cluster.metadata.name === cluster_name);
+
+    if (!loaded_cluster) {
+      console.error(`Cluster '${cluster_name}' not found`);
+      return failure({
+        code: 'NOT_FOUND',
+        message: `Cluster '${cluster_name}' not found`,
+      });
+    }
+
+    // Collect all version substitutions from templates enabled in this cluster
+    const version_subs: Array<{
+      template_name: string;
+      kustomization_name: string;
+      substitution: VersionSubstitutionType;
+      current_value: string | undefined;
+    }> = [];
+
+    for (const loaded_template of project.templates) {
+      const template = loaded_template.template;
+      const template_config = loaded_cluster.cluster.spec.templates?.find(
+        (t) => t.name === template.metadata.name,
+      );
+
+      // Skip disabled templates
+      if (template_config?.enabled === false) {
+        continue;
+      }
+
+      for (const kustomization of template.spec.kustomizations) {
+        for (const sub of kustomization.substitutions ?? []) {
+          if (is_version_substitution(sub)) {
+            if (substitution_filter && sub.name !== substitution_filter) {
+              continue;
+            }
+
+            version_subs.push({
+              template_name: template.metadata.name,
+              kustomization_name: kustomization.name,
+              substitution: sub,
+              current_value: template_config?.values?.[sub.name] ?? sub.default,
+            });
+          }
+        }
+      }
+    }
+
+    if (version_subs.length === 0) {
+      if (!json_output) {
+        console.log('No version substitutions found.');
+      } else {
+        console.log('[]');
+      }
+      return success(undefined);
+    }
+
+    if (!json_output) {
+      console.log(`Found ${version_subs.length} version substitution(s) to check\n`);
+    }
+
+    // Check each version substitution
+    const results: UpdateResultType[] = [];
+    const updates_to_apply: Map<string, Record<string, string>> = new Map();
+
+    for (const { template_name, substitution, current_value } of version_subs) {
+      const image_ref = parse_image_reference(substitution.registry.image);
+      const client = create_client_for_image(image_ref);
+
+      if (!json_output) {
+        console.log(`Checking ${substitution.name} (${substitution.registry.image})...`);
+      }
+
+      const tags_result = await client.list_tags(image_ref);
+      if (!is_success(tags_result)) {
+        if (!json_output) {
+          console.error(`  Failed to fetch tags: ${tags_result.error.message}`);
+        }
+        continue;
+      }
+
+      const versions = filter_semver_tags(tags_result.value, {
+        exclude_prerelease: substitution.exclude_prerelease ?? true,
+      });
+
+      if (versions.length === 0) {
+        if (!json_output) {
+          console.log('  No valid semver tags found');
+        }
+        continue;
+      }
+
+      const current = current_value ?? substitution.default ?? '0.0.0';
+      const check = check_version_update(current, versions, substitution.constraint);
+
+      const result: UpdateResultType = {
+        cluster: cluster_name,
+        template: template_name,
+        substitution: substitution.name,
+        image: substitution.registry.image,
+        current: check.current_version,
+        latest: check.latest_version,
+        constraint: substitution.constraint,
+        updated: false,
+      };
+
+      if (check.has_update) {
+        result.updated = !dry_run;
+
+        if (!dry_run) {
+          // Queue update for this template
+          const existing = updates_to_apply.get(template_name) ?? {};
+          existing[substitution.name] = check.latest_version;
+          updates_to_apply.set(template_name, existing);
+        }
+
+        if (!json_output) {
+          const action = dry_run ? 'available' : 'will update';
+          console.log(`  ${current} -> ${check.latest_version} (${action})`);
+        }
+      } else if (!json_output) {
+        console.log(`  ${current} (up to date)`);
+      }
+
+      results.push(result);
+    }
+
+    // Apply updates to cluster.yaml
+    if (!dry_run && updates_to_apply.size > 0) {
+      const cluster_path = path.join(loaded_cluster.path, 'cluster.yaml');
+      const cluster_yaml_result = await read_yaml_file<Record<string, unknown>>(cluster_path);
+
+      if (!is_success(cluster_yaml_result)) {
+        return cluster_yaml_result;
+      }
+
+      const cluster_data = cluster_yaml_result.value;
+      const spec = cluster_data['spec'] as Record<string, unknown> | undefined;
+      const templates = (spec?.['templates'] as Array<Record<string, unknown>> | undefined) ?? [];
+
+      for (const [template_name, values] of updates_to_apply) {
+        const template_idx = templates.findIndex((t) => t['name'] === template_name);
+
+        if (template_idx >= 0) {
+          const template = templates[template_idx];
+          const existing_values = (template?.['values'] as Record<string, string>) ?? {};
+          if (template) {
+            template['values'] = { ...existing_values, ...values };
+          }
+        } else {
+          // Add new template config with values
+          templates.push({
+            name: template_name,
+            values,
+          });
+        }
+      }
+
+      // Ensure spec.templates exists
+      if (spec) {
+        spec['templates'] = templates;
+      }
+
+      const write_result = await write_yaml_file(cluster_path, cluster_data);
+      if (!is_success(write_result)) {
+        return write_result;
+      }
+
+      if (!json_output) {
+        console.log(`\nUpdated ${cluster_path}`);
+      }
+    }
+
+    // Output results
+    if (json_output) {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      const update_count = results.filter(
+        (r) => r.updated || (dry_run && r.current !== r.latest),
+      ).length;
+      const action = dry_run ? 'available' : 'applied';
+      console.log(`\n${update_count} update(s) ${action}`);
+    }
+
+    return success(undefined);
+  },
+});

package/src/commands/validate.ts

@@ -0,0 +1,112 @@
+import { failure, success } from '@kustodian/core';
+import { validate_dependency_graph } from '@kustodian/generator';
+import { find_project_root, load_project } from '@kustodian/loader';
+
+import { define_command } from '../command.js';
+
+/**
+ * Validate command - validates cluster and template configurations.
+ */
+export const validate_command = define_command({
+  name: 'validate',
+  description: 'Validate cluster and template configurations',
+  options: [
+    {
+      name: 'cluster',
+      short: 'c',
+      description: 'Validate a specific cluster only',
+      type: 'string',
+    },
+    {
+      name: 'project',
+      short: 'p',
+      description: 'Path to project root (defaults to current directory)',
+      type: 'string',
+    },
+  ],
+  handler: async (ctx) => {
+    const project_path = (ctx.options['project'] as string) || process.cwd();
+    const cluster_filter = ctx.options['cluster'] as string | undefined;
+
+    // Find project root
+    console.log('Finding project root...');
+    const root_result = await find_project_root(project_path);
+    if (!root_result.success) {
+      console.error(`Error: ${root_result.error.message}`);
+      console.error(
+        'Make sure you are in a Kustodian project directory with a kustodian.yaml file.',
+      );
+      return root_result;
+    }
+
+    const project_root = root_result.value;
+    console.log(`Project root: ${project_root}`);
+
+    // Load project
+    console.log('Loading project...');
+    const project_result = await load_project(project_root);
+    if (!project_result.success) {
+      console.error(`Validation failed: ${project_result.error.message}`);
+      return project_result;
+    }
+
+    const project = project_result.value;
+
+    // Report templates
+    console.log(`\nTemplates: ${project.templates.length} found`);
+    for (const t of project.templates) {
+      console.log(`  ✓ ${t.template.metadata.name}`);
+    }
+
+    // Report clusters
+    const clusters = cluster_filter
+      ? project.clusters.filter((c) => c.cluster.metadata.name === cluster_filter)
+      : project.clusters;
+
+    if (cluster_filter && clusters.length === 0) {
+      console.error(`\nError: Cluster '${cluster_filter}' not found`);
+      return {
+        success: false as const,
+        error: { code: 'NOT_FOUND', message: `Cluster '${cluster_filter}' not found` },
+      };
+    }
+
+    console.log(`\nClusters: ${clusters.length} found`);
+    for (const c of clusters) {
+      console.log(`  ✓ ${c.cluster.metadata.name}`);
+      if (c.cluster.spec.templates) {
+        for (const t of c.cluster.spec.templates) {
+          const status = t.enabled === false ? '(disabled)' : '';
+          console.log(`      - ${t.name} ${status}`);
+        }
+      }
+    }
+
+    // Validate dependency graph
+    console.log('\nValidating dependency graph...');
+    const templates = project.templates.map((t) => t.template);
+    const graph_result = validate_dependency_graph(templates);
+
+    if (!graph_result.valid) {
+      console.error('\nDependency validation errors:');
+      for (const error of graph_result.errors) {
+        console.error(`  ✗ ${error.message}`);
+      }
+      return failure({
+        code: 'DEPENDENCY_VALIDATION_ERROR',
+        message: 'Dependency validation failed',
+      });
+    }
+
+    // Show deployment order if there are dependencies
+    if (graph_result.topological_order && graph_result.topological_order.length > 0) {
+      console.log(`\nDeployment order (${graph_result.topological_order.length} kustomizations):`);
+      graph_result.topological_order.forEach((id, index) => {
+        console.log(`  ${index + 1}. ${id}`);
+      });
+    }
+
+    console.log('\n✓ All configurations are valid');
+    return success(undefined);
+  },
+});