multi-model-flow 0.1.0

package/.claude/commands/mmf-analyze.md

@@ -0,0 +1,49 @@
+---
+description: "Parallel analysis: ace-tool retrieval + dual-model analysis (Codex backend + Gemini frontend)"
+---
+
+# Parallel Multi-Model Analysis
+
+You are performing a parallel analysis using code retrieval and dual-model insights.
+
+## Step 1: Retrieve Context
+
+```
+mcp__ace-tool__codebase-retrieval({ information_request: "<describe what to analyze>", directory_path: "<project root>" })
+```
+
+Optionally search for technical references:
+```
+mcp__grok-search__web_search({ query: "<relevant technical query>" })
+```
+Fallback to context7 if grok-search fails.
+
+## Step 2: Submit Parallel Analysis
+
+### Codex Analysis
+```
+mcp__workflow__task_submit({
+  prompt: "Analyze the following code/requirement from a backend perspective:\n$CONTEXT\n\nProvide: architecture assessment, improvement suggestions, risk analysis.",
+  domain: "backend"
+})
+```
+
+### Gemini Analysis
+```
+mcp__workflow__task_submit({
+  prompt: "Analyze the following code/requirement from a frontend perspective:\n$CONTEXT\n\nProvide: UX assessment, component analysis, design recommendations.",
+  domain: "frontend"
+})
+```
+
+## Step 3: Poll and Collect
+
+Poll both tasks every 15-30 seconds using `task_status`. Retrieve results with `task_result` when complete.
+
+## Step 4: Synthesize
+
+Present a unified analysis:
+- **Consensus**: Points both models agree on
+- **Backend insights**: Codex-specific findings (architecture, security, performance)
+- **Frontend insights**: Gemini-specific findings (UX, accessibility, design)
+- **Recommendations**: Prioritized action items

package/.claude/commands/mmf-codex.md

@@ -0,0 +1,51 @@
+---
+description: "Ask Codex (OpenAI) to analyze code, generate diffs, or answer backend questions"
+---
+
+# Codex Task
+
+You are delegating a task to Codex (OpenAI). Codex specializes in backend logic, architecture, security, and performance.
+
+## Step 1: Collect Context
+
+If the task involves existing code, retrieve context first:
+```
+mcp__ace-tool__codebase-retrieval({ information_request: "<describe relevant code>", directory_path: "<project root>" })
+```
+
+## Step 2: Determine Task Length
+
+### Quick task (simple question, short analysis)
+Use synchronous `chat`:
+```
+mcp__workflow__chat({
+  prompt: "<user's request>\n\nContext:\n<code context>",
+  domain: "backend"
+})
+```
+
+### Long task (deep analysis, large codebase review, diff generation)
+Use async `task_submit`:
+```
+mcp__workflow__task_submit({
+  prompt: "<user's request>\n\nContext:\n<code context>",
+  domain: "backend"
+})
+```
+Then poll with `task_status` every 15-30 seconds until complete. Retrieve with `task_result`.
+
+## Step 3: Multi-turn Follow-up
+
+To continue the conversation, pass the `session_id` from the previous response:
+```
+mcp__workflow__chat({
+  prompt: "<follow-up question>",
+  session_id: "<session_id from previous call>"
+})
+```
+
+## Result Handling
+
+- Present as "Codex analysis:"
+- Preserve all code blocks and Unified Diff patches
+- Never auto-apply changes — ask user for confirmation first

package/.claude/commands/mmf-gemini.md

@@ -0,0 +1,51 @@
+---
+description: "Ask Gemini to analyze UI/UX, frontend architecture, or design questions"
+---
+
+# Gemini Task
+
+You are delegating a task to Gemini. Gemini specializes in frontend, UI/UX design, component architecture, and accessibility.
+
+## Step 1: Collect Context
+
+If the task involves existing code, retrieve context first:
+```
+mcp__ace-tool__codebase-retrieval({ information_request: "<describe relevant code>", directory_path: "<project root>" })
+```
+
+## Step 2: Determine Task Length
+
+### Quick task (simple question, short analysis)
+Use synchronous `chat`:
+```
+mcp__workflow__chat({
+  prompt: "<user's request>\n\nContext:\n<code context>",
+  domain: "frontend"
+})
+```
+
+### Long task (deep analysis, large component review, diff generation)
+Use async `task_submit`:
+```
+mcp__workflow__task_submit({
+  prompt: "<user's request>\n\nContext:\n<code context>",
+  domain: "frontend"
+})
+```
+Then poll with `task_status` every 15-30 seconds until complete. Retrieve with `task_result`.
+
+## Step 3: Multi-turn Follow-up
+
+To continue the conversation, pass the `session_id` from the previous response:
+```
+mcp__workflow__chat({
+  prompt: "<follow-up question>",
+  session_id: "<session_id from previous call>"
+})
+```
+
+## Result Handling
+
+- Present as "Gemini analysis:"
+- Preserve all code blocks and Unified Diff patches
+- Never auto-apply changes — ask user for confirmation first

