@thiagodiogo/pastelsdd 1.0.0-beta.1

package/dist/telemetry/config.d.ts

@@ -0,0 +1,38 @@
+export declare const CONFIG_DIR_NAME = "pastelsdd";
+export declare const CONFIG_FILE_NAME = "config.json";
+export interface TelemetryConfig {
+    anonymousId?: string;
+    noticeSeen?: boolean;
+}
+export interface GlobalConfig {
+    telemetry?: TelemetryConfig;
+    [key: string]: unknown;
+}
+/**
+ * Get the path to the global config file.
+ * Follows XDG Base Directory Specification and platform conventions.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/pastelsdd/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/pastelsdd/
+ * - Windows fallback: %APPDATA%/pastelsdd/
+ */
+export declare function getConfigPath(): string;
+/**
+ * Read the global config file.
+ * Returns an empty object if the file doesn't exist.
+ */
+export declare function readConfig(): Promise<GlobalConfig>;
+/**
+ * Write to the global config file.
+ * Preserves existing fields and merges in new values.
+ */
+export declare function writeConfig(updates: Partial<GlobalConfig>): Promise<void>;
+/**
+ * Get the telemetry config section.
+ */
+export declare function getTelemetryConfig(): Promise<TelemetryConfig>;
+/**
+ * Update the telemetry config section.
+ */
+export declare function updateTelemetryConfig(updates: Partial<TelemetryConfig>): Promise<void>;
+//# sourceMappingURL=config.d.ts.map

package/dist/telemetry/config.js

@@ -0,0 +1,136 @@
+/**
+ * Global configuration for telemetry state.
+ * Stores anonymous ID and notice-seen flag in the platform-appropriate config directory.
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, getGlobalConfigDir, } from '../core/global-config.js';
+// Constants
+export const CONFIG_DIR_NAME = GLOBAL_CONFIG_DIR_NAME;
+export const CONFIG_FILE_NAME = GLOBAL_CONFIG_FILE_NAME;
+function getConfigDir() {
+    return getGlobalConfigDir();
+}
+function getLegacyConfigPath() {
+    return path.join(os.homedir(), '.config', CONFIG_DIR_NAME, CONFIG_FILE_NAME);
+}
+async function readConfigFile(configPath) {
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return { status: 'ok', config: JSON.parse(content) };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { status: 'missing' };
+        }
+        // If parse fails or another read error occurs, ignore the file.
+        return { status: 'invalid', config: {} };
+    }
+}
+async function writeConfigFile(configPath, config) {
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+function hasMissingTelemetryFields(config) {
+    const telemetry = config.telemetry;
+    return (!telemetry ||
+        telemetry.anonymousId === undefined ||
+        telemetry.noticeSeen === undefined);
+}
+function mergeLegacyTelemetry(config, legacyConfig) {
+    const legacyTelemetry = legacyConfig.telemetry;
+    if (!legacyTelemetry) {
+        return undefined;
+    }
+    const currentTelemetry = config.telemetry ?? {};
+    const shouldMigrate = (currentTelemetry.anonymousId === undefined && legacyTelemetry.anonymousId !== undefined) ||
+        (currentTelemetry.noticeSeen === undefined && legacyTelemetry.noticeSeen !== undefined);
+    if (!shouldMigrate) {
+        return undefined;
+    }
+    return {
+        ...config,
+        telemetry: {
+            ...legacyTelemetry,
+            ...currentTelemetry,
+        },
+    };
+}
+async function migrateLegacyTelemetryConfig(configPath, config, persist) {
+    const legacyConfigPath = getLegacyConfigPath();
+    if (path.resolve(configPath) === path.resolve(legacyConfigPath) || !hasMissingTelemetryFields(config)) {
+        return config;
+    }
+    const legacyRead = await readConfigFile(legacyConfigPath);
+    if (legacyRead.status !== 'ok') {
+        return config;
+    }
+    const migrated = mergeLegacyTelemetry(config, legacyRead.config);
+    if (!migrated) {
+        return config;
+    }
+    if (persist) {
+        try {
+            await writeConfigFile(configPath, migrated);
+        }
+        catch {
+            // Preserve telemetry for this run even if the one-time migration cannot be persisted.
+        }
+    }
+    return migrated;
+}
+/**
+ * Get the path to the global config file.
+ * Follows XDG Base Directory Specification and platform conventions.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/pastelsdd/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/pastelsdd/
+ * - Windows fallback: %APPDATA%/pastelsdd/
+ */
+export function getConfigPath() {
+    const configDir = getConfigDir();
+    return path.join(configDir, CONFIG_FILE_NAME);
+}
+/**
+ * Read the global config file.
+ * Returns an empty object if the file doesn't exist.
+ */
+export async function readConfig() {
+    const configPath = getConfigPath();
+    const read = await readConfigFile(configPath);
+    const config = read.status === 'ok' ? read.config : {};
+    return migrateLegacyTelemetryConfig(configPath, config, read.status !== 'invalid');
+}
+/**
+ * Write to the global config file.
+ * Preserves existing fields and merges in new values.
+ */
+export async function writeConfig(updates) {
+    const configPath = getConfigPath();
+    // Read existing config and merge
+    const existing = await readConfig();
+    const merged = { ...existing, ...updates };
+    // Deep merge for telemetry object
+    if (updates.telemetry && existing.telemetry) {
+        merged.telemetry = { ...existing.telemetry, ...updates.telemetry };
+    }
+    await writeConfigFile(configPath, merged);
+}
+/**
+ * Get the telemetry config section.
+ */
+export async function getTelemetryConfig() {
+    const config = await readConfig();
+    return config.telemetry ?? {};
+}
+/**
+ * Update the telemetry config section.
+ */
+export async function updateTelemetryConfig(updates) {
+    const existing = await getTelemetryConfig();
+    await writeConfig({
+        telemetry: { ...existing, ...updates },
+    });
+}
+//# sourceMappingURL=config.js.map

