@compilr-dev/cli 0.4.0 → 0.5.0

package/dist/ui/overlay/impl/workflow-overlay-v2.js

@@ -0,0 +1,637 @@
+/**
+ * Workflow Overlay V2
+ *
+ * Unified project dashboard with tabbed interface:
+ *   [Actions]   - Quick actions based on workflow state
+ *   [Details]   - Project metadata (read-only)
+ *   [Dashboard] - Overview of project status (placeholder)
+ *   [Manage]    - Project management actions
+ *
+ * Access paths:
+ *   /workflow         - Opens workflow for active project
+ *   /projects → Enter - Opens workflow for selected project
+ *
+ * Workflow phases:
+ *   /new → /design|/sketch → /backlog → /build → /scaffold → done
+ */
+import { BaseOverlayV2 } from '../../base/overlay-base-v2.js';
+import { getCurrentProject, setCurrentProject, clearCurrentProject } from '../../../tools/project-db.js';
+import { projectRepository, workItemRepository, documentRepository } from '../../../db/repositories/index.js';
+import { BacklogOverlayV2 } from './backlog-overlay-v2.js';
+import { DocsOverlayV2 } from './docs-overlay-v2.js';
+import { AnchorsOverlayV2 } from './anchors-overlay-v2.js';
+// =============================================================================
+// Constants
+// =============================================================================
+const PHASES = [
+    {
+        id: 'init',
+        name: 'Initialize',
+        command: '/new',
+        description: 'Create project structure',
+        isComplete: (project) => !!project,
+        isActive: (project) => !project,
+    },
+    {
+        id: 'design',
+        name: 'Design',
+        command: '/design',
+        description: 'Define requirements and PRD',
+        isComplete: (_project, stats) => stats.hasPrd,
+        isActive: (_project, stats) => !stats.hasPrd && stats.totalItems === 0,
+    },
+    {
+        id: 'backlog',
+        name: 'Backlog',
+        command: '/backlog',
+        description: 'Plan and prioritize work items',
+        isComplete: (_project, stats) => stats.totalItems >= 3,
+        isActive: (_project, stats) => stats.hasPrd && stats.totalItems < 3,
+    },
+    {
+        id: 'scaffold',
+        name: 'Scaffold',
+        command: '/scaffold',
+        description: 'Create project foundation',
+        isComplete: (_project, stats) => stats.hasScaffold,
+        isActive: (_project, stats) => stats.totalItems >= 3 && !stats.hasScaffold,
+    },
+    {
+        id: 'build',
+        name: 'Build',
+        command: '/build',
+        description: 'Implement backlog items',
+        isComplete: (_project, stats) => stats.completedItems >= stats.totalItems && stats.totalItems > 0,
+        isActive: (_project, stats) => stats.hasScaffold && stats.completedItems < stats.totalItems,
+    },
+];
+const TABS = ['Actions', 'Details', 'Dashboard', 'Manage'];
+const MAX_ACTIONS = 6;
+// =============================================================================
+// Helper Functions
+// =============================================================================
+function getProjectStats(project) {
+    const itemsResult = workItemRepository.query({
+        project_id: project.id,
+        limit: 1000,
+    });
+    const items = itemsResult.items;
+    const completedItems = items.filter(i => i.status === 'completed').length;
+    const inProgressItems = items.filter(i => i.status === 'in_progress').length;
+    const docs = documentRepository.listByProject(project.id);
+    const hasPrd = docs.some(d => d.docType === 'prd');
+    const hasArchDocs = docs.some(d => d.docType === 'architecture');
+    const hasScaffold = items.some(i => i.title.toLowerCase().includes('scaffold') && i.status === 'completed') || project.metadata?.scaffolded === true;
+    return {
+        totalItems: items.length,
+        completedItems,
+        inProgressItems,
+        hasPrd,
+        hasArchDocs,
+        hasScaffold,
+    };
+}
+function buildActionsItems(project, stats) {
+    const actions = [];
+    if (!project) {
+        actions.push({
+            label: 'Initialize Project',
+            command: '/new',
+            description: 'Create a new project',
+            enabled: true,
+        });
+        return actions;
+    }
+    if (!stats) {
+        return actions;
+    }
+    if (!stats.hasPrd) {
+        actions.push({
+            label: 'Design Project',
+            command: '/design',
+            description: 'Create PRD and requirements',
+            enabled: true,
+        });
+        actions.push({
+            label: 'Quick Sketch',
+            command: '/sketch',
+            description: 'Lightweight project outline',
+            enabled: true,
+        });
+    }
+    if (stats.hasPrd || stats.totalItems > 0) {
+        actions.push({
+            label: 'View Backlog',
+            command: '/backlog',
+            description: `${String(stats.totalItems)} items, ${String(stats.completedItems)} done`,
+            enabled: true,
+        });
+    }
+    if (stats.totalItems > 0 && !stats.hasScaffold) {
+        actions.push({
+            label: 'Scaffold Project',
+            command: '/scaffold',
+            description: 'Create project foundation',
+            enabled: true,
+        });
+    }
+    if (stats.hasScaffold && stats.totalItems > stats.completedItems) {
+        actions.push({
+            label: 'Build Next Item',
+            command: '/build',
+            description: `${String(stats.totalItems - stats.completedItems)} items remaining`,
+            enabled: true,
+        });
+    }
+    actions.push({
+        label: 'View Documents',
+        command: '/docs',
+        description: 'Browse project documents',
+        enabled: stats.hasPrd || stats.hasArchDocs,
+    });
+    actions.push({
+        label: 'View Anchors',
+        command: '/anchors',
+        description: 'Manage persistent context',
+        enabled: true,
+    });
+    return actions;
+}
+function buildManageActions(project) {
+    const actions = [];
+    if (!project) {
+        return actions;
+    }
+    actions.push({
+        id: 'edit',
+        label: 'Edit Project',
+        command: '',
+        description: 'Change name, description',
+        enabled: true,
+        style: 'normal',
+    });
+    const currentProject = getCurrentProject();
+    const isCurrentProject = currentProject?.id === project.id;
+    actions.push({
+        id: 'set-active',
+        label: 'Set as Current',
+        command: '',
+        description: isCurrentProject ? 'Already the current project' : 'Make this the current working project',
+        enabled: !isCurrentProject,
+        style: 'normal',
+    });
+    if (project.status === 'archived') {
+        actions.push({
+            id: 'restore',
+            label: 'Restore Project',
+            command: '',
+            description: 'Restore from archive',
+            enabled: true,
+            style: 'normal',
+        });
+    }
+    else {
+        actions.push({
+            id: 'archive',
+            label: 'Archive Project',
+            command: '',
+            description: 'Hide from active list',
+            enabled: true,
+            style: 'warning',
+        });
+    }
+    actions.push({
+        id: 'delete',
+        label: 'Delete Project',
+        command: '',
+        description: 'Permanently remove',
+        enabled: true,
+        style: 'danger',
+    });
+    return actions;
+}
+function formatRelativeTime(date) {
+    if (!date)
+        return 'never';
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+    if (diffMins < 1)
+        return 'just now';
+    if (diffMins < 60)
+        return `${String(diffMins)}m ago`;
+    if (diffHours < 24)
+        return `${String(diffHours)}h ago`;
+    if (diffDays < 7)
+        return `${String(diffDays)}d ago`;
+    return date.toLocaleDateString();
+}
+function formatStatus(status, s) {
+    switch (status) {
+        case 'active':
+            return s.success('active');
+        case 'paused':
+            return s.warning('paused');
+        case 'completed':
+            return s.info('completed');
+        case 'archived':
+            return s.muted('archived');
+        default:
+            return s.muted(status);
+    }
+}
+// =============================================================================
+// Workflow Overlay V2 Class
+// =============================================================================
+export class WorkflowOverlayV2 extends BaseOverlayV2 {
+    type = 'inline';
+    id = 'workflow-overlay-v2';
+    constructor(projectId) {
+        // Load project data
+        let project = null;
+        let stats = null;
+        if (projectId) {
+            try {
+                project = projectRepository.getById(projectId);
+                if (project) {
+                    stats = getProjectStats(project);
+                }
+            }
+            catch {
+                // Project not found
+            }
+        }
+        else {
+            const activeProject = getCurrentProject();
+            if (activeProject) {
+                try {
+                    project = projectRepository.getById(activeProject.id);
+                    if (project) {
+                        stats = getProjectStats(project);
+                    }
+                }
+                catch {
+                    // Project not found
+                }
+            }
+        }
+        super({
+            currentTab: 0,
+            project,
+            stats,
+            actionsIndex: 0,
+            manageActionIndex: 0,
+            actionsItems: buildActionsItems(project, stats),
+            manageActions: buildManageActions(project),
+        });
+        this.minHeight = 22;
+    }
+    renderContent(_context) {
+        const s = this.getStyles();
+        const lines = [];
+        // Header with project name
+        const projectName = this.state.project ? this.state.project.displayName : 'No Project';
+        lines.push(...this.renderHeader('Workflow', projectName));
+        // Tab bar
+        const tabBar = this.renderTabs(s);
+        const tabHint = s.muted('(Tab/←→ · 1-4)');
+        lines.push(`  ${tabBar}  ${tabHint}`);
+        lines.push('');
+        // Project info + Progress row
+        if (this.state.project && this.state.stats) {
+            const progress = this.state.stats.totalItems > 0
+                ? Math.round((this.state.stats.completedItems / this.state.stats.totalItems) * 100)
+                : 0;
+            const barWidth = 20;
+            const filledWidth = Math.round((progress / 100) * barWidth);
+            const bar = '█'.repeat(filledWidth) + '░'.repeat(barWidth - filledWidth);
+            const currentProject = getCurrentProject();
+            const isCurrentProject = currentProject?.id === this.state.project.id;
+            const currentIndicator = isCurrentProject ? `  ${s.success('★ Current')}` : '';
+            lines.push(`  ${s.muted('Status:')} ${formatStatus(this.state.project.status, s)}  ${s.muted('Mode:')} ${this.state.project.workflowMode}${currentIndicator}`);
+            lines.push(`  ${s.muted('Progress:')} ${String(this.state.stats.completedItems)}/${String(this.state.stats.totalItems)} [${s.primary(bar)}] ${String(progress)}%`);
+        }
+        else {
+            lines.push(`  ${s.warning('No current project')}  ${s.muted('Run /new to create')}`);
+            lines.push('');
+        }
+        lines.push('');
+        // Workflow phases (horizontal)
+        lines.push(this.renderPhases(s));
+        lines.push('');
+        lines.push(this.renderBorder());
+        // Tab content
+        const tabId = TABS[this.state.currentTab];
+        switch (tabId) {
+            case 'Actions':
+                this.renderActionsTab(lines, s);
+                break;
+            case 'Details':
+                this.renderDetailsTab(lines, s);
+                break;
+            case 'Dashboard':
+                this.renderDashboardTab(lines, s);
+                break;
+            case 'Manage':
+                this.renderManageTab(lines, s);
+                break;
+        }
+        // Footer
+        lines.push(...this.renderFooter('↑↓/jk Navigate · ←→/hl Tabs · Enter Action · q/Esc Close'));
+        return lines;
+    }
+    renderTabs(s) {
+        return TABS.map((tab, i) => {
+            if (i === this.state.currentTab) {
+                return s.primaryBold(`[${tab}]`);
+            }
+            return s.muted(`[${tab}]`);
+        }).join(' ');
+    }
+    renderPhases(s) {
+        if (this.state.project && this.state.stats) {
+            let phaseLine = '  ';
+            for (const phase of PHASES) {
+                const isComplete = phase.isComplete(this.state.project, this.state.stats);
+                const isActive = phase.isActive(this.state.project, this.state.stats);
+                let icon;
+                let label;
+                if (isComplete) {
+                    icon = s.success('✓');
+                    label = s.muted(phase.name);
+                }
+                else if (isActive) {
+                    icon = s.primary('►');
+                    label = s.primary(phase.name);
+                }
+                else {
+                    icon = s.muted('○');
+                    label = s.muted(phase.name);
+                }
+                phaseLine += `${icon} ${label}  `;
+            }
+            return phaseLine;
+        }
+        return `  ${s.muted('○ Init  ○ Design  ○ Backlog  ○ Scaffold  ○ Build')}`;
+    }
+    renderActionsTab(lines, s) {
+        lines.push(`  ${s.muted('Quick Actions:')}`);
+        lines.push('');
+        if (this.state.actionsItems.length > 0) {
+            const displayActions = this.state.actionsItems.slice(0, MAX_ACTIONS);
+            for (let i = 0; i < displayActions.length; i++) {
+                const action = displayActions[i];
+                const isSelected = i === this.state.actionsIndex;
+                const prefix = isSelected ? s.primary('❯ ') : '  ';
+                const labelWidth = 20;
+                const paddedLabel = action.label.padEnd(labelWidth);
+                if (action.enabled) {
+                    const label = isSelected ? s.primary(paddedLabel) : paddedLabel;
+                    const desc = s.muted(action.description);
+                    lines.push(`  ${prefix}${label}  ${desc}`);
+                }
+                else {
+                    lines.push(`  ${prefix}${s.muted(paddedLabel)}  ${s.muted(action.description)}`);
+                }
+            }
+        }
+        else {
+            lines.push(`  ${s.muted('  No actions available')}`);
+        }
+    }
+    renderDetailsTab(lines, s) {
+        if (!this.state.project) {
+            lines.push(`  ${s.muted('No project selected')}`);
+            return;
+        }
+        const project = this.state.project;
+        lines.push(`  ${s.muted('Project Details:')}`);
+        lines.push('');
+        const infoRows = [
+            ['Name', project.name],
+            ['Display Name', project.displayName],
+            ['Type', project.type],
+            ['Path', project.path],
+            ['Created', project.createdAt.toLocaleDateString()],
+            ['Last Activity', formatRelativeTime(project.lastActivityAt)],
+            ['Lifecycle', project.lifecycleState],
+        ];
+        for (const [label, value] of infoRows) {
+            lines.push(`  ${s.muted(label.padEnd(15))} ${value}`);
+        }
+        if (project.description) {
+            lines.push('');
+            lines.push(`  ${s.muted('Description:')}`);
+            lines.push(`    ${project.description}`);
+        }
+    }
+    renderDashboardTab(lines, s) {
+        if (!this.state.project) {
+            lines.push(`  ${s.muted('No project selected')}`);
+            return;
+        }
+        lines.push(`  ${s.muted('Dashboard:')}`);
+        lines.push('');
+        lines.push(`  ${s.warning('Coming soon...')}`);
+        lines.push('');
+        lines.push(`  ${s.muted('This tab will show:')}`);
+        lines.push(`  ${s.muted('• Current in-progress work item')}`);
+        lines.push(`  ${s.muted('• Recent activity')}`);
+        lines.push(`  ${s.muted('• Project health indicators')}`);
+    }
+    renderManageTab(lines, s) {
+        if (!this.state.project) {
+            lines.push(`  ${s.muted('No project selected')}`);
+            return;
+        }
+        lines.push(`  ${s.muted('Management Actions:')}`);
+        lines.push('');
+        const actions = this.state.manageActions;
+        if (actions.length > 0) {
+            for (let i = 0; i < actions.length; i++) {
+                const action = actions[i];
+                const isSelected = i === this.state.manageActionIndex;
+                const prefix = isSelected ? s.primary('❯ ') : '  ';
+                const labelWidth = 20;
+                const paddedLabel = action.label.padEnd(labelWidth);
+                let labelStyle;
+                if (!action.enabled) {
+                    // Disabled actions are always muted
+                    labelStyle = s.muted;
+                }
+                else if (isSelected) {
+                    labelStyle = action.style === 'danger' ? s.error :
+                        action.style === 'warning' ? s.warning : s.primary;
+                }
+                else {
+                    labelStyle = action.style === 'danger' ? s.error :
+                        action.style === 'warning' ? s.warning : (text) => text;
+                }
+                lines.push(`  ${prefix}${labelStyle(paddedLabel)}  ${s.muted(action.description)}`);
+            }
+        }
+    }
+    handleKey(key) {
+        // Ctrl+C always closes
+        if (this.isInterruptKey(key)) {
+            return this.close({ command: null });
+        }
+        // q or Esc closes
+        if (this.isCloseKey(key)) {
+            return this.close({ command: null });
+        }
+        // Tab switching: Tab/→ for next, Shift+Tab/← for previous
+        if (this.isTabKey(key) || this.isRightKey(key)) {
+            this.state.currentTab = (this.state.currentTab + 1) % TABS.length;
+            return this.rerender();
+        }
+        if (this.isShiftTabKey(key) || this.isLeftKey(key)) {
+            this.state.currentTab = (this.state.currentTab - 1 + TABS.length) % TABS.length;
+            return this.rerender();
+        }
+        // Number keys to jump to tab (1-4)
+        const num = this.getNumberKey(key);
+        if (num && num <= TABS.length) {
+            this.state.currentTab = num - 1;
+            return this.rerender();
+        }
+        // Tab-specific key handling
+        const tabId = TABS[this.state.currentTab];
+        if (tabId === 'Actions') {
+            return this.handleActionsTabKey(key);
+        }
+        else if (tabId === 'Manage') {
+            return this.handleManageTabKey(key);
+        }
+        // Details and Dashboard tabs are read-only
+        return this.noAction();
+    }
+    handleActionsTabKey(key) {
+        if (this.isUpKey(key)) {
+            if (this.state.actionsItems.length > 0) {
+                this.state.actionsIndex = (this.state.actionsIndex - 1 + this.state.actionsItems.length) % this.state.actionsItems.length;
+                return this.rerender();
+            }
+            return this.noAction();
+        }
+        if (this.isDownKey(key)) {
+            if (this.state.actionsItems.length > 0) {
+                this.state.actionsIndex = (this.state.actionsIndex + 1) % this.state.actionsItems.length;
+                return this.rerender();
+            }
+            return this.noAction();
+        }
+        if (this.isEnterKey(key)) {
+            if (this.state.actionsItems.length > 0) {
+                const action = this.state.actionsItems[this.state.actionsIndex];
+                if (action.enabled) {
+                    // Try to push overlay for known commands (enables parent navigation on Escape)
+                    const overlay = this.createOverlayForCommand(action.command);
+                    if (overlay) {
+                        return this.push(overlay);
+                    }
+                    // Fall back to closing with command for commands without V2 overlays
+                    return this.close({ command: action.command });
+                }
+            }
+            return this.noAction();
+        }
+        return this.noAction();
+    }
+    /**
+     * Create an overlay instance for a command.
+     * Returns null for commands that don't have V2 overlay implementations.
+     * Passes the current project ID to child overlays so they show data for this project,
+     * not the globally active project.
+     */
+    createOverlayForCommand(command) {
+        const projectId = this.state.project?.id;
+        switch (command) {
+            case '/backlog':
+                return new BacklogOverlayV2(projectId);
+            case '/docs':
+                return new DocsOverlayV2(projectId);
+            case '/anchors':
+                return new AnchorsOverlayV2(projectId);
+            default:
+                return null;
+        }
+    }
+    handleManageTabKey(key) {
+        if (this.isUpKey(key)) {
+            if (this.state.manageActions.length > 0) {
+                this.state.manageActionIndex = (this.state.manageActionIndex - 1 + this.state.manageActions.length) % this.state.manageActions.length;
+                return this.rerender();
+            }
+            return this.noAction();
+        }
+        if (this.isDownKey(key)) {
+            if (this.state.manageActions.length > 0) {
+                this.state.manageActionIndex = (this.state.manageActionIndex + 1) % this.state.manageActions.length;
+                return this.rerender();
+            }
+            return this.noAction();
+        }
+        if (this.isEnterKey(key)) {
+            if (this.state.manageActions.length > 0 && this.state.project) {
+                const action = this.state.manageActions[this.state.manageActionIndex];
+                // Don't execute disabled actions
+                if (!action.enabled) {
+                    return this.noAction();
+                }
+                return this.executeManageAction(action);
+            }
+            return this.noAction();
+        }
+        return this.noAction();
+    }
+    executeManageAction(action) {
+        if (!this.state.project)
+            return this.noAction();
+        switch (action.id) {
+            case 'set-active':
+                setCurrentProject({
+                    id: this.state.project.id,
+                    name: this.state.project.name,
+                    displayName: this.state.project.displayName,
+                    path: this.state.project.path,
+                });
+                projectRepository.touch(this.state.project.id);
+                this.state.manageActions = buildManageActions(this.state.project);
+                return this.rerender();
+            case 'archive': {
+                projectRepository.update(this.state.project.id, { status: 'archived' });
+                const activeProject = getCurrentProject();
+                if (activeProject?.id === this.state.project.id) {
+                    clearCurrentProject();
+                }
+                this.refreshProject();
+                return this.rerender();
+            }
+            case 'restore':
+                projectRepository.update(this.state.project.id, { status: 'active' });
+                this.refreshProject();
+                return this.rerender();
+            case 'edit':
+            case 'delete':
+                return this.close({
+                    command: null,
+                    action: action.id,
+                    projectId: this.state.project.id,
+                });
+        }
+        return this.noAction();
+    }
+    refreshProject() {
+        if (!this.state.project)
+            return;
+        this.state.project = projectRepository.getById(this.state.project.id);
+        if (this.state.project) {
+            this.state.stats = getProjectStats(this.state.project);
+            this.state.actionsItems = buildActionsItems(this.state.project, this.state.stats);
+            this.state.manageActions = buildManageActions(this.state.project);
+        }
+    }
+}

