parse-hcl 0.1.1 → 1.0.0

package/README.md

@@ -111,6 +111,7 @@ parse-hcl --file main.tf --out ./out/result.json --stdout
 - `--out-dir` sets the root for per-file outputs (directory mode). If omitted but `--out` is provided, per-file results go under `per-file/` next to the `--out` target. Disable per-file writes with `--no-split`.
 - `--file` auto-detects artifacts: paths containing `tfvars` use the tfvars parser, `.tfstate` uses the state parser, and `plan.json` uses the plan parser. Other files are treated as Terraform configs. The `--graph` flag only applies to Terraform configs; artifact parsers ignore it and emit the raw parse.
 - `--dir` walks recursively, parsing only `.tf` and `.tf.json` files while skipping `.terraform`, `.git`, and `node_modules`. Default output contains `combined` (aggregated document) and `files` (per-file results). With `--graph`, the dependency graph is built from the aggregated document.
+- When split outputs are enabled, each `files` entry includes `relative_path`, `output_path`, and `output_dir` (all relative). Module blocks include `source_raw` (as written) and, when local, `source_output_dir`, pointing to the per-file output directory for that module.
 - Warnings and usage go to stderr. The CLI exits non-zero on invalid arguments or parsing failures.
 - `--format` applies to every output shape; `--no-prune` keeps empty arrays/objects that are removed by default for compactness.
 - Run without a global install via `npx parse-hcl ...` or `yarn dlx parse-hcl ...`.

package/dist/cli.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const terraformParser_1 = require("./services/terraformParser");
 const artifactParsers_1 = require("./services/artifactParsers");
 const serializer_1 = require("./utils/serialization/serializer");
+const outputMetadata_1 = require("./utils/outputMetadata");
 const DEFAULT_SINGLE_BASENAME = 'parse-hcl-output';
 const DEFAULT_COMBINED_BASENAME = 'parse-hcl-output.combined';
 const DEFAULT_PER_FILE_DIR = 'parse-hcl-output/files';
