docvars 0.3.0

package/README.md

@@ -0,0 +1,209 @@
+# docvars
+
+A CLI tool to replace `{{variables}}` in document templates with values from a YAML file.
+
+Supports any text-based files: Markdown, HTML, TXT, and more.
+
+## Installation
+
+```bash
+npm install -g docvars
+```
+
+Or use with npx:
+
+```bash
+npx docvars ./templates ./output
+```
+
+## Usage
+
+```bash
+docvars <input> <output> [options]
+```
+
+### Arguments
+
+| Argument | Description                               |
+| -------- | ----------------------------------------- |
+| `input`  | Input directory containing template files |
+| `output` | Output directory for processed files      |
+
+### Options
+
+| Option          | Default          | Description                                         |
+| --------------- | ---------------- | --------------------------------------------------- |
+| `--vars`        | `variables.yaml` | Path to the variables YAML file                     |
+| `--include`     | -                | Glob pattern to include specific files              |
+| `--exclude`     | -                | Glob pattern to exclude specific files              |
+| `--watch`       | `false`          | Watch for file changes and rebuild automatically    |
+| `--rename-from` | -                | Variable name to rename from (use with --rename-to) |
+| `--rename-to`   | -                | Variable name to rename to (use with --rename-from) |
+| `--list-vars`   | `false`          | List all variables used in templates                |
+| `--dry-run`     | `false`          | Preview changes without writing files               |
+
+## Examples
+
+### Basic usage
+
+```bash
+docvars ./templates ./output
+```
+
+### Custom variables file
+
+```bash
+docvars ./templates ./output --vars production.yaml
+```
+
+### Filter files
+
+```bash
+# Include only files matching pattern
+docvars ./templates ./output --include "api-*.md"
+
+# Exclude files matching pattern
+docvars ./templates ./output --exclude "draft-*.md"
+```
+
+### Watch mode
+
+```bash
+docvars ./templates ./output --watch
+```
+
+This will watch for changes in:
+- Template files in the input directory
+- The variables YAML file
+
+When changes are detected, templates are automatically rebuilt.
+
+### Rename variables
+
+Rename a variable across all template files and the variables YAML file:
+
+```bash
+# Simple rename
+docvars ./templates ./output --rename-from "name" --rename-to "title"
+
+# Rename nested variable
+docvars ./templates ./output --rename-from "database.host" --rename-to "db.host"
+```
+
+This updates:
+- All `{{oldName}}` occurrences in template files → `{{newName}}`
+- The key in the variables YAML file
+
+### List variables
+
+Show all variables used in templates and their status:
+
+```bash
+docvars ./templates ./output --list-vars
+```
+
+Output:
+
+```
+Variables used in templates:
+
+  app.name (✓)
+    → README.md
+    → config.md
+  api.key (✗ undefined)
+    → config.md
+
+Unused variables (defined but not used):
+
+  deprecated.setting
+```
+
+### Dry run
+
+Preview what files would be created or updated without actually writing them:
+
+```bash
+docvars ./templates ./output --dry-run
+```
+
+Output:
+
+```
+Dry run - no files written
+
+Files to create (1):
+  + config.md
+
+Files to update (2):
+  ~ README.md
+  ~ api.md
+
+Files unchanged (1):
+  = changelog.md
+
+Summary: 1 create, 2 update, 1 unchanged
+```
+
+## Template Syntax
+
+Use `{{variableName}}` syntax in your template files:
+
+**Template (templates/hello.md):**
+```markdown
+# Hello {{name}}
+
+Welcome to {{project}}!
+```
+
+**Variables (variables.yaml):**
+```yaml
+name: World
+project: My Project
+```
+
+**Output (output/hello.md):**
+```markdown
+# Hello World
+
+Welcome to My Project!
+```
+
+### Nested Variables
+
+You can use nested objects in your variables file and access them with dot notation:
+
+**Template:**
+```markdown
+# {{app.name}}
+
+Database: {{database.host}}:{{database.port}}
+```
+
+**Variables (variables.yaml):**
+```yaml
+app:
+  name: My App
+
+database:
+  host: localhost
+  port: 5432
+```
+
+**Output:**
+```markdown
+# My App
+
+Database: localhost:5432
+```
+
+## Error Handling
+
+| Case                        | Behavior                                            |
+| --------------------------- | --------------------------------------------------- |
+| Undefined variable          | Warning is displayed, variable syntax is kept as-is |
+| Same input/output directory | Error and exit                                      |
+| Variables file not found    | Error and exit                                      |
+
+## License
+
+MIT

