@proletariat/cli 0.1.4 → 0.3.0

package/dist/lib/themes.js

@@ -0,0 +1,301 @@
+import { createTheme, addThemeNames, getThemes, } from './database/index.js';
+/**
+ * Default workspace directory for persistent agents (fallback if no theme)
+ */
+export const DEFAULT_AGENTS_DIR = 'staff';
+/**
+ * Default directory for ephemeral agents (fallback if no theme)
+ */
+export const TEMP_AGENTS_DIR = 'temp';
+/**
+ * Default theme for ephemeral agent name generation
+ */
+export const DEFAULT_EPHEMERAL_THEME = 'billionaires';
+/**
+ * Adjectives for ephemeral agent name generation
+ * ~100 short, positive adjectives for readable agent names
+ */
+export const AGENT_ADJECTIVES = [
+    // Original set
+    'bold', 'calm', 'cool', 'deep', 'fair', 'fast', 'firm', 'free', 'good',
+    'keen', 'kind', 'neat', 'pure', 'safe', 'sure', 'true', 'warm', 'wise',
+    'able', 'avid', 'blue', 'deft', 'fine', 'glad', 'gold', 'open', 'real',
+    'rich', 'soft', 'tall', 'vast', 'wild', 'zest',
+    // Expanded set
+    'apt', 'big', 'brave', 'bright', 'brisk', 'busy', 'chief', 'civic',
+    'civil', 'clean', 'clear', 'close', 'crisp', 'dense', 'dry', 'dual',
+    'due', 'eager', 'early', 'easy', 'elite', 'epic', 'equal', 'even',
+    'exact', 'extra', 'faint', 'fancy', 'first', 'fit', 'flat', 'fleet',
+    'flush', 'focal', 'fond', 'frank', 'fresh', 'full', 'game', 'grand',
+    'grave', 'great', 'green', 'hale', 'happy', 'hardy', 'hasty', 'hazy',
+    'heavy', 'high', 'hot', 'huge', 'ideal', 'key', 'large', 'late', 'lean',
+    'legal', 'light', 'lithe', 'live', 'local', 'long', 'loose', 'loud',
+    'loyal', 'lucid', 'lucky', 'lunar', 'lusty', 'mad', 'main', 'major',
+    'meek', 'merry', 'mild', 'mini', 'minor', 'mint', 'modal', 'modern',
+    'moist', 'moral', 'naval', 'new', 'next', 'nice', 'noble', 'novel',
+    'odd', 'outer', 'pale', 'peak', 'perky', 'phat', 'plush', 'polar',
+    'polite', 'prime', 'proud', 'quick', 'quiet', 'rapid', 'rare', 'raw',
+    'ready', 'regal', 'royal', 'ruby', 'rural', 'rusty', 'salty', 'sandy',
+    'sassy', 'shiny', 'short', 'silky', 'slick', 'slim', 'slow', 'small',
+    'smart', 'smooth', 'snug', 'solar', 'solid', 'sonic', 'sound', 'spare',
+    'stark', 'steady', 'steel', 'steep', 'stoic', 'stout', 'strong', 'super',
+    'sweet', 'swift', 'tame', 'tart', 'tense', 'thick', 'thin', 'tidy',
+    'tight', 'tiny', 'top', 'total', 'tough', 'trim', 'ultra', 'upper',
+    'urban', 'valid', 'vivid', 'vocal', 'wary', 'whole', 'wide', 'witty',
+    'young', 'zappy', 'zen', 'zero', 'zippy', 'zonal'
+];
+/**
+ * Validate an agent name
+ * Agent names must be alphanumeric with optional hyphens/underscores (case-insensitive for uniqueness)
+ */
+export function isValidAgentName(name) {
+    return /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(name);
+}
+/**
+ * Normalize a name to valid agent name format:
+ * - Trim whitespace
+ * - Replace spaces with dashes
+ * - Remove any invalid characters
+ * Note: Preserves case - uniqueness is enforced case-insensitively elsewhere
+ */
+export function normalizeAgentName(name) {
+    return name
+        .trim()
+        .replace(/\s+/g, '-') // spaces to dashes
+        .replace(/[^a-zA-Z0-9-_]/g, ''); // remove invalid chars
+}
+/**
+ * Get the canonical (lowercase) form of a name for uniqueness comparisons
+ */
+export function canonicalAgentName(name) {
+    return name.toLowerCase();
+}
+/**
+ * Get suggested agent names (for interactive selection when no theme)
+ */
+export function getSuggestedAgentNames() {
+    return ['agent-1', 'agent-2', 'agent-3', 'agent-4', 'agent-5'];
+}
+export const BUILTIN_THEMES = [
+    {
+        id: 'billionaires',
+        name: 'billionaires',
+        displayName: 'Billionaires & Tech Elite',
+        description: 'The ultra-wealthy work for you',
+        persistentDir: 'staff',
+        ephemeralDir: 'temp',
+        names: [
+            // Tech founders & executives
+            'altman', 'andreesen', 'bezos', 'branson', 'brin', 'buffett',
+            'cook', 'dalio', 'dario', 'dorsey', 'ellison', 'gates', 'huang',
+            'iger', 'jobs', 'kalanick', 'karpathy', 'lecun', 'ma', 'musk',
+            'nadella', 'page', 'pichai', 'sandberg', 'schultz', 'sutskever',
+            'thiel', 'wojcicki', 'zuck',
+            // More tech leaders
+            'ballmer', 'benioff', 'chesky', 'collison', 'dell', 'durov',
+            'fink', 'fridman', 'grove', 'hastings', 'hoffman', 'horowitz',
+            'hurd', 'ive', 'khosla', 'knight', 'kutcher', 'levie', 'levinson',
+            'lynch', 'marcus', 'mayer', 'mcnealy', 'morin', 'neumann',
+            'omidyar', 'packard', 'parker', 'powell', 'rabois', 'rometty',
+            'ross', 'schmidt', 'sequoia', 'siebel', 'silbermann', 'sinofsky',
+            'spiegel', 'spolsky', 'sweeney', 'systrom', 'torvalds', 'wales',
+            'wozniak', 'yang', 'yegge', 'zhang', 'zhong'
+        ]
+    },
+    {
+        id: 'toyotas',
+        name: 'toyotas',
+        displayName: 'Toyota Garage',
+        description: 'Reliable workhorses for your project',
+        persistentDir: 'garage',
+        ephemeralDir: 'pit',
+        names: [
+            // Classic & current models
+            '4runner', 'avalon', 'camry', 'celica', 'corolla', 'cressida',
+            'fj40', 'fj60', 'fj80', 'highlander', 'hilux', 'landcruiser',
+            'mr2', 'prius', 'rav4', 'sequoia', 'sienna', 'supra', 'tacoma',
+            'tercel', 'tundra', 'venza', 'yaris',
+            // More models & variants
+            'auris', 'belta', 'brevis', 'caldina', 'carina', 'century',
+            'chaser', 'coaster', 'corona', 'cresta', 'crown', 'dyna',
+            'estima', 'etios', 'fortuner', 'granvia', 'harrier', 'innova',
+            'ipsum', 'kluger', 'levin', 'lite', 'lucida', 'mark2',
+            'matrix', 'mirai', 'noah', 'paseo', 'picnic', 'platz',
+            'previa', 'premio', 'probox', 'raize', 'rukus', 'sera',
+            'soarer', 'solara', 'starlet', 'surf', 'tarago', 'trueno',
+            'urban', 'verso', 'vios', 'vista', 'vitz', 'wish'
+        ]
+    },
+    {
+        id: 'companies',
+        name: 'companies',
+        displayName: 'Company Portfolio',
+        description: 'Your corporate portfolio',
+        persistentDir: 'portfolio',
+        ephemeralDir: 'incubator',
+        names: [
+            // Major tech companies
+            'adobe', 'airbnb', 'amazon', 'apple', 'atlassian', 'cisco',
+            'coinbase', 'databricks', 'discord', 'dropbox', 'figma', 'github',
+            'google', 'intel', 'meta', 'microsoft', 'netflix', 'notion',
+            'nvidia', 'openai', 'oracle', 'palantir', 'salesforce', 'shopify',
+            'slack', 'snowflake', 'spotify', 'square', 'stripe', 'tesla',
+            'twilio', 'twitter', 'uber', 'vercel', 'zoom',
+            // More companies
+            'airtable', 'algolia', 'asana', 'auth0', 'brex', 'canva',
+            'carta', 'checkout', 'clickup', 'cloudera', 'contentful', 'datadog',
+            'deel', 'docusign', 'doordash', 'elastic', 'fastly', 'fivetran',
+            'gitlab', 'gusto', 'hashicorp', 'hubspot', 'instacart', 'klarna',
+            'launchdark', 'linear', 'loom', 'lyft', 'mailchimp', 'miro',
+            'monday', 'mongo', 'netlify', 'okta', 'pagerduty', 'plaid',
+            'postman', 'reddit', 'retool', 'revolut', 'rippling', 'robinhood',
+            'segment', 'sentry', 'supabase', 'toast', 'twitch', 'webflow',
+            'wiz', 'workday', 'zendesk', 'zscaler'
+        ]
+    }
+];
+/**
+ * Ensure built-in themes are seeded in the database
+ * Called lazily when themes are first used
+ */
+export function ensureBuiltinThemes(workspacePath) {
+    const existingThemes = getThemes(workspacePath);
+    const existingIds = new Set(existingThemes.map(t => t.id));
+    for (const theme of BUILTIN_THEMES) {
+        if (!existingIds.has(theme.id)) {
+            // Create the theme
+            createTheme(workspacePath, {
+                id: theme.id,
+                name: theme.name,
+                displayName: theme.displayName,
+                description: theme.description,
+                builtin: true
+            });
+            // Add names to the theme
+            addThemeNames(workspacePath, theme.id, theme.names);
+        }
+    }
+}
+/**
+ * Get a built-in theme by ID (from constants, not database)
+ */
+export function getBuiltinTheme(themeId) {
+    return BUILTIN_THEMES.find(t => t.id === themeId);
+}
+/**
+ * Check if a theme ID is a built-in theme
+ */
+export function isBuiltinTheme(themeId) {
+    return BUILTIN_THEMES.some(t => t.id === themeId);
+}
+/**
+ * Get the persistent agents directory name for a theme
+ * Falls back to DEFAULT_AGENTS_DIR if theme not found
+ */
+export function getThemePersistentDir(themeId) {
+    if (!themeId)
+        return DEFAULT_AGENTS_DIR;
+    const theme = BUILTIN_THEMES.find(t => t.id === themeId);
+    return theme?.persistentDir ?? DEFAULT_AGENTS_DIR;
+}
+/**
+ * Get the ephemeral agents directory name for a theme
+ * Falls back to TEMP_AGENTS_DIR if theme not found
+ */
+export function getThemeEphemeralDir(themeId) {
+    if (!themeId)
+        return TEMP_AGENTS_DIR;
+    const theme = BUILTIN_THEMES.find(t => t.id === themeId);
+    return theme?.ephemeralDir ?? TEMP_AGENTS_DIR;
+}
+/**
+ * Get both directory names for a theme
+ */
+export function getThemeDirectories(themeId) {
+    return {
+        persistentDir: getThemePersistentDir(themeId),
+        ephemeralDir: getThemeEphemeralDir(themeId),
+    };
+}
+/**
+ * Pick a random adjective from the list
+ */
+export function pickAdjective() {
+    return AGENT_ADJECTIVES[Math.floor(Math.random() * AGENT_ADJECTIVES.length)];
+}
+/**
+ * Pick a random theme name from a specific theme
+ */
+export function pickThemeName(themeId) {
+    const theme = BUILTIN_THEMES.find(t => t.id === themeId);
+    if (!theme) {
+        // Fall back to billionaires if theme not found
+        const fallback = BUILTIN_THEMES[0];
+        return fallback.names[Math.floor(Math.random() * fallback.names.length)];
+    }
+    return theme.names[Math.floor(Math.random() * theme.names.length)];
+}
+/**
+ * Pick a random theme name from any available theme
+ */
+export function pickRandomThemeName() {
+    const theme = BUILTIN_THEMES[Math.floor(Math.random() * BUILTIN_THEMES.length)];
+    const name = theme.names[Math.floor(Math.random() * theme.names.length)];
+    return { themeName: name, themeId: theme.id };
+}
+/**
+ * Generate a unique ephemeral agent name.
+ * Format: {adjective}-{theme_name}-{number}
+ * Example: "bold-bezos-1", "keen-camry-2"
+ *
+ * @param existingNames - Set of existing agent names (for uniqueness checking)
+ * @param options - Optional configuration for name generation
+ */
+export function generateEphemeralAgentName(existingNames, options) {
+    // Handle backwards compatibility: string arg = themeId
+    const opts = typeof options === 'string'
+        ? { themeId: options }
+        : (options ?? {});
+    const maxAttempts = 100;
+    // Use specified theme or default (no mixing themes)
+    const themeId = opts.themeId ?? DEFAULT_EPHEMERAL_THEME;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const adjective = pickAdjective();
+        const themeName = pickThemeName(themeId);
+        // Try finding a unique number suffix (4 digits max)
+        for (let num = 1; num <= 9999; num++) {
+            const candidateName = `${adjective}-${themeName}-${num}`;
+            // Check database/in-memory conflicts first
+            if (existingNames.has(candidateName.toLowerCase())) {
+                continue;
+            }
+            // Check external resource conflicts if callback provided
+            if (opts.checkExternalConflict) {
+                const result = opts.checkExternalConflict(candidateName);
+                if (result.conflict) {
+                    opts.onConflictSkipped?.(candidateName, result.reason ?? 'external conflict');
+                    continue;
+                }
+            }
+            return candidateName;
+        }
+    }
+    // Fallback: use timestamp if all attempts fail
+    const timestamp = Date.now().toString(36);
+    return `agent-${timestamp}`;
+}
+/**
+ * Check if a name looks like an ephemeral agent name.
+ * Ephemeral names follow pattern: {adjective}-{name}-{number}
+ */
+export function isEphemeralAgentName(name) {
+    const parts = name.split('-');
+    if (parts.length < 3)
+        return false;
+    const lastPart = parts[parts.length - 1];
+    const num = parseInt(lastPart, 10);
+    if (isNaN(num) || num < 1)
+        return false;
+    const adjective = parts[0].toLowerCase();
+    return AGENT_ADJECTIVES.includes(adjective);
+}

