@atomic-ehr/codegen 0.0.1-canary.20250822114054.4ca1428 → 0.0.1-canary.20250822150706.c3b8669

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

@@ -1,8 +1,8 @@
 /**
  * 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";
+import { createSpinner } from "./spinner.js";
+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.js";
 export { createSpinner };
 /**
  * Run a task with a spinner

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

@@ -1 +1 @@
-{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/log.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG1C,OAAO,EACN,KAAK,aAAa,EAClB,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,KAAK,EACL,GAAG,EACH,KAAK,EACL,MAAM,EACN,IAAI,EACJ,KAAK,UAAU,EACf,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,OAAO,EACP,KAAK,EACL,IAAI,GACJ,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,aAAa,EAAE,CAAC;AAEzB;;GAEG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAClC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,EAAE,MAAM,EACf,cAAc,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,CAAC,CAAC,CAUZ"}
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/log.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C,OAAO,EACN,KAAK,aAAa,EAClB,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,KAAK,EACL,GAAG,EACH,KAAK,EACL,MAAM,EACN,IAAI,EACJ,KAAK,UAAU,EACf,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,OAAO,EACP,KAAK,EACL,IAAI,GACJ,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,aAAa,EAAE,CAAC;AAEzB;;GAEG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAClC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,EAAE,MAAM,EACf,cAAc,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,CAAC,CAAC,CAUZ"}

package/dist/cli/utils/log.js

@@ -0,0 +1,23 @@
+/**
+ * CLI Utilities - Re-exports from main utils with spinner support
+ */
+import { createSpinner } from "./spinner.js";
+// 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.js";
+// 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.js

@@ -0,0 +1,224 @@
+/**
+ * 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" },
+            { name: "REST Client", value: "rest-client" },
+        ],
+    });
+    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;
+        case "rest-client":
+            config.httpClient = await select({
+                message: "HTTP client library:",
+                choices: [
+                    { name: "Fetch (native)", value: "fetch" },
+                    { name: "Axios", value: "axios" },
+                    { name: "Node fetch", value: "node-fetch" },
+                ],
+                default: "fetch",
+            });
+            config.authentication = await select({
+                message: "Authentication type:",
+                choices: [
+                    { name: "None", value: "none" },
+                    { name: "Bearer token", value: "bearer" },
+                    { name: "Basic auth", value: "basic" },
+                    { name: "OAuth2", value: "oauth2" },
+                ],
+                default: "none",
+            });
+            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.js

@@ -0,0 +1,270 @@
+/**
+ * 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;
+}