package/.claude/commands/mmf-review.md

@@ -0,0 +1,53 @@
+---
+description: "Dual-model code review: Codex (logic/security) + Gemini (UI/accessibility) in parallel"
+---
+
+# Dual-Model Code Review
+
+You are performing a parallel code review using both Codex and Gemini.
+
+## Step 1: Collect Review Context
+
+Use ace-tool to retrieve the code to review:
+```
+mcp__ace-tool__codebase-retrieval({ information_request: "<describe the code to review>", directory_path: "<project root>" })
+```
+
+Also gather the git diff if applicable (use `git diff` or `git diff --staged`).
+
+## Step 2: Submit Parallel Reviews
+
+### Codex Review (Logic + Security + Performance)
+```
+mcp__workflow__task_submit({
+  prompt: "Review the following code. Focus on:\n1. Logic bugs and edge cases\n2. Security vulnerabilities\n3. Performance issues\n4. Error handling gaps\n\nRate each finding: Critical / Major / Minor / Suggestion\nInclude specific line numbers.\n\nCode:\n$CODE",
+  domain: "review"
+})
+```
+
+### Gemini Review (UI + Accessibility + Design)
+```
+mcp__workflow__task_submit({
+  prompt: "Review the following code. Focus on:\n1. UI/UX consistency\n2. Accessibility compliance\n3. Responsive design issues\n4. Component architecture\n\nRate each finding: Critical / Major / Minor / Suggestion\nInclude specific line numbers.\n\nCode:\n$CODE",
+  domain: "frontend"
+})
+```
+
+## Step 3: Poll Progress
+
+Poll both tasks every 15-30 seconds using `task_status`. When complete, retrieve with `task_result`.
+
+## Step 4: Synthesize Review
+
+Merge findings from both reviewers:
+- Deduplicate overlapping findings
+- Backend/logic findings → trust Codex
+- Frontend/UI findings → trust Gemini
+- Present unified review with severity ratings
+
+## Step 5: Apply Fixes (if requested)
+
+If the user wants fixes applied:
+1. Address Critical and Major findings first
+2. Apply changes using Claude's file editing tools
+3. Re-run review on changed files if needed

package/.claude/commands/mmf-workflow.md