package/dist/telemetry/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Check if telemetry is enabled.
+ *
+ * Disabled when:
+ * - PASTELSDD_TELEMETRY=0
+ * - DO_NOT_TRACK=1
+ * - CI=true (any CI environment)
+ */
+export declare function isTelemetryEnabled(): boolean;
+/**
+ * Get or create the anonymous user ID.
+ * Lazily generates a UUID on first call and persists it.
+ */
+export declare function getOrCreateAnonymousId(): Promise<string>;
+/**
+ * Track a command execution.
+ *
+ * @param commandName - The command name (e.g., 'init', 'change:apply')
+ * @param version - The Pastelsdd version
+ */
+export declare function trackCommand(commandName: string, version: string): Promise<void>;
+/**
+ * Show first-run telemetry notice if not already seen.
+ */
+export declare function maybeShowTelemetryNotice(): Promise<void>;
+/**
+ * Shutdown the PostHog client and flush pending events.
+ * Call this before CLI exit.
+ */
+export declare function shutdown(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.js

@@ -0,0 +1,164 @@
+/**
+ * Telemetry module for anonymous usage analytics.
+ *
+ * Privacy-first design:
+ * - Only tracks command name and version
+ * - No arguments, file paths, or content
+ * - Opt-out via PASTELSDD_TELEMETRY=0 or DO_NOT_TRACK=1
+ * - Auto-disabled in CI environments
+ * - Anonymous ID is a random UUID with no relation to the user
+ */
+import { PostHog } from 'posthog-node';
+import { randomUUID } from 'crypto';
+import { getTelemetryConfig, updateTelemetryConfig } from './config.js';
+// PostHog API key - public key for client-side analytics
+// This is safe to embed as it only allows sending events, not reading data
+const POSTHOG_API_KEY = 'phc_Hthu8YvaIJ9QaFKyTG4TbVwkbd5ktcAFzVTKeMmoW2g';
+// Using reverse proxy to avoid ad blockers and keep traffic on our domain
+const POSTHOG_HOST = 'https://edge.pastelsdd.dev';
+const TELEMETRY_REQUEST_TIMEOUT_MS = 1000;
+let posthogClient = null;
+let anonymousId = null;
+async function safeTelemetryFetch(url, options) {
+    try {
+        const response = await fetch(url, options);
+        if (response.ok) {
+            return response;
+        }
+    }
+    catch {
+        // Silent failure - telemetry should never surface network noise
+    }
+    return new Response(null, { status: 204 });
+}
+/**
+ * Check if telemetry is enabled.
+ *
+ * Disabled when:
+ * - PASTELSDD_TELEMETRY=0
+ * - DO_NOT_TRACK=1
+ * - CI=true (any CI environment)
+ */
+export function isTelemetryEnabled() {
+    // Check explicit opt-out
+    if (process.env.PASTELSDD_TELEMETRY === '0') {
+        return false;
+    }
+    // Respect DO_NOT_TRACK standard
+    if (process.env.DO_NOT_TRACK === '1') {
+        return false;
+    }
+    // Auto-disable in CI environments
+    if (process.env.CI === 'true') {
+        return false;
+    }
+    return true;
+}
+/**
+ * Get or create the anonymous user ID.
+ * Lazily generates a UUID on first call and persists it.
+ */
+export async function getOrCreateAnonymousId() {
+    // Return cached value if available
+    if (anonymousId) {
+        return anonymousId;
+    }
+    // Try to load from config
+    const config = await getTelemetryConfig();
+    if (config.anonymousId) {
+        anonymousId = config.anonymousId;
+        return anonymousId;
+    }
+    // Generate new UUID and persist
+    anonymousId = randomUUID();
+    await updateTelemetryConfig({ anonymousId });
+    return anonymousId;
+}
+/**
+ * Get the PostHog client instance.
+ * Creates it on first call with CLI-optimized settings.
+ */
+function getClient() {
+    if (!posthogClient) {
+        posthogClient = new PostHog(POSTHOG_API_KEY, {
+            host: POSTHOG_HOST,
+            flushAt: 1, // Send immediately, don't batch
+            flushInterval: 0, // No timer-based flushing
+            fetchRetryCount: 0,
+            requestTimeout: TELEMETRY_REQUEST_TIMEOUT_MS,
+            preloadFeatureFlags: false,
+            disableRemoteConfig: true,
+            disableSurveys: true,
+            fetch: safeTelemetryFetch,
+        });
+    }
+    return posthogClient;
+}
+/**
+ * Track a command execution.
+ *
+ * @param commandName - The command name (e.g., 'init', 'change:apply')
+ * @param version - The Pastelsdd version
+ */
+export async function trackCommand(commandName, version) {
+    if (!isTelemetryEnabled()) {
+        return;
+    }
+    try {
+        const userId = await getOrCreateAnonymousId();
+        const client = getClient();
+        client.capture({
+            distinctId: userId,
+            event: 'command_executed',
+            properties: {
+                command: commandName,
+                version: version,
+                surface: 'cli',
+                $ip: null, // Explicitly disable IP tracking
+            },
+        });
+    }
+    catch {
+        // Silent failure - telemetry should never break CLI
+    }
+}
+/**
+ * Show first-run telemetry notice if not already seen.
+ */
+export async function maybeShowTelemetryNotice() {
+    if (!isTelemetryEnabled()) {
+        return;
+    }
+    try {
+        const config = await getTelemetryConfig();
+        if (config.noticeSeen) {
+            return;
+        }
+        // Display notice
+        console.log('Note: Pastelsdd collects anonymous usage stats. Opt out: PASTELSDD_TELEMETRY=0');
+        // Mark as seen
+        await updateTelemetryConfig({ noticeSeen: true });
+    }
+    catch {
+        // Silent failure - telemetry should never break CLI
+    }
+}
+/**
+ * Shutdown the PostHog client and flush pending events.
+ * Call this before CLI exit.
+ */
+export async function shutdown() {
+    if (!posthogClient) {
+        return;
+    }
+    try {
+        await posthogClient.shutdown();
+    }
+    catch {
+        // Silent failure - telemetry should never break CLI exit
+    }
+    finally {
+        posthogClient = null;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/ui/ascii-patterns.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ASCII art animation patterns for the welcome screen.
+ * Pastelsdd logo animation - diamond/rhombus shape with hollow center "O".
+ */
+/**
+ * Welcome animation frames - Pastelsdd logo building from center
+ * 7 rows × 6 columns diamond with hollow center "O"
+ * Center bar is 2 cols × 3 rows (rows 3,4,5 cols 3,4)
+ * Each frame is an array of strings (lines of ASCII art)
+ * Grid: 6 cols × 2 chars = 12 chars wide
+ */
+export declare const WELCOME_ANIMATION: {
+    interval: number;
+    frames: string[][];
+};
+//# sourceMappingURL=ascii-patterns.d.ts.map

package/dist/ui/ascii-patterns.js

@@ -0,0 +1,133 @@
+/**
+ * ASCII art animation patterns for the welcome screen.
+ * Pastelsdd logo animation - diamond/rhombus shape with hollow center "O".
+ */
+// Detect if full Unicode is supported
+const supportsUnicode = process.platform !== 'win32' ||
+    !!process.env.WT_SESSION || // Windows Terminal
+    !!process.env.TERM_PROGRAM; // Modern terminal
+// Character set based on Unicode support
+// Block characters for pixel-art aesthetic
+const CHARS = supportsUnicode
+    ? { full: '██', dim: '░░', empty: '  ' }
+    : { full: '##', dim: '++', empty: '  ' };
+const _ = CHARS.empty;
+const F = CHARS.full;
+const D = CHARS.dim;
+/**
+ * Welcome animation frames - Pastelsdd logo building from center
+ * 7 rows × 6 columns diamond with hollow center "O"
+ * Center bar is 2 cols × 3 rows (rows 3,4,5 cols 3,4)
+ * Each frame is an array of strings (lines of ASCII art)
+ * Grid: 6 cols × 2 chars = 12 chars wide
+ */
+export const WELCOME_ANIMATION = {
+    interval: 120,
+    frames: [
+        // Frame 1: Empty
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+        ],
+        // Frame 2: Center blocks appear (dim) - 2x3 center bar
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+        ],
+        // Frame 3: Center blocks solidify
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+        ],
+        // Frame 4: Top and bottom points appear
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${_}${_}${_}${_}`,
+            `${_}${_}${_}${_}${D}${D}${_}${_}`,
+        ],
+        // Frame 5: Inner ring forming
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${D}${_}${_}${D}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${D}${_}${_}${D}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+        ],
+        // Frame 6: Outer ring appearing
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${D}${_}${F}${F}${_}${D}`,
+            `${_}${_}${D}${_}${F}${F}${_}${D}`,
+            `${_}${_}${D}${_}${F}${F}${_}${D}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+        ],
+        // Frame 7: Full logo
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+        ],
+        // Frame 8: Hold complete logo
+        [
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 1
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 2
+            `${_}${_}${_}${_}${_}${_}${_}${_}`, // padding row 3
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${F}${_}${F}${F}${_}${F}`,
+            `${_}${_}${_}${F}${_}${_}${F}${_}`,
+            `${_}${_}${_}${_}${F}${F}${_}${_}`,
+        ],
+    ],
+};
+//# sourceMappingURL=ascii-patterns.js.map

