@atomic-ehr/codegen 0.0.1-canary.20251006070905.fb6ed98 → 0.0.1-canary.20251006094042.7f0be72

package/dist/api/generators/base/builders/IndexBuilder.js

@@ -1,290 +0,0 @@
-/**
- * Index file builder for automated exports
- *
- * Automatically generates index files that export all types and functions
- * from a directory, with support for grouping and namespaces.
- */
-/**
- * Builder for index files with intelligent export management
- *
- * Features:
- * - Automatic export detection
- * - Namespace support
- * - Export grouping
- * - Custom headers
- * - Template support
- */
-export class IndexBuilder {
-    config;
-    exports = new Map(); // symbol -> from path
-    namespaces = new Map(); // namespace -> path
-    reExports = new Map(); // export all from path
-    header = "";
-    footer = "";
-    groupingFunction;
-    sortFunction;
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Add exports from a specific file
-     * @param exportNames Export names
-     * @param fromPath Path to file (without extension)
-     */
-    withExports(exportNames, fromPath) {
-        for (const name of exportNames) {
-            this.exports.set(name, fromPath);
-        }
-        return this;
-    }
-    /**
-     * Add a single export
-     * @param exportName Export name
-     * @param fromPath Path to file
-     */
-    withExport(exportName, fromPath) {
-        this.exports.set(exportName, fromPath);
-        return this;
-    }
-    /**
-     * Add namespace exports
-     * @param namespaces Map of namespace to path
-     */
-    withNamespaces(namespaces) {
-        for (const [ns, path] of Object.entries(namespaces)) {
-            this.namespaces.set(ns, path);
-        }
-        return this;
-    }
-    /**
-     * Add namespace export
-     * @param namespace Namespace name
-     * @param path Path to export as namespace
-     */
-    withNamespace(namespace, path) {
-        this.namespaces.set(namespace, path);
-        return this;
-    }
-    /**
-     * Re-export all from paths
-     * @param paths Paths to re-export all from
-     */
-    withReExports(paths) {
-        for (const path of paths) {
-            this.reExports.set(path, path);
-        }
-        return this;
-    }
-    /**
-     * Add re-export
-     * @param path Path to re-export all from
-     */
-    withReExport(path) {
-        this.reExports.set(path, path);
-        return this;
-    }
-    /**
-     * Set header content
-     * @param header Header content
-     */
-    withHeader(header) {
-        this.header = header;
-        return this;
-    }
-    /**
-     * Set footer content
-     * @param footer Footer content
-     */
-    withFooter(footer) {
-        this.footer = footer;
-        return this;
-    }
-    /**
-     * Group exports by function
-     * @param fn Function that returns group name for export
-     */
-    groupBy(fn) {
-        this.groupingFunction = fn;
-        return this;
-    }
-    /**
-     * Sort exports by function
-     * @param fn Sort function for [exportName, fromPath] tuples
-     */
-    sortBy(fn) {
-        this.sortFunction = fn;
-        return this;
-    }
-    /**
-     * Auto-discover exports from directory
-     * @param filePattern Pattern to match files (e.g., "*.ts")
-     */
-    async autoDiscover(_filePattern) {
-        // This is a placeholder - in a real implementation, this would:
-        // 1. Read all files in the directory
-        // 2. Parse TypeScript/JavaScript to extract exports
-        // 3. Add them to the exports map
-        this.config.logger.debug(`Auto-discovering exports in ${this.config.directory}`);
-        // For now, just log that this feature would be implemented
-        this.config.logger.warn("Auto-discovery not yet implemented - manually add exports");
-        return this;
-    }
-    /**
-     * Save the index file
-     */
-    async save() {
-        const content = this.generateContent();
-        const indexPath = `${this.config.directory}/index.ts`;
-        const result = await this.config.fileManager.writeFile(indexPath, content);
-        this.config.logger.debug(`Generated index file: ${indexPath}`);
-        return result.path;
-    }
-    /**
-     * Build content without saving (for preview)
-     */
-    build() {
-        return this.generateContent();
-    }
-    /**
-     * Generate the index file content
-     */
-    generateContent() {
-        const lines = [];
-        // Add header
-        if (this.header) {
-            lines.push(this.header);
-            lines.push("");
-        }
-        // Add re-exports first
-        if (this.reExports.size > 0) {
-            lines.push("// Re-exports");
-            for (const path of this.reExports.values()) {
-                lines.push(`export * from './${path}';`);
-            }
-            lines.push("");
-        }
-        // Process exports
-        if (this.exports.size > 0) {
-            if (this.groupingFunction) {
-                this.generateGroupedExports(lines);
-            }
-            else {
-                this.generateSimpleExports(lines);
-            }
-            lines.push("");
-        }
-        // Add namespace exports
-        if (this.namespaces.size > 0) {
-            lines.push("// Namespace exports");
-            const sortedNamespaces = Array.from(this.namespaces.entries()).sort();
-            for (const [ns, path] of sortedNamespaces) {
-                lines.push(`export * as ${ns} from './${path}';`);
-            }
-            lines.push("");
-        }
-        // Add footer
-        if (this.footer) {
-            lines.push(this.footer);
-        }
-        // Clean up extra empty lines
-        const content = lines
-            .join("\n")
-            .replace(/\n{3,}/g, "\n\n")
-            .trim();
-        return `${content}\n`; // Ensure file ends with newline
-    }
-    /**
-     * Generate simple exports without grouping
-     */
-    generateSimpleExports(lines) {
-        lines.push("// Exports");
-        let exportEntries = Array.from(this.exports.entries());
-        // Apply custom sorting if provided
-        if (this.sortFunction) {
-            exportEntries = exportEntries.sort(this.sortFunction);
-        }
-        else {
-            // Default: sort by export name
-            exportEntries = exportEntries.sort(([a], [b]) => a.localeCompare(b));
-        }
-        // Group by path for cleaner output
-        const exportsByPath = new Map();
-        for (const [exportName, fromPath] of exportEntries) {
-            if (!exportsByPath.has(fromPath)) {
-                exportsByPath.set(fromPath, []);
-            }
-            exportsByPath.get(fromPath)?.push(exportName);
-        }
-        // Generate export statements
-        for (const [path, exports] of exportsByPath) {
-            const sortedExports = exports.sort();
-            if (sortedExports.length === 1) {
-                lines.push(`export type { ${sortedExports[0]} } from './${path}';`);
-            }
-            else if (sortedExports.length <= 3) {
-                lines.push(`export type { ${sortedExports.join(", ")} } from './${path}';`);
-            }
-            else {
-                lines.push(`export type {`);
-                sortedExports.forEach((exp, index) => {
-                    const isLast = index === sortedExports.length - 1;
-                    lines.push(`\t${exp}${isLast ? "" : ","}`);
-                });
-                lines.push(`} from './${path}';`);
-            }
-        }
-    }
-    /**
-     * Generate grouped exports
-     */
-    generateGroupedExports(lines) {
-        if (!this.groupingFunction)
-            return;
-        const groups = new Map();
-        // Group exports
-        for (const [exportName, fromPath] of this.exports) {
-            const group = this.groupingFunction(exportName);
-            if (!groups.has(group)) {
-                groups.set(group, new Map());
-            }
-            const groupMap = groups.get(group);
-            if (!groupMap.has(fromPath)) {
-                groupMap.set(fromPath, []);
-            }
-            groupMap.get(fromPath)?.push(exportName);
-        }
-        // Generate grouped output
-        const sortedGroups = Array.from(groups.entries()).sort();
-        for (const [groupName, groupExports] of sortedGroups) {
-            lines.push(`// ${groupName}`);
-            for (const [path, exports] of groupExports) {
-                const sortedExports = exports.sort();
-                if (sortedExports.length === 1) {
-                    lines.push(`export type { ${sortedExports[0]} } from './${path}';`);
-                }
-                else {
-                    lines.push(`export type { ${sortedExports.join(", ")} } from './${path}';`);
-                }
-            }
-            lines.push("");
-        }
-    }
-    /**
-     * Get current exports (for testing/debugging)
-     */
-    getExports() {
-        return new Map(this.exports);
-    }
-    /**
-     * Get current namespaces (for testing/debugging)
-     */
-    getNamespaces() {
-        return new Map(this.namespaces);
-    }
-    /**
-     * Get current re-exports (for testing/debugging)
-     */
-    getReExports() {
-        return new Map(this.reExports);
-    }
-}