@@ -106,16 +107,23 @@ function emitSingle(filePath, data, opts) {
 }
 function emitDirectory(dirPath, files, combinedDoc, opts) {
     const ext = getExt(opts.format);
+    const perFileBase = opts.split ? resolvePerFileBase(opts) : undefined;
+    (0, outputMetadata_1.annotateOutputMetadata)({
+        dirPath,
+        files,
+        perFileBase,
+        ext,
+        cwd: process.cwd()
+    });
     const combinedData = opts.graph ? combinedDoc : { combined: combinedDoc, files: opts.split ? files : [] };
     const combinedRendered = render(combinedData, opts);
     const combinedDefaultName = `${DEFAULT_COMBINED_BASENAME}${ext}`;
     const combinedTarget = resolveOutPath(opts.out, combinedDefaultName, opts.format, true);
     writeFile(combinedTarget, combinedRendered);
-    if (opts.split) {
-        const baseDir = resolvePerFileBase(opts);
+    if (opts.split && perFileBase) {
         files.forEach((file) => {
-            const relPath = path_1.default.relative(dirPath, path_1.default.resolve(file.path));
-            const perFileTarget = path_1.default.join(baseDir, `${relPath}${ext}`);
+            const relPath = file.relative_path ?? path_1.default.relative(dirPath, path_1.default.resolve(file.path));
+            const perFileTarget = path_1.default.join(perFileBase, `${relPath}${ext}`);
             const rendered = render(file.document, opts);
             writeFile(perFileTarget, rendered);
         });

package/dist/types/blocks.d.ts

@@ -196,6 +196,10 @@ export interface ModuleBlock {
     name: string;
     /** All properties defined in the block (including source, version, etc.) */
     properties: Record<string, Value>;
+    /** Raw source string as written in HCL (useful when a resolved output dir is added) */
+    source_raw?: string;
+    /** Relative path to the per-file parse output for the referenced source directory (when available) */
+    source_output_dir?: string;
     /** The original raw text */
     raw: string;
     /** Source file path */
@@ -396,6 +400,12 @@ export declare function createEmptyDocument(): TerraformDocument;
 export interface FileParseResult {
     /** The file path */
     path: string;
+    /** Path relative to the parsed directory root */
+    relative_path?: string;
+    /** Relative path (from cwd) to the per-file parse output */
+    output_path?: string;
+    /** Relative directory containing the per-file parse output */
+    output_dir?: string;
     /** The parsed document */
     document: TerraformDocument;
 }

package/dist/utils/outputMetadata.d.ts

@@ -0,0 +1,20 @@
+import { FileParseResult } from '../types/blocks';
+type FileWithMetadata = FileParseResult & {
+    relative_path?: string;
+    output_path?: string;
+    output_dir?: string;
+};
+interface MetadataOptions {
+    dirPath: string;
+    files: FileWithMetadata[];
+    perFileBase?: string;
+    ext: '.json' | '.yaml';
+    cwd?: string;
+}
+/**
+ * Attaches relative path metadata to per-file results and module blocks.
+ * - Adds relative paths for files and their output targets (when split outputs are enabled).
+ * - Adds `source_output_dir` to module blocks that point to local directories within the parsed tree.
+ */
+export declare function annotateOutputMetadata(options: MetadataOptions): void;
+export {};

package/dist/utils/outputMetadata.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.annotateOutputMetadata = annotateOutputMetadata;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const valueHelpers_1 = require("./common/valueHelpers");
+/**
+ * Attaches relative path metadata to per-file results and module blocks.
+ * - Adds relative paths for files and their output targets (when split outputs are enabled).
+ * - Adds `source_output_dir` to module blocks that point to local directories within the parsed tree.
+ */
+function annotateOutputMetadata(options) {
+    const root = path_1.default.resolve(options.dirPath);
+    const cwd = options.cwd ? path_1.default.resolve(options.cwd) : process.cwd();
+    const perFileBase = options.perFileBase ? path_1.default.resolve(options.perFileBase) : undefined;
+    for (const file of options.files) {
+        const absPath = path_1.default.resolve(file.path);
+        const relPath = path_1.default.relative(root, absPath);
+        file.relative_path = relPath;
+        if (perFileBase) {
+            const perFileTarget = path_1.default.join(perFileBase, `${relPath}${options.ext}`);
+            const outputPath = normalizeRelative(cwd, perFileTarget);
+            file.output_path = outputPath;
+            file.output_dir = path_1.default.dirname(outputPath);
+        }
+    }
+    for (const file of options.files) {
+        const fileDir = path_1.default.dirname(path_1.default.resolve(file.path));
+        for (const mod of file.document.module) {
+            const sourceRaw = getRawSource(mod.properties.source);
+            if (sourceRaw) {
+                mod.source_raw = sourceRaw;
+            }
+            if (!perFileBase) {
+                continue;
+            }
+            const sourceLiteral = (0, valueHelpers_1.literalString)(mod.properties.source);
+            if (!sourceLiteral || !isLocalPath(sourceLiteral)) {
+                continue;
+            }
+            const resolvedSource = path_1.default.resolve(fileDir, sourceLiteral);
+            if (!fs_1.default.existsSync(resolvedSource) || !fs_1.default.statSync(resolvedSource).isDirectory()) {
+                continue;
+            }
+            const relToRoot = path_1.default.relative(root, resolvedSource);
+            if (relToRoot.startsWith('..') || path_1.default.isAbsolute(relToRoot)) {
+                continue;
+            }
+            const outputDir = path_1.default.join(perFileBase, relToRoot);
+            mod.source_output_dir = normalizeRelative(cwd, outputDir);
+        }
+    }
+}
+function isLocalPath(source) {
+    if (source.includes('://') || source.includes('::')) {
+        return false;
+    }
+    return source.startsWith('.') || path_1.default.isAbsolute(source);
+}
+function normalizeRelative(from, to) {
+    const rel = path_1.default.relative(from, to);
+    return rel || '.';
+}
+function getRawSource(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (value.type === 'literal' && typeof value.value === 'string') {
+        return value.value;
+    }
+    if ('raw' in value && typeof value.raw === 'string') {
+        return value.raw;
+    }
+    return undefined;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "parse-hcl",
-    "version": "0.1.1",
-    "description": "Lightweight HCL parser focused on identifying and classifying blocks. Supports common Terraform blocks (resource, variable, output, locals, etc.) for tooling and automation.",
+    "version": "1.0.0",
+    "description": "CLI-first Terraform/HCL parser with JSON/YAML output, dependency graph export, and per-file metadata for IaC tooling.",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "exports": {
@@ -27,10 +27,18 @@
     "keywords": [
         "terraform",
         "hcl",
-        "parser",
+        "terraform parser",
+        "iac",
+        "infrastructure-as-code",
         "tfvars",
         "tfstate",
-        "plan"
+        "plan",
+        "plan.json",
+        "cli",
+        "json",
+        "yaml",
+        "dependency graph",
+        "static analysis"
     ],
     "sideEffects": false,
     "engines": {