package/dist/ui/welcome-screen.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Animated welcome screen for the experimental artifact workflow setup.
+ * Shows side-by-side layout with animated ASCII art on left and welcome text on right.
+ */
+/**
+ * Shows the animated welcome screen.
+ * Returns when user presses Enter.
+ */
+export declare function showWelcomeScreen(): Promise<void>;
+//# sourceMappingURL=welcome-screen.d.ts.map

package/dist/ui/welcome-screen.js

@@ -0,0 +1,146 @@
+/**
+ * Animated welcome screen for the experimental artifact workflow setup.
+ * Shows side-by-side layout with animated ASCII art on left and welcome text on right.
+ */
+import chalk from 'chalk';
+import { WELCOME_ANIMATION } from './ascii-patterns.js';
+// Minimum terminal width for side-by-side layout
+const MIN_WIDTH = 60;
+// Width of the ASCII art column (with padding)
+const ART_COLUMN_WIDTH = 24;
+/**
+ * Welcome text content (right column)
+ */
+function getWelcomeText() {
+    return [
+        chalk.white.bold('Welcome to Pastelsdd'),
+        chalk.dim('A lightweight spec-driven framework'),
+        '',
+        chalk.white('This setup will configure:'),
+        chalk.dim('  • Agent Skills for AI tools'),
+        chalk.dim('  • /pastel:* slash commands'),
+        '',
+        chalk.white('Quick start after setup:'),
+        `  ${chalk.yellow('/pastel:new')}      ${chalk.dim('Create a change')}`,
+        `  ${chalk.yellow('/pastel:continue')} ${chalk.dim('Next artifact')}`,
+        `  ${chalk.yellow('/pastel:apply')}    ${chalk.dim('Implement tasks')}`,
+        '',
+        chalk.cyan('Press Enter to select tools...'),
+    ];
+}
+/**
+ * Renders a single frame with side-by-side layout
+ */
+function renderFrame(artLines, textLines) {
+    const maxLines = Math.max(artLines.length, textLines.length);
+    const lines = [];
+    for (let i = 0; i < maxLines; i++) {
+        const artLine = artLines[i] || '';
+        const textLine = textLines[i] || '';
+        // Pad the art column to fixed width
+        const paddedArt = artLine.padEnd(ART_COLUMN_WIDTH);
+        // Color the ASCII art with cyan for visual appeal
+        const coloredArt = chalk.cyan(paddedArt);
+        // Clear line before writing to prevent residual characters
+        lines.push(`\x1b[2K${coloredArt}${textLine}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Checks if the terminal supports animation
+ */
+function canAnimate() {
+    // Must be TTY
+    if (!process.stdout.isTTY)
+        return false;
+    // Respect NO_COLOR
+    if (process.env.NO_COLOR)
+        return false;
+    // Check terminal width
+    const columns = process.stdout.columns || 80;
+    if (columns < MIN_WIDTH)
+        return false;
+    return true;
+}
+/**
+ * Wait for Enter key press
+ */
+function waitForEnter() {
+    return new Promise((resolve) => {
+        const { stdin } = process;
+        // Handle non-TTY gracefully
+        if (!stdin.isTTY) {
+            resolve();
+            return;
+        }
+        const wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        const onData = (data) => {
+            const char = data.toString();
+            // Enter key or Ctrl+C
+            if (char === '\r' || char === '\n' || char === '\u0003') {
+                stdin.removeListener('data', onData);
+                stdin.setRawMode(wasRaw);
+                stdin.pause();
+                // Handle Ctrl+C
+                if (char === '\u0003') {
+                    process.stdout.write('\n');
+                    process.exit(0);
+                }
+                resolve();
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
+/**
+ * Shows the animated welcome screen.
+ * Returns when user presses Enter.
+ */
+export async function showWelcomeScreen() {
+    const textLines = getWelcomeText();
+    if (!canAnimate()) {
+        // Fallback: show static welcome
+        const frame = WELCOME_ANIMATION.frames[3]; // Peak frame
+        process.stdout.write('\n' + renderFrame(frame, textLines) + '\n\n');
+        return;
+    }
+    let frameIndex = 0;
+    let running = true;
+    let isFirstRender = true;
+    // Content height for cursor movement between frames
+    const numContentLines = Math.max(WELCOME_ANIMATION.frames[0].length, textLines.length);
+    const frameHeight = numContentLines + 1; // internal newlines (11) + trailing newlines (2) = 13
+    // Total height including initial newline (for cleanup)
+    const totalHeight = frameHeight + 1; // 14
+    // Initial render
+    process.stdout.write('\n');
+    // Animation loop
+    const interval = setInterval(() => {
+        if (!running)
+            return;
+        const frame = WELCOME_ANIMATION.frames[frameIndex];
+        // Move cursor up to overwrite previous frame (always after first render)
+        if (!isFirstRender) {
+            process.stdout.write(`\x1b[${frameHeight}A`);
+        }
+        isFirstRender = false;
+        // Render current frame
+        process.stdout.write(renderFrame(frame, textLines) + '\n\n');
+        // Advance to next frame
+        frameIndex = (frameIndex + 1) % WELCOME_ANIMATION.frames.length;
+    }, WELCOME_ANIMATION.interval);
+    // Wait for Enter
+    await waitForEnter();
+    // Stop animation
+    running = false;
+    clearInterval(interval);
+    // Clear the welcome screen and move on
+    process.stdout.write(`\x1b[${totalHeight}A`);
+    for (let i = 0; i < totalHeight; i++) {
+        process.stdout.write('\x1b[2K\n'); // Clear line
+    }
+    process.stdout.write(`\x1b[${totalHeight}A`); // Move back up
+}
+//# sourceMappingURL=welcome-screen.js.map