@caleuche/cli 0.1.3 → 0.1.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @caleuche/cli
 
+## 0.1.4
+
+### Patch Changes
+
+- a471981: CLI now properly handles errors.
+
 ## 0.1.3
 
 ### Patch Changes

package/README.md

@@ -1,103 +1,102 @@
-# Caleuche CLI
-
-Caleuche CLI is a command-line tool for compiling code samples and generating project files from templates. It supports multiple languages and flexible sample definitions, including inline templates and external template files.
-
-## Installation
-
-```sh
-npm install @caleuche/cli
-```
-
-## Usage
-
-```
-che compile <sample-directory|sample-file> <data-file> <output-directory> [options]
-```
-
-- `<sample-directory|sample-file>`: Path to a directory containing a `sample.yaml` or a direct path to a sample YAML file.
-- `<data-file>`: Path to the data file (JSON or YAML).
-- `<output-directory>`: Directory where the generated project will be placed.
-
-### Options
-
-- `-p, --project` Generate project file (e.g., csproj, go.mod, etc.)
-
-## Examples
-
-### 1. Sample with Inline Template
-
-**sample.yaml**
-
-```yaml
-template: |
-  Hello, <%= name %>!
-type: python
-dependencies: []
-input:
-  - name: name
-    type: string
-    required: true
-```
-
-**data.yaml**
-
-```yaml
-name: World
-```
-
-**Command:**
-
-```sh
-che compile ./my-sample ./data.yaml ./output
-```
-
-### 2. Sample with Template File Reference
-
-**Directory structure:**
-
-```
-my-sample/
-  sample.yaml
-  main.py.tmpl
-```
-
-**sample.yaml**
-
-```yaml
-template: main.py.tmpl
-type: python
-dependencies: []
-input:
-  - name: name
-    type: string
-    required: true
-```
-
-**main.py.tmpl**
-
-```python
-print("Hello, <%= name %>!")
-```
-
-**data.yaml**
-
-```yaml
-name: Alice
-```
-
-**Command:**
-
-```sh
-che compile ./my-sample ./data.yaml ./output
-```
-
-## Sample and Data File Structure
-
-- **Sample file**: YAML describing the sample, including the template (inline or file reference), language, dependencies, and input fields.
-
-- **Data file**: JSON or YAML with the data to inject into the sample.
-
-
-## License
-
-MIT
+# Caleuche CLI
+
+Caleuche CLI is a command-line tool for compiling code samples and generating project files from templates. It supports multiple languages and flexible sample definitions, including inline templates and external template files.
+
+## Installation
+
+```sh
+npm install @caleuche/cli
+```
+
+## Usage
+
+```
+che compile <sample-directory|sample-file> <data-file> <output-directory> [options]
+```
+
+- `<sample-directory|sample-file>`: Path to a directory containing a `sample.yaml` or a direct path to a sample YAML file.
+- `<data-file>`: Path to the data file (JSON or YAML).
+- `<output-directory>`: Directory where the generated project will be placed.
+
+### Options
+
+- `-p, --project` Generate project file (e.g., csproj, go.mod, etc.)
+
+## Examples
+
+### 1. Sample with Inline Template
+
+**sample.yaml**
+
+```yaml
+template: |
+  Hello, <%= name %>!
+type: python
+dependencies: []
+input:
+  - name: name
+    type: string
+    required: true
+```
+
+**data.yaml**
+
+```yaml
+name: World
+```
+
+**Command:**
+
+```sh
+che compile ./my-sample ./data.yaml ./output
+```
+
+### 2. Sample with Template File Reference
+
+**Directory structure:**
+
+```
+my-sample/
+  sample.yaml
+  main.py.tmpl
+```
+
+**sample.yaml**
+
+```yaml
+template: main.py.tmpl
+type: python
+dependencies: []
+input:
+  - name: name
+    type: string
+    required: true
+```
+
+**main.py.tmpl**
+
+```python
+print("Hello, <%= name %>!")
+```
+
+**data.yaml**
+
+```yaml
+name: Alice
+```
+
+**Command:**
+
+```sh
+che compile ./my-sample ./data.yaml ./output
+```
+
+## Sample and Data File Structure
+
+- **Sample file**: YAML describing the sample, including the template (inline or file reference), language, dependencies, and input fields.
+
+- **Data file**: JSON or YAML with the data to inject into the sample.
+
+## License
+
+MIT