package/dist/lib/ui/BoardUI.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+interface BoardSection {
+    title: string;
+    icon: string;
+    tickets: Array<{
+        id: string;
+        title: string;
+        completed: boolean;
+        assignee: string;
+        priority?: string;
+        queue?: string;
+    }>;
+}
+interface BoardUIProps {
+    boardTitle: string;
+    sections: BoardSection[];
+    onEdit?: () => void;
+    onOpen?: () => void;
+}
+export declare function BoardUI({ boardTitle, sections, onEdit, onOpen }: BoardUIProps): React.JSX.Element;
+export {};

package/dist/lib/ui/BoardUI.js

@@ -0,0 +1,85 @@
+import React, { useState } from 'react';
+import { Box, Text, useApp, useInput, Spacer } from 'ink';
+export function BoardUI({ boardTitle, sections, onEdit, onOpen }) {
+    const { exit } = useApp();
+    const [selectedSection, setSelectedSection] = useState(0);
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            exit();
+        }
+        if (key.leftArrow) {
+            setSelectedSection(prev => Math.max(0, prev - 1));
+        }
+        if (key.rightArrow) {
+            setSelectedSection(prev => Math.min(sections.length - 1, prev + 1));
+        }
+        if (input === 'e' && onEdit) {
+            onEdit();
+            exit();
+        }
+        if (input === 'o' && onOpen) {
+            onOpen();
+            exit();
+        }
+    });
+    const getPriorityColor = (priority) => {
+        switch (priority) {
+            case 'high': return 'red';
+            case 'medium': return 'yellow';
+            case 'low': return 'green';
+            default: return 'gray';
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "cyan", bold: true },
+                "\uD83D\uDCCB ",
+                boardTitle),
+            React.createElement(Spacer, null),
+            React.createElement(Text, { dimColor: true }, "\u2190 \u2192 Navigate | e: Edit | o: Open in Obsidian | q: Quit")),
+        React.createElement(Box, null, sections.map((section, index) => (React.createElement(Box, { key: section.title, flexDirection: "column", width: "25%", marginRight: 1, borderStyle: selectedSection === index ? 'double' : 'single', borderColor: selectedSection === index ? 'cyan' : 'gray', padding: 1 },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: selectedSection === index ? 'cyan' : 'white' },
+                    section.icon,
+                    " ",
+                    section.title)),
+            section.tickets.length === 0 ? (React.createElement(Text, { dimColor: true, italic: true }, "No tickets")) : (section.tickets.map(ticket => (React.createElement(Box, { key: ticket.id, marginBottom: 1 },
+                React.createElement(Text, null,
+                    ticket.completed ? '✅' : '☐',
+                    " ",
+                    ticket.id),
+                React.createElement(Box, { marginLeft: 2 },
+                    React.createElement(Text, { wrap: "truncate" }, ticket.title)),
+                (ticket.priority || ticket.queue || ticket.assignee) && (React.createElement(Box, { marginLeft: 2 },
+                    ticket.priority && (React.createElement(Text, { color: getPriorityColor(ticket.priority) },
+                        "#",
+                        ticket.priority,
+                        ' ')),
+                    ticket.queue && (React.createElement(Text, { color: "blue" },
+                        "+",
+                        ticket.queue,
+                        ' ')),
+                    ticket.assignee && (React.createElement(Text, { color: "magenta" },
+                        "@",
+                        ticket.assignee)))))))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    section.tickets.length,
+                    " ticket",
+                    section.tickets.length !== 1 ? 's' : '')))))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Total: ",
+                sections.reduce((sum, s) => sum + s.tickets.length, 0),
+                " tickets"),
+            React.createElement(Text, { dimColor: true }, " | "),
+            React.createElement(Text, { color: "green" },
+                "Done: ",
+                sections.find(s => s.title === 'Done')?.tickets.length || 0),
+            React.createElement(Text, { dimColor: true }, " | "),
+            React.createElement(Text, { color: "yellow" },
+                "Active: ",
+                sections
+                    .filter(s => ['In Progress', 'In Review', 'Blocked'].includes(s.title))
+                    .reduce((sum, s) => sum + s.tickets.length, 0)))));
+}