package/dist/ui/overlay/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Overlay System
+ *
+ * Exports all overlay-related types, utilities, and V2 implementations.
+ */
+export type { Overlay, RenderContext, OverlayContent, OverlayAction, KeyEvent, OverlayResolver, OverlayRenderState, } from './types.js';
+export { isCloseWithResult, isCloseCancelled } from './types.js';
+export { parseKeyEvent, matchesKey } from './key-utils.js';
+export { HelpOverlayV2 } from './impl/help-overlay-v2.js';
+export { ThemeOverlayV2, type ThemeOverlayOptions, type ThemeOverlayResult } from './impl/theme-overlay-v2.js';
+export { ModelOverlayV2, type ModelOverlayV2Options, type ModelOverlayV2Result } from './impl/model-overlay-v2.js';
+export { ToolsOverlayV2, type ToolsOverlayV2Options, type ToolsOverlayV2Result, type ToolInfo, type ToolParameter, type ToolPermissionInfo } from './impl/tools-overlay-v2.js';
+export { KeysOverlayV2, type KeysOverlayV2Result } from './impl/keys-overlay-v2.js';
+export { MascotOverlayV2, type MascotOverlayV2Options, type MascotOverlayV2Result } from './impl/mascot-overlay-v2.js';
+export { TutorialOverlayV2, type TutorialOverlayV2Result } from './impl/tutorial-overlay-v2.js';
+export { CommandsOverlayV2, type CommandsOverlayV2Result } from './impl/commands-overlay-v2.js';
+export { AgentsOverlayV2, type AgentsOverlayV2Result } from './impl/agents-overlay-v2.js';
+export { BacklogOverlayV2, type BacklogOverlayV2Result, type BacklogItem, type BacklogType, type BacklogPriority, type BacklogStatus } from './impl/backlog-overlay-v2.js';
+export { WorkflowOverlayV2, type WorkflowOverlayV2Result } from './impl/workflow-overlay-v2.js';
+export { DocsOverlayV2, type DocsOverlayV2Result } from './impl/docs-overlay-v2.js';
+export { DocumentDetailOverlayV2, type DocumentDetailResult } from './impl/document-detail-overlay-v2.js';
+export { AnchorsOverlayV2, type AnchorsOverlayV2Result } from './impl/anchors-overlay-v2.js';
+export { ProjectsOverlayV2, type ProjectsOverlayV2Result } from './impl/projects-overlay-v2.js';
+export { ConfigOverlayV2, type ConfigOverlayV2Options, type ConfigOverlayV2Result } from './impl/config-overlay-v2.js';
+export { AskUserSimpleOverlayV2, type AskUserSimpleOptionsV2, type AskUserSimpleResultV2 } from './impl/ask-user-simple-overlay-v2.js';
+export { GuardrailOverlayV2, type GuardrailConfirmOptionsV2, type GuardrailConfirmResultV2 } from './impl/guardrail-overlay-v2.js';
+export { AskUserOverlayV2, type AskUserOptionsV2, type AskUserResultV2 } from './impl/ask-user-overlay-v2.js';
+export { IterationLimitOverlayV2, type IterationLimitOptionsV2, type IterationLimitResultV2 } from './impl/iteration-limit-overlay-v2.js';
+export { ModelWarningOverlayV2, type ModelWarningOptionsV2, type ModelWarningChoiceV2 } from './impl/model-warning-overlay-v2.js';
+export { NewProjectOverlayV2, type NewProjectResultV2 } from './impl/new-overlay-v2.js';
+export { InitSetupOverlayV2, type InitSetupResultV2 } from './impl/init-setup-overlay-v2.js';
+export { ArchTypeOverlayV2, type ArchTypeChoiceV2, type ArchDocType } from './impl/arch-type-overlay-v2.js';
+export { DashboardOverlayV2, type DashboardOverlayV2Result } from './impl/dashboard-overlay-v2.js';