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

package/dist/cli/index.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-/**
- * Atomic Codegen CLI - Simplified High-Level API
- *
- * Clean, performant CLI with only essential commands:
- * - typeschema: Create and manage TypeSchema files
- * - generate: Generate code from TypeSchema
- */
-export {};

package/dist/cli/utils/log.d.ts

@@ -1,10 +0,0 @@
-/**
- * CLI Utilities - Re-exports from main utils with spinner support
- */
-import { createSpinner } from "./spinner";
-export { type CodegenLogger, complete, configure, createLogger, debug, dim, error, header, info, type LogOptions, list, plain, progress, section, step, success, table, warn, } from "../../utils/codegen-logger";
-export { createSpinner };
-/**
- * Run a task with a spinner
- */
-export declare function withSpinner<T>(promise: Promise<T>, message: string, successMessage?: string): Promise<T>;

package/dist/cli/utils/log.js

@@ -1,23 +0,0 @@
-/**
- * CLI Utilities - Re-exports from main utils with spinner support
- */
-import { createSpinner } from "./spinner";
-// Re-export all logger functions from the main utils
-export { complete, configure, createLogger, debug, dim, error, header, info, list, plain, progress, section, step, success, table, warn, } from "../../utils/codegen-logger";
-// Export CLI-specific utilities
-export { createSpinner };
-/**
- * Run a task with a spinner
- */
-export async function withSpinner(promise, message, successMessage) {
-    const spinner = createSpinner(message).start();
-    try {
-        const result = await promise;
-        spinner.succeed(successMessage || message);
-        return result;
-    }
-    catch (error) {
-        spinner.fail(`Failed: ${message}`);
-        throw error;
-    }
-}

package/dist/cli/utils/prompts.d.ts

@@ -1,56 +0,0 @@
-/**
- * CLI Prompts Utility
- *
- * Interactive prompts for better CLI user experience
- */
-/**
- * Prompt for project initialization
- */
-export declare function promptInitConfig(): Promise<{
-    projectName: string;
-    description?: string;
-    outputDir: string;
-    generators: string[];
-    packageManager: "npm" | "yarn" | "pnpm" | "bun";
-    typescript: boolean;
-}>;
-/**
- * Prompt for FHIR package selection
- */
-export declare function promptFHIRPackage(): Promise<{
-    packageId: string;
-    version?: string;
-    profiles?: string[];
-}>;
-/**
- * Prompt for generator configuration
- */
-export declare function promptGeneratorConfig(generatorId: string): Promise<Record<string, any>>;
-/**
- * Prompt for confirmation with custom message
- */
-export declare function promptConfirm(message: string, defaultValue?: boolean): Promise<boolean>;
-/**
- * Prompt for text input with validation
- */
-export declare function promptInput(message: string, options?: {
-    default?: string;
-    validate?: (value: string) => boolean | string;
-    transform?: (value: string) => string;
-}): Promise<string>;
-/**
- * Show success message
- */
-export declare function showSuccess(message: string): void;
-/**
- * Show error message
- */
-export declare function showError(message: string): void;
-/**
- * Show warning message
- */
-export declare function showWarning(message: string): void;
-/**
- * Show info message
- */
-export declare function showInfo(message: string): void;

package/dist/cli/utils/prompts.js

