@aramassa/ai-rules 0.1.1-npmjs.20250910072942

package/dist/filter.d.ts

@@ -0,0 +1,8 @@
+import { MarkdownFile } from "@internal/extract";
+export interface FilterOptions {
+    types?: string[];
+    languages?: string[];
+    attrFilters: string[];
+}
+export declare function filterFiles(files: MarkdownFile[], options: FilterOptions): MarkdownFile[];
+//# sourceMappingURL=filter.d.ts.map

package/dist/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../src/filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAkDD,wBAAgB,WAAW,CACzB,KAAK,EAAE,YAAY,EAAE,EACrB,OAAO,EAAE,aAAa,GACrB,YAAY,EAAE,CA+BhB"}

package/dist/filter.js

@@ -0,0 +1,72 @@
+import { getByDotNotation } from "./utils/objectUtils.js";
+/**
+ * Checks if a value is considered empty (undefined, null, or empty string)
+ * @param value The value to check
+ * @returns true if the value is empty
+ */
+function isEmptyValue(value) {
+    return value === undefined || value === null || value === '';
+}
+/**
+ * Generic filter function for attribute matching
+ * @param value The value to check
+ * @param allowedValues The list of allowed values (empty string allowed for undefined/empty)
+ * @returns true if the value matches the filter criteria
+ */
+function matchesAttributeFilter(value, allowedValues) {
+    // Handle empty values
+    if (isEmptyValue(value)) {
+        return allowedValues.includes('');
+    }
+    // Handle array values - check if any element matches
+    if (Array.isArray(value)) {
+        return value.some(item => {
+            const stringValue = String(item);
+            return allowedValues.includes(stringValue);
+        });
+    }
+    // Handle single values
+    const stringValue = String(value);
+    return allowedValues.includes(stringValue);
+}
+/**
+ * Filters files based on attribute criteria
+ * @param files Array of markdown files to filter
+ * @param attributeName The attribute name to filter on
+ * @param allowedValues Array of allowed values for the attribute
+ * @returns Filtered array of files
+ */
+function filterByAttribute(files, attributeName, allowedValues) {
+    return files.filter(file => {
+        const value = file.attrs[attributeName];
+        return matchesAttributeFilter(value, allowedValues);
+    });
+}
+export function filterFiles(files, options) {
+    const { types, languages, attrFilters } = options;
+    let filteredFiles = files;
+    // Filter by type using generic function
+    if (types) {
+        filteredFiles = filterByAttribute(filteredFiles, 'type', types);
+    }
+    // Filter by language using generic function  
+    if (languages) {
+        filteredFiles = filterByAttribute(filteredFiles, 'language', languages);
+    }
+    // Filter by custom attributes using dot notation
+    for (const attr of attrFilters) {
+        const [key, value = ''] = attr.split('=');
+        filteredFiles = filteredFiles.filter(f => {
+            const fileVal = getByDotNotation(f.attrs, key);
+            // Handle pipe-separated values for OR logic (from array filters)
+            if (value.includes('|')) {
+                const possibleValues = value.split('|');
+                return matchesAttributeFilter(fileVal, possibleValues);
+            }
+            else {
+                return matchesAttributeFilter(fileVal, [value]);
+            }
+        });
+    }
+    return filteredFiles;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/optionValidator.d.ts

@@ -0,0 +1,28 @@
+export declare enum WriteMode {
+    APPEND = "append",
+    PREPEND = "prepend",
+    OVERWRITE = "overwrite"
+}
+export interface ExtractOptions {
+    srcDir: string;
+    outFile: string;
+    types?: string[];
+    languages?: string[];
+    attrFilters: string[];
+    title?: string;
+    mode: WriteMode;
+    attr?: Record<string, unknown>;
+    debug?: boolean;
+    vars?: string;
+    envFile?: string;
+}
+export interface StatsOptions {
+    srcDir: string;
+    variables?: boolean;
+}
+export declare class CliOptionValidator {
+    private static readonly ERROR_MESSAGES;
+    static validateExtractOptions(options: ExtractOptions): void;
+    static validateStatsOptions(options: StatsOptions): void;
+}
+//# sourceMappingURL=optionValidator.d.ts.map

package/dist/optionValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optionValidator.d.ts","sourceRoot":"","sources":["../src/optionValidator.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACnB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,SAAS,cAAc;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAIpC;WAEY,sBAAsB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;WAYrD,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;CAKhE"}

package/dist/optionValidator.js

@@ -0,0 +1,29 @@
+export var WriteMode;
+(function (WriteMode) {
+    WriteMode["APPEND"] = "append";
+    WriteMode["PREPEND"] = "prepend";
+    WriteMode["OVERWRITE"] = "overwrite";
+})(WriteMode || (WriteMode = {}));
+export class CliOptionValidator {
+    static validateExtractOptions(options) {
+        if (!options.srcDir) {
+            throw new Error(this.ERROR_MESSAGES.SRC_DIR_REQUIRED);
+        }
+        if (!options.outFile) {
+            throw new Error(this.ERROR_MESSAGES.OUT_FILE_REQUIRED);
+        }
+        if (!Object.values(WriteMode).includes(options.mode)) {
+            throw new Error(this.ERROR_MESSAGES.INVALID_MODE);
+        }
+    }
+    static validateStatsOptions(options) {
+        if (!options.srcDir) {
+            throw new Error(this.ERROR_MESSAGES.SRC_DIR_REQUIRED);
+        }
+    }
+}
+CliOptionValidator.ERROR_MESSAGES = {
+    SRC_DIR_REQUIRED: "Source directory (srcDir) is required",
+    OUT_FILE_REQUIRED: "Output file (outFile) is required",
+    INVALID_MODE: "Invalid mode. Must be one of: append, prepend, overwrite"
+};

package/dist/templateEngine.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Template variable definition extracted from template content
+ */
+export interface TemplateVariable {
+    name: string;
+    defaultValue?: string;
+    required: boolean;
+}
+/**
+ * Options for template engine processing
+ */
+export interface TemplateEngineOptions {
+    variables: Record<string, string>;
+    strictMode?: boolean;
+}
+/**
+ * Core template engine for processing variable substitution in markdown content
+ */
+export declare class TemplateEngine {
+    private static readonly VARIABLE_WITH_DEFAULT_REGEX;
+    private static readonly REQUIRED_VARIABLE_REGEX;
+    /**
+     * Parse template content to extract all variable definitions
+     * @param content Template content to parse
+     * @returns Array of template variables found
+     */
+    parseTemplate(content: string): TemplateVariable[];
+    /**
+     * Render template content by substituting variables
+     * @param content Template content to render
+     * @param options Rendering options including variables
+     * @returns Rendered content with variables substituted
+     */
+    renderTemplate(content: string, options: TemplateEngineOptions): string;
+    /**
+     * Validate that all required variables are provided
+     * @param content Template content to validate
+     * @param variables Available variables
+     * @throws Error if required variables are missing
+     */
+    validateRequiredVariables(content: string, variables: Record<string, string>): void;
+    /**
+     * Check if content contains any template variables
+     * @param content Content to check
+     * @returns True if content contains template variables
+     */
+    hasTemplateVariables(content: string): boolean;
+    /**
+     * Extract only the required variable names from content
+     * @param content Content to scan for required variables
+     * @returns Array of required variable names found
+     */
+    extractRequiredVariables(content: string): string[];
+}
+//# sourceMappingURL=templateEngine.d.ts.map

package/dist/templateEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateEngine.d.ts","sourceRoot":"","sources":["../src/templateEngine.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,qBAAa,cAAc;IAEzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,2BAA2B,CAAuC;IAC1F,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAA8B;IAE7E;;;;OAIG;IACI,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,EAAE;IAuCzD;;;;;OAKG;IACI,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,GAAG,MAAM;IA8B9E;;;;;OAKG;IACI,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAkB1F;;;;OAIG;IACI,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKrD;;;;OAIG;IACI,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;CAiB3D"}

package/dist/templateEngine.js

@@ -0,0 +1,124 @@
+/**
+ * Core template engine for processing variable substitution in markdown content
+ */
+export class TemplateEngine {
+    /**
+     * Parse template content to extract all variable definitions
+     * @param content Template content to parse
+     * @returns Array of template variables found
+     */
+    parseTemplate(content) {
+        const variables = [];
+        const seenVariables = new Set();
+        // Parse variables with default values: ${VAR:default}
+        let match;
+        while ((match = TemplateEngine.VARIABLE_WITH_DEFAULT_REGEX.exec(content)) !== null) {
+            const [, name, defaultValue] = match;
+            if (!seenVariables.has(name)) {
+                variables.push({
+                    name,
+                    defaultValue,
+                    required: false
+                });
+                seenVariables.add(name);
+            }
+        }
+        // Reset regex for next use
+        TemplateEngine.VARIABLE_WITH_DEFAULT_REGEX.lastIndex = 0;
+        // Parse required variables: !{VAR}
+        while ((match = TemplateEngine.REQUIRED_VARIABLE_REGEX.exec(content)) !== null) {
+            const [, name] = match;
+            if (!seenVariables.has(name)) {
+                variables.push({
+                    name,
+                    required: true
+                });
+                seenVariables.add(name);
+            }
+        }
+        // Reset regex for next use
+        TemplateEngine.REQUIRED_VARIABLE_REGEX.lastIndex = 0;
+        return variables;
+    }
+    /**
+     * Render template content by substituting variables
+     * @param content Template content to render
+     * @param options Rendering options including variables
+     * @returns Rendered content with variables substituted
+     */
+    renderTemplate(content, options) {
+        // First validate required variables if in strict mode
+        if (options.strictMode) {
+            this.validateRequiredVariables(content, options.variables);
+        }
+        let result = content;
+        // Replace variables with default values: ${VAR:default}
+        result = result.replace(TemplateEngine.VARIABLE_WITH_DEFAULT_REGEX, (match, name, defaultValue) => {
+            return options.variables[name] ?? defaultValue;
+        });
+        // Replace required variables: !{VAR}
+        result = result.replace(TemplateEngine.REQUIRED_VARIABLE_REGEX, (match, name) => {
+            const value = options.variables[name];
+            if (value === undefined) {
+                if (options.strictMode) {
+                    // This will be caught by the validation that happens before this
+                    return match;
+                }
+                // In non-strict mode, leave the variable placeholder
+                return match;
+            }
+            return value;
+        });
+        return result;
+    }
+    /**
+     * Validate that all required variables are provided
+     * @param content Template content to validate
+     * @param variables Available variables
+     * @throws Error if required variables are missing
+     */
+    validateRequiredVariables(content, variables) {
+        const templateVars = this.parseTemplate(content);
+        const missingRequired = [];
+        for (const variable of templateVars) {
+            if (variable.required && variables[variable.name] === undefined) {
+                missingRequired.push(variable.name);
+            }
+        }
+        if (missingRequired.length > 0) {
+            throw new Error(`Required variables are missing: ${missingRequired.join(', ')}\n` +
+                `Please provide values using --vars "${missingRequired.map(v => `${v}=value`).join(' ')}" or environment files.`);
+        }
+    }
+    /**
+     * Check if content contains any template variables
+     * @param content Content to check
+     * @returns True if content contains template variables
+     */
+    hasTemplateVariables(content) {
+        return TemplateEngine.VARIABLE_WITH_DEFAULT_REGEX.test(content) ||
+            TemplateEngine.REQUIRED_VARIABLE_REGEX.test(content);
+    }
+    /**
+     * Extract only the required variable names from content
+     * @param content Content to scan for required variables
+     * @returns Array of required variable names found
+     */
+    extractRequiredVariables(content) {
+        const requiredVariables = [];
+        let match;
+        // Parse required variables: !{VAR}
+        while ((match = TemplateEngine.REQUIRED_VARIABLE_REGEX.exec(content)) !== null) {
+            const [, name] = match;
+            if (!requiredVariables.includes(name)) {
+                requiredVariables.push(name);
+            }
+        }
+        // Reset regex for next use
+        TemplateEngine.REQUIRED_VARIABLE_REGEX.lastIndex = 0;
+        return requiredVariables;
+    }
+}
+// Regular expressions for parsing template variables
+TemplateEngine.VARIABLE_WITH_DEFAULT_REGEX = /\$\{([A-Z_][A-Z0-9_]*):([^}]*)\}/g;
+TemplateEngine.REQUIRED_VARIABLE_REGEX = /!\{([A-Z_][A-Z0-9_]*)\}/g;