@@ -0,0 +1,104 @@
+---
+description: "Multi-model workflow: ace-tool retrieval + grok search + Codex/Gemini parallel analysis"
+---
+
+# Multi-Model Collaborative Workflow
+
+You are orchestrating a multi-model collaborative workflow. Follow these phases strictly.
+
+## Core Protocol
+
+- **Code Sovereignty**: External models (Codex/Gemini) have ZERO file write permission. They return analysis and Unified Diff patches only. YOU (Claude) are the sole code executor.
+- **Trust Rules**: Backend logic → trust Codex. Frontend/UI → trust Gemini.
+- **Language**: Respond in the same language as the user's input.
+
+## Phase 1: Research [模式：研究]
+
+### 1.1 Code Retrieval
+Use ace-tool to retrieve relevant code context:
+```
+mcp__ace-tool__codebase-retrieval({ information_request: "<describe what code is relevant>", directory_path: "<project root>" })
+```
+
+### 1.2 Web Search
+Search for technical references using grok-search:
+```
+mcp__grok-search__web_search({ query: "<technical search query>" })
+```
+
+**Fallback**: If grok-search fails or is unavailable, use context7:
+```
+mcp__plugin_context7_context7__resolve-library-id({ libraryName: "<library>" })
+mcp__plugin_context7_context7__query-docs({ context7CompatibleLibraryID: "<id>", topic: "<topic>" })
+```
+
+### 1.3 Completeness Check
+Before proceeding, verify you have:
+- [ ] Relevant source code context
+- [ ] Technical references (if needed)
+- [ ] Clear understanding of the user's requirements
+
+## Phase 2: Parallel Analysis [模式：分析]
+
+Submit tasks to BOTH models in parallel using `task_submit`:
+
+### Backend Analysis (Codex)
+```
+mcp__workflow__task_submit({
+  prompt: "Analyze the following requirement and code context. Provide:\n1. Architecture analysis\n2. Implementation approach with Unified Diff patches\n3. Security considerations\n4. Performance implications\n\nRequirement: $REQUIREMENT\n\nCode Context:\n$CODE_CONTEXT\n\nTechnical References:\n$SEARCH_RESULTS",
+  domain: "backend"
+})
+```
+
+### Frontend Analysis (Gemini)
+```
+mcp__workflow__task_submit({
+  prompt: "Analyze the following requirement and code context. Provide:\n1. UI/UX impact analysis\n2. Component architecture with Unified Diff patches\n3. Accessibility considerations\n4. Design consistency review\n\nRequirement: $REQUIREMENT\n\nCode Context:\n$CODE_CONTEXT\n\nTechnical References:\n$SEARCH_RESULTS",
+  domain: "frontend"
+})
+```
+
+Record both task IDs.
+
+## Phase 3: Progress Monitoring [模式：轮询]
+
+Poll both tasks every 15-30 seconds:
+```
+mcp__workflow__task_status({ task_id: "<codex_task_id>" })
+mcp__workflow__task_status({ task_id: "<gemini_task_id>" })
+```
+
+Report progress to the user. When both complete, retrieve results:
+```
+mcp__workflow__task_result({ task_id: "<codex_task_id>" })
+mcp__workflow__task_result({ task_id: "<gemini_task_id>" })
+```
+
+## Phase 4: Cross-Validation [模式：综合]
+
+Compare the two analyses:
+1. **Consensus** — Both agree → strong signal, adopt directly
+2. **Disagreements** — Conflict → apply trust rules (backend→Codex, frontend→Gemini), explain reasoning
+3. **Complementary** — Each covers different aspects → merge insights
+
+Produce a unified implementation plan.
+
+## Phase 5: Execution [模式：执行]
+
+Apply the synthesized plan:
+1. Apply Unified Diff patches from the trusted model
+2. Refactor "dirty prototype" code to production quality
+3. Ensure consistency across frontend and backend changes
+4. Run any available tests
+
+## Phase 6: Review [模式：审查]
+
+Submit a final review task:
+```
+mcp__workflow__task_submit({
+  prompt: "Review the following code changes for bugs, security issues, and quality:\n\n$CHANGES",
+  domain: "review"
+})
+```
+
+Report findings and apply fixes if needed.

package/.claude/skills/codex-task/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: codex-task
+description: Delegate code analysis, review, or generation tasks to Codex (OpenAI) with context collection
+user-invocable: false
+allowed-tools:
+  - mcp__workflow__chat
+  - mcp__workflow__task_submit
+  - mcp__workflow__task_status
+  - mcp__workflow__task_result
+  - mcp__workflow__task_cancel
+  - mcp__ace-tool__codebase-retrieval
+---
+
+# Codex Task Skill
+
+## Trigger Detection
+
+Activate when the user says:
+- "use codex", "ask codex", "codex review", "codex analyze", "let codex do"
+- Any request explicitly targeting backend logic, security, performance, or architecture analysis
+
+## Context Collection
+
+### 1. Determine Scope
+- **Single-file**: Read target file + up to 3 imports + test file
+- **Multi-file**: List directory (2 levels) + read up to 5 relevant files + config files
+- **Project-wide**: Use `mcp__ace-tool__codebase-retrieval` for semantic search
+
+### 2. Assemble Prompt
+Structure the prompt as:
+```
+Task: <user's request>
+
+Project Context:
+<CLAUDE.md summary if exists, keep under 100 lines>
+
+Code:
+<relevant file contents, truncate files >300 lines to first 50 + last 20>
+
+Instructions:
+<specific focus areas based on task type>
+```
+
+### 3. Select System Prompt by Task Type
+- **Review**: "senior code reviewer" — bugs, security, performance, style
+- **Architecture**: "senior backend architect" — scalability, patterns, trade-offs
+- **General**: "senior software engineer" — analysis and code suggestions
+
+## Delegation
+
+- Quick tasks → `mcp__workflow__chat({ prompt, domain: "backend" })`
+- Long tasks → `mcp__workflow__task_submit({ prompt, domain: "backend" })` + poll every 15-30s
+- Follow-up → pass `session_id` from previous call
+
+## Result Presentation
+
+- Attribute as "Codex analysis:"
+- Preserve code blocks and diffs
+- Never auto-apply — ask user confirmation first

