diff --git a/examples/interactive/README.md b/examples/interactive/README.md
new file mode 100644
index 0000000000..dbea0d40da
--- /dev/null
+++ b/examples/interactive/README.md
@@ -0,0 +1,228 @@
+# Click 交互式命令行向导示例
+
+本示例展示了 Click 新增的交互式命令行向导功能。
+
+## 功能特性
+
+### 1. 交互式命令 (InteractiveCommand)
+- 自动提示用户输入所有参数
+- 支持 `interactive_all` 模式，强制提示所有参数
+- 支持 `interactive_skip` 跳过特定参数
+
+### 2. 交互式命令组 (InteractiveGroup)
+- 显示交互式菜单供用户选择子命令
+- 当没有指定子命令时自动显示菜单
+
+### 3. 交互式选项 (InteractiveOption)
+- 支持条件提问 (`interactive_condition`)
+- 支持顺序依赖 (`interactive_after`)
+- 支持动态条件 (`interactive_when`)
+- 支持交互式帮助 (`interactive_help`)
+
+## 快速开始
+
+### 1. 安装依赖
+
+```bash
+pip install flask flask-cors
+```
+
+### 2. 运行命令行示例
+
+```bash
+# 直接运行交互式命令
+python interactive_demo.py
+
+# 运行特定子命令
+python interactive_demo.py echo-cmd
+python interactive_demo.py copy
+python interactive_demo.py process
+```
+
+### 3. 运行 Web API 服务器
+
+```bash
+python web_api.py
+```
+
+服务器将在 `http://localhost:5000` 启动。
+
+### 4. 打开 Web 界面
+
+在浏览器中打开 `index.html` 文件即可使用交互式 Web 界面。
+
+## API 端点
+
+### GET /api/commands
+获取所有可用命令的信息。
+
+### GET /api/commands/<command_path>
+获取特定命令的详细信息。
+
+### POST /api/execute
+执行命令，支持交互式提示。
+
+请求体:
+```json
+{
+    "command": ["echo-cmd"],
+    "args": [],
+    "answers": ["Hello World", 3]
+}
+```
+
+响应:
+```json
+{
+    "status": "completed",
+    "stdout": "1: Hello World\n2: Hello World\n3: Hello World\n",
+    "stderr": "",
+    "prompts": [...]
+}
+```
+
+如果需要用户输入:
+```json
+{
+    "status": "waiting_for_input",
+    "prompt": {
+        "type": "prompt",
+        "text": "Message to echo?",
+        "default": null
+    },
+    "prompts": [...]
+}
+```
+
+## 使用示例
+
+### 基础交互式命令
+
+```python
+import click
+from click import interactive_command
+
+@interactive_command()
+@click.option('--name', prompt='What is your name?')
+@click.option('--age', type=int, prompt='How old are you?')
+def greet(name, age):
+    click.echo(f'Hello {name}, you are {age} years old!')
+
+if __name__ == '__main__':
+    greet()
+```
+
+### 条件提问
+
+```python
+import click
+from click import interactive_command, interactive_option
+
+@interactive_command()
+@click.option('--project-type', type=click.Choice(['python', 'javascript']))
+@interactive_option(
+    '--python-version',
+    interactive_after='project_type',
+    interactive_condition=lambda params: params.get('project_type') == 'python',
+    prompt='Python version?',
+    type=click.Choice(['3.8', '3.9', '3.10', '3.11', '3.12'])
+)
+@interactive_option(
+    '--node-version',
+    interactive_after='project_type',
+    interactive_condition=lambda params: params.get('project_type') == 'javascript',
+    prompt='Node.js version?',
+    type=click.Choice(['16', '18', '20', '21'])
+)
+def create_project(project_type, python_version, node_version):
+    click.echo(f'Creating {project_type} project...')
+    if python_version:
+        click.echo(f'Python version: {python_version}')
+    if node_version:
+        click.echo(f'Node.js version: {node_version}')
+```
+
+### 交互式命令组
+
+```python
+import click
+from click import interactive_group
+
+@interactive_group()
+def cli():
+    pass
+
+@cli.command()
+@click.option('--message', prompt='Message?')
+def echo(message):
+    click.echo(message)
+
+@cli.command()
+@click.option('--source', prompt='Source?')
+@click.option('--dest', prompt='Destination?')
+def copy(source, dest):
+    click.echo(f'Copying {source} to {dest}')
+
+if __name__ == '__main__':
+    cli()
+```
+
+## 新增的装饰器和类
+
+### 装饰器
+- `@interactive_command` - 创建交互式命令
+- `@interactive_group` - 创建交互式命令组
+- `@interactive_option` - 创建交互式选项
+- `@with_interactive` - 添加 `--interactive` 标志
+
+### 类
+- `InteractiveCommand` - 交互式命令类
+- `InteractiveGroup` - 交互式命令组类
+- `InteractiveOption` - 交互式选项类
+
+## 参数说明
+
+### InteractiveOption 参数
+- `interactive` - 是否启用交互式模式
+- `interactive_when` - 动态条件函数，接收 Context
+- `interactive_after` - 依赖的参数名称
+- `interactive_condition` - 条件函数，接收已处理的参数字典
+- `interactive_help` - 交互式帮助文本
+
+### InteractiveCommand 参数
+- `interactive` - 是否启用交互式模式
+- `interactive_all` - 是否提示所有参数
+- `interactive_skip` - 跳过的参数名称列表
+
+### InteractiveGroup 参数
+- `interactive` - 是否启用交互式模式
+- `interactive_menu` - 是否显示交互式菜单
+
+## 测试
+
+### 命令行测试
+
+```bash
+# 测试简单问候
+python interactive_demo.py simple-greet
+
+# 测试条件提问
+python interactive_demo.py create-project
+
+# 测试交互式菜单
+python interactive_demo.py
+```
+
+### Web 界面测试
+
+1. 启动 API 服务器: `python web_api.py`
+2. 打开 `index.html`
+3. 选择命令并点击执行
+4. 按照提示输入答案
+
+## 注意事项
+
+1. 确保 Python 版本 >= 3.8
+2. Web API 需要 Flask 和 Flask-CORS
+3. 交互式功能与现有的 Click 参数解析系统完全兼容
+4. 条件提问支持复杂的业务逻辑
diff --git a/examples/interactive/index.html b/examples/interactive/index.html
new file mode 100644
index 0000000000..e0f4c2613c
--- /dev/null
+++ b/examples/interactive/index.html
@@ -0,0 +1,823 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Click 交互式命令行向导 - 实验环境</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        .header {
+            text-align: center;
+            color: white;
+            margin-bottom: 30px;
+        }
+
+        .header h1 {
+            font-size: 2.5rem;
+            margin-bottom: 10px;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.2);
+        }
+
+        .header p {
+            font-size: 1.1rem;
+            opacity: 0.9;
+        }
+
+        .main-content {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+        }
+
+        @media (max-width: 900px) {
+            .main-content {
+                grid-template-columns: 1fr;
+            }
+        }
+
+        .card {
+            background: white;
+            border-radius: 12px;
+            box-shadow: 0 10px 40px rgba(0,0,0,0.2);
+            overflow: hidden;
+        }
+
+        .card-header {
+            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+            color: white;
+            padding: 15px 20px;
+            font-weight: 600;
+            font-size: 1.1rem;
+        }
+
+        .card-body {
+            padding: 20px;
+            max-height: 600px;
+            overflow-y: auto;
+        }
+
+        .command-list {
+            list-style: none;
+        }
+
+        .command-item {
+            padding: 12px 15px;
+            border-radius: 8px;
+            margin-bottom: 8px;
+            cursor: pointer;
+            transition: all 0.2s ease;
+            border: 2px solid transparent;
+        }
+
+        .command-item:hover {
+            background: #f0f4ff;
+            border-color: #667eea;
+        }
+
+        .command-item.selected {
+            background: #667eea;
+            color: white;
+        }
+
+        .command-name {
+            font-weight: 600;
+            margin-bottom: 4px;
+        }
+
+        .command-desc {
+            font-size: 0.85rem;
+            opacity: 0.7;
+        }
+
+        .param-list {
+            list-style: none;
+        }
+
+        .param-item {
+            padding: 12px 15px;
+            border-radius: 8px;
+            margin-bottom: 8px;
+            background: #f8f9fa;
+            border-left: 4px solid #667eea;
+        }
+
+        .param-name {
+            font-weight: 600;
+            color: #1a1a2e;
+            margin-bottom: 4px;
+        }
+
+        .param-details {
+            font-size: 0.85rem;
+            color: #666;
+        }
+
+        .param-details span {
+            display: inline-block;
+            background: #e9ecef;
+            padding: 2px 8px;
+            border-radius: 4px;
+            margin-right: 5px;
+            margin-top: 3px;
+        }
+
+        .terminal {
+            background: #1a1a2e;
+            color: #00ff88;
+            font-family: 'Consolas', 'Monaco', monospace;
+            padding: 15px;
+            border-radius: 8px;
+            min-height: 200px;
+            max-height: 400px;
+            overflow-y: auto;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+        }
+
+        .terminal-line {
+            margin-bottom: 5px;
+        }
+
+        .terminal-prompt {
+            color: #ff6b6b;
+        }
+
+        .terminal-output {
+            color: #00ff88;
+        }
+
+        .terminal-error {
+            color: #ff6b6b;
+        }
+
+        .prompt-dialog {
+            background: #f8f9fa;
+            border-radius: 8px;
+            padding: 15px;
+            margin-bottom: 15px;
+            border: 2px solid #667eea;
+        }
+
+        .prompt-text {
+            font-weight: 600;
+            margin-bottom: 10px;
+            color: #1a1a2e;
+        }
+
+        .prompt-input {
+            width: 100%;
+            padding: 10px 15px;
+            border: 2px solid #ddd;
+            border-radius: 6px;
+            font-size: 1rem;
+            transition: border-color 0.2s;
+        }
+
+        .prompt-input:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+
+        .prompt-select {
+            width: 100%;
+            padding: 10px 15px;
+            border: 2px solid #ddd;
+            border-radius: 6px;
+            font-size: 1rem;
+            background: white;
+        }
+
+        .prompt-checkbox {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .prompt-checkbox input[type="checkbox"] {
+            width: 20px;
+            height: 20px;
+            cursor: pointer;
+        }
+
+        .btn {
+            padding: 10px 20px;
+            border: none;
+            border-radius: 6px;
+            font-size: 1rem;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.2s ease;
+        }
+
+        .btn-primary {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+        }
+
+        .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 20px rgba(102, 126, 234, 0.4);
+        }
+
+        .btn-secondary {
+            background: #6c757d;
+            color: white;
+        }
+
+        .btn-secondary:hover {
+            background: #5a6268;
+        }
+
+        .btn-success {
+            background: #28a745;
+            color: white;
+        }
+
+        .btn-success:hover {
+            background: #218838;
+        }
+
+        .btn-group {
+            display: flex;
+            gap: 10px;
+            margin-top: 15px;
+        }
+
+        .loading {
+            text-align: center;
+            padding: 20px;
+            color: #667eea;
+        }
+
+        .spinner {
+            border: 3px solid #f3f3f3;
+            border-top: 3px solid #667eea;
+            border-radius: 50%;
+            width: 30px;
+            height: 30px;
+            animation: spin 1s linear infinite;
+            margin: 0 auto 10px;
+        }
+
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        .tabs {
+            display: flex;
+            border-bottom: 2px solid #e9ecef;
+            margin-bottom: 15px;
+        }
+
+        .tab {
+            padding: 10px 20px;
+            cursor: pointer;
+            border-bottom: 2px solid transparent;
+            transition: all 0.2s;
+            font-weight: 500;
+        }
+
+        .tab:hover {
+            color: #667eea;
+        }
+
+        .tab.active {
+            color: #667eea;
+            border-bottom-color: #667eea;
+        }
+
+        .tab-content {
+            display: none;
+        }
+
+        .tab-content.active {
+            display: block;
+        }
+
+        .code-block {
+            background: #1a1a2e;
+            color: #e9ecef;
+            padding: 15px;
+            border-radius: 8px;
+            font-family: 'Consolas', 'Monaco', monospace;
+            font-size: 0.9rem;
+            overflow-x: auto;
+            white-space: pre-wrap;
+        }
+
+        .code-keyword {
+            color: #ff6b6b;
+        }
+
+        .code-string {
+            color: #ffd93d;
+        }
+
+        .code-comment {
+            color: #6c757d;
+        }
+
+        .code-function {
+            color: #6bcb77;
+        }
+
+        .section-title {
+            font-size: 1.1rem;
+            font-weight: 600;
+            color: #1a1a2e;
+            margin-bottom: 10px;
+            padding-bottom: 8px;
+            border-bottom: 2px solid #e9ecef;
+        }
+
+        .info-box {
+            background: #e7f5ff;
+            border-left: 4px solid #339af0;
+            padding: 12px 15px;
+            border-radius: 4px;
+            margin-bottom: 15px;
+        }
+
+        .info-box h4 {
+            color: #1864ab;
+            margin-bottom: 5px;
+        }
+
+        .info-box p {
+            color: #495057;
+            font-size: 0.9rem;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🎯 Click 交互式命令行向导</h1>
+            <p>实验环境 - 测试交互式命令行功能</p>
+        </div>
+
+        <div class="main-content">
+            <div class="card">
+                <div class="card-header">
+                    📋 可用命令
+                </div>
+                <div class="card-body">
+                    <div class="tabs">
+                        <div class="tab active" data-tab="commands">命令列表</div>
+                        <div class="tab" data-tab="examples">使用示例</div>
+                        <div class="tab" data-tab="docs">功能文档</div>
+                    </div>
+
+                    <div id="commands-tab" class="tab-content active">
+                        <div class="info-box">
+                            <h4>💡 提示</h4>
+                            <p>选择一个命令查看详细信息，然后点击"执行命令"按钮运行它。</p>
+                        </div>
+                        <ul class="command-list" id="command-list">
+                            <li class="loading">
+                                <div class="spinner"></div>
+                                加载命令列表...
+                            </li>
+                        </ul>
+                    </div>
+
+                    <div id="examples-tab" class="tab-content">
+                        <div class="section-title">基础示例</div>
+                        <div class="code-block">
+<span class="code-keyword">import</span> click
+<span class="code-keyword">from</span> click <span class="code-keyword">import</span> interactive_command
+
+<span class="code-comment"># 简单的交互式命令</span>
+<span class="code-function">@interactive_command</span>()
+<span class="code-function">@click.option</span>(<span class="code-string">'--name'</span>, <span class="code-keyword">prompt</span>=<span class="code-string">'你的名字?'</span>)
+<span class="code-function">@click.option</span>(<span class="code-string">'--age'</span>, <span class="code-keyword">type</span>=<span class="code-keyword">int</span>, <span class="code-keyword">prompt</span>=<span class="code-string">'你的年龄?'</span>)
+<span class="code-keyword">def</span> <span class="code-function">greet</span>(name, age):
+    click.echo(<span class="code-string">f'你好 {name}，你 {age} 岁了！'</span>)
+                        </div>
+
+                        <div class="section-title" style="margin-top: 20px;">条件提问示例</div>
+                        <div class="code-block">
+<span class="code-keyword">from</span> click <span class="code-keyword">import</span> interactive_option
+
+<span class="code-function">@interactive_command</span>()
+<span class="code-function">@click.option</span>(<span class="code-string">'--project-type'</span>, 
+              <span class="code-keyword">type</span>=click.Choice([<span class="code-string">'python'</span>, <span class="code-string">'javascript'</span>]))
+<span class="code-function">@interactive_option</span>(
+    <span class="code-string">'--python-version'</span>,
+    <span class="code-keyword">interactive_after</span>=<span class="code-string">'project_type'</span>,
+    <span class="code-keyword">interactive_condition</span>=<span class="code-keyword">lambda</span> params: params.get(<span class="code-string">'project_type'</span>) == <span class="code-string">'python'</span>,
+    <span class="code-keyword">prompt</span>=<span class="code-string">'Python 版本?'</span>
+)
+<span class="code-function">@interactive_option</span>(
+    <span class="code-string">'--node-version'</span>,
+    <span class="code-keyword">interactive_after</span>=<span class="code-string">'project_type'</span>,
+    <span class="code-keyword">interactive_condition</span>=<span class="code-keyword">lambda</span> params: params.get(<span class="code-string">'project_type'</span>) == <span class="code-string">'javascript'</span>,
+    <span class="code-keyword">prompt</span>=<span class="code-string">'Node.js 版本?'</span>
+)
+<span class="code-keyword">def</span> <span class="code-function">create_project</span>(project_type, python_version, node_version):
+    <span class="code-keyword">pass</span>
+                        </div>
+                    </div>
+
+                    <div id="docs-tab" class="tab-content">
+                        <div class="section-title">新增功能</div>
+                        
+                        <div class="info-box">
+                            <h4>🎯 InteractiveCommand</h4>
+                            <p>支持交互式模式的命令类。当启用时，会自动提示用户输入所有参数。</p>
+                        </div>
+
+                        <div class="info-box">
+                            <h4>🎯 InteractiveGroup</h4>
+                            <p>支持交互式菜单的命令组。当没有指定子命令时，显示交互式菜单供用户选择。</p>
+                        </div>
+
+                        <div class="info-box">
+                            <h4>🎯 InteractiveOption</h4>
+                            <p>支持条件提问的选项类。可以根据之前的回答决定是否提示该选项。</p>
+                        </div>
+
+                        <div class="section-title" style="margin-top: 20px;">装饰器</div>
+                        
+                        <div class="info-box">
+                            <h4>@interactive_command</h4>
+                            <p>创建交互式命令的装饰器。参数：interactive, interactive_all, interactive_skip</p>
+                        </div>
+
+                        <div class="info-box">
+                            <h4>@interactive_group</h4>
+                            <p>创建交互式命令组的装饰器。参数：interactive, interactive_menu</p>
+                        </div>
+
+                        <div class="info-box">
+                            <h4>@interactive_option</h4>
+                            <p>创建交互式选项的装饰器。支持条件提问：interactive_when, interactive_after, interactive_condition</p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <div class="card">
+                <div class="card-header">
+                    🚀 命令执行
+                </div>
+                <div class="card-body">
+                    <div id="command-details" style="display: none;">
+                        <div class="section-title">命令信息</div>
+                        <div id="command-info" style="margin-bottom: 15px;"></div>
+                        
+                        <div class="section-title">参数列表</div>
+                        <ul class="param-list" id="param-list"></ul>
+                        
+                        <div class="btn-group">
+                            <button class="btn btn-primary" id="execute-btn">
+                                ▶️ 执行命令
+                            </button>
+                            <button class="btn btn-secondary" id="clear-btn">
+                                🗑️ 清空输出
+                            </button>
+                        </div>
+                    </div>
+
+                    <div id="no-selection" style="text-align: center; padding: 40px; color: #6c757d;">
+                        <div style="font-size: 3rem; margin-bottom: 15px;">👈</div>
+                        <p>请从左侧选择一个命令</p>
+                    </div>
+
+                    <div id="prompt-area" style="display: none; margin-top: 20px;">
+                        <div class="section-title">交互式输入</div>
+                        <div id="prompt-dialog"></div>
+                        <div class="btn-group">
+                            <button class="btn btn-success" id="submit-answer-btn">
+                                ✅ 提交答案
+                            </button>
+                        </div>
+                    </div>
+
+                    <div id="output-area" style="display: none; margin-top: 20px;">
+                        <div class="section-title">输出结果</div>
+                        <div class="terminal" id="terminal-output"></div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const API_BASE = 'http://localhost:5000/api';
+        
+        let commandsData = null;
+        let selectedCommand = null;
+        let currentAnswers = [];
+        let currentCommandPath = [];
+
+        document.querySelectorAll('.tab').forEach(tab => {
+            tab.addEventListener('click', () => {
+                document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+                document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
+                
+                tab.classList.add('active');
+                document.getElementById(`${tab.dataset.tab}-tab`).classList.add('active');
+            });
+        });
+
+        async function loadCommands() {
+            try {
+                const response = await fetch(`${API_BASE}/commands`);
+                commandsData = await response.json();
+                renderCommandList(commandsData.commands);
+            } catch (error) {
+                document.getElementById('command-list').innerHTML = `
+                    <li style="color: #dc3545; padding: 15px;">
+                        ❌ 无法连接到 API 服务器<br>
+                        请确保已运行: python web_api.py
+                    </li>
+                `;
+            }
+        }
+
+        function renderCommandList(group, parentPath = []) {
+            const listEl = document.getElementById('command-list');
+            
+            if (parentPath.length === 0) {
+                listEl.innerHTML = '';
+            }
+
+            if (group.is_group && group.commands) {
+                Object.entries(group.commands).forEach(([name, cmd]) => {
+                    const item = document.createElement('li');
+                    item.className = 'command-item';
+                    item.innerHTML = `
+                        <div class="command-name">
+                            ${cmd.is_group ? '📁' : '📄'} ${name}
+                        </div>
+                        <div class="command-desc">${cmd.short_help || '暂无描述'}</div>
+                    `;
+                    
+                    const cmdPath = [...parentPath, name];
+                    item.addEventListener('click', () => selectCommand(cmd, cmdPath));
+                    listEl.appendChild(item);
+                });
+            }
+        }
+
+        function selectCommand(cmd, path) {
+            selectedCommand = cmd;
+            currentCommandPath = path;
+            currentAnswers = [];
+
+            document.querySelectorAll('.command-item').forEach(item => {
+                item.classList.remove('selected');
+            });
+            event.currentTarget.classList.add('selected');
+
+            document.getElementById('no-selection').style.display = 'none';
+            document.getElementById('command-details').style.display = 'block';
+            document.getElementById('prompt-area').style.display = 'none';
+            document.getElementById('output-area').style.display = 'none';
+
+            renderCommandDetails(cmd);
+        }
+
+        function renderCommandDetails(cmd) {
+            const infoEl = document.getElementById('command-info');
+            infoEl.innerHTML = `
+                <div style="margin-bottom: 10px;">
+                    <strong>名称:</strong> ${cmd.name}
+                </div>
+                <div style="margin-bottom: 10px;">
+                    <strong>描述:</strong> ${cmd.help || '暂无描述'}
+                </div>
+                <div>
+                    <strong>类型:</strong> ${cmd.is_group ? '命令组' : '命令'}
+                </div>
+            `;
+
+            const paramListEl = document.getElementById('param-list');
+            paramListEl.innerHTML = '';
+
+            if (cmd.params && cmd.params.length > 0) {
+                cmd.params.forEach(param => {
+                    if (param.name === 'help') return;
+                    
+                    const item = document.createElement('li');
+                    item.className = 'param-item';
+                    
+                    let details = '';
+                    if (param.required) {
+                        details += '<span style="background: #dc3545; color: white;">必需</span>';
+                    }
+                    if (param.has_prompt) {
+                        details += '<span style="background: #28a745; color: white;">交互式</span>';
+                    }
+                    if (param.is_flag) {
+                        details += '<span>标志</span>';
+                    }
+                    if (param.default !== null) {
+                        details += `<span>默认: ${param.default}</span>`;
+                    }
+                    if (param.choices) {
+                        details += `<span>选项: ${param.choices.join(', ')}</span>`;
+                    }
+
+                    item.innerHTML = `
+                        <div class="param-name">--${param.name}</div>
+                        <div class="param-details">
+                            ${param.help || '暂无描述'}
+                            ${details ? `<br>${details}` : ''}
+                        </div>
+                    `;
+                    paramListEl.appendChild(item);
+                });
+            } else {
+                paramListEl.innerHTML = '<li style="padding: 15px; color: #6c757d;">该命令没有参数</li>';
+            }
+        }
+
+        document.getElementById('execute-btn').addEventListener('click', async () => {
+            currentAnswers = [];
+            await executeCommand();
+        });
+
+        document.getElementById('clear-btn').addEventListener('click', () => {
+            document.getElementById('output-area').style.display = 'none';
+            document.getElementById('prompt-area').style.display = 'none';
+            currentAnswers = [];
+        });
+
+        async function executeCommand() {
+            const outputEl = document.getElementById('terminal-output');
+            const outputArea = document.getElementById('output-area');
+            
+            outputArea.style.display = 'block';
+            outputEl.innerHTML = '<div class="terminal-line"><span class="terminal-prompt">$</span> 执行命令中...</div>';
+
+            try {
+                const response = await fetch(`${API_BASE}/execute`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        command: currentCommandPath,
+                        args: [],
+                        answers: currentAnswers.length > 0 ? currentAnswers : null
+                    })
+                });
+
+                const result = await response.json();
+                handleExecutionResult(result);
+            } catch (error) {
+                outputEl.innerHTML += `
+                    <div class="terminal-line terminal-error">
+                        ❌ 错误: ${error.message}
+                    </div>
+                `;
+            }
+        }
+
+        function handleExecutionResult(result) {
+            const outputEl = document.getElementById('terminal-output');
+            const promptArea = document.getElementById('prompt-area');
+            const promptDialog = document.getElementById('prompt-dialog');
+
+            if (result.stdout) {
+                outputEl.innerHTML += `
+                    <div class="terminal-line terminal-output">
+                        ${result.stdout.replace(/\n/g, '<br>')}
+                    </div>
+                `;
+            }
+
+            if (result.stderr) {
+                outputEl.innerHTML += `
+                    <div class="terminal-line terminal-error">
+                        ${result.stderr.replace(/\n/g, '<br>')}
+                    </div>
+                `;
+            }
+
+            if (result.status === 'waiting_for_input') {
+                promptArea.style.display = 'block';
+                
+                const prompt = result.prompt;
+                let inputHtml = '';
+
+                if (prompt.type === 'confirm') {
+                    inputHtml = `
+                        <div class="prompt-checkbox">
+                            <input type="checkbox" id="prompt-answer" ${prompt.default ? 'checked' : ''}>
+                            <label for="prompt-answer">${prompt.default !== null ? (prompt.default ? '是 (默认)' : '否 (默认)') : '请选择'}</label>
+                        </div>
+                    `;
+                } else if (prompt.choices) {
+                    inputHtml = `
+                        <select class="prompt-select" id="prompt-answer">
+                            ${prompt.choices.map(choice => 
+                                `<option value="${choice}" ${choice === prompt.default ? 'selected' : ''}>${choice}</option>`
+                            ).join('')}
+                        </select>
+                    `;
+                } else {
+                    inputHtml = `
+                        <input type="${prompt.hide_input ? 'password' : 'text'}" 
+                               class="prompt-input" 
+                               id="prompt-answer"
+                               placeholder="${prompt.default !== null ? `默认: ${prompt.default}` : '请输入...'}"
+                               value="${prompt.default !== null ? prompt.default : ''}">
+                    `;
+                }
+
+                promptDialog.innerHTML = `
+                    <div class="prompt-dialog">
+                        <div class="prompt-text">
+                            ${prompt.type === 'confirm' ? '❓' : '💬'} ${prompt.text}
+                        </div>
+                        ${inputHtml}
+                    </div>
+                `;
+
+                outputEl.innerHTML += `
+                    <div class="terminal-line">
+                        <span class="terminal-prompt">?</span> ${prompt.text}
+                    </div>
+                `;
+            } else if (result.status === 'completed') {
+                promptArea.style.display = 'none';
+                outputEl.innerHTML += `
+                    <div class="terminal-line" style="color: #4dabf7;">
+                        ✅ 命令执行完成
+                    </div>
+                `;
+                if (result.result !== undefined) {
+                    outputEl.innerHTML += `
+                        <div class="terminal-line">
+                            结果: ${JSON.stringify(result.result)}
+                        </div>
+                    `;
+                }
+            } else if (result.status === 'error') {
+                promptArea.style.display = 'none';
+                outputEl.innerHTML += `
+                    <div class="terminal-line terminal-error">
+                        ❌ 错误: ${result.error}
+                    </div>
+                `;
+            }
+        }
+
+        document.getElementById('submit-answer-btn').addEventListener('click', async () => {
+            const answerEl = document.getElementById('prompt-answer');
+            let answer;
+
+            if (answerEl.type === 'checkbox') {
+                answer = answerEl.checked;
+            } else if (answerEl.tagName === 'SELECT') {
+                answer = answerEl.value;
+            } else {
+                answer = answerEl.value;
+            }
+
+            currentAnswers.push(answer);
+            
+            const outputEl = document.getElementById('terminal-output');
+            outputEl.innerHTML += `
+                <div class="terminal-line">
+                    <span class="terminal-prompt">></span> ${answer}
+                </div>
+            `;
+
+            await executeCommand();
+        });
+
+        document.addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') {
+                const promptArea = document.getElementById('prompt-area');
+                if (promptArea.style.display !== 'none') {
+                    document.getElementById('submit-answer-btn').click();
+                }
+            }
+        });
+
+        loadCommands();
+    </script>
+</body>
+</html>
diff --git a/examples/interactive/interactive_demo.py b/examples/interactive/interactive_demo.py
new file mode 100644
index 0000000000..237c1f73f8
--- /dev/null
+++ b/examples/interactive/interactive_demo.py
@@ -0,0 +1,141 @@
+"""
+Interactive Command Line Wizard Example for Click
+
+This example demonstrates the interactive features added to Click:
+1. Interactive commands and groups
+2. Conditional prompting
+3. Interactive menus
+4. Web API integration
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "src"))
+
+import click
+from click import interactive_command
+from click import interactive_group
+from click import interactive_option
+
+
+@interactive_command()
+@click.option("--name", prompt="What is your name?", help="Your name")
+@click.option("--age", type=int, prompt="How old are you?", help="Your age")
+@click.option("--city", prompt="Where do you live?", help="Your city")
+def simple_greet(name: str, age: int, city: str) -> None:
+    """A simple interactive greeting command."""
+    click.echo(f"\nHello {name}!")
+    click.echo(f"You are {age} years old and live in {city}.")
+
+
+@interactive_command(interactive_all=True)
+@click.option("--username", help="Username for login")
+@click.option("--password", hide_input=True, help="Password for login")
+@click.option("--remember-me", is_flag=True, help="Remember login")
+def login(username: str, password: str, remember_me: bool) -> None:
+    """Login command with interactive mode for all parameters."""
+    click.echo(f"\nLogging in as {username}...")
+    if remember_me:
+        click.echo("Will remember your login.")
+    click.echo("Login successful!")
+
+
+@interactive_command()
+@click.option("--name", prompt="Project name?", help="Name of the project")
+@click.option("--project-type", type=click.Choice(["python", "javascript", "rust"]),
+              prompt="Project type?", help="Type of project")
+@interactive_option(
+    "--use-docker",
+    is_flag=True,
+    interactive_help="Docker helps with containerization and deployment",
+    prompt="Use Docker?",
+)
+@interactive_option(
+    "--python-version",
+    type=click.Choice(["3.8", "3.9", "3.10", "3.11", "3.12"]),
+    interactive_after="project_type",
+    interactive_condition=lambda params: params.get("project_type") == "python",
+    prompt="Python version?",
+)
+@interactive_option(
+    "--node-version",
+    type=click.Choice(["16", "18", "20", "21"]),
+    interactive_after="project_type",
+    interactive_condition=lambda params: params.get("project_type") == "javascript",
+    prompt="Node.js version?",
+)
+@interactive_option(
+    "--rust-edition",
+    type=click.Choice(["2018", "2021"]),
+    interactive_after="project_type",
+    interactive_condition=lambda params: params.get("project_type") == "rust",
+    prompt="Rust edition?",
+)
+def create_project(
+    name: str,
+    project_type: str,
+    use_docker: bool,
+    python_version: str | None,
+    node_version: str | None,
+    rust_edition: str | None,
+) -> None:
+    """Create a new project with conditional options."""
+    click.echo(f"\nCreating {project_type} project: {name}")
+    click.echo(f"Use Docker: {'Yes' if use_docker else 'No'}")
+
+    if python_version:
+        click.echo(f"Python version: {python_version}")
+    if node_version:
+        click.echo(f"Node.js version: {node_version}")
+    if rust_edition:
+        click.echo(f"Rust edition: {rust_edition}")
+
+    click.echo("\nProject created successfully!")
+
+
+@interactive_group()
+def cli() -> None:
+    """Interactive CLI Demo - A demonstration of Click's interactive features."""
+    pass
+
+
+@cli.command()
+@click.option("--message", prompt="Message to echo?", help="Message to display")
+@click.option("--count", type=int, default=1, help="Number of times to echo")
+def echo_cmd(message: str, count: int) -> None:
+    """Echo a message multiple times."""
+    for i in range(count):
+        click.echo(f"{i + 1}: {message}")
+
+
+@cli.command()
+@click.option("--source", prompt="Source file?", help="Source file path")
+@click.option("--destination", prompt="Destination?", help="Destination path")
+@click.option("--force", is_flag=True, help="Force overwrite")
+def copy(source: str, destination: str, force: bool) -> None:
+    """Copy a file (simulated)."""
+    click.echo(f"\nCopying {source} to {destination}...")
+    if force:
+        click.echo("Force mode enabled.")
+    click.echo("Copy completed!")
+
+
+@cli.command()
+@click.option("--input-file", prompt="Input file?", help="Input file path")
+@click.option("--output-format", type=click.Choice(["json", "csv", "xml"]),
+              prompt="Output format?", help="Output format")
+@click.option("--verbose", is_flag=True, help="Verbose output")
+def process(input_file: str, output_format: str, verbose: bool) -> None:
+    """Process a file (simulated)."""
+    click.echo(f"\nProcessing {input_file}...")
+    if verbose:
+        click.echo(f"Output format: {output_format}")
+        click.echo("Running in verbose mode...")
+    click.echo("Processing completed!")
+
+
+if __name__ == "__main__":
+    cli()
diff --git a/examples/interactive/pyproject.toml b/examples/interactive/pyproject.toml
new file mode 100644
index 0000000000..2dedb196c6
--- /dev/null
+++ b/examples/interactive/pyproject.toml
@@ -0,0 +1,22 @@
+[project]
+name = "click-interactive-demo"
+version = "0.1.0"
+description = "Interactive Command Line Wizard Demo for Click"
+requires-python = ">=3.8"
+dependencies = [
+    "flask>=2.0.0",
+    "flask-cors>=3.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py38"
+
+[tool.mypy]
+python_version = "3.8"
+strict = true
diff --git a/examples/interactive/test_interactive.py b/examples/interactive/test_interactive.py
new file mode 100644
index 0000000000..e914e5a2dd
--- /dev/null
+++ b/examples/interactive/test_interactive.py
@@ -0,0 +1,272 @@
+"""
+Test script for Click interactive features.
+
+This script tests the basic functionality of the interactive command line wizard.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "src"))
+
+import click
+from click import interactive_command
+from click import interactive_group
+from click import interactive_option
+from click.interactive import InteractiveCommand
+from click.interactive import InteractiveGroup
+from click.interactive import InteractiveOption
+
+
+def test_interactive_option_creation():
+    """Test that InteractiveOption can be created."""
+    opt = InteractiveOption(
+        ["--name"],
+        interactive=True,
+        prompt="What is your name?",
+    )
+    assert opt.interactive is True
+    assert opt.prompt == "What is your name?"
+    print("✅ InteractiveOption creation test passed")
+
+
+def test_interactive_command_creation():
+    """Test that InteractiveCommand can be created."""
+    
+    @interactive_command()
+    @click.option("--name", prompt="Name?")
+    def test_cmd(name):
+        return name
+    
+    assert isinstance(test_cmd, InteractiveCommand)
+    assert test_cmd.interactive is True
+    print("✅ InteractiveCommand creation test passed")
+
+
+def test_interactive_group_creation():
+    """Test that InteractiveGroup can be created."""
+    
+    @interactive_group()
+    def test_grp():
+        pass
+    
+    assert isinstance(test_grp, InteractiveGroup)
+    assert test_grp.interactive is True
+    assert test_grp.interactive_menu is True
+    print("✅ InteractiveGroup creation test passed")
+
+
+def test_conditional_interactive_option():
+    """Test conditional interactive options."""
+    
+    def condition(params):
+        return params.get("project_type") == "python"
+    
+    opt = InteractiveOption(
+        ["--python-version"],
+        interactive=True,
+        interactive_after="project_type",
+        interactive_condition=condition,
+        prompt="Python version?",
+    )
+    
+    assert opt.interactive_after == "project_type"
+    assert opt.interactive_condition is condition
+    
+    assert opt.interactive_condition({"project_type": "python"}) is True
+    assert opt.interactive_condition({"project_type": "javascript"}) is False
+    print("✅ Conditional interactive option test passed")
+
+
+def test_interactive_option_info_dict():
+    """Test that InteractiveOption properly exports info dict."""
+    opt = InteractiveOption(
+        ["--test"],
+        interactive=True,
+        interactive_help="This is a test option",
+    )
+    
+    info = opt.to_info_dict()
+    assert info["interactive"] is True
+    assert info["interactive_help"] == "This is a test option"
+    print("✅ InteractiveOption info dict test passed")
+
+
+def test_interactive_all_flag():
+    """Test the interactive_all flag."""
+    
+    @interactive_command(interactive_all=True)
+    @click.option("--name")
+    @click.option("--age", type=int)
+    def test_cmd(name, age):
+        pass
+    
+    assert test_cmd.interactive_all is True
+    print("✅ interactive_all flag test passed")
+
+
+def test_interactive_skip():
+    """Test the interactive_skip parameter."""
+    
+    @interactive_command(interactive_skip=["help", "version"])
+    @click.option("--name", prompt="Name?")
+    def test_cmd(name):
+        pass
+    
+    assert "help" in test_cmd.interactive_skip
+    assert "version" in test_cmd.interactive_skip
+    print("✅ interactive_skip test passed")
+
+
+def test_interactive_menu_flag():
+    """Test the interactive_menu flag for groups."""
+    
+    @interactive_group(interactive_menu=False)
+    def test_grp():
+        pass
+    
+    assert test_grp.interactive_menu is False
+    print("✅ interactive_menu flag test passed")
+
+
+def test_should_interactive_prompt():
+    """Test the should_interactive_prompt method."""
+    from click.core import Context
+    
+    opt = InteractiveOption(
+        ["--test"],
+        interactive=True,
+    )
+    
+    ctx = Context(click.Command("test"))
+    
+    assert opt.should_interactive_prompt(ctx, {}) is True
+    print("✅ should_interactive_prompt test passed")
+
+
+def test_should_interactive_prompt_with_condition():
+    """Test should_interactive_prompt with conditions."""
+    from click.core import Context
+    
+    opt = InteractiveOption(
+        ["--python-version"],
+        interactive=True,
+        interactive_after="project_type",
+        interactive_condition=lambda params: params.get("project_type") == "python",
+    )
+    
+    ctx = Context(click.Command("test"))
+    
+    assert opt.should_interactive_prompt(ctx, {}) is False
+    assert opt.should_interactive_prompt(ctx, {"project_type": "javascript"}) is False
+    assert opt.should_interactive_prompt(ctx, {"project_type": "python"}) is True
+    print("✅ should_interactive_prompt with condition test passed")
+
+
+def test_interactive_group_subcommand():
+    """Test that InteractiveGroup creates InteractiveCommand subcommands."""
+    
+    @interactive_group()
+    def test_grp():
+        pass
+    
+    @test_grp.command()
+    @click.option("--name", prompt="Name?")
+    def greet(name):
+        return name
+    
+    assert isinstance(test_grp, InteractiveGroup)
+    assert test_grp.interactive is True
+    
+    cmd = test_grp.get_command(click.Context(test_grp), "greet")
+    assert cmd is not None
+    assert isinstance(cmd, InteractiveCommand)
+    assert cmd.interactive is True
+    print("✅ InteractiveGroup subcommand test passed")
+
+
+def test_interactive_group_with_custom_cls():
+    """Test that InteractiveGroup respects custom cls parameter."""
+    
+    @interactive_group()
+    def test_grp():
+        pass
+    
+    @test_grp.command(cls=click.Command)
+    @click.option("--name")
+    def hello(name):
+        return name
+    
+    cmd = test_grp.get_command(click.Context(test_grp), "hello")
+    assert cmd is not None
+    assert not isinstance(cmd, InteractiveCommand)
+    print("✅ InteractiveGroup with custom cls test passed")
+
+
+def test_interactive_group_non_interactive():
+    """Test InteractiveGroup with interactive=False."""
+    
+    @interactive_group(interactive=False)
+    def test_grp():
+        pass
+    
+    @test_grp.command()
+    @click.option("--name")
+    def welcome(name):
+        return name
+    
+    assert test_grp.interactive is False
+    
+    cmd = test_grp.get_command(click.Context(test_grp), "welcome")
+    assert cmd is not None
+    assert not isinstance(cmd, InteractiveCommand)
+    print("✅ InteractiveGroup non-interactive test passed")
+
+
+def run_all_tests():
+    """Run all tests."""
+    print("=" * 60)
+    print("Running Click Interactive Features Tests")
+    print("=" * 60)
+    print()
+    
+    tests = [
+        test_interactive_option_creation,
+        test_interactive_command_creation,
+        test_interactive_group_creation,
+        test_conditional_interactive_option,
+        test_interactive_option_info_dict,
+        test_interactive_all_flag,
+        test_interactive_skip,
+        test_interactive_menu_flag,
+        test_should_interactive_prompt,
+        test_should_interactive_prompt_with_condition,
+        test_interactive_group_subcommand,
+        test_interactive_group_with_custom_cls,
+        test_interactive_group_non_interactive,
+    ]
+    
+    passed = 0
+    failed = 0
+    
+    for test in tests:
+        try:
+            test()
+            passed += 1
+        except Exception as e:
+            print(f"❌ {test.__name__} failed: {e}")
+            failed += 1
+    
+    print()
+    print("=" * 60)
+    print(f"Test Results: {passed} passed, {failed} failed")
+    print("=" * 60)
+    
+    return failed == 0
+
+
+if __name__ == "__main__":
+    success = run_all_tests()
+    sys.exit(0 if success else 1)
diff --git a/examples/interactive/web_api.py b/examples/interactive/web_api.py
new file mode 100644
index 0000000000..c066dd9eed
--- /dev/null
+++ b/examples/interactive/web_api.py
@@ -0,0 +1,290 @@
+"""
+Web API for Interactive Click Commands
+
+This module provides a Flask-based API that allows executing Click commands
+interactively through HTTP requests. It captures prompts and returns them
+to the client for user input.
+"""
+
+from __future__ import annotations
+
+import io
+import sys
+import typing as t
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "src"))
+
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+
+import click
+from click._termui_impl import ProgressBar
+from click.core import Command, Context, Group, Option, Parameter
+from click.termui import confirm, prompt
+
+
+class InteractivePromptCapture:
+    """
+    A class that captures prompts and allows providing answers programmatically.
+    """
+
+    def __init__(self) -> None:
+        self.prompts: list[dict[str, t.Any]] = []
+        self.answers: list[t.Any] = []
+        self.current_prompt_index = 0
+
+    def capture_prompt(
+        self,
+        text: str,
+        default: t.Any | None = None,
+        hide_input: bool = False,
+        type: t.Any | None = None,
+        **kwargs: t.Any,
+    ) -> t.Any:
+        """
+        Capture a prompt and return the answer if available,
+        otherwise raise a special exception to indicate waiting for input.
+        """
+        prompt_info = {
+            "type": "prompt",
+            "text": text,
+            "default": default,
+            "hide_input": hide_input,
+            "type": str(type) if type else None,
+            "choices": getattr(type, "choices", None) if hasattr(type, "choices") else None,
+        }
+        self.prompts.append(prompt_info)
+
+        if self.current_prompt_index < len(self.answers):
+            answer = self.answers[self.current_prompt_index]
+            self.current_prompt_index += 1
+            return answer
+        else:
+            raise PromptWaitingException(prompt_info)
+
+    def capture_confirm(
+        self,
+        text: str,
+        default: bool | None = False,
+        **kwargs: t.Any,
+    ) -> bool:
+        """
+        Capture a confirmation prompt.
+        """
+        prompt_info = {
+            "type": "confirm",
+            "text": text,
+            "default": default,
+        }
+        self.prompts.append(prompt_info)
+
+        if self.current_prompt_index < len(self.answers):
+            answer = self.answers[self.current_prompt_index]
+            self.current_prompt_index += 1
+            return bool(answer)
+        else:
+            raise PromptWaitingException(prompt_info)
+
+    def set_answers(self, answers: list[t.Any]) -> None:
+        """Set the answers for the prompts."""
+        self.answers = answers
+        self.current_prompt_index = 0
+
+    def reset(self) -> None:
+        """Reset the capture state."""
+        self.prompts = []
+        self.answers = []
+        self.current_prompt_index = 0
+
+
+class PromptWaitingException(Exception):
+    """Exception raised when waiting for user input for a prompt."""
+
+    def __init__(self, prompt_info: dict[str, t.Any]) -> None:
+        self.prompt_info = prompt_info
+        super().__init__("Waiting for user input")
+
+
+app = Flask(__name__)
+CORS(app)
+
+prompt_capture = InteractivePromptCapture()
+
+
+def get_command_info(cmd: Command, ctx: Context | None = None) -> dict[str, t.Any]:
+    """
+    Get information about a command, including its parameters.
+    """
+    if ctx is None:
+        ctx = Context(cmd)
+
+    info = {
+        "name": cmd.name,
+        "help": cmd.help,
+        "short_help": cmd.get_short_help_str(),
+        "params": [],
+        "is_group": isinstance(cmd, Group),
+    }
+
+    for param in cmd.get_params(ctx):
+        param_info = {
+            "name": param.name,
+            "type": param.param_type_name,
+            "required": param.required,
+            "help": getattr(param, "help", None),
+            "default": param.default if param.default is not click.UNSET else None,
+            "has_prompt": getattr(param, "prompt", None) is not None,
+            "prompt": getattr(param, "prompt", None),
+            "is_flag": getattr(param, "is_flag", False),
+            "is_bool_flag": getattr(param, "is_bool_flag", False),
+            "hide_input": getattr(param, "hide_input", False),
+            "type_info": param.type.to_info_dict() if hasattr(param.type, "to_info_dict") else {},
+        }
+
+        if hasattr(param.type, "choices"):
+            param_info["choices"] = list(param.type.choices)
+
+        info["params"].append(param_info)
+
+    if isinstance(cmd, Group):
+        info["commands"] = {}
+        for name in cmd.list_commands(ctx):
+            sub_cmd = cmd.get_command(ctx, name)
+            if sub_cmd and not sub_cmd.hidden:
+                info["commands"][name] = get_command_info(sub_cmd, ctx)
+
+    return info
+
+
+def execute_command_with_capture(
+    cmd: Command,
+    args: list[str],
+    answers: list[t.Any] | None = None,
+) -> dict[str, t.Any]:
+    """
+    Execute a command with prompt capture.
+    """
+    original_prompt = click.termui.prompt
+    original_confirm = click.termui.confirm
+
+    prompt_capture.reset()
+    if answers:
+        prompt_capture.set_answers(answers)
+
+    stdout_buffer = io.StringIO()
+    stderr_buffer = io.StringIO()
+
+    try:
+        click.termui.prompt = prompt_capture.capture_prompt
+        click.termui.confirm = prompt_capture.capture_confirm
+
+        with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
+            try:
+                result = cmd.main(args, standalone_mode=False)
+                return {
+                    "status": "completed",
+                    "result": result,
+                    "stdout": stdout_buffer.getvalue(),
+                    "stderr": stderr_buffer.getvalue(),
+                    "prompts": prompt_capture.prompts,
+                }
+            except PromptWaitingException as e:
+                return {
+                    "status": "waiting_for_input",
+                    "prompt": e.prompt_info,
+                    "prompts": prompt_capture.prompts,
+                    "stdout": stdout_buffer.getvalue(),
+                    "stderr": stderr_buffer.getvalue(),
+                }
+            except SystemExit as e:
+                return {
+                    "status": "completed",
+                    "exit_code": e.code,
+                    "stdout": stdout_buffer.getvalue(),
+                    "stderr": stderr_buffer.getvalue(),
+                    "prompts": prompt_capture.prompts,
+                }
+            except click.ClickException as e:
+                return {
+                    "status": "error",
+                    "error": str(e),
+                    "stdout": stdout_buffer.getvalue(),
+                    "stderr": stderr_buffer.getvalue(),
+                    "prompts": prompt_capture.prompts,
+                }
+    finally:
+        click.termui.prompt = original_prompt
+        click.termui.confirm = original_confirm
+
+
+@app.route("/api/commands", methods=["GET"])
+def list_commands() -> t.Any:
+    """
+    List all available commands.
+    """
+    from examples.interactive.interactive_demo import cli
+
+    info = get_command_info(cli)
+    return jsonify({"commands": info})
+
+
+@app.route("/api/commands/<path:command_path>", methods=["GET"])
+def get_command(command_path: str) -> t.Any:
+    """
+    Get information about a specific command.
+    """
+    from examples.interactive.interactive_demo import cli
+
+    parts = command_path.split("/")
+    cmd: Command | None = cli
+
+    for part in parts:
+        if isinstance(cmd, Group):
+            cmd = cmd.get_command(Context(cmd), part)
+        else:
+            cmd = None
+        if cmd is None:
+            return jsonify({"error": f"Command not found: {command_path}"}), 404
+
+    info = get_command_info(cmd)
+    return jsonify({"command": info})
+
+
+@app.route("/api/execute", methods=["POST"])
+def execute_command() -> t.Any:
+    """
+    Execute a command with optional answers for prompts.
+
+    Request body:
+    {
+        "command": ["command", "subcommand"],
+        "args": ["--option", "value"],
+        "answers": ["answer1", "answer2", ...]
+    }
+    """
+    from examples.interactive.interactive_demo import cli
+
+    data = request.get_json() or {}
+
+    command_parts = data.get("command", [])
+    args = data.get("args", [])
+    answers = data.get("answers")
+
+    full_args = command_parts + args
+
+    result = execute_command_with_capture(cli, full_args, answers)
+    return jsonify(result)
+
+
+@app.route("/api/health", methods=["GET"])
+def health_check() -> t.Any:
+    """
+    Health check endpoint.
+    """
+    return jsonify({"status": "ok", "message": "Interactive Click API is running"})
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=5000, debug=True)
diff --git a/src/click/__init__.py b/src/click/__init__.py
index 1aa547c57a..2c7daf80a9 100644
--- a/src/click/__init__.py
+++ b/src/click/__init__.py
@@ -70,6 +70,14 @@
 from .utils import get_text_stream as get_text_stream
 from .utils import open_file as open_file
 
+from .interactive import InteractiveCommand as InteractiveCommand
+from .interactive import InteractiveGroup as InteractiveGroup
+from .interactive import InteractiveOption as InteractiveOption
+from .interactive import interactive_command as interactive_command
+from .interactive import interactive_group as interactive_group
+from .interactive import interactive_option as interactive_option
+from .interactive import with_interactive as with_interactive
+
 
 def __getattr__(name: str) -> object:
     import warnings
diff --git a/src/click/interactive.py b/src/click/interactive.py
new file mode 100644
index 0000000000..9505077cec
--- /dev/null
+++ b/src/click/interactive.py
@@ -0,0 +1,495 @@
+from __future__ import annotations
+
+import inspect
+import typing as t
+from functools import update_wrapper
+from gettext import gettext as _
+
+from .core import Command
+from .core import Context
+from .core import Group
+from .core import Option
+from .core import Parameter
+from .core import ParameterSource
+from .core import UNSET
+from .decorators import _param_memo
+from .exceptions import Abort
+from .exceptions import ClickException
+from .termui import confirm
+from .termui import prompt
+from .termui import style
+from .utils import echo
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    P = te.ParamSpec("P")
+
+R = t.TypeVar("R")
+T = t.TypeVar("T")
+_AnyCallable = t.Callable[..., t.Any]
+FC = t.TypeVar("FC", bound="_AnyCallable | Command")
+
+
+class InteractiveOption(Option):
+    """
+    An extension of Option that supports conditional prompting and
+    additional interactive features.
+
+    :param interactive: Whether this option should be prompted interactively.
+        If set to True, the option will be prompted even if a default is set.
+    :param interactive_when: A callable that determines if this option should
+        be prompted interactively. It receives the current context and returns
+        a boolean.
+    :param interactive_after: The name of another parameter. This option will
+        only be prompted if the specified parameter has a certain value.
+    :param interactive_condition: A callable that receives the values of
+        previously processed parameters and returns True if this option
+        should be prompted.
+    :param interactive_help: Additional help text to show during interactive
+        prompting.
+    """
+
+    def __init__(
+        self,
+        param_decls: t.Sequence[str] | None = None,
+        interactive: bool = False,
+        interactive_when: t.Callable[[Context], bool] | None = None,
+        interactive_after: str | None = None,
+        interactive_condition: t.Callable[[dict[str, t.Any]], bool] | None = None,
+        interactive_help: str | None = None,
+        **attrs: t.Any,
+    ) -> None:
+        super().__init__(param_decls, **attrs)
+        self.interactive = interactive
+        self.interactive_when = interactive_when
+        self.interactive_after = interactive_after
+        self.interactive_condition = interactive_condition
+        self.interactive_help = interactive_help
+
+    def should_interactive_prompt(self, ctx: Context, params: dict[str, t.Any]) -> bool:
+        """
+        Determine if this option should be prompted interactively.
+        """
+        if not self.interactive and self.prompt is None:
+            return False
+
+        if self.interactive_when is not None:
+            if not self.interactive_when(ctx):
+                return False
+
+        if self.interactive_after is not None:
+            if self.interactive_after not in params:
+                return False
+
+        if self.interactive_condition is not None:
+            if not self.interactive_condition(params):
+                return False
+
+        return True
+
+    def to_info_dict(self) -> dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict.update(
+            interactive=self.interactive,
+            interactive_help=self.interactive_help,
+        )
+        return info_dict
+
+
+class InteractiveCommand(Command):
+    """
+    A Command that supports interactive prompting for all parameters.
+
+    :param interactive: Whether to enable interactive mode by default.
+    :param interactive_all: Whether to prompt for all parameters interactively,
+        even those without prompt=True.
+    :param interactive_skip: List of parameter names to skip in interactive mode.
+    """
+
+    def __init__(
+        self,
+        name: str | None = None,
+        interactive: bool = False,
+        interactive_all: bool = False,
+        interactive_skip: list[str] | None = None,
+        **attrs: t.Any,
+    ) -> None:
+        super().__init__(name, **attrs)
+        self.interactive = interactive
+        self.interactive_all = interactive_all
+        self.interactive_skip = interactive_skip or []
+
+    def invoke(self, ctx: Context) -> t.Any:
+        if self.interactive or ctx.params.get("_interactive", False):
+            self._run_interactive_mode(ctx)
+
+        return super().invoke(ctx)
+
+    def _run_interactive_mode(self, ctx: Context) -> None:
+        """
+        Run the command in interactive mode, prompting for parameters.
+        """
+        echo(style(_("=== Interactive Mode ==="), fg="cyan", bold=True))
+        echo()
+
+        params = ctx.params.copy()
+        processed_params: dict[str, t.Any] = {}
+
+        for param in self.get_params(ctx):
+            if param.name in self.interactive_skip:
+                continue
+
+            if param.name in params and params[param.name] is not None:
+                if not self.interactive_all:
+                    processed_params[param.name] = params[param.name]
+                    continue
+
+            if isinstance(param, InteractiveOption):
+                if not param.should_interactive_prompt(ctx, processed_params):
+                    continue
+
+                if param.interactive_help:
+                    echo(style(f"ℹ {param.interactive_help}", fg="yellow"))
+
+                value = self._prompt_for_param(ctx, param)
+                processed_params[param.name] = value
+                ctx.params[param.name] = value
+                ctx.set_parameter_source(param.name, ParameterSource.PROMPT)
+
+            elif isinstance(param, Option):
+                if param.prompt is not None or self.interactive_all:
+                    value = self._prompt_for_param(ctx, param)
+                    processed_params[param.name] = value
+                    ctx.params[param.name] = value
+                    ctx.set_parameter_source(param.name, ParameterSource.PROMPT)
+                else:
+                    if param.name in params:
+                        processed_params[param.name] = params[param.name]
+
+            elif param.name in params:
+                processed_params[param.name] = params[param.name]
+
+        echo()
+        echo(style(_("=== Summary ==="), fg="cyan", bold=True))
+        for name, value in processed_params.items():
+            echo(f"  {name}: {value}")
+        echo()
+
+    def _prompt_for_param(self, ctx: Context, param: Parameter) -> t.Any:
+        """
+        Prompt the user for a parameter value.
+        """
+        if isinstance(param, Option):
+            if param.prompt is not None:
+                return param.prompt_for_value(ctx)
+            else:
+                prompt_text = param.name.replace("_", " ").capitalize() if param.name else "Value"
+
+                if param.is_flag and param.is_bool_flag:
+                    default = param.get_default(ctx)
+                    if default is UNSET:
+                        default = None
+                    else:
+                        default = bool(default)
+                    return confirm(prompt_text, default=default)
+                else:
+                    default = param.get_default(ctx)
+                    if default is UNSET:
+                        default = None
+
+                    return prompt(
+                        prompt_text,
+                        default=default,
+                        type=param.type,
+                        show_choices=getattr(param, "show_choices", True),
+                    )
+
+        return None
+
+
+class InteractiveGroup(Group):
+    """
+    A Group that supports interactive mode for subcommands.
+
+    :param interactive: Whether to enable interactive mode by default.
+    :param interactive_menu: Whether to show an interactive menu for selecting
+        subcommands when none is specified.
+    """
+
+    def __init__(
+        self,
+        name: str | None = None,
+        interactive: bool = False,
+        interactive_menu: bool = True,
+        **attrs: t.Any,
+    ) -> None:
+        super().__init__(name, **attrs)
+        self.interactive = interactive
+        self.interactive_menu = interactive_menu
+
+    def invoke(self, ctx: Context) -> t.Any:
+        if self.interactive or ctx.params.get("_interactive", False):
+            if not ctx.invoked_subcommand and self.interactive_menu:
+                ctx.invoked_subcommand = self._show_interactive_menu(ctx)
+
+        return super().invoke(ctx)
+
+    def _show_interactive_menu(self, ctx: Context) -> str | None:
+        """
+        Show an interactive menu for selecting a subcommand.
+        """
+        echo(style(_("=== Available Commands ==="), fg="cyan", bold=True))
+
+        commands = []
+        for name in self.list_commands(ctx):
+            cmd = self.get_command(ctx, name)
+            if cmd and not cmd.hidden:
+                commands.append((name, cmd))
+
+        if not commands:
+            echo(_("No commands available."))
+            return None
+
+        for i, (name, cmd) in enumerate(commands, 1):
+            help_text = cmd.get_short_help_str()
+            echo(f"  {i}. {name:<20} - {help_text}")
+
+        echo()
+
+        while True:
+            try:
+                choice = prompt(
+                    _("Enter command number or name"),
+                    type=str,
+                )
+
+                if choice.isdigit():
+                    idx = int(choice) - 1
+                    if 0 <= idx < len(commands):
+                        return commands[idx][0]
+                    else:
+                        echo(style(_("Invalid selection. Please try again."), fg="red"))
+                else:
+                    for name, _ in commands:
+                        if name.lower() == choice.lower():
+                            return name
+                    echo(style(_("Command not found. Please try again."), fg="red"))
+            except (KeyboardInterrupt, EOFError):
+                raise Abort()
+
+    def command(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.Callable[[t.Callable[..., t.Any]], Command] | Command:
+        from .decorators import command
+
+        interactive = kwargs.pop("interactive", self.interactive)
+
+        if interactive and "cls" not in kwargs:
+            kwargs["cls"] = InteractiveCommand
+
+        original_decorator = super().command(*args, **kwargs)
+
+        def wrap_decorator(f: t.Callable[..., t.Any]) -> Command:
+            cmd = original_decorator(f)
+            if interactive and isinstance(cmd, InteractiveCommand):
+                cmd.interactive = interactive
+            return cmd
+
+        if callable(original_decorator):
+            return wrap_decorator
+        return original_decorator
+
+
+def interactive_option(
+    *param_decls: str,
+    interactive: bool = True,
+    interactive_when: t.Callable[[Context], bool] | None = None,
+    interactive_after: str | None = None,
+    interactive_condition: t.Callable[[dict[str, t.Any]], bool] | None = None,
+    interactive_help: str | None = None,
+    cls: type[InteractiveOption] | None = None,
+    **attrs: t.Any,
+) -> t.Callable[[FC], FC]:
+    """
+    Decorator to create an interactive option.
+
+    This is similar to :func:`option`, but creates an :class:`InteractiveOption`
+    that supports conditional prompting and additional interactive features.
+
+    :param interactive: Whether this option should be prompted interactively.
+    :param interactive_when: A callable that determines if this option should
+        be prompted interactively.
+    :param interactive_after: The name of another parameter. This option will
+        only be prompted after the specified parameter.
+    :param interactive_condition: A callable that receives the values of
+        previously processed parameters and returns True if this option
+        should be prompted.
+    :param interactive_help: Additional help text to show during interactive
+        prompting.
+    :param cls: The option class to use. Defaults to :class:`InteractiveOption`.
+    :param attrs: Other arguments passed to :class:`InteractiveOption`.
+
+    Example::
+
+        @click.command()
+        @click.interactive_option('--name', prompt='Your name')
+        @click.interactive_option('--age', type=int, interactive_help='Age in years')
+        @click.interactive_option(
+            '--city',
+            interactive_after='name',
+            interactive_condition=lambda params: params.get('age', 0) >= 18
+        )
+        def greet(name, age, city):
+            click.echo(f'Hello {name}!')
+    """
+    if cls is None:
+        cls = InteractiveOption
+
+    def decorator(f: FC) -> FC:
+        _param_memo(
+            f,
+            cls(
+                param_decls,
+                interactive=interactive,
+                interactive_when=interactive_when,
+                interactive_after=interactive_after,
+                interactive_condition=interactive_condition,
+                interactive_help=interactive_help,
+                **attrs,
+            ),
+        )
+        return f
+
+    return decorator
+
+
+def interactive_command(
+    name: str | _AnyCallable | None = None,
+    cls: type[InteractiveCommand] | None = None,
+    interactive: bool = True,
+    interactive_all: bool = False,
+    interactive_skip: list[str] | None = None,
+    **attrs: t.Any,
+) -> InteractiveCommand | t.Callable[[_AnyCallable], InteractiveCommand]:
+    """
+    Decorator to create an interactive command.
+
+    This is similar to :func:`command`, but creates an :class:`InteractiveCommand`
+    that supports interactive prompting for parameters.
+
+    :param name: The name of the command.
+    :param cls: The command class to use. Defaults to :class:`InteractiveCommand`.
+    :param interactive: Whether to enable interactive mode by default.
+    :param interactive_all: Whether to prompt for all parameters interactively.
+    :param interactive_skip: List of parameter names to skip in interactive mode.
+    :param attrs: Other arguments passed to :class:`InteractiveCommand`.
+
+    Example::
+
+        @click.interactive_command()
+        @click.option('--name', prompt='Your name')
+        @click.option('--age', type=int, prompt='Your age')
+        def greet(name, age):
+            click.echo(f'Hello {name}, you are {age} years old!')
+    """
+    if cls is None:
+        cls = InteractiveCommand
+
+    func: t.Callable[[_AnyCallable], t.Any] | None = None
+
+    if callable(name):
+        func = name
+        name = None
+
+    def decorator(f: _AnyCallable) -> InteractiveCommand:
+        from .decorators import command
+
+        cmd = command(name, cls=cls, **attrs)(f)
+        cmd.interactive = interactive
+        cmd.interactive_all = interactive_all
+        cmd.interactive_skip = interactive_skip or []
+        return cmd
+
+    if func is not None:
+        return decorator(func)
+
+    return decorator
+
+
+def interactive_group(
+    name: str | _AnyCallable | None = None,
+    cls: type[InteractiveGroup] | None = None,
+    interactive: bool = True,
+    interactive_menu: bool = True,
+    **attrs: t.Any,
+) -> InteractiveGroup | t.Callable[[_AnyCallable], InteractiveGroup]:
+    """
+    Decorator to create an interactive group.
+
+    This is similar to :func:`group`, but creates an :class:`InteractiveGroup`
+    that supports interactive menus for subcommands.
+
+    :param name: The name of the group.
+    :param cls: The group class to use. Defaults to :class:`InteractiveGroup`.
+    :param interactive: Whether to enable interactive mode by default.
+    :param interactive_menu: Whether to show an interactive menu for selecting
+        subcommands when none is specified.
+    :param attrs: Other arguments passed to :class:`InteractiveGroup`.
+
+    Example::
+
+        @click.interactive_group()
+        def cli():
+            pass
+
+        @cli.command()
+        @click.option('--name', prompt='Your name')
+        def greet(name):
+            click.echo(f'Hello {name}!')
+    """
+    if cls is None:
+        cls = InteractiveGroup
+
+    func: t.Callable[[_AnyCallable], t.Any] | None = None
+
+    if callable(name):
+        func = name
+        name = None
+
+    def decorator(f: _AnyCallable) -> InteractiveGroup:
+        from .decorators import group
+
+        grp = group(name, cls=cls, **attrs)(f)
+        grp.interactive = interactive
+        grp.interactive_menu = interactive_menu
+        return grp
+
+    if func is not None:
+        return decorator(func)
+
+    return decorator
+
+
+def with_interactive(f: t.Callable[te.Concatenate[bool, P], R]) -> t.Callable[P, R]:
+    """
+    Decorator that adds an --interactive flag to a command.
+
+    When the --interactive flag is provided, the command will run in
+    interactive mode, prompting for all parameters.
+
+    Example::
+
+        @click.command()
+        @click.option('--name')
+        @click.option('--age', type=int)
+        @click.with_interactive
+        def greet(interactive, name, age):
+            click.echo(f'Hello {name}, you are {age} years old!')
+    """
+
+    def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+        interactive = kwargs.pop("_interactive", False)
+        return f(interactive, *args, **kwargs)
+
+    return update_wrapper(new_func, f)