package/dist/utils/objectUtils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utility functions for object manipulation
+ */
+/**
+ * Gets a value from an object using dot notation path
+ * @param obj The object to query
+ * @param path The dot notation path (e.g., "a.b.c")
+ * @returns The value at the path, or undefined if not found
+ */
+export declare function getByDotNotation(obj: unknown, path: string): unknown;
+//# sourceMappingURL=objectUtils.d.ts.map

package/dist/utils/objectUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectUtils.d.ts","sourceRoot":"","sources":["../../src/utils/objectUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAOpE"}

package/dist/utils/objectUtils.js

@@ -0,0 +1,17 @@
+/**
+ * Utility functions for object manipulation
+ */
+/**
+ * Gets a value from an object using dot notation path
+ * @param obj The object to query
+ * @param path The dot notation path (e.g., "a.b.c")
+ * @returns The value at the path, or undefined if not found
+ */
+export function getByDotNotation(obj, path) {
+    return path.split('.').reduce((o, k) => {
+        if (o && typeof o === 'object' && k in o) {
+            return o[k];
+        }
+        return undefined;
+    }, obj);
+}

package/dist/utils/test/structureExtractors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 指定した TypeScript ファイルからクラス・メソッド・プロパティの構造を抽出
+ */
+export declare function extractClassStructure(filePath: string): Record<string, {
+    methods: string[];
+    statics: string[];
+    properties: string[];
+}>;
+/**
+ * 指定した TypeScript ファイルから関数名を抽出（トップレベル関数とエクスポートされた関数のみ）
+ */
+export declare function extractFunctionStructure(filePath: string): string[];
+/**
+ * Extract interface names and their members from a TypeScript file
+ */
+export declare function extractInterfaceStructure(filePath: string): Record<string, {
+    properties: string[];
+    methods: string[];
+}>;
+/**
+ * Extract type alias names and, if the alias is an object type, its property names
+ */
+export declare function extractTypeAliasStructure(filePath: string): Record<string, {
+    properties: string[];
+}>;
+/**
+ * Extract exported constant objects and their property names from a TypeScript file
+ */
+export declare function extractConstantStructure(filePath: string): Record<string, string[]>;
+//# sourceMappingURL=structureExtractors.d.ts.map