package/dist/application/use-cases/dry-run.d.ts

@@ -0,0 +1,12 @@
+import type { CliOptions } from "../../shared/types.js";
+export interface FileChange {
+    relativePath: string;
+    outputPath: string;
+    status: "create" | "update" | "unchanged";
+    undefinedVariables: string[];
+}
+export interface DryRunResult {
+    changes: FileChange[];
+    warnings: string[];
+}
+export declare function dryRun(options: CliOptions): Promise<DryRunResult>;

package/dist/application/use-cases/dry-run.js

@@ -0,0 +1,45 @@
+import { resolve, relative, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { SameInputOutputError } from "../../shared/errors.js";
+import { loadVariables } from "../../infrastructure/repositories/variables-repository.js";
+import { readTemplate } from "../../infrastructure/repositories/template-repository.js";
+import { scanTemplates } from "../../infrastructure/services/file-scanner.js";
+import { renderTemplate } from "../../domain/services/template-renderer.js";
+export async function dryRun(options) {
+    const inputDir = resolve(options.input);
+    const outputDir = resolve(options.output);
+    if (inputDir === outputDir) {
+        throw new SameInputOutputError();
+    }
+    const variables = loadVariables(options.vars);
+    const files = await scanTemplates(inputDir, {
+        include: options.include,
+        exclude: options.exclude,
+    });
+    const changes = [];
+    const warnings = [];
+    for (const filePath of files) {
+        const template = readTemplate(filePath);
+        const result = renderTemplate(template.content, variables);
+        const relativePath = relative(inputDir, filePath);
+        const outputPath = join(outputDir, relativePath);
+        let status;
+        if (!existsSync(outputPath)) {
+            status = "create";
+        }
+        else {
+            const existingContent = readFileSync(outputPath, "utf-8");
+            status = existingContent === result.content ? "unchanged" : "update";
+        }
+        changes.push({
+            relativePath,
+            outputPath,
+            status,
+            undefinedVariables: result.undefinedVariables,
+        });
+        for (const varName of result.undefinedVariables) {
+            warnings.push(`Warning: undefined variable "{{${varName}}}" in ${relativePath}`);
+        }
+    }
+    return { changes, warnings };
+}

package/dist/application/use-cases/list-variables.d.ts

@@ -0,0 +1,16 @@
+export interface ListVariablesOptions {
+    input: string;
+    vars: string;
+    include?: string;
+    exclude?: string;
+}
+export interface VariableUsage {
+    name: string;
+    files: string[];
+    isDefined: boolean;
+}
+export interface ListVariablesResult {
+    variables: VariableUsage[];
+    unusedVariables: string[];
+}
+export declare function listVariables(options: ListVariablesOptions): Promise<ListVariablesResult>;

package/dist/application/use-cases/list-variables.js

@@ -0,0 +1,48 @@
+import { readFileSync, existsSync } from "node:fs";
+import { relative } from "node:path";
+import { scanTemplates } from "../../infrastructure/services/file-scanner.js";
+import { loadVariables } from "../../infrastructure/repositories/variables-repository.js";
+import { VariablesFileNotFoundError } from "../../shared/errors.js";
+const VARIABLE_PATTERN = /\{\{([\w.]+)\}\}/g;
+export async function listVariables(options) {
+    const { input, vars, include, exclude } = options;
+    if (!existsSync(vars)) {
+        throw new VariablesFileNotFoundError(vars);
+    }
+    // Load defined variables
+    const definedVars = loadVariables(vars);
+    const definedVarNames = new Set(Object.keys(definedVars));
+    // Scan templates and extract variable usage
+    const templateFiles = await scanTemplates(input, { include, exclude });
+    const variableUsageMap = new Map();
+    for (const file of templateFiles) {
+        const content = readFileSync(file, "utf-8");
+        const relativePath = relative(input, file);
+        let match;
+        while ((match = VARIABLE_PATTERN.exec(content)) !== null) {
+            const varName = match[1];
+            if (!variableUsageMap.has(varName)) {
+                variableUsageMap.set(varName, new Set());
+            }
+            variableUsageMap.get(varName).add(relativePath);
+        }
+    }
+    // Build result
+    const usedVarNames = new Set(variableUsageMap.keys());
+    const variables = [];
+    // Variables used in templates
+    for (const [name, files] of variableUsageMap) {
+        variables.push({
+            name,
+            files: Array.from(files).sort(),
+            isDefined: definedVarNames.has(name),
+        });
+    }
+    // Sort by name
+    variables.sort((a, b) => a.name.localeCompare(b.name));
+    // Find unused variables (defined but not used)
+    const unusedVariables = Array.from(definedVarNames)
+        .filter((name) => !usedVarNames.has(name))
+        .sort();
+    return { variables, unusedVariables };
+}

package/dist/application/use-cases/process-templates.d.ts

@@ -0,0 +1,2 @@
+import type { CliOptions, ProcessResult } from "../../shared/types.js";
+export declare function processTemplates(options: CliOptions): Promise<ProcessResult>;

package/dist/application/use-cases/process-templates.js

@@ -0,0 +1,32 @@
+import { resolve, relative, join } from "node:path";
+import { SameInputOutputError } from "../../shared/errors.js";
+import { loadVariables } from "../../infrastructure/repositories/variables-repository.js";
+import { readTemplate, writeTemplate } from "../../infrastructure/repositories/template-repository.js";
+import { scanTemplates } from "../../infrastructure/services/file-scanner.js";
+import { renderTemplate } from "../../domain/services/template-renderer.js";
+export async function processTemplates(options) {
+    const inputDir = resolve(options.input);
+    const outputDir = resolve(options.output);
+    if (inputDir === outputDir) {
+        throw new SameInputOutputError();
+    }
+    const variables = loadVariables(options.vars);
+    const files = await scanTemplates(inputDir, {
+        include: options.include,
+        exclude: options.exclude,
+    });
+    const processedFiles = [];
+    const warnings = [];
+    for (const filePath of files) {
+        const template = readTemplate(filePath);
+        const result = renderTemplate(template.content, variables);
+        const relativePath = relative(inputDir, filePath);
+        const outputPath = join(outputDir, relativePath);
+        writeTemplate(outputPath, result.content);
+        processedFiles.push(relativePath);
+        for (const varName of result.undefinedVariables) {
+            warnings.push(`Warning: undefined variable "{{${varName}}}" in ${relativePath}`);
+        }
+    }
+    return { processedFiles, warnings };
+}

package/dist/application/use-cases/rename-variable.d.ts

@@ -0,0 +1,13 @@
+export interface RenameOptions {
+    input: string;
+    vars: string;
+    from: string;
+    to: string;
+    include?: string;
+    exclude?: string;
+}
+export interface RenameResult {
+    renamedInFiles: string[];
+    renamedInVars: boolean;
+}
+export declare function renameVariable(options: RenameOptions): Promise<RenameResult>;

package/dist/application/use-cases/rename-variable.js

@@ -0,0 +1,80 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { parse, stringify } from "yaml";
+import { scanTemplates } from "../../infrastructure/services/file-scanner.js";
+import { VariablesFileNotFoundError } from "../../shared/errors.js";
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export async function renameVariable(options) {
+    const { input, vars, from, to, include, exclude } = options;
+    if (!existsSync(vars)) {
+        throw new VariablesFileNotFoundError(vars);
+    }
+    const result = {
+        renamedInFiles: [],
+        renamedInVars: false,
+    };
+    // Rename in template files
+    const templateFiles = await scanTemplates(input, { include, exclude });
+    const pattern = new RegExp(`\\{\\{${escapeRegex(from)}(\\}\\}|\\|)`, "g");
+    for (const file of templateFiles) {
+        const content = readFileSync(file, "utf-8");
+        const newContent = content.replace(pattern, `{{${to}$1`);
+        if (content !== newContent) {
+            writeFileSync(file, newContent, "utf-8");
+            result.renamedInFiles.push(file);
+        }
+    }
+    // Rename in variables file
+    const varsContent = readFileSync(vars, "utf-8");
+    const varsData = parse(varsContent);
+    if (renameKeyInObject(varsData, from, to)) {
+        writeFileSync(vars, stringify(varsData), "utf-8");
+        result.renamedInVars = true;
+    }
+    return result;
+}
+function renameKeyInObject(obj, from, to) {
+    const fromParts = from.split(".");
+    const toParts = to.split(".");
+    // Simple key rename (no dots)
+    if (fromParts.length === 1 && toParts.length === 1) {
+        if (from in obj) {
+            obj[to] = obj[from];
+            delete obj[from];
+            return true;
+        }
+        return false;
+    }
+    // Nested key rename
+    const fromParent = getNestedParent(obj, fromParts);
+    const fromKey = fromParts[fromParts.length - 1];
+    if (!fromParent || !(fromKey in fromParent)) {
+        return false;
+    }
+    const value = fromParent[fromKey];
+    delete fromParent[fromKey];
+    // Create target path if needed
+    const toParentParts = toParts.slice(0, -1);
+    const toKey = toParts[toParts.length - 1];
+    let toParent = obj;
+    for (const part of toParentParts) {
+        if (!(part in toParent)) {
+            toParent[part] = {};
+        }
+        toParent = toParent[part];
+    }
+    toParent[toKey] = value;
+    return true;
+}
+function getNestedParent(obj, parts) {
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!(part in current) || typeof current[part] !== "object") {
+            return null;
+        }
+        current = current[part];
+    }
+    return current;
+}