package/dist/lib/ui/ClaimTicketUI.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+interface Ticket {
+    id: string;
+    title: string;
+    assignee: string;
+}
+interface ClaimTicketUIProps {
+    tickets: Ticket[];
+    needsAgentName: boolean;
+    defaultAgentName?: string;
+    onComplete: (data: {
+        ticketId: string;
+        agentName: string;
+    }) => void;
+}
+export declare function ClaimTicketUI({ tickets, needsAgentName, defaultAgentName, onComplete }: ClaimTicketUIProps): React.JSX.Element;
+export {};

package/dist/lib/ui/ClaimTicketUI.js

@@ -0,0 +1,64 @@
+import React, { useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { TextInput, Spinner } from '@inkjs/ui';
+export function ClaimTicketUI({ tickets, needsAgentName, defaultAgentName = '', onComplete }) {
+    const { exit } = useApp();
+    const [step, setStep] = useState(tickets.length === 0 ? 'done' : 'select');
+    const [selectedTicket, setSelectedTicket] = useState('');
+    const [agentName, setAgentName] = useState(defaultAgentName);
+    useInput((input, key) => {
+        if (key.escape) {
+            exit();
+        }
+    });
+    if (tickets.length === 0) {
+        return (React.createElement(Box, { padding: 1 },
+            React.createElement(Text, { color: "yellow" }, "No tickets available in backlog.")));
+    }
+    const ticketItems = tickets.map(ticket => ({
+        label: `${ticket.id} - ${ticket.title}`,
+        value: ticket.id
+    }));
+    const handleTicketSelect = (item) => {
+        setSelectedTicket(item.value);
+        if (needsAgentName && !defaultAgentName) {
+            setStep('agent');
+        }
+        else {
+            onComplete({ ticketId: item.value, agentName: agentName || defaultAgentName });
+            setStep('done');
+            setTimeout(() => exit(), 100);
+        }
+    };
+    const handleAgentSubmit = (value) => {
+        if (value.trim()) {
+            setAgentName(value);
+            onComplete({ ticketId: selectedTicket, agentName: value });
+            setStep('done');
+            setTimeout(() => exit(), 100);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "cyan", bold: true }, "\uD83C\uDFAF Claim Ticket")),
+        step === 'select' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, null, "Select ticket to claim:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: ticketItems, onSelect: handleTicketSelect })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    tickets.length,
+                    " ticket",
+                    tickets.length !== 1 ? 's' : '',
+                    " available")))),
+        step === 'agent' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, null, "Enter agent name:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "gray" }, "\u203A "),
+                React.createElement(TextInput, { defaultValue: agentName, onSubmit: handleAgentSubmit, placeholder: process.env.USER || 'agent' })))),
+        step === 'done' && (React.createElement(Box, null,
+            React.createElement(Text, { color: "green" },
+                React.createElement(Spinner, { type: "dots" }),
+                " Claiming ticket...")))));
+}