package/dist/utils/test/structureExtractors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structureExtractors.d.ts","sourceRoot":"","sources":["../../../src/utils/test/structureExtractors.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA2BhF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CA+BnE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA4B7D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA0B1C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CA6C1B"}

package/dist/utils/test/structureExtractors.js

@@ -0,0 +1,164 @@
+import * as ts from "typescript";
+import * as fs from "fs";
+/**
+ * 指定した TypeScript ファイルからクラス・メソッド・プロパティの構造を抽出
+ */
+export function extractClassStructure(filePath) {
+    const src = fs.readFileSync(filePath, "utf8");
+    const sourceFile = ts.createSourceFile(filePath, src, ts.ScriptTarget.Latest, true);
+    const classes = {};
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isClassDeclaration(node) && node.name) {
+            const className = node.name.text;
+            const methods = [];
+            const statics = [];
+            const properties = [];
+            node.members.forEach((member) => {
+                if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+                    if (member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword)) {
+                        statics.push(member.name.text);
+                    }
+                    else {
+                        methods.push(member.name.text);
+                    }
+                }
+                if (ts.isPropertyDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+                    properties.push(member.name.text);
+                }
+            });
+            classes[className] = { methods, statics, properties };
+        }
+    });
+    return classes;
+}
+/**
+ * 指定した TypeScript ファイルから関数名を抽出（トップレベル関数とエクスポートされた関数のみ）
+ */
+export function extractFunctionStructure(filePath) {
+    const src = fs.readFileSync(filePath, "utf8");
+    const sourceFile = ts.createSourceFile(filePath, src, ts.ScriptTarget.Latest, true);
+    const functions = [];
+    // トップレベルのみ探索する
+    sourceFile.forEachChild((node) => {
+        // トップレベルの function 宣言
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            functions.push(node.name.text);
+        }
+        // トップレベルの export const foo = () => {}
+        if (ts.isVariableStatement(node)) {
+            const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+            node.declarationList.declarations.forEach((declaration) => {
+                if (ts.isVariableDeclaration(declaration) &&
+                    declaration.name &&
+                    ts.isIdentifier(declaration.name) &&
+                    declaration.initializer &&
+                    ts.isArrowFunction(declaration.initializer)) {
+                    // export されているもののみ抽出
+                    if (isExported) {
+                        functions.push(declaration.name.text);
+                    }
+                }
+            });
+        }
+    });
+    return functions.sort();
+}
+/**
+ * Extract interface names and their members from a TypeScript file
+ */
+export function extractInterfaceStructure(filePath) {
+    const src = fs.readFileSync(filePath, "utf8");
+    const sourceFile = ts.createSourceFile(filePath, src, ts.ScriptTarget.Latest, true);
+    const interfaces = {};
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isInterfaceDeclaration(node) && node.name) {
+            const ifaceName = node.name.text;
+            const properties = [];
+            const methods = [];
+            node.members.forEach((member) => {
+                if (ts.isPropertySignature(member) && member.name && ts.isIdentifier(member.name)) {
+                    properties.push(member.name.text);
+                }
+                if (ts.isMethodSignature(member) && member.name && ts.isIdentifier(member.name)) {
+                    methods.push(member.name.text);
+                }
+            });
+            interfaces[ifaceName] = {
+                properties: properties.sort(),
+                methods: methods.sort(),
+            };
+        }
+    });
+    return interfaces;
+}
+/**
+ * Extract type alias names and, if the alias is an object type, its property names
+ */
+export function extractTypeAliasStructure(filePath) {
+    const src = fs.readFileSync(filePath, "utf8");
+    const sourceFile = ts.createSourceFile(filePath, src, ts.ScriptTarget.Latest, true);
+    const aliases = {};
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isTypeAliasDeclaration(node) && node.name) {
+            const aliasName = node.name.text;
+            const properties = [];
+            if (ts.isTypeLiteralNode(node.type)) {
+                node.type.members.forEach((member) => {
+                    if (ts.isPropertySignature(member) && member.name && ts.isIdentifier(member.name)) {
+                        properties.push(member.name.text);
+                    }
+                    if (ts.isMethodSignature(member) && member.name && ts.isIdentifier(member.name)) {
+                        properties.push(member.name.text);
+                    }
+                });
+            }
+            aliases[aliasName] = { properties: properties.sort() };
+        }
+    });
+    return aliases;
+}
+/**
+ * Extract exported constant objects and their property names from a TypeScript file
+ */
+export function extractConstantStructure(filePath) {
+    const src = fs.readFileSync(filePath, "utf8");
+    const sourceFile = ts.createSourceFile(filePath, src, ts.ScriptTarget.Latest, true);
+    const constants = {};
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isVariableStatement(node)) {
+            const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+            if (!isExported)
+                return;
+            node.declarationList.declarations.forEach((decl) => {
+                if (ts.isVariableDeclaration(decl) &&
+                    decl.name &&
+                    ts.isIdentifier(decl.name) &&
+                    decl.initializer) {
+                    let objLit;
+                    if (ts.isObjectLiteralExpression(decl.initializer)) {
+                        objLit = decl.initializer;
+                    }
+                    else if (ts.isAsExpression(decl.initializer) ||
+                        ts.isTypeAssertionExpression(decl.initializer)) {
+                        const expr = decl.initializer.expression;
+                        if (ts.isObjectLiteralExpression(expr))
+                            objLit = expr;
+                    }
+                    if (objLit) {
+                        const props = [];
+                        objLit.properties.forEach((prop) => {
+                            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                                props.push(prop.name.text);
+                            }
+                            else if (ts.isShorthandPropertyAssignment(prop)) {
+                                props.push(prop.name.text);
+                            }
+                        });
+                        constants[decl.name.text] = props;
+                    }
+                }
+            });
+        }
+    });
+    return constants;
+}