package/dist/domain/entities/template.d.ts

@@ -0,0 +1,5 @@
+export declare class Template {
+    readonly path: string;
+    readonly content: string;
+    constructor(path: string, content: string);
+}

package/dist/domain/entities/template.js

@@ -0,0 +1,8 @@
+export class Template {
+    path;
+    content;
+    constructor(path, content) {
+        this.path = path;
+        this.content = content;
+    }
+}

package/dist/domain/services/template-renderer.d.ts

@@ -0,0 +1,3 @@
+import type { Variables } from "../value-objects/variables.js";
+import type { RenderResult } from "../../shared/types.js";
+export declare function renderTemplate(content: string, variables: Variables): RenderResult;

package/dist/domain/services/template-renderer.js

@@ -0,0 +1,15 @@
+const VARIABLE_PATTERN = /\{\{([\w.]+)\}\}/g;
+export function renderTemplate(content, variables) {
+    const undefinedVariables = [];
+    const renderedContent = content.replace(VARIABLE_PATTERN, (match, varName) => {
+        if (varName in variables) {
+            return variables[varName];
+        }
+        undefinedVariables.push(varName);
+        return match;
+    });
+    return {
+        content: renderedContent,
+        undefinedVariables,
+    };
+}

package/dist/domain/value-objects/variables.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+declare const PrimitiveValueSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+type NestedValue = z.infer<typeof PrimitiveValueSchema> | {
+    [key: string]: NestedValue;
+};
+export declare const VariablesSchema: z.ZodRecord<z.ZodString, z.ZodType<NestedValue, z.ZodTypeDef, NestedValue>>;
+export type Variables = Record<string, string>;
+export declare function flattenVariables(obj: Record<string, NestedValue>, prefix?: string): Variables;
+export {};