@@ -1,202 +0,0 @@
-/**
- * CLI Prompts Utility
- *
- * Interactive prompts for better CLI user experience
- */
-import { checkbox, confirm, input, select } from "@inquirer/prompts";
-import pc from "picocolors";
-/**
- * Prompt for project initialization
- */
-export async function promptInitConfig() {
-    console.log(pc.bold(pc.blue("\n🚀 Initialize Atomic Codegen Project\n")));
-    const projectName = await input({
-        message: "Project name:",
-        default: "my-fhir-types",
-        validate: (value) => {
-            if (!value.trim())
-                return "Project name is required";
-            if (!/^[a-z0-9-_]+$/i.test(value)) {
-                return "Project name can only contain letters, numbers, hyphens, and underscores";
-            }
-            return true;
-        },
-    });
-    const description = await input({
-        message: "Project description (optional):",
-        default: "",
-    });
-    const outputDir = await input({
-        message: "Output directory for generated code:",
-        default: "./generated",
-    });
-    const generators = await checkbox({
-        message: "Select generators to use:",
-        choices: [
-            { name: "TypeScript", value: "typescript", checked: true },
-            { name: "Python", value: "python" },
-        ],
-    });
-    const packageManager = (await select({
-        message: "Package manager:",
-        choices: [
-            { name: "Bun", value: "bun" },
-            { name: "npm", value: "npm" },
-            { name: "Yarn", value: "yarn" },
-            { name: "pnpm", value: "pnpm" },
-        ],
-        default: "bun",
-    }));
-    const typescript = await confirm({
-        message: "Use TypeScript for configuration?",
-        default: true,
-    });
-    return {
-        projectName,
-        description,
-        outputDir,
-        generators,
-        packageManager,
-        typescript,
-    };
-}
-/**
- * Prompt for FHIR package selection
- */
-export async function promptFHIRPackage() {
-    const packageId = await select({
-        message: "Select FHIR package:",
-        choices: [
-            { name: "FHIR R4 Core", value: "hl7.fhir.r4.core" },
-            { name: "FHIR R5 Core", value: "hl7.fhir.r5.core" },
-            { name: "US Core", value: "hl7.fhir.us.core" },
-            { name: "Custom package...", value: "custom" },
-        ],
-    });
-    let finalPackageId = packageId;
-    let version;
-    if (packageId === "custom") {
-        finalPackageId = await input({
-            message: "Enter package ID (e.g., hl7.fhir.us.core):",
-            validate: (value) => {
-                if (!value.trim())
-                    return "Package ID is required";
-                return true;
-            },
-        });
-        version = await input({
-            message: "Package version (optional):",
-            default: "",
-        });
-    }
-    const includeProfiles = await confirm({
-        message: "Include profiles in generation?",
-        default: false,
-    });
-    let profiles = [];
-    if (includeProfiles) {
-        const profileSelection = await select({
-            message: "Profile selection:",
-            choices: [
-                { name: "All profiles", value: "all" },
-                { name: "None", value: "none" },
-            ],
-            default: "none",
-        });
-        if (profileSelection === "all") {
-            profiles = ["*"];
-        }
-    }
-    return {
-        packageId: finalPackageId,
-        version: version || undefined,
-        profiles,
-    };
-}
-/**
- * Prompt for generator configuration
- */
-export async function promptGeneratorConfig(generatorId) {
-    const config = {};
-    switch (generatorId) {
-        case "typescript":
-            config.moduleFormat = await select({
-                message: "Module format:",
-                choices: [
-                    { name: "ESM", value: "esm" },
-                    { name: "CommonJS", value: "cjs" },
-                    { name: "Both", value: "both" },
-                ],
-                default: "esm",
-            });
-            config.strict = await confirm({
-                message: "Enable strict TypeScript checks?",
-                default: true,
-            });
-            config.generateIndex = await confirm({
-                message: "Generate index files?",
-                default: true,
-            });
-            break;
-        case "python":
-            config.style = await select({
-                message: "Python style:",
-                choices: [
-                    { name: "Dataclasses", value: "dataclass" },
-                    { name: "Pydantic", value: "pydantic" },
-                    { name: "Plain classes", value: "plain" },
-                ],
-                default: "dataclass",
-            });
-            config.typeHints = await confirm({
-                message: "Include type hints?",
-                default: true,
-            });
-            break;
-    }
-    return config;
-}
-/**
- * Prompt for confirmation with custom message
- */
-export async function promptConfirm(message, defaultValue = false) {
-    return await confirm({
-        message,
-        default: defaultValue,
-    });
-}
-/**
- * Prompt for text input with validation
- */
-export async function promptInput(message, options) {
-    return await input({
-        message,
-        default: options?.default,
-        validate: options?.validate,
-        transformer: options?.transform,
-    });
-}
-/**
- * Show success message
- */
-export function showSuccess(message) {
-    console.log(pc.green(`✅ ${message}`));
-}
-/**
- * Show error message
- */
-export function showError(message) {
-    console.log(pc.red(`❌ ${message}`));
-}
-/**
- * Show warning message
- */
-export function showWarning(message) {
-    console.log(pc.yellow(`⚠️  ${message}`));
-}
-/**
- * Show info message
- */
-export function showInfo(message) {
-    console.log(pc.blue(`ℹ️  ${message}`));
-}

package/dist/cli/utils/spinner.d.ts