package/dist/lib/ui/CreateTicketUI.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface CreateTicketUIProps {
+    initialTitle?: string;
+    queues: string[];
+    onComplete: (data: {
+        title: string;
+        priority: 'high' | 'medium' | 'low';
+        queue: string;
+        description: string;
+    }) => void;
+}
+export declare function CreateTicketUI({ initialTitle, queues, onComplete }: CreateTicketUIProps): React.JSX.Element;
+export {};

package/dist/lib/ui/CreateTicketUI.js

@@ -0,0 +1,101 @@
+import React, { useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { TextInput, Spinner } from '@inkjs/ui';
+export function CreateTicketUI({ initialTitle, queues, onComplete }) {
+    const { exit } = useApp();
+    const [step, setStep] = useState(initialTitle ? 'priority' : 'title');
+    const [title, setTitle] = useState(initialTitle || '');
+    const [priority, setPriority] = useState('medium');
+    const [queue, setQueue] = useState('');
+    const [description, setDescription] = useState('');
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    useInput((input, key) => {
+        if (key.escape) {
+            exit();
+        }
+    });
+    const priorityItems = [
+        { label: '🔴 High', value: 'high' },
+        { label: '🟡 Medium', value: 'medium' },
+        { label: '🟢 Low', value: 'low' }
+    ];
+    const queueItems = queues.map(q => ({
+        label: `${getQueueIcon(q)} ${q.charAt(0).toUpperCase() + q.slice(1)}`,
+        value: q
+    }));
+    function getQueueIcon(queue) {
+        const icons = {
+            feature: '✨',
+            bug: '🐛',
+            refactor: '🔧',
+            docs: '📚',
+            devops: '⚙️',
+            research: '🔬'
+        };
+        return icons[queue.toLowerCase()] || '📋';
+    }
+    const handleTitleSubmit = (value) => {
+        if (value.trim()) {
+            setTitle(value);
+            setStep('priority');
+        }
+    };
+    const handlePrioritySelect = (item) => {
+        setPriority(item.value);
+        setStep('queue');
+    };
+    const handleQueueSelect = (item) => {
+        setQueue(item.value);
+        setStep('description');
+    };
+    const handleDescriptionSubmit = (value) => {
+        setDescription(value || getDefaultDescription());
+        setIsSubmitting(true);
+        onComplete({
+            title,
+            priority,
+            queue,
+            description: value || getDefaultDescription()
+        });
+        setStep('done');
+        setTimeout(() => exit(), 100);
+    };
+    const getDefaultDescription = () => {
+        return `## Description
+
+## Acceptance Criteria
+- [ ] 
+
+## Technical Notes
+`;
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "cyan", bold: true }, "\uD83C\uDFAB Create New Ticket")),
+        step === 'title' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, null, "Enter ticket title:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "gray" }, "\u203A "),
+                React.createElement(TextInput, { defaultValue: title, onSubmit: handleTitleSubmit })))),
+        step === 'priority' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, null, "Select priority:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: priorityItems, onSelect: handlePrioritySelect })))),
+        step === 'queue' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, null, "Select queue/category:"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: queueItems, onSelect: handleQueueSelect })))),
+        step === 'description' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, null, "Enter description (optional, press Enter to skip):"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "gray" }, "\u203A "),
+                React.createElement(TextInput, { defaultValue: description, onSubmit: handleDescriptionSubmit, placeholder: "Press Enter to use default template..." })))),
+        step === 'done' && (React.createElement(Box, null, isSubmitting ? (React.createElement(Text, { color: "green" },
+            React.createElement(Spinner, { type: "dots" }),
+            " Creating ticket...")) : (React.createElement(Text, { color: "green" }, "\u2705 Ticket data collected!")))),
+        step !== 'done' && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Step: ",
+                step === 'title' ? '1/4' : step === 'priority' ? '2/4' : step === 'queue' ? '3/4' : '4/4')))));
+}