package/dist/domain/value-objects/variables.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+const PrimitiveValueSchema = z.union([z.string(), z.number(), z.boolean()]);
+const NestedValueSchema = z.lazy(() => z.union([PrimitiveValueSchema, z.record(z.string(), NestedValueSchema)]));
+export const VariablesSchema = z.record(z.string(), NestedValueSchema);
+export function flattenVariables(obj, prefix = "") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === "object" && value !== null) {
+            Object.assign(result, flattenVariables(value, fullKey));
+        }
+        else {
+            result[fullKey] = String(value);
+        }
+    }
+    return result;
+}

package/dist/infrastructure/repositories/template-repository.d.ts

@@ -0,0 +1,3 @@
+import { Template } from "../../domain/entities/template.js";
+export declare function readTemplate(filePath: string): Template;
+export declare function writeTemplate(filePath: string, content: string): void;

package/dist/infrastructure/repositories/template-repository.js

@@ -0,0 +1,11 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { Template } from "../../domain/entities/template.js";
+export function readTemplate(filePath) {
+    const content = readFileSync(filePath, "utf-8");
+    return new Template(filePath, content);
+}
+export function writeTemplate(filePath, content) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content, "utf-8");
+}

package/dist/infrastructure/repositories/variables-repository.d.ts