package/.claude/skills/gemini-task/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: gemini-task
+description: Delegate UI/UX analysis, frontend review, or design tasks to Gemini with context collection
+user-invocable: false
+allowed-tools:
+  - mcp__workflow__chat
+  - mcp__workflow__task_submit
+  - mcp__workflow__task_status
+  - mcp__workflow__task_result
+  - mcp__workflow__task_cancel
+  - mcp__ace-tool__codebase-retrieval
+---
+
+# Gemini Task Skill
+
+## Trigger Detection
+
+Activate when the user says:
+- "use gemini", "ask gemini", "gemini review", "gemini analyze", "let gemini do"
+- Any request explicitly targeting frontend, UI/UX, accessibility, or design analysis
+
+## Context Collection
+
+### 1. Determine Scope
+- **Single-file**: Read target file + up to 3 imports + test file
+- **Multi-file**: List directory (2 levels) + read up to 5 relevant files + config files
+- **Project-wide**: Use `mcp__ace-tool__codebase-retrieval` for semantic search
+
+### 2. Assemble Prompt
+Structure the prompt as:
+```
+Task: <user's request>
+
+Project Context:
+<CLAUDE.md summary if exists, keep under 100 lines>
+
+Code:
+<relevant file contents, truncate files >300 lines to first 50 + last 20>
+
+Instructions:
+<specific focus areas based on task type>
+```
+
+### 3. Select System Prompt by Task Type
+- **Review**: "senior frontend reviewer" — UI consistency, accessibility, responsive design
+- **Design**: "senior UI/UX architect" — component patterns, design systems, user experience
+- **General**: "senior frontend engineer" — analysis and code suggestions
+
+## Delegation
+
+- Quick tasks → `mcp__workflow__chat({ prompt, domain: "frontend" })`
+- Long tasks → `mcp__workflow__task_submit({ prompt, domain: "frontend" })` + poll every 15-30s
+- Follow-up → pass `session_id` from previous call
+
+## Result Presentation
+
+- Attribute as "Gemini analysis:"
+- Preserve code blocks and diffs
+- Never auto-apply — ask user confirmation first

package/.claude/skills/multi-model-task/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: multi-model-task
+description: Orchestrate tasks across Codex and Gemini with context collection, search fallback, and progress polling
+user-invocable: false
+allowed-tools:
+  - mcp__workflow__chat
+  - mcp__workflow__task_submit
+  - mcp__workflow__task_status
+  - mcp__workflow__task_result
+  - mcp__workflow__task_cancel
+  - mcp__ace-tool__codebase-retrieval
+  - mcp__grok-search__web_search
+  - mcp__grok-search__web_fetch
+  - mcp__plugin_context7_context7__resolve-library-id
+  - mcp__plugin_context7_context7__query-docs
+---
+
+# Multi-Model Task Orchestration Skill
+
+## Trigger Detection
+
+Activate this skill when the user says:
+- "use codex", "ask codex", "codex review", "codex analyze"
+- "use gemini", "ask gemini", "gemini review", "gemini analyze"
+- "parallel analysis", "dual review", "multi-model"
+- "let codex/gemini do..."
+
+## Context Collection Strategy
+
+### Single-file scope
+- Read the target file
+- Read up to 3 local imports/dependencies
+- Read corresponding test file if exists
+
+### Multi-file scope
+- List directory structure (2 levels)
+- Read package.json / tsconfig.json
+- Read up to 5 relevant files
+
+### Project-wide scope
+- Use `mcp__ace-tool__codebase-retrieval` for semantic search
+- Read project config files
+- Read key entry points
+
+## Search Strategy
+
+1. **Primary**: Use `mcp__grok-search__web_search` for technical references
+2. **Fallback**: If grok-search returns an error or is unavailable:
+   - Use `mcp__plugin_context7_context7__resolve-library-id` to find the library
+   - Then `mcp__plugin_context7_context7__query-docs` to query documentation
+3. **Skip**: If the task doesn't require external references, skip search entirely
+
+## Task Delegation
+
+### Quick tasks (< 30 seconds expected)
+Use `mcp__workflow__chat` for synchronous single-turn calls:
+```
+mcp__workflow__chat({ prompt: "...", domain: "backend" })
+```
+
+### Long tasks (> 30 seconds expected)
+Use `mcp__workflow__task_submit` + polling:
+```
+mcp__workflow__task_submit({ prompt: "...", domain: "backend" })
+// then poll with task_status every 15-30 seconds
+```
+
+### Multi-turn conversations
+Pass `session_id` to continue a conversation:
+```
+mcp__workflow__chat({ prompt: "follow-up question", session_id: "<previous session id>" })
+```
+
+## Polling Protocol
+
+When a task is submitted:
+1. Wait 15 seconds before first poll
+2. Poll every 15-30 seconds with `task_status`
+3. Report progress to user (show partial output if meaningful)
+4. When status is "completed", retrieve with `task_result`
+5. If status is "failed", report error and suggest retry
+
+## Result Presentation
+
+- Attribute results: "Codex analysis:" or "Gemini analysis:"
+- Preserve all code blocks and diff patches
+- Never auto-apply code changes — always ask user for confirmation
+- If both models were used, present cross-validation summary
+
+## Trust Rules
+
+- Backend logic, security, performance → Codex is authoritative
+- Frontend UI, accessibility, design → Gemini is authoritative
+- When models disagree, explain both perspectives and recommend based on domain authority