package/dist/variableResolver.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Options for variable resolution from multiple sources
+ */
+export interface VariableResolutionOptions {
+    cliVariables?: Record<string, string>;
+    recipeVariables?: Record<string, string>;
+    envFile?: string;
+    environmentVariables?: boolean;
+}
+/**
+ * Variable resolver that handles collecting variables from multiple sources
+ * with proper priority order: CLI > recipe > .env > environment variables
+ */
+export declare class VariableResolver {
+    /**
+     * Resolve variables from multiple sources according to priority
+     * @param options Resolution options specifying sources
+     * @returns Merged variables with proper priority
+     */
+    resolveVariables(options: VariableResolutionOptions): Promise<Record<string, string>>;
+    /**
+     * Load variables from .env file
+     * @param filePath Path to .env file
+     * @returns Variables loaded from file
+     */
+    private loadEnvFile;
+    /**
+     * Parse .env file content into variables object
+     * @param content .env file content
+     * @returns Parsed variables
+     */
+    private parseEnvContent;
+    /**
+     * Remove surrounding quotes from environment variable values
+     * @param value Value to unquote
+     * @returns Unquoted value
+     */
+    private unquoteValue;
+    /**
+     * Get relevant environment variables (those that match template variable naming convention)
+     * @returns Environment variables that could be used as template variables
+     */
+    private getEnvironmentVariables;
+    /**
+     * Merge variables from multiple sources with later sources taking precedence
+     * @param sources Variable objects in order of precedence (lowest to highest)
+     * @returns Merged variables object
+     */
+    private mergeVariables;
+    /**
+     * Parse CLI variables string in key=value format
+     * @param varsString Comma-separated key=value pairs
+     * @returns Parsed variables object
+     */
+    static parseCliVariables(varsString: string): Record<string, string>;
+    /**
+     * Get variables by source for display purposes
+     * @param options Options specifying which sources to check
+     * @returns Object with variables grouped by source
+     */
+    getVariablesBySource(options: {
+        envFile?: string;
+    }): Promise<{
+        environment: Record<string, string>;
+        envFile: Record<string, string>;
+    }>;
+}
+//# sourceMappingURL=variableResolver.d.ts.map

package/dist/variableResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variableResolver.d.ts","sourceRoot":"","sources":["../src/variableResolver.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B;;;;OAIG;IACU,gBAAgB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IA+BlG;;;;OAIG;YACW,WAAW;IAazB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAwBvB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAYpB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAyC/B;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAItB;;;;OAIG;WACW,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IA+B3E;;;;OAIG;IACU,oBAAoB,CAAC,OAAO,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QACxE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACpC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACjC,CAAC;CAiBH"}