@@ -0,0 +1,2 @@
+import { type Variables } from "../../domain/value-objects/variables.js";
+export declare function loadVariables(filePath: string): Variables;

package/dist/infrastructure/repositories/variables-repository.js

@@ -0,0 +1,16 @@
+import { readFileSync, existsSync } from "node:fs";
+import { parse } from "yaml";
+import { VariablesSchema, flattenVariables } from "../../domain/value-objects/variables.js";
+import { VariablesFileNotFoundError, InvalidVariablesError } from "../../shared/errors.js";
+export function loadVariables(filePath) {
+    if (!existsSync(filePath)) {
+        throw new VariablesFileNotFoundError(filePath);
+    }
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parse(content);
+    const result = VariablesSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new InvalidVariablesError(result.error.message);
+    }
+    return flattenVariables(result.data);
+}

package/dist/infrastructure/services/file-scanner.d.ts

@@ -0,0 +1,5 @@
+export interface ScanOptions {
+    include?: string;
+    exclude?: string;
+}
+export declare function scanTemplates(inputDir: string, options?: ScanOptions): Promise<string[]>;

package/dist/infrastructure/services/file-scanner.js

@@ -0,0 +1,8 @@
+import fg from "fast-glob";
+export async function scanTemplates(inputDir, options = {}) {
+    const pattern = options.include
+        ? `${inputDir}/${options.include}`
+        : `${inputDir}/**/*.md`;
+    const ignore = options.exclude ? [`${inputDir}/${options.exclude}`] : [];
+    return fg(pattern, { ignore });
+}

package/dist/presentation/cli/commands/main.d.ts