package/dist/compile.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+const core_1 = require("@caleuche/core");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+function compile(samplePath, dataPath, outputPath, options) {
+    const sampleFilePath = (0, utils_1.resolveSampleFile)(samplePath);
+    if (!fs_1.default.existsSync(sampleFilePath)) {
+        console.error(`Sample file not found: ${sampleFilePath}`);
+        process.exit(1);
+    }
+    const sample = (0, utils_1.parse)(sampleFilePath);
+    if (!sample) {
+        console.error(`Failed to parse sample file: ${sampleFilePath}`);
+        process.exit(1);
+    }
+    sample.template = (0, utils_1.resolveTemplate)(samplePath, sample);
+    const inputData = (0, utils_1.parse)(dataPath);
+    if (!inputData || !(0, utils_1.isObject)(inputData)) {
+        console.error(`Failed to parse input data file: ${dataPath}`);
+        process.exit(1);
+    }
+    const output = (() => {
+        try {
+            return (0, core_1.compileSample)(sample, inputData, {
+                project: options.project || false,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(`Error during compilation: ${error.message}`);
+            }
+            else {
+                console.error("An unknown error occurred during compilation.");
+            }
+            return null;
+        }
+    })();
+    if (!output) {
+        process.exit(1);
+    }
+    if (!(0, utils_1.isObject)(inputData)) {
+        console.error("Input data must be an object.");
+        process.exit(1);
+    }
+    (0, utils_1.createOutputDirectory)(outputPath);
+    for (const { fileName, content } of output.items) {
+        const itemOutputPath = path_1.default.join(outputPath, fileName);
+        fs_1.default.writeFileSync(itemOutputPath, content);
+    }
+}

package/dist/index.js

@@ -1,50 +1,15 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const core_1 = require("@caleuche/core");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const utils_1 = require("./utils");
+const compile_1 = require("./compile");
+const package_json_1 = require("../package.json");
 commander_1.program
     .name("@caleuche/cli")
     .description("Caleuche CLI for compiling samples")
-    .version("1.0.0");
-function compile(samplePath, dataPath, outputPath, options) {
-    const sampleFilePath = (0, utils_1.resolveSampleFile)(samplePath);
-    if (!fs_1.default.existsSync(sampleFilePath)) {
-        console.error(`Sample file not found: ${sampleFilePath}`);
-        process.exit(1);
-    }
-    const sample = (0, utils_1.parse)(sampleFilePath);
-    if (!sample) {
-        console.error(`Failed to parse sample file: ${sampleFilePath}`);
-        process.exit(1);
-    }
-    sample.template = (0, utils_1.resolveTemplate)(samplePath, sample);
-    const inputData = (0, utils_1.parse)(dataPath);
-    if (!inputData || !(0, utils_1.isObject)(inputData)) {
-        console.error(`Failed to parse input data file: ${dataPath}`);
-        process.exit(1);
-    }
-    const output = (0, core_1.compileSample)(sample, inputData, {
-        project: options.project || false,
-    });
-    if (!(0, utils_1.isObject)(inputData)) {
-        console.error("Input data must be an object.");
-        process.exit(1);
-    }
-    (0, utils_1.createOutputDirectory)(outputPath);
-    for (const { fileName, content } of output.items) {
-        const itemOutputPath = path_1.default.join(outputPath, fileName);
-        fs_1.default.writeFileSync(itemOutputPath, content);
-    }
-}
+    .version(package_json_1.version);
 commander_1.program
     .command("compile <sample-directory> <data-file> <output-directory>")
     .option("-p, --project", "Generate project file")
-    .action(compile);
+    .action(compile_1.compile);
 commander_1.program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caleuche/cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "main": "dist/index.js",
   "bin": {
     "che": "dist/index.js"
@@ -11,7 +11,9 @@
     "build:clean": "rimraf dist && tsc",
     "build:clean:watch": "rimraf dist && tsc --watch",
     "clean": "rimraf dist",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "author": "",
   "license": "MIT",
@@ -25,10 +27,8 @@
     "@types/node": "^24.0.0",
     "prettier": "^3.5.3",
     "rimraf": "^6.0.1",
-    "typescript": "^5.8.3"
-  },
-  "publishConfig": {
-    "access": "public"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3"
   },
   "repository": {
     "type": "git",

package/src/compile.ts

@@ -0,0 +1,67 @@
+import { compileSample, Sample } from "@caleuche/core";
+import fs from "fs";
+import path from "path";
+import {
+  createOutputDirectory,
+  isObject,
+  parse,
+  resolveSampleFile,
+  resolveTemplate,
+} from "./utils";
+
+export function compile(
+  samplePath: string,
+  dataPath: string,
+  outputPath: string,
+  options: { project?: boolean },
+) {
+  const sampleFilePath = resolveSampleFile(samplePath);
+  if (!fs.existsSync(sampleFilePath)) {
+    console.error(`Sample file not found: ${sampleFilePath}`);
+    process.exit(1);
+  }
+
+  const sample = parse<Sample>(sampleFilePath);
+  if (!sample) {
+    console.error(`Failed to parse sample file: ${sampleFilePath}`);
+    process.exit(1);
+  }
+  sample.template = resolveTemplate(samplePath, sample);
+
+  const inputData = parse<Record<string, any>>(dataPath);
+  if (!inputData || !isObject(inputData)) {
+    console.error(`Failed to parse input data file: ${dataPath}`);
+    process.exit(1);
+  }
+
+  const output = (() => {
+    try {
+      return compileSample(sample, inputData, {
+        project: options.project || false,
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(`Error during compilation: ${error.message}`);
+      } else {
+        console.error("An unknown error occurred during compilation.");
+      }
+      return null;
+    }
+  })();
+
+  if (!output) {
+    process.exit(1);
+  }
+
+  if (!isObject(inputData)) {
+    console.error("Input data must be an object.");
+    process.exit(1);
+  }
+
+  createOutputDirectory(outputPath);
+
+  for (const { fileName, content } of output.items) {
+    const itemOutputPath = path.join(outputPath, fileName);
+    fs.writeFileSync(itemOutputPath, content);
+  }
+}

package/src/index.ts

@@ -1,67 +1,17 @@
-#!/usr/bin/env node
-
-import { program } from "commander";
-import { compileSample, Sample } from "@caleuche/core";
-import fs from "fs";
-import path from "path";
-import {
-  createOutputDirectory,
-  isObject,
-  parse,
-  resolveSampleFile,
-  resolveTemplate,
-} from "./utils";
-
-program
-  .name("@caleuche/cli")
-  .description("Caleuche CLI for compiling samples")
-  .version("1.0.0");
-
-function compile(
-  samplePath: string,
-  dataPath: string,
-  outputPath: string,
-  options: { project?: boolean },
-) {
-  const sampleFilePath = resolveSampleFile(samplePath);
-  if (!fs.existsSync(sampleFilePath)) {
-    console.error(`Sample file not found: ${sampleFilePath}`);
-    process.exit(1);
-  }
-
-  const sample = parse<Sample>(sampleFilePath);
-  if (!sample) {
-    console.error(`Failed to parse sample file: ${sampleFilePath}`);
-    process.exit(1);
-  }
-  sample.template = resolveTemplate(samplePath, sample);
-
-  const inputData = parse<Record<string, any>>(dataPath);
-  if (!inputData || !isObject(inputData)) {
-    console.error(`Failed to parse input data file: ${dataPath}`);
-    process.exit(1);
-  }
-
-  const output = compileSample(sample, inputData, {
-    project: options.project || false,
-  });
-
-  if (!isObject(inputData)) {
-    console.error("Input data must be an object.");
-    process.exit(1);
-  }
-
-  createOutputDirectory(outputPath);
-
-  for (const { fileName, content } of output.items) {
-    const itemOutputPath = path.join(outputPath, fileName);
-    fs.writeFileSync(itemOutputPath, content);
-  }
-}
-
-program
-  .command("compile <sample-directory> <data-file> <output-directory>")
-  .option("-p, --project", "Generate project file")
-  .action(compile);
-
-program.parse();
+#!/usr/bin/env node
+
+import { program } from "commander";
+import { compile } from "./compile";
+import { version } from "../package.json";
+
+program
+  .name("@caleuche/cli")
+  .description("Caleuche CLI for compiling samples")
+  .version(version);
+
+program
+  .command("compile <sample-directory> <data-file> <output-directory>")
+  .option("-p, --project", "Generate project file")
+  .action(compile);
+
+program.parse();

package/src/utils.ts

@@ -1,50 +1,50 @@
-import { parse as parseYaml } from "yaml";
-import fs from "fs";
-import path from "path";
-import { Sample } from "@caleuche/core";
-
-export function parse<T>(filePath: string): T | null {
-  try {
-    const fileContent = fs.readFileSync(filePath, "utf-8");
-    if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
-      return parseYaml(fileContent) as T;
-    }
-    return JSON.parse(fileContent) as T;
-  } catch (error) {
-    return null;
-  }
-}
-
-export function resolveSampleFile(samplePath: string): string {
-  if (isDirectory(samplePath)) {
-    return path.join(samplePath, "sample.yaml");
-  }
-  return samplePath;
-}
-
-export function isDirectory(path: string): boolean {
-  return fs.existsSync(path) && fs.lstatSync(path).isDirectory();
-}
-
-export function createOutputDirectory(outputPath: string) {
-  if (!fs.existsSync(outputPath)) {
-    fs.mkdirSync(outputPath, { recursive: true });
-  }
-}
-
-export function resolveTemplate(samplePath: string, sample: Sample): string {
-  try {
-    const templatePath = path.join(samplePath, sample.template);
-    if (!fs.existsSync(templatePath)) {
-      return sample.template;
-    }
-    return fs.readFileSync(templatePath, "utf-8");
-  } catch (error) {
-    console.error("Error reading template file.");
-    process.exit(1);
-  }
-}
-
-export function isObject(value: any): value is Record<string, any> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
+import { parse as parseYaml } from "yaml";
+import fs from "fs";
+import path from "path";
+import { Sample } from "@caleuche/core";
+
+export function parse<T>(filePath: string): T | null {
+  try {
+    const fileContent = fs.readFileSync(filePath, "utf-8");
+    if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+      return parseYaml(fileContent) as T;
+    }
+    return JSON.parse(fileContent) as T;
+  } catch (error) {
+    return null;
+  }
+}
+
+export function resolveSampleFile(samplePath: string): string {
+  if (isDirectory(samplePath)) {
+    return path.join(samplePath, "sample.yaml");
+  }
+  return samplePath;
+}
+
+export function isDirectory(path: string): boolean {
+  return fs.existsSync(path) && fs.lstatSync(path).isDirectory();
+}
+
+export function createOutputDirectory(outputPath: string) {
+  if (!fs.existsSync(outputPath)) {
+    fs.mkdirSync(outputPath, { recursive: true });
+  }
+}
+
+export function resolveTemplate(samplePath: string, sample: Sample): string {
+  try {
+    const templatePath = path.join(samplePath, sample.template);
+    if (!fs.existsSync(templatePath)) {
+      return sample.template;
+    }
+    return fs.readFileSync(templatePath, "utf-8");
+  } catch (error) {
+    console.error("Error reading template file.");
+    process.exit(1);
+  }
+}
+
+export function isObject(value: any): value is Record<string, any> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/test/compile.test.ts

@@ -0,0 +1,284 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import path from "path";
+
+vi.mock("fs");
+import fs from "fs";
+const mockFs = vi.mocked(fs);
+
+vi.mock("@caleuche/core");
+import { compileSample, Sample } from "@caleuche/core";
+const mockCompileSample = vi.mocked(compileSample);
+
+vi.mock("../src/utils");
+import {
+  parse,
+  resolveSampleFile,
+  createOutputDirectory,
+  resolveTemplate,
+  isObject,
+} from "../src/utils";
+const mockParse = vi.mocked(parse);
+const mockResolveSampleFile = vi.mocked(resolveSampleFile);
+const mockCreateOutputDirectory = vi.mocked(createOutputDirectory);
+const mockResolveTemplate = vi.mocked(resolveTemplate);
+const mockIsObject = vi.mocked(isObject);
+
+import { compile } from "../src/compile";
+
+describe("compile", () => {
+  let mockExit: any;
+  let mockConsoleError: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+    mockConsoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("error handling", () => {
+    it("should exit when sample file does not exist", () => {
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(false);
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Sample file not found: /path/to/sample.yaml",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("should exit when sample file cannot be parsed", () => {
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(null);
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Failed to parse sample file: /path/to/sample.yaml",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("should exit when data file cannot be parsed", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(null);
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Failed to parse input data file: data.json",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("should exit when data is not an object", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce("not an object");
+      mockIsObject.mockReturnValue(false);
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Failed to parse input data file: data.json",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("should exit when compilation fails", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockImplementation(() => {
+        throw new Error("Compilation error");
+      });
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Error during compilation: Compilation error",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("should handle unknown compilation errors", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockImplementation(() => {
+        throw "Unknown error";
+      });
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "An unknown error occurred during compilation.",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe("successful compilation", () => {
+    it("should compile successfully and write output files", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+      const mockOutput = {
+        items: [
+          { fileName: "sample.js", content: "console.log('test');" },
+          { fileName: "package.json", content: '{"name": "test"}' },
+        ],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockReturnValue(mockOutput);
+      mockCreateOutputDirectory.mockImplementation(() => {});
+      mockFs.writeFileSync.mockImplementation(() => {});
+
+      // This should not throw
+      compile("sample", "data.json", "output", { project: true });
+
+      expect(mockCreateOutputDirectory).toHaveBeenCalledWith("output");
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+        path.join("output", "sample.js"),
+        "console.log('test');",
+      );
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+        path.join("output", "package.json"),
+        '{"name": "test"}',
+      );
+    });
+
+    it("should pass correct options to compileSample", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+      const mockOutput = {
+        items: [{ fileName: "sample.js", content: "console.log('test');" }],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockReturnValue(mockOutput);
+      mockCreateOutputDirectory.mockImplementation(() => {});
+      mockFs.writeFileSync.mockImplementation(() => {});
+
+      compile("sample", "data.json", "output", { project: true });
+
+      expect(mockCompileSample).toHaveBeenCalledWith(
+        { ...mockSample, template: "resolved template" },
+        mockData,
+        { project: true },
+      );
+    });
+
+    it("should default project option to false", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+      const mockOutput = {
+        items: [{ fileName: "sample.js", content: "console.log('test');" }],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockReturnValue(mockOutput);
+      mockCreateOutputDirectory.mockImplementation(() => {});
+      mockFs.writeFileSync.mockImplementation(() => {});
+
+      compile("sample", "data.json", "output", {});
+
+      expect(mockCompileSample).toHaveBeenCalledWith(
+        { ...mockSample, template: "resolved template" },
+        mockData,
+        { project: false },
+      );
+    });
+  });
+});

