@intentius/chant 0.0.1

package/src/cli/commands/import.test.ts

@@ -0,0 +1,379 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { importCommand, type ImportOptions } from "./import";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("importCommand", () => {
+  let testDir: string;
+  let templateDir: string;
+  let outputDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-import-test-${Date.now()}-${Math.random()}`);
+    templateDir = join(testDir, "templates");
+    outputDir = join(testDir, "output");
+    await mkdir(templateDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("imports CloudFormation template", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Description: "Test CloudFormation template",
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: "my-bucket",
+            VersioningConfiguration: {
+              Status: "Enabled",
+            },
+          },
+        },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const options: ImportOptions = {
+      templatePath,
+      output: outputDir,
+    };
+
+    const result = await importCommand(options);
+
+    expect(result.success).toBe(true);
+    expect(result.lexicon).toBe("aws");
+    expect(result.generatedFiles.length).toBeGreaterThan(0);
+    expect(existsSync(outputDir)).toBe(true);
+  });
+
+  test("imports CloudFormation template with multiple resources", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        MyQueue: {
+          Type: "AWS::SQS::Queue",
+          Properties: {
+            QueueName: "my-queue",
+          },
+        },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const options: ImportOptions = {
+      templatePath,
+      output: outputDir,
+    };
+
+    const result = await importCommand(options);
+
+    expect(result.success).toBe(true);
+    expect(result.lexicon).toBe("aws");
+    expect(result.generatedFiles.length).toBeGreaterThan(0);
+  });
+
+  test("auto-detects AWS lexicon with AWSTemplateFormatVersion", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Parameters: { Env: { Type: "String" } },
+      Resources: {},
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+    });
+
+    expect(result.lexicon).toBe("aws");
+  });
+
+  test("auto-detects AWS lexicon with AWS:: resource types", async () => {
+    const template = {
+      Resources: {
+        Bucket: {
+          Type: "AWS::S3::Bucket",
+        },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+    });
+
+    expect(result.lexicon).toBe("aws");
+  });
+
+  test("fails for unknown lexicon", async () => {
+    const template = {
+      version: "1.0",
+      unknownField: {},
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("Could not detect");
+  });
+
+  test("fails for non-existent template", async () => {
+    const result = await importCommand({
+      templatePath: "/nonexistent/template.json",
+      output: outputDir,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("not found");
+  });
+
+  test("uses default output directory", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        Bucket: { Type: "AWS::S3::Bucket", Properties: {} },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    // Change to test dir so default ./infra/ is relative to it
+    const originalCwd = process.cwd();
+    process.chdir(testDir);
+
+    try {
+      const result = await importCommand({ templatePath });
+
+      expect(result.success).toBe(true);
+      expect(existsSync(join(testDir, "infra"))).toBe(true);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  test("generates TypeScript with correct syntax", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        DataBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: "data-bucket",
+            VersioningConfiguration: {
+              Status: "Enabled",
+            },
+          },
+        },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+    });
+
+    expect(result.success).toBe(true);
+
+    // Find a generated file and check content
+    const mainFile = result.generatedFiles.find((f) => f.endsWith(".ts"));
+    expect(mainFile).toBeDefined();
+
+    const content = readFileSync(join(outputDir, mainFile!), "utf-8");
+    expect(content).toContain("import {");
+    expect(content).toContain("export const");
+    expect(content).toContain("Bucket");
+  });
+
+  test("warns about non-empty output directory", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        Bucket: { Type: "AWS::S3::Bucket", Properties: {} },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    // Create output dir with existing file
+    await mkdir(outputDir, { recursive: true });
+    await writeFile(join(outputDir, "existing.ts"), "// existing");
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.warnings.some((w) => w.includes("not empty"))).toBe(true);
+  });
+
+  test("force overwrites existing files", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        Bucket: { Type: "AWS::S3::Bucket", Properties: {} },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    // Create output dir with existing file
+    await mkdir(outputDir, { recursive: true });
+    await writeFile(join(outputDir, "main.ts"), "// old content");
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+      force: true,
+    });
+
+    expect(result.success).toBe(true);
+
+    // Check that main.ts was overwritten
+    const content = readFileSync(join(outputDir, "main.ts"), "utf-8");
+    expect(content).not.toContain("old content");
+    expect(content).toContain("Bucket");
+  });
+
+  test("organizes resources by category for large templates", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        Bucket1: { Type: "AWS::S3::Bucket", Properties: {} },
+        Bucket2: { Type: "AWS::S3::Bucket", Properties: {} },
+        Queue1: { Type: "AWS::SQS::Queue", Properties: {} },
+        LB1: { Type: "AWS::ElasticLoadBalancingV2::LoadBalancer", Properties: {} },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+    });
+
+    expect(result.success).toBe(true);
+    // With 4 resources, should create separate files
+    expect(result.generatedFiles.length).toBeGreaterThan(1);
+  });
+
+  test("creates index.ts for organized imports", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        Bucket1: { Type: "AWS::S3::Bucket", Properties: {} },
+        Bucket2: { Type: "AWS::S3::Bucket", Properties: {} },
+        Lambda1: { Type: "AWS::Lambda::Function", Properties: {} },
+        LB1: { Type: "AWS::ElasticLoadBalancingV2::LoadBalancer", Properties: {} },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+    });
+
+    expect(result.success).toBe(true);
+
+    if (result.generatedFiles.includes("index.ts")) {
+      const indexContent = readFileSync(join(outputDir, "index.ts"), "utf-8");
+      expect(indexContent).toContain("export {");
+    }
+  });
+
+  test("handles template with parameters", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Parameters: {
+        Environment: { Type: "String" },
+        BucketName: { Type: "String" },
+      },
+      Resources: {
+        MyBucket: {
+          Type: "AWS::S3::Bucket",
+          Properties: {
+            BucketName: { Ref: "BucketName" },
+          },
+        },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+    });
+
+    expect(result.success).toBe(true);
+
+    // Find main file and check for Parameter imports
+    const files = result.generatedFiles.filter((f) => f.endsWith(".ts"));
+    let hasParameter = false;
+    for (const file of files) {
+      const content = readFileSync(join(outputDir, file), "utf-8");
+      if (content.includes("Parameter")) {
+        hasParameter = true;
+        break;
+      }
+    }
+    expect(hasParameter).toBe(true);
+  });
+
+  test("prints generated files on success", async () => {
+    const template = {
+      AWSTemplateFormatVersion: "2010-09-09",
+      Resources: {
+        Bucket: { Type: "AWS::S3::Bucket", Properties: {} },
+      },
+    };
+
+    const templatePath = join(templateDir, "template.json");
+    await writeFile(templatePath, JSON.stringify(template));
+
+    const result = await importCommand({
+      templatePath,
+      output: outputDir,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.generatedFiles.length).toBeGreaterThan(0);
+    // Each file should be a .ts file
+    for (const file of result.generatedFiles) {
+      expect(file.endsWith(".ts")).toBe(true);
+    }
+  });
+});

package/src/cli/commands/import.ts

@@ -0,0 +1,335 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, resolve, basename } from "path";
+import { formatSuccess, formatWarning, formatError } from "../format";
+import type { TemplateIR, ResourceIR, TemplateParser } from "../../import/parser";
+import type { GeneratedFile, TypeScriptGenerator } from "../../import/generator";
+import { loadPlugins, resolveProjectLexicons } from "../plugins";
+import type { LexiconPlugin } from "../../lexicon";
+
+/**
+ * Import command options
+ */
+export interface ImportOptions {
+  /** Path to template file */
+  templatePath: string;
+  /** Output directory (defaults to ./infra/) */
+  output?: string;
+  /** Force overwrite existing files */
+  force?: boolean;
+}
+
+/**
+ * Import command result
+ */
+export interface ImportResult {
+  /** Whether import succeeded */
+  success: boolean;
+  /** Generated files */
+  generatedFiles: string[];
+  /** Warning messages */
+  warnings: string[];
+  /** Error message if failed */
+  error?: string;
+  /** Detected lexicon */
+  lexicon?: string;
+}
+
+/**
+ * Resource category for organizing files
+ */
+type ResourceCategory = "storage" | "compute" | "network" | "other";
+
+/**
+ * Detect which plugin handles a template by asking each plugin.
+ * @param data - Parsed JSON object
+ * @param plugins - Loaded lexicon plugins
+ * @returns The matching plugin, or undefined if none match
+ */
+function detectPlugin(data: unknown, plugins: LexiconPlugin[]): LexiconPlugin | undefined {
+  for (const plugin of plugins) {
+    if (plugin.detectTemplate?.(data)) {
+      return plugin;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Get the category for a resource type
+ */
+function getResourceCategory(type: string): ResourceCategory {
+  const typeLower = type.toLowerCase();
+
+  // Storage resources
+  if (typeLower.includes("bucket") || typeLower.includes("storage") || typeLower.includes("queue")) {
+    return "storage";
+  }
+
+  // Compute resources
+  if (typeLower.includes("container") || typeLower.includes("service") || typeLower.includes("function")) {
+    return "compute";
+  }
+
+  // Network resources
+  if (typeLower.includes("loadbalancer") || typeLower.includes("lb") || typeLower.includes("network")) {
+    return "network";
+  }
+
+  return "other";
+}
+
+/**
+ * Organize resources into categories
+ */
+function organizeByCategory(ir: TemplateIR): Map<ResourceCategory, ResourceIR[]> {
+  const categories = new Map<ResourceCategory, ResourceIR[]>();
+
+  for (const resource of ir.resources) {
+    const category = getResourceCategory(resource.type);
+    const existing = categories.get(category) ?? [];
+    existing.push(resource);
+    categories.set(category, existing);
+  }
+
+  return categories;
+}
+
+/**
+ * Generate organized files with separate modules
+ */
+function generateOrganizedFiles(
+  ir: TemplateIR,
+  generator: TypeScriptGenerator,
+): GeneratedFile[] {
+  const files: GeneratedFile[] = [];
+  const categories = organizeByCategory(ir);
+  const exports: string[] = [];
+
+  // If all resources fit in one file, just generate main.ts
+  if (ir.resources.length <= 3) {
+    return generator.generate(ir);
+  }
+
+  // Generate files for each category
+  for (const [category, resources] of categories) {
+    if (resources.length === 0) continue;
+
+    const categoryIr: TemplateIR = {
+      parameters: category === "other" ? ir.parameters : [],
+      resources,
+    };
+
+    const generated = generator.generate(categoryIr);
+    const fileName = `${category}.ts`;
+
+    files.push({
+      path: fileName,
+      content: generated[0].content,
+    });
+
+    // Track exports
+    for (const resource of resources) {
+      const varName = resource.logicalId.charAt(0).toLowerCase() + resource.logicalId.slice(1);
+      exports.push(`export { ${varName} } from "./${category}";`);
+    }
+  }
+
+  // Handle parameters separately if not included in other category
+  if (ir.parameters.length > 0 && !categories.has("other")) {
+    const paramsIr: TemplateIR = {
+      parameters: ir.parameters,
+      resources: [],
+    };
+    const generated = generator.generate(paramsIr);
+    files.push({
+      path: "parameters.ts",
+      content: generated[0].content,
+    });
+
+    for (const param of ir.parameters) {
+      const varName = param.name.charAt(0).toLowerCase() + param.name.slice(1);
+      exports.push(`export { ${varName} } from "./parameters";`);
+    }
+  }
+
+  // Generate index.ts
+  if (exports.length > 0) {
+    files.push({
+      path: "index.ts",
+      content: exports.join("\n") + "\n",
+    });
+  }
+
+  return files;
+}
+
+/**
+ * Execute the import command
+ */
+export async function importCommand(options: ImportOptions): Promise<ImportResult> {
+  const templatePath = resolve(options.templatePath);
+  const outputDir = resolve(options.output ?? "./infra/");
+  const generatedFiles: string[] = [];
+  const warnings: string[] = [];
+
+  // Check if template exists
+  if (!existsSync(templatePath)) {
+    return {
+      success: false,
+      generatedFiles: [],
+      warnings: [],
+      error: `Template file not found: ${templatePath}`,
+    };
+  }
+
+  // Read template content
+  let content: string;
+  try {
+    content = readFileSync(templatePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      generatedFiles: [],
+      warnings: [],
+      error: `Failed to read template: ${err}`,
+    };
+  }
+
+  // Load plugins and detect lexicon
+  let data: unknown;
+  try {
+    data = JSON.parse(content);
+  } catch {
+    return {
+      success: false,
+      generatedFiles: [],
+      warnings: [],
+      error: "Template is not valid JSON.",
+    };
+  }
+
+  // Load plugins from project config, falling back to all installed lexicons
+  let plugins: LexiconPlugin[];
+  try {
+    const lexiconNames = await resolveProjectLexicons(resolve("."));
+    plugins = await loadPlugins(lexiconNames);
+  } catch {
+    plugins = [];
+  }
+
+  // If no plugins resolved (no config, no source files), try common lexicons
+  if (plugins.length === 0) {
+    try {
+      plugins = await loadPlugins(["aws"]);
+    } catch {
+      // No lexicons available at all
+    }
+  }
+
+  const plugin = detectPlugin(data, plugins);
+  if (!plugin) {
+    return {
+      success: false,
+      generatedFiles: [],
+      warnings: [],
+      error: "Could not detect template lexicon. No installed lexicon recognizes this template.",
+    };
+  }
+
+  const lexicon = plugin.name;
+
+  if (!plugin.templateParser || !plugin.templateGenerator) {
+    return {
+      success: false,
+      generatedFiles: [],
+      warnings: [],
+      error: `Lexicon "${plugin.name}" does not support template import.`,
+      lexicon,
+    };
+  }
+
+  // Parse template
+  let ir: TemplateIR;
+  try {
+    const parser = plugin.templateParser();
+    ir = parser.parse(content);
+  } catch (err) {
+    return {
+      success: false,
+      generatedFiles: [],
+      warnings: [],
+      error: `Failed to parse template: ${err}`,
+    };
+  }
+
+  const generator = plugin.templateGenerator();
+
+  // Check output directory
+  if (existsSync(outputDir) && !options.force) {
+    const files = require("fs").readdirSync(outputDir);
+    if (files.length > 0) {
+      warnings.push(`Output directory ${outputDir} is not empty. Use --force to overwrite.`);
+    }
+  }
+
+  // Create output directory
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Generate files
+  const files = generateOrganizedFiles(ir, generator);
+
+  // Write files
+  for (const file of files) {
+    const filePath = join(outputDir, file.path);
+    const dirPath = join(outputDir, file.path.split("/").slice(0, -1).join("/"));
+
+    if (dirPath && !existsSync(dirPath)) {
+      mkdirSync(dirPath, { recursive: true });
+    }
+
+    // Check for existing file
+    if (existsSync(filePath) && !options.force) {
+      warnings.push(`File ${file.path} already exists, skipping`);
+      continue;
+    }
+
+    writeFileSync(filePath, file.content);
+    generatedFiles.push(file.path);
+  }
+
+  return {
+    success: true,
+    generatedFiles,
+    warnings,
+    lexicon,
+  };
+}
+
+/**
+ * Print import result
+ */
+export function printImportResult(result: ImportResult): void {
+  if (!result.success) {
+    console.error(formatError({ message: result.error ?? "Import failed" }));
+    return;
+  }
+
+  for (const warning of result.warnings) {
+    console.error(formatWarning({ message: warning }));
+  }
+
+  if (result.lexicon) {
+    console.log(`Detected lexicon: ${result.lexicon}`);
+  }
+
+  if (result.generatedFiles.length > 0) {
+    console.log(formatSuccess("Generated files:"));
+    for (const file of result.generatedFiles) {
+      console.log(`  ${file}`);
+    }
+  } else {
+    console.log("No files generated.");
+  }
+}