@@ -0,0 +1,48 @@
+export declare const mainCommand: import("citty").CommandDef<{
+    input: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    output: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    vars: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    include: {
+        type: "string";
+        description: string;
+    };
+    exclude: {
+        type: "string";
+        description: string;
+    };
+    watch: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    "rename-from": {
+        type: "string";
+        description: string;
+    };
+    "rename-to": {
+        type: "string";
+        description: string;
+    };
+    "list-vars": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    "dry-run": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;

package/dist/presentation/cli/commands/main.js

@@ -0,0 +1,311 @@
+import { defineCommand } from "citty";
+import { resolve } from "node:path";
+import pc from "picocolors";
+import Table from "cli-table3";
+import { watch } from "chokidar";
+import { processTemplates } from "../../../application/use-cases/process-templates.js";
+import { renameVariable } from "../../../application/use-cases/rename-variable.js";
+import { listVariables } from "../../../application/use-cases/list-variables.js";
+import { dryRun } from "../../../application/use-cases/dry-run.js";
+import { VariablesFileNotFoundError, SameInputOutputError, InvalidVariablesError } from "../../../shared/errors.js";
+async function runProcess(options) {
+    try {
+        const result = await processTemplates(options);
+        if (result.warnings.length > 0) {
+            for (const warning of result.warnings) {
+                console.warn(pc.yellow(`⚠ ${warning}`));
+            }
+            console.log();
+        }
+        if (result.processedFiles.length === 0) {
+            console.log(pc.gray("No files to process"));
+            return true;
+        }
+        const table = new Table({
+            head: [pc.bold("File"), pc.bold("Status")],
+            style: { head: [], border: [] },
+        });
+        for (const file of result.processedFiles) {
+            table.push([file, pc.green("✓ done")]);
+        }
+        console.log(pc.bold(pc.cyan("\n✨ Build complete\n")));
+        console.log(table.toString());
+        console.log();
+        console.log(pc.bold("Processed: ") + pc.green(`${result.processedFiles.length} file(s)`));
+        return true;
+    }
+    catch (error) {
+        if (error instanceof VariablesFileNotFoundError ||
+            error instanceof SameInputOutputError ||
+            error instanceof InvalidVariablesError) {
+            console.error(pc.red(`✗ Error: ${error.message}`));
+            return false;
+        }
+        throw error;
+    }
+}
+function startWatch(options) {
+    const inputPath = resolve(options.input);
+    const varsPath = resolve(options.vars);
+    let debounceTimer = null;
+    const handleChange = (eventType, filePath) => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+            console.log(pc.cyan(`\n👀 Change detected: ${pc.bold(filePath)} (${eventType})\n`));
+            await runProcess(options);
+        }, 100);
+    };
+    console.log(pc.bold(pc.magenta("\n👁 Watch mode enabled\n")));
+    const watchTable = new Table({
+        style: { head: [], border: [] },
+    });
+    watchTable.push([pc.gray("Templates"), inputPath], [pc.gray("Variables"), varsPath]);
+    console.log(watchTable.toString());
+    console.log();
+    console.log(pc.gray("Waiting for changes... (Ctrl+C to stop)\n"));
+    const watcher = watch([inputPath, varsPath], {
+        ignoreInitial: true,
+        ignored: /(^|[\/\\])\../,
+    });
+    watcher.on("all", handleChange);
+}
+export const mainCommand = defineCommand({
+    meta: {
+        name: "docvars",
+        description: "Replace {{variables}} in document templates with YAML values",
+    },
+    args: {
+        input: {
+            type: "positional",
+            description: "Input directory containing templates",
+            required: true,
+        },
+        output: {
+            type: "positional",
+            description: "Output directory for processed files",
+            required: true,
+        },
+        vars: {
+            type: "string",
+            description: "Path to variables YAML file",
+            default: "variables.yaml",
+        },
+        include: {
+            type: "string",
+            description: "Glob pattern to include files",
+        },
+        exclude: {
+            type: "string",
+            description: "Glob pattern to exclude files",
+        },
+        watch: {
+            type: "boolean",
+            description: "Watch for file changes and rebuild automatically",
+            default: false,
+        },
+        "rename-from": {
+            type: "string",
+            description: "Variable name to rename from (use with --rename-to)",
+        },
+        "rename-to": {
+            type: "string",
+            description: "Variable name to rename to (use with --rename-from)",
+        },
+        "list-vars": {
+            type: "boolean",
+            description: "List all variables used in templates",
+            default: false,
+        },
+        "dry-run": {
+            type: "boolean",
+            description: "Preview changes without writing files",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        // Handle dry-run mode
+        if (args["dry-run"]) {
+            try {
+                const result = await dryRun({
+                    input: args.input,
+                    output: args.output,
+                    vars: args.vars,
+                    include: args.include,
+                    exclude: args.exclude,
+                });
+                console.log(pc.bold(pc.cyan("\n🔍 Dry run - no files written\n")));
+                if (result.warnings.length > 0) {
+                    for (const warning of result.warnings) {
+                        console.warn(pc.yellow(`⚠ ${warning}`));
+                    }
+                    console.log();
+                }
+                if (result.changes.length === 0) {
+                    console.log(pc.gray("No files to process"));
+                    return;
+                }
+                const table = new Table({
+                    head: [pc.bold("File"), pc.bold("Status")],
+                    style: { head: [], border: [] },
+                });
+                for (const change of result.changes) {
+                    let status;
+                    switch (change.status) {
+                        case "create":
+                            status = pc.green("+ create");
+                            break;
+                        case "update":
+                            status = pc.yellow("~ update");
+                            break;
+                        case "unchanged":
+                            status = pc.gray("= unchanged");
+                            break;
+                    }
+                    table.push([change.relativePath, status]);
+                }
+                console.log(table.toString());
+                console.log();
+                const creates = result.changes.filter((c) => c.status === "create").length;
+                const updates = result.changes.filter((c) => c.status === "update").length;
+                const unchanged = result.changes.filter((c) => c.status === "unchanged").length;
+                console.log(pc.bold("Summary: ") +
+                    pc.green(`${creates} create`) +
+                    pc.gray(" · ") +
+                    pc.yellow(`${updates} update`) +
+                    pc.gray(" · ") +
+                    pc.gray(`${unchanged} unchanged`));
+            }
+            catch (error) {
+                if (error instanceof VariablesFileNotFoundError ||
+                    error instanceof SameInputOutputError ||
+                    error instanceof InvalidVariablesError) {
+                    console.error(`Error: ${error.message}`);
+                    process.exit(1);
+                }
+                throw error;
+            }
+            return;
+        }
+        // Handle list-vars mode
+        if (args["list-vars"]) {
+            try {
+                const result = await listVariables({
+                    input: args.input,
+                    vars: args.vars,
+                    include: args.include,
+                    exclude: args.exclude,
+                });
+                console.log(pc.bold(pc.cyan("\n📋 Variables\n")));
+                if (result.variables.length === 0 && result.unusedVariables.length === 0) {
+                    console.log(pc.gray("No variables found"));
+                    return;
+                }
+                if (result.variables.length > 0) {
+                    const table = new Table({
+                        head: [pc.bold("Variable"), pc.bold("Status"), pc.bold("Used in")],
+                        style: { head: [], border: [] },
+                        wordWrap: true,
+                    });
+                    for (const v of result.variables) {
+                        const status = v.isDefined ? pc.green("✓ defined") : pc.red("✗ undefined");
+                        const files = v.files.map((f) => pc.gray(f)).join("\n");
+                        table.push([v.name, status, files]);
+                    }
+                    console.log(table.toString());
+                }
+                if (result.unusedVariables.length > 0) {
+                    console.log(pc.bold(pc.yellow("\n⚠ Unused variables (defined but not used):\n")));
+                    for (const name of result.unusedVariables) {
+                        console.log(pc.gray(`  ${name}`));
+                    }
+                }
+                console.log();
+                const defined = result.variables.filter((v) => v.isDefined).length;
+                const undefined_ = result.variables.filter((v) => !v.isDefined).length;
+                console.log(pc.bold("Summary: ") +
+                    pc.green(`${defined} defined`) +
+                    pc.gray(" · ") +
+                    (undefined_ > 0 ? pc.red(`${undefined_} undefined`) : pc.gray("0 undefined")) +
+                    pc.gray(" · ") +
+                    pc.yellow(`${result.unusedVariables.length} unused`));
+            }
+            catch (error) {
+                if (error instanceof VariablesFileNotFoundError) {
+                    console.error(pc.red(`✗ Error: ${error.message}`));
+                    process.exit(1);
+                }
+                throw error;
+            }
+            return;
+        }
+        // Handle rename mode
+        if (args["rename-from"] || args["rename-to"]) {
+            if (!args["rename-from"] || !args["rename-to"]) {
+                console.error(pc.red("✗ Error: Both --rename-from and --rename-to are required"));
+                process.exit(1);
+            }
+            try {
+                const result = await renameVariable({
+                    input: args.input,
+                    vars: args.vars,
+                    from: args["rename-from"],
+                    to: args["rename-to"],
+                    include: args.include,
+                    exclude: args.exclude,
+                });
+                if (result.renamedInFiles.length === 0 && !result.renamedInVars) {
+                    console.log(pc.yellow(`⚠ No occurrences of "${args["rename-from"]}" found`));
+                }
+                else {
+                    console.log(pc.bold(pc.cyan("\n✏️  Rename complete\n")) +
+                        pc.gray(`   ${args["rename-from"]}`) +
+                        pc.cyan(" → ") +
+                        pc.green(args["rename-to"]) +
+                        "\n");
+                    const table = new Table({
+                        head: [pc.bold("File"), pc.bold("Status")],
+                        style: { head: [], border: [] },
+                    });
+                    if (result.renamedInVars) {
+                        table.push([pc.italic("variables.yaml"), pc.green("✓ updated")]);
+                    }
+                    for (const file of result.renamedInFiles) {
+                        table.push([file, pc.green("✓ updated")]);
+                    }
+                    console.log(table.toString());
+                    console.log();
+                    const total = result.renamedInFiles.length + (result.renamedInVars ? 1 : 0);
+                    console.log(pc.bold("Updated: ") + pc.green(`${total} file(s)`));
+                }
+            }
+            catch (error) {
+                if (error instanceof VariablesFileNotFoundError) {
+                    console.error(pc.red(`✗ Error: ${error.message}`));
+                    process.exit(1);
+                }
+                throw error;
+            }
+            return;
+        }
+        // Normal processing mode
+        const options = {
+            input: args.input,
+            output: args.output,
+            vars: args.vars,
+            include: args.include,
+            exclude: args.exclude,
+        };
+        const success = await runProcess(options);
+        if (args.watch) {
+            if (!success) {
+                console.log("\nFix errors and save to retry...\n");
+            }
+            startWatch(options);
+        }
+        else if (!success) {
+            process.exit(1);
+        }
+    },
+});

package/dist/presentation/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/presentation/cli/index.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runMain } from "citty";
+import { mainCommand } from "./commands/main.js";
+runMain(mainCommand);