package/test/utils.test.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import { tmpdir } from "os";
+import {
+  parse,
+  resolveSampleFile,
+  isDirectory,
+  createOutputDirectory,
+  resolveTemplate,
+  isObject,
+} from "../src/utils";
+import { Sample } from "@caleuche/core";
+
+function multiline(strings: TemplateStringsArray, ...values: any[]) {
+  let result = strings[0];
+  for (let i = 0; i < values.length; i++) {
+    result += values[i] + strings[i + 1];
+  }
+
+  const lines = result.split("\n");
+
+  if (lines[0].trim() === "") lines.shift();
+  if (lines[lines.length - 1].trim() === "") lines.pop();
+
+  const nonEmptyLines = lines.filter((line) => line.trim() !== "");
+  if (nonEmptyLines.length === 0) return "";
+
+  const minIndent = Math.min(
+    ...nonEmptyLines.map((line) => line.match(/^ */)?.[0].length || 0),
+  );
+
+  return lines.map((line) => line.slice(minIndent)).join("\n");
+}
+
+describe("utils", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(tmpdir(), "caleuche-cli-test-"));
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("parse", () => {
+    it("should parse valid JSON file", () => {
+      const jsonFile = path.join(tempDir, "test.json");
+      const testData = { name: "test", value: 42 };
+      fs.writeFileSync(jsonFile, JSON.stringify(testData));
+
+      const result = parse(jsonFile);
+      expect(result).toEqual(testData);
+    });
+
+    it("should parse valid YAML file", () => {
+      const yamlFile = path.join(tempDir, "test.yaml");
+      const yamlContent = multiline`
+        name: test
+        value: 42`;
+      fs.writeFileSync(yamlFile, yamlContent);
+
+      const result = parse(yamlFile);
+      expect(result).toEqual({ name: "test", value: 42 });
+    });
+
+    it("should parse valid YML file", () => {
+      const ymlFile = path.join(tempDir, "test.yml");
+      const ymlContent = multiline`
+        name: test
+        value: 42`;
+      fs.writeFileSync(ymlFile, ymlContent);
+
+      const result = parse(ymlFile);
+      expect(result).toEqual({ name: "test", value: 42 });
+    });
+
+    it("should return null for invalid JSON", () => {
+      const invalidJsonFile = path.join(tempDir, "invalid.json");
+      fs.writeFileSync(invalidJsonFile, "{ invalid json }");
+
+      const result = parse(invalidJsonFile);
+      expect(result).toBeNull();
+    });
+
+    it("should return null for invalid YAML", () => {
+      const invalidYamlFile = path.join(tempDir, "invalid.yaml");
+      fs.writeFileSync(
+        invalidYamlFile,
+        multiline`
+        invalid: yaml: structure:
+          broken
+      `,
+      );
+
+      const result = parse(invalidYamlFile);
+      expect(result).toBeNull();
+    });
+
+    it("should return null for non-existent file", () => {
+      const nonExistentFile = path.join(tempDir, "nonexistent.json");
+      const result = parse(nonExistentFile);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("resolveSampleFile", () => {
+    it("should return the file path if it's a file", () => {
+      const filePath = path.join(tempDir, "sample.yaml");
+      fs.writeFileSync(filePath, "test content");
+
+      const result = resolveSampleFile(filePath);
+      expect(result).toBe(filePath);
+    });
+
+    it("should return sample.yaml path if input is a directory", () => {
+      const dirPath = path.join(tempDir, "sample-dir");
+      fs.mkdirSync(dirPath);
+
+      const result = resolveSampleFile(dirPath);
+      expect(result).toBe(path.join(dirPath, "sample.yaml"));
+    });
+
+    it("should return the path as-is if it doesn't exist", () => {
+      const nonExistentPath = path.join(tempDir, "nonexistent");
+
+      const result = resolveSampleFile(nonExistentPath);
+      expect(result).toBe(nonExistentPath);
+    });
+  });
+
+  describe("isDirectory", () => {
+    it("should return true for directories", () => {
+      const dirPath = path.join(tempDir, "testdir");
+      fs.mkdirSync(dirPath);
+
+      expect(isDirectory(dirPath)).toBe(true);
+    });
+
+    it("should return false for files", () => {
+      const filePath = path.join(tempDir, "testfile.txt");
+      fs.writeFileSync(filePath, "test content");
+
+      expect(isDirectory(filePath)).toBe(false);
+    });
+
+    it("should return false for non-existent paths", () => {
+      const nonExistentPath = path.join(tempDir, "nonexistent");
+      expect(isDirectory(nonExistentPath)).toBe(false);
+    });
+  });
+
+  describe("createOutputDirectory", () => {
+    it("should create directory if it doesn't exist", () => {
+      const newDir = path.join(tempDir, "new-output");
+      expect(fs.existsSync(newDir)).toBe(false);
+
+      createOutputDirectory(newDir);
+      expect(fs.existsSync(newDir)).toBe(true);
+      expect(fs.lstatSync(newDir).isDirectory()).toBe(true);
+    });
+
+    it("should create nested directories", () => {
+      const nestedDir = path.join(tempDir, "nested", "output", "dir");
+      expect(fs.existsSync(nestedDir)).toBe(false);
+
+      createOutputDirectory(nestedDir);
+      expect(fs.existsSync(nestedDir)).toBe(true);
+      expect(fs.lstatSync(nestedDir).isDirectory()).toBe(true);
+    });
+
+    it("should not throw if directory already exists", () => {
+      const existingDir = path.join(tempDir, "existing");
+      fs.mkdirSync(existingDir);
+
+      expect(() => createOutputDirectory(existingDir)).not.toThrow();
+    });
+  });
+
+  describe("resolveTemplate", () => {
+    it("should read template file from sample directory", () => {
+      const sampleDir = path.join(tempDir, "sample");
+      fs.mkdirSync(sampleDir);
+
+      const templateContent = "Hello, <%= name %>!";
+      const templateFile = path.join(sampleDir, "template.txt");
+      fs.writeFileSync(templateFile, templateContent);
+
+      const sample: Sample = {
+        template: "template.txt",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      const result = resolveTemplate(sampleDir, sample);
+      expect(result).toBe(templateContent);
+    });
+
+    it("should return template string if file doesn't exist", () => {
+      const sampleDir = path.join(tempDir, "sample");
+      fs.mkdirSync(sampleDir);
+
+      const sample: Sample = {
+        template: "inline template content",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      const result = resolveTemplate(sampleDir, sample);
+      expect(result).toBe("inline template content");
+    });
+
+    it("should handle template files with various extensions", () => {
+      const sampleDir = path.join(tempDir, "sample");
+      fs.mkdirSync(sampleDir);
+
+      const templateContent = "function test() { return 'hello'; }";
+      const templateFile = path.join(sampleDir, "template.js");
+      fs.writeFileSync(templateFile, templateContent);
+
+      const sample: Sample = {
+        template: "template.js",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      const result = resolveTemplate(sampleDir, sample);
+      expect(result).toBe(templateContent);
+    });
+  });
+
+  describe("isObject", () => {
+    it("should return true for plain objects", () => {
+      expect(isObject({})).toBe(true);
+      expect(isObject({ a: 1, b: 2 })).toBe(true);
+      expect(isObject({ nested: { object: true } })).toBe(true);
+    });
+
+    it("should return false for arrays", () => {
+      expect(isObject([])).toBe(false);
+      expect(isObject([1, 2, 3])).toBe(false);
+      expect(isObject([{}])).toBe(false);
+    });
+
+    it("should return false for null", () => {
+      expect(isObject(null)).toBe(false);
+    });
+
+    it("should return false for primitives", () => {
+      expect(isObject("string")).toBe(false);
+      expect(isObject(42)).toBe(false);
+      expect(isObject(true)).toBe(false);
+      expect(isObject(undefined)).toBe(false);
+    });
+
+    it("should return false for functions", () => {
+      expect(isObject(() => {})).toBe(false);
+      expect(isObject(function () {})).toBe(false);
+    });
+  });
+});

package/tsconfig.json

@@ -1,11 +1,12 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "commonjs",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true
-  },
-  "include": ["src/**/*"]
-}
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"]
+}