package/CLAUDE.md

@@ -0,0 +1,60 @@
+# MMF - Claude Code 全局提示词
+
+## 核心约定
+- 使用 mise 去调用 Java、Python 这类语言的运行时
+- 运行在 Windows 系统内，运行环境是 PowerShell
+- 先列好方案，向用户确认是否要修改代码，再去修改
+- 思考用英文，回复用户用中文
+- 使用标准 Markdown 格式；代码块用反引号包裹
+- 简洁直接，不废话
+
+## MCP 工具速查表
+
+优先使用 MCP 工具，而非手动方式：
+
+| 工具 | 使用时机 | 说明 |
+|------|---------|------|
+| `mcp__ace-tool__codebase-retrieval` | 生成任何代码之前 | 语义代码检索，用英文查询 |
+| `mcp__grok-search__web_search` | 需要外部文档、最新信息 | 失败时回退到 context7 |
+| `mcp__plugin_context7_context7__query-docs` | grok-search 不可用或失败时 | 库文档查询回退方案 |
+| `mcp__diy-workflow__chat` | 快速 Codex/Gemini 单轮任务 | 用 `domain` 参数智能路由 |
+| `mcp__diy-workflow__task_submit` | 长时间 Codex/Gemini 任务 | 用 `task_status` 轮询，`task_result` 获取结果 |
+
+## 命令速查表
+
+| 命令 | 使用时机 |
+|------|---------|
+| `/mmf-workflow` | 完整多模型开发流程（研究→分析→综合→执行→审查） |
+| `/mmf-codex` | 单独调 Codex 做后端/逻辑/安全分析 |
+| `/mmf-gemini` | 单独调 Gemini 做前端/UI/设计分析 |
+| `/mmf-review` | 双模型并行代码审查（Codex + Gemini） |
+| `/mmf-analyze` | 并行分析（代码检索 + 双模型） |
+
+## 工作流原则
+
+1. **先检索，后生成** — 写代码前必须调用 `codebase-retrieval` 或 `web_search`
+2. **简单任务 → Claude 单独完成** — 不要在简单任务上强行多模型协作
+3. **代码主权** — Codex/Gemini 只负责分析；所有代码修改由 Claude 执行
+4. **并行执行** — 独立的 MCP 调用和模型查询并行运行
+5. **搜索回退** — grok-search 失败 → context7；绝不跳过研究阶段
+
+## 智能路由
+
+- 前端 / UI / 设计 → Gemini（`domain: "frontend"`）
+- 后端 / 逻辑 / 安全 → Codex（`domain: "backend"`）
+- 代码审查 → Codex（`domain: "review"`）
+- 通用任务 → Codex（`domain: "general"`）
+
+## 多模型协作规范
+
+- 外部模型拥有 **零文件写入权限** — 只返回分析结果和 Unified Diff 补丁
+- 信任规则：后端逻辑 → 信任 Codex，前端 UI → 信任 Gemini
+- 模型意见冲突时 → 按领域权威裁决，说明理由
+- 应用建议修改前必须征求用户确认
+- 长任务每 15-30 秒轮询一次 `task_status`
+
+## Session 复用
+
+- 首次调用返回 `session_id` — 后续调用传入即可续接多轮对话
+- Session 闲置 1 小时后自动过期
+- 适用于迭代优化场景（审查 → 修复 → 再审查）

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}