package/dist/shared/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class VariablesFileNotFoundError extends Error {
+    constructor(filePath: string);
+}
+export declare class SameInputOutputError extends Error {
+    constructor();
+}
+export declare class InvalidVariablesError extends Error {
+    constructor(message: string);
+}

package/dist/shared/errors.js

@@ -0,0 +1,18 @@
+export class VariablesFileNotFoundError extends Error {
+    constructor(filePath) {
+        super(`Variables file not found: ${filePath}`);
+        this.name = "VariablesFileNotFoundError";
+    }
+}
+export class SameInputOutputError extends Error {
+    constructor() {
+        super("Input and output directories cannot be the same");
+        this.name = "SameInputOutputError";
+    }
+}
+export class InvalidVariablesError extends Error {
+    constructor(message) {
+        super(`Invalid variables file: ${message}`);
+        this.name = "InvalidVariablesError";
+    }
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,15 @@
+export interface CliOptions {
+    input: string;
+    output: string;
+    vars: string;
+    include?: string;
+    exclude?: string;
+}
+export interface ProcessResult {
+    processedFiles: string[];
+    warnings: string[];
+}
+export interface RenderResult {
+    content: string;
+    undefinedVariables: string[];
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "docvars",
+  "author": "Shunta Toda",
+  "version": "0.3.0",
+  "description": "Replace {{variables}} in document templates with YAML values",
+  "type": "module",
+  "main": "./dist/application/use-cases/process-templates.js",
+  "types": "./dist/application/use-cases/process-templates.d.ts",
+  "bin": {
+    "docvars": "./dist/presentation/cli/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node ./dist/presentation/cli/index.js",
+    "dev": "tsc --watch",
+    "test": "vitest",
+    "prepublishOnly": "pnpm test run && pnpm build"
+  },
+  "keywords": [
+    "template",
+    "variables",
+    "yaml",
+    "cli",
+    "documents",
+    "markdown",
+    "html",
+    "text"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ShuntaToda/docvars.git"
+  },
+  "homepage": "https://github.com/ShuntaToda/docvars#readme",
+  "bugs": {
+    "url": "https://github.com/ShuntaToda/docvars/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "citty": "^0.1.6",
+    "cli-table3": "^0.6.5",
+    "fast-glob": "^3.3.2",
+    "picocolors": "^1.1.1",
+    "yaml": "^2.3.4",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  }
+}