package/dist/api/generators/base/enhanced-errors.d.ts

@@ -1,84 +0,0 @@
-/**
- * Enhanced error handling with rich context and suggestions
- *
- * This module builds on the basic GeneratorError classes to provide
- * even more detailed error context, smarter suggestions, and better
- * user experience for developers at all skill levels.
- */
-import type { TypeSchema } from "@typeschema/index";
-import { GeneratorError } from "./errors";
-/**
- * Enhanced schema validation error with smart suggestions
- */
-export declare class EnhancedSchemaValidationError extends GeneratorError {
-    readonly schema: TypeSchema;
-    readonly validationErrors: string[];
-    readonly userContext?: {
-        isBeginnerMode?: boolean;
-        previousSuccessfulSchemas?: string[];
-        commonPatterns?: string[];
-    } | undefined;
-    constructor(message: string, schema: TypeSchema, validationErrors: string[], userContext?: {
-        isBeginnerMode?: boolean;
-        previousSuccessfulSchemas?: string[];
-        commonPatterns?: string[];
-    } | undefined);
-    getSuggestions(): string[];
-    /**
-     * Get formatted error message for display
-     */
-    getFormattedMessage(): string;
-}
-/**
- * Enhanced file operation error with recovery suggestions
- */
-export declare class EnhancedFileOperationError extends GeneratorError {
-    readonly operation: "create" | "write" | "read" | "delete";
-    readonly filePath: string;
-    readonly originalError?: Error | undefined;
-    readonly recoveryOptions?: {
-        canRetry?: boolean;
-        alternativePaths?: string[];
-        permissionFix?: string;
-    } | undefined;
-    constructor(message: string, operation: "create" | "write" | "read" | "delete", filePath: string, originalError?: Error | undefined, recoveryOptions?: {
-        canRetry?: boolean;
-        alternativePaths?: string[];
-        permissionFix?: string;
-    } | undefined);
-    getSuggestions(): string[];
-    /**
-     * Check if this error is recoverable
-     */
-    isRecoverable(): boolean;
-    /**
-     * Get recovery actions user can take
-     */
-    getRecoveryActions(): Array<{
-        action: string;
-        command?: string;
-        automatic?: boolean;
-    }>;
-}
-/**
- * Enhanced template error with template debugging info
- */
-export declare class EnhancedTemplateError extends GeneratorError {
-    readonly templateName: string;
-    readonly templateContext: Record<string, unknown>;
-    readonly debugInfo?: {
-        availableTemplates?: string[];
-        missingVariables?: string[];
-        templateSource?: string;
-        lineNumber?: number;
-    } | undefined;
-    constructor(message: string, templateName: string, templateContext: Record<string, unknown>, debugInfo?: {
-        availableTemplates?: string[];
-        missingVariables?: string[];
-        templateSource?: string;
-        lineNumber?: number;
-    } | undefined);
-    getSuggestions(): string[];
-    private findSimilarTemplates;
-    private levenshteinDistance;
-}