@@ -1,110 +0,0 @@
-/**
- * CLI Spinner and Progress Utilities
- *
- * Visual progress indicators for long-running operations
- */
-/**
- * Task progress tracker
- */
-export declare class ProgressTracker {
-    private tasks;
-    private currentSpinner;
-    /**
-     * Start a new task
-     */
-    startTask(taskId: string, message: string): void;
-    /**
-     * Update task progress
-     */
-    updateTask(taskId: string, message: string): void;
-    /**
-     * Complete a task successfully
-     */
-    completeTask(taskId: string, message?: string): void;
-    /**
-     * Fail a task
-     */
-    failTask(taskId: string, error?: string): void;
-    /**
-     * Stop all spinners
-     */
-    stop(): void;
-    /**
-     * Get task statistics
-     */
-    getStats(): {
-        total: number;
-        completed: number;
-        failed: number;
-        running: number;
-        pending: number;
-    };
-}
-/**
- * Simple spinner for single operations
- */
-export declare class SimpleSpinner {
-    private spinner;
-    constructor(message: string);
-    start(message?: string): SimpleSpinner;
-    update(message: string): SimpleSpinner;
-    succeed(message?: string): void;
-    fail(message?: string): void;
-    warn(message?: string): void;
-    info(message?: string): void;
-    stop(): void;
-}
-/**
- * Progress bar for batch operations
- */
-export declare class ProgressBar {
-    private total;
-    private message;
-    private current;
-    private barLength;
-    private startTime;
-    constructor(total: number, message: string);
-    /**
-     * Update progress
-     */
-    update(current: number, additionalInfo?: string): void;
-    /**
-     * Increment progress by 1
-     */
-    increment(additionalInfo?: string): void;
-    /**
-     * Complete the progress bar
-     */
-    complete(message?: string): void;
-    /**
-     * Render the progress bar
-     */
-    private render;
-}
-/**
- * Create a simple spinner
- */
-export declare function createSpinner(message: string): SimpleSpinner;
-/**
- * Create a progress tracker for multiple tasks
- */
-export declare function createProgressTracker(): ProgressTracker;
-/**
- * Create a progress bar
- */
-export declare function createProgressBar(total: number, message: string): ProgressBar;
-/**
- * Show a spinner for a promise
- */
-export declare function withSpinner<T>(promise: Promise<T>, options: {
-    start: string;
-    success?: string | ((result: T) => string);
-    fail?: string | ((error: any) => string);
-}): Promise<T>;
-/**
- * Multi-step task execution with progress
- */
-export declare function executeSteps<T>(steps: Array<{
-    name: string;
-    task: () => Promise<T>;
-}>): Promise<T[]>;

package/dist/cli/utils/spinner.js