package/dist/api/generators/base/enhanced-errors.js

@@ -1,259 +0,0 @@
-/**
- * Enhanced error handling with rich context and suggestions
- *
- * This module builds on the basic GeneratorError classes to provide
- * even more detailed error context, smarter suggestions, and better
- * user experience for developers at all skill levels.
- */
-import { GeneratorError } from "./errors";
-/**
- * Enhanced schema validation error with smart suggestions
- */
-export class EnhancedSchemaValidationError extends GeneratorError {
-    schema;
-    validationErrors;
-    userContext;
-    constructor(message, schema, validationErrors, userContext) {
-        super(message, "validation", {
-            schemaName: schema.identifier.name,
-            schemaKind: schema.identifier.kind,
-            schemaPackage: schema.identifier.package,
-            validationErrors,
-            userContext,
-        });
-        this.schema = schema;
-        this.validationErrors = validationErrors;
-        this.userContext = userContext;
-    }
-    getSuggestions() {
-        const suggestions = [];
-        // Basic suggestions
-        suggestions.push("Check the schema structure matches TypeSchema specification");
-        suggestions.push("Verify all required fields are present");
-        // Context-aware suggestions based on validation errors
-        for (const error of this.validationErrors) {
-            if (error.includes("identifier.name")) {
-                suggestions.push("Add missing identifier.name field to the schema");
-                suggestions.push("Ensure identifier.name is a non-empty string");
-            }
-            if (error.includes("identifier.kind")) {
-                suggestions.push("Set identifier.kind to one of: resource, complex-type, profile, primitive-type");
-                suggestions.push("Check FHIR specification for valid kind values");
-            }
-            if (error.includes("circular")) {
-                suggestions.push("Remove circular references between schemas");
-                suggestions.push("Use forward references for recursive types");
-            }
-        }
-        // Beginner-friendly suggestions
-        if (this.userContext?.isBeginnerMode) {
-            suggestions.push("📚 Review the TypeSchema documentation at: docs/typeschema.md");
-            suggestions.push("🔍 Use --verbose flag for more detailed error information");
-            if (this.userContext.previousSuccessfulSchemas?.length) {
-                suggestions.push(`✅ Compare with working schema: ${this.userContext.previousSuccessfulSchemas[0]}`);
-            }
-        }
-        return suggestions;
-    }
-    /**
-     * Get formatted error message for display
-     */
-    getFormattedMessage() {
-        const lines = [
-            `❌ Schema Validation Failed: ${this.message}`,
-            "",
-            "📍 Context:",
-            `   Schema: ${this.schema.identifier.name}`,
-            `   Kind: ${this.schema.identifier.kind}`,
-            `   Package: ${this.schema.identifier.package || "unknown"}`,
-            "",
-        ];
-        if (this.validationErrors.length > 0) {
-            lines.push("🔍 Validation Errors:");
-            this.validationErrors.forEach((error, index) => {
-                lines.push(`   ${index + 1}. ${error}`);
-            });
-            lines.push("");
-        }
-        const suggestions = this.getSuggestions();
-        if (suggestions.length > 0) {
-            lines.push("💡 Suggestions:");
-            suggestions.forEach((suggestion) => {
-                lines.push(`   • ${suggestion}`);
-            });
-        }
-        return lines.join("\n");
-    }
-}
-/**
- * Enhanced file operation error with recovery suggestions
- */
-export class EnhancedFileOperationError extends GeneratorError {
-    operation;
-    filePath;
-    originalError;
-    recoveryOptions;
-    constructor(message, operation, filePath, originalError, recoveryOptions) {
-        super(message, "writing", {
-            operation,
-            filePath,
-            originalError: originalError?.message,
-            recoveryOptions,
-        });
-        this.operation = operation;
-        this.filePath = filePath;
-        this.originalError = originalError;
-        this.recoveryOptions = recoveryOptions;
-    }
-    getSuggestions() {
-        const suggestions = [];
-        // Operation-specific suggestions
-        switch (this.operation) {
-            case "create":
-            case "write":
-                suggestions.push("Check if the directory exists and is writable");
-                suggestions.push("Verify you have permission to write to this location");
-                if (this.filePath.includes(" ")) {
-                    suggestions.push("File path contains spaces - ensure proper escaping");
-                }
-                if (this.recoveryOptions?.alternativePaths?.length) {
-                    suggestions.push("Try alternative output directory:");
-                    this.recoveryOptions.alternativePaths.forEach((path) => {
-                        suggestions.push(`  • ${path}`);
-                    });
-                }
-                break;
-            case "read":
-                suggestions.push("Verify the file exists at the specified path");
-                suggestions.push("Check file permissions are readable");
-                break;
-            case "delete":
-                suggestions.push("Check if file is locked by another process");
-                suggestions.push("Verify delete permissions for this directory");
-                break;
-        }
-        // Permission-specific suggestions
-        if (this.originalError?.message.includes("EACCES")) {
-            suggestions.push("Permission denied - try running with elevated permissions");
-            if (this.recoveryOptions?.permissionFix) {
-                suggestions.push(`Fix command: ${this.recoveryOptions.permissionFix}`);
-            }
-        }
-        // Space-related suggestions
-        if (this.originalError?.message.includes("ENOSPC")) {
-            suggestions.push("Insufficient disk space - free up space and retry");
-            suggestions.push("Consider using a different output directory");
-        }
-        // Recovery suggestions
-        if (this.recoveryOptions?.canRetry) {
-            suggestions.push("This operation can be retried safely");
-        }
-        return suggestions;
-    }
-    /**
-     * Check if this error is recoverable
-     */
-    isRecoverable() {
-        return this.recoveryOptions?.canRetry || false;
-    }
-    /**
-     * Get recovery actions user can take
-     */
-    getRecoveryActions() {
-        const actions = [];
-        if (this.originalError?.message.includes("EACCES")) {
-            actions.push({
-                action: "Fix file permissions",
-                command: `chmod 755 "${this.filePath}"`,
-                automatic: false,
-            });
-        }
-        if (this.originalError?.message.includes("ENOENT")) {
-            actions.push({
-                action: "Create missing directory",
-                command: `mkdir -p "${this.filePath}"`,
-                automatic: true,
-            });
-        }
-        return actions;
-    }
-}
-/**
- * Enhanced template error with template debugging info
- */
-export class EnhancedTemplateError extends GeneratorError {
-    templateName;
-    templateContext;
-    debugInfo;
-    constructor(message, templateName, templateContext, debugInfo) {
-        super(message, "generation", {
-            templateName,
-            contextKeys: Object.keys(templateContext),
-            debugInfo,
-        });
-        this.templateName = templateName;
-        this.templateContext = templateContext;
-        this.debugInfo = debugInfo;
-    }
-    getSuggestions() {
-        const suggestions = [];
-        // Template existence suggestions
-        if (this.debugInfo?.availableTemplates?.length) {
-            suggestions.push("Available templates:");
-            this.debugInfo.availableTemplates.forEach((template) => {
-                suggestions.push(`  • ${template}`);
-            });
-            // Suggest similar template names
-            const similar = this.findSimilarTemplates(this.templateName, this.debugInfo.availableTemplates);
-            if (similar.length > 0) {
-                suggestions.push("Did you mean:");
-                similar.forEach((template) => {
-                    suggestions.push(`  • ${template}`);
-                });
-            }
-        }
-        // Missing variables suggestions
-        if (this.debugInfo?.missingVariables?.length) {
-            suggestions.push("Missing template variables:");
-            this.debugInfo.missingVariables.forEach((variable) => {
-                suggestions.push(`  • ${variable}`);
-            });
-            suggestions.push("Add these variables to the template context");
-        }
-        // Template syntax suggestions
-        if (this.debugInfo?.lineNumber) {
-            suggestions.push(`Check template syntax around line ${this.debugInfo.lineNumber}`);
-        }
-        suggestions.push("Enable template debugging: { debug: true }");
-        suggestions.push("Verify template file exists and has correct syntax");
-        return suggestions;
-    }
-    findSimilarTemplates(target, available) {
-        return available
-            .filter((template) => {
-            const distance = this.levenshteinDistance(target.toLowerCase(), template.toLowerCase());
-            return distance <= 2 && distance > 0;
-        })
-            .slice(0, 3);
-    }
-    levenshteinDistance(str1, str2) {
-        const matrix = [];
-        for (let i = 0; i <= str2.length; i++) {
-            matrix[i] = [i];
-        }
-        for (let j = 0; j <= str1.length; j++) {
-            matrix[0][j] = j;
-        }
-        for (let i = 1; i <= str2.length; i++) {
-            for (let j = 1; j <= str1.length; j++) {
-                if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
-                    matrix[i][j] = matrix[i - 1]?.[j - 1];
-                }
-                else {
-                    matrix[i][j] = Math.min(matrix[i - 1]?.[j - 1] + 1, matrix[i]?.[j - 1] + 1, matrix[i - 1]?.[j] + 1);
-                }
-            }
-        }
-        return matrix[str2.length]?.[str1.length];
-    }
-}