@@ -1,266 +0,0 @@
-/**
- * CLI Spinner and Progress Utilities
- *
- * Visual progress indicators for long-running operations
- */
-import { performance } from "node:perf_hooks";
-import ora from "ora";
-import pc from "picocolors";
-/**
- * Task progress tracker
- */
-export class ProgressTracker {
-    tasks = new Map();
-    currentSpinner = null;
-    /**
-     * Start a new task
-     */
-    startTask(taskId, message) {
-        this.tasks.set(taskId, {
-            startTime: performance.now(),
-            status: "running",
-        });
-        if (this.currentSpinner) {
-            this.currentSpinner.stop();
-        }
-        this.currentSpinner = ora({
-            text: message,
-            spinner: "dots",
-        }).start();
-    }
-    /**
-     * Update task progress
-     */
-    updateTask(taskId, message) {
-        const task = this.tasks.get(taskId);
-        if (!task || task.status !== "running")
-            return;
-        if (this.currentSpinner) {
-            this.currentSpinner.text = message;
-        }
-    }
-    /**
-     * Complete a task successfully
-     */
-    completeTask(taskId, message) {
-        const task = this.tasks.get(taskId);
-        if (!task)
-            return;
-        const duration = Math.round(performance.now() - task.startTime);
-        task.status = "completed";
-        if (this.currentSpinner) {
-            const finalMessage = message || this.currentSpinner.text;
-            this.currentSpinner.succeed(`${finalMessage} ${pc.gray(`(${duration}ms)`)}`);
-            this.currentSpinner = null;
-        }
-    }
-    /**
-     * Fail a task
-     */
-    failTask(taskId, error) {
-        const task = this.tasks.get(taskId);
-        if (!task)
-            return;
-        task.status = "failed";
-        if (this.currentSpinner) {
-            const errorMessage = error ? `: ${error}` : "";
-            this.currentSpinner.fail(this.currentSpinner.text + errorMessage);
-            this.currentSpinner = null;
-        }
-    }
-    /**
-     * Stop all spinners
-     */
-    stop() {
-        if (this.currentSpinner) {
-            this.currentSpinner.stop();
-            this.currentSpinner = null;
-        }
-    }
-    /**
-     * Get task statistics
-     */
-    getStats() {
-        let completed = 0;
-        let failed = 0;
-        let running = 0;
-        let pending = 0;
-        for (const task of this.tasks.values()) {
-            switch (task.status) {
-                case "completed":
-                    completed++;
-                    break;
-                case "failed":
-                    failed++;
-                    break;
-                case "running":
-                    running++;
-                    break;
-                case "pending":
-                    pending++;
-                    break;
-            }
-        }
-        return {
-            total: this.tasks.size,
-            completed,
-            failed,
-            running,
-            pending,
-        };
-    }
-}
-/**
- * Simple spinner for single operations
- */
-export class SimpleSpinner {
-    spinner;
-    constructor(message) {
-        this.spinner = ora({
-            text: message,
-            spinner: "dots",
-        });
-    }
-    start(message) {
-        if (message) {
-            this.spinner.text = message;
-        }
-        this.spinner.start();
-        return this;
-    }
-    update(message) {
-        this.spinner.text = message;
-        return this;
-    }
-    succeed(message) {
-        this.spinner.succeed(message);
-    }
-    fail(message) {
-        this.spinner.fail(message);
-    }
-    warn(message) {
-        this.spinner.warn(message);
-    }
-    info(message) {
-        this.spinner.info(message);
-    }
-    stop() {
-        this.spinner.stop();
-    }
-}
-/**
- * Progress bar for batch operations
- */
-export class ProgressBar {
-    total;
-    message;
-    current = 0;
-    barLength = 30;
-    startTime = performance.now();
-    constructor(total, message) {
-        this.total = total;
-        this.message = message;
-    }
-    /**
-     * Update progress
-     */
-    update(current, additionalInfo) {
-        this.current = Math.min(current, this.total);
-        this.render(additionalInfo);
-    }
-    /**
-     * Increment progress by 1
-     */
-    increment(additionalInfo) {
-        this.update(this.current + 1, additionalInfo);
-    }
-    /**
-     * Complete the progress bar
-     */
-    complete(message) {
-        this.current = this.total;
-        this.render();
-        const duration = Math.round(performance.now() - this.startTime);
-        console.log(pc.green(`✅ ${message || this.message} ${pc.gray(`(${duration}ms)`)}`));
-    }
-    /**
-     * Render the progress bar
-     */
-    render(additionalInfo) {
-        const percentage = Math.round((this.current / this.total) * 100);
-        const filled = Math.round((this.current / this.total) * this.barLength);
-        const empty = this.barLength - filled;
-        const bar = pc.green("█".repeat(filled)) + pc.gray("░".repeat(empty));
-        const progress = `${this.current}/${this.total}`;
-        const info = additionalInfo ? pc.gray(` ${additionalInfo}`) : "";
-        // Clear line and write progress
-        process.stdout.clearLine(0);
-        process.stdout.cursorTo(0);
-        process.stdout.write(`${this.message} ${bar} ${pc.cyan(progress)} ${pc.yellow(`${percentage}%`)}${info}`);
-        // Add newline when complete
-        if (this.current === this.total) {
-            process.stdout.write("\n");
-        }
-    }
-}
-/**
- * Create a simple spinner
- */
-export function createSpinner(message) {
-    return new SimpleSpinner(message);
-}
-/**
- * Create a progress tracker for multiple tasks
- */
-export function createProgressTracker() {
-    return new ProgressTracker();
-}
-/**
- * Create a progress bar
- */
-export function createProgressBar(total, message) {
-    return new ProgressBar(total, message);
-}
-/**
- * Show a spinner for a promise
- */
-export async function withSpinner(promise, options) {
-    const spinner = ora({
-        text: options.start,
-        spinner: "dots",
-    }).start();
-    try {
-        const result = await promise;
-        const successMessage = typeof options.success === "function" ? options.success(result) : options.success || options.start;
-        spinner.succeed(successMessage);
-        return result;
-    }
-    catch (error) {
-        const failMessage = typeof options.fail === "function" ? options.fail(error) : options.fail || `Failed: ${options.start}`;
-        spinner.fail(failMessage);
-        throw error;
-    }
-}
-/**
- * Multi-step task execution with progress
- */
-export async function executeSteps(steps) {
-    const results = [];
-    const progressBar = new ProgressBar(steps.length, "Executing tasks");
-    for (let i = 0; i < steps.length; i++) {
-        const step = steps[i];
-        progressBar.update(i, step?.name);
-        try {
-            const result = await step?.task();
-            if (result) {
-                results.push(result);
-            }
-        }
-        catch (error) {
-            progressBar.complete(`Failed at step: ${step?.name}`);
-            throw error;
-        }
-    }
-    progressBar.complete("All tasks completed");
-    return results;
-}