β³ This skill is pending AI review.
Scores will appear once the review pipeline completes.
component-refactoring
Refactor high-complexity React components in Dify frontend. Use when `pnpm analyze-component --json` shows complexity > 50 or lineCount > 300, when the user asks for code splitting, hook extraction, or complexity reduction, or when `pnpm analyze-component` warns to refactor before testing; avoid for simple/well-structured components, third-party wrappers, or when the user explicitly wants testing without refactoring.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
Not yet listed on ClawHub or SkillsMP
// README
Dorothy

A beautiful desktop app to orchestrate your Claude Code ,Codex, Gemini, Grok and local agents. Deploy, monitor, and debug β all from one delightful interface. Free and open source.

Table of Contents
- Why Dorothy
- Core Features
- Automations
- Kanban Task Management
- Scheduled Tasks
- Remote Control
- Vault
- SocialData (Twitter/X)
- Google Workspace
- MCP Servers & Tools
- Installation
- Architecture
- Project Structure
- Tech Stack
- Configuration & Storage
- Development
- Contributing
- License
Why Dorothy
AI CLI tools are powerful β but it runs one agent at a time, in one terminal. Dorothy removes that limitation:
- Run 10+ agents simultaneously across different projects and codebases
- Automate agent workflows β trigger agents on GitHub PRs, issues, and external events
- Delegate and coordinate β a Super Agent orchestrates other agents via MCP tools
- Manage tasks visually β Kanban board with automatic agent assignment
- Schedule recurring work β cron-based tasks that run autonomously
- Control from anywhere β Telegram and Slack integration for remote management
Core Features
Parallel Agent Management
Run multiple agents simultaneously, each in its own isolated PTY terminal session. Agents operate independently across different projects, codebases, and tasks.

Capabilities:
- Spawn unlimited concurrent agents across multiple projects
- Each agent runs in an isolated terminal with full PTY support
- Assign skills, model selection (sonnet, opus, haiku), and project context per agent
- Send interactive input to any running agent in real-time
- Real-time terminal output streaming per agent
- Agent lifecycle management:
idleβrunningβcompleted/error/waiting - Secondary project paths via
--add-dirfor multi-repo context - Git worktree support for branch-isolated development
- Persistent agent state across app restarts
- Autonomous execution mode (
--dangerously-skip-permissions) for unattended operation
Super Agent (Orchestrator)
A meta-agent that programmatically controls all other agents. Give it a high-level task and it delegates, monitors, and coordinates the work across your agent pool.

- Creates, starts, and stops agents programmatically via MCP tools
- Delegates tasks based on agent capabilities and assigned skills
- Monitors progress, captures output, and handles errors
- Responds to Telegram and Slack messages for remote orchestration
- Can spin up temporary agents for one-off tasks and clean them up after
Usage Tracking
Monitor Claude Code API usage across all agents β token consumption, conversation history, cost tracking, and activity patterns.

Skills & Plugin System
Extend agent capabilities with skills from skills.sh and the built-in plugin marketplace.

- Code Intelligence: LSP plugins for TypeScript, Python, Rust, Go, and more
- External Integrations: GitHub, GitLab, Jira, Figma, Slack, Vercel
- Development Workflows: Commit commands, PR review tools
- Install skills per-agent for specialized task handling
Settings Management
Configure Claude Code settings directly β permissions, environment variables, hooks, and model defaults.
Automations
Automations poll external sources, detect new or updated items, and spawn Claude agents to process each item autonomously. This enables fully automated CI/CD-like workflows powered by AI.
Supported Sources
| Source | Status | Polling Method |
|---|---|---|
| GitHub | Active | gh CLI β pull requests, issues, releases |
| JIRA | Active | REST API v3 β issues, bugs, stories, tasks |
| Pipedrive | Planned | β |
| Planned | β | |
| RSS | Planned | β |
| Custom | Planned | Webhook support |
Execution Pipeline
- Scheduler triggers the automation on its cron schedule or interval
- Poller fetches items from the source (e.g., GitHub PRs via
ghCLI) - Filter applies trigger conditions (event type, new vs. updated)
- Deduplication skips already-processed items using content hashing
- Agent spawning β a temporary agent is created for each item
- Prompt injection β item data injected via template variables
- Autonomous execution β agent runs with full MCP tool access
- Output delivery β agent posts results to Telegram, Slack, or GitHub comments
- Cleanup β temporary agent is deleted after completion
Template Variables
Use these in your agentPrompt and outputTemplate:
GitHub Variables
| Variable | Description |
|---|---|
{{title}} | Item title (PR title, issue title, etc.) |
{{url}} | Item URL |
{{author}} | Item author |
{{body}} | Item body/description |
{{labels}} | Item labels |
{{repo}} | Repository name |
{{number}} | Item number (PR #, issue #) |
{{type}} | Item type (pull_request, issue, etc.) |
JIRA Variables
| Variable | Description |
|---|---|
{{key}} | Issue key (e.g., PROJ-123) |
{{summary}} | Issue summary |
{{status}} | Current issue status |
{{issueType}} | Issue type (Task, Bug, Story, etc.) |
{{priority}} | Issue priority |
{{assignee}} | Assigned user |
{{reporter}} | Reporter name |
{{url}} | Issue URL |
{{body}} | Issue description |
Example: Automated PR Review Bot
create_automation({
name: "PR Code Reviewer",
sourceType: "github",
sourceConfig: '{"repos": ["myorg/myrepo"], "pollFor": ["pull_requests"]}',
scheduleMinutes: 15,
agentEnabled: true,
agentPrompt: "Review this PR for code quality, security issues, and performance. PR: {{title}} ({{url}}). Description: {{body}}",
agentProjectPath: "/path/to/myrepo",
outputGitHubComment: true,
outputSlack: true
})
Example: JIRA Issue Processor
create_automation({
name: "JIRA Task Agent",
sourceType: "jira",
sourceConfig: '{"projectKeys": ["PROJ"], "jql": "status = Open"}',
scheduleMinutes: 5,
agentEnabled: true,
agentPrompt: "Work on JIRA issue {{key}}: {{summary}}. Description: {{body}}. Priority: {{priority}}.",
agentProjectPath: "/path/to/project",
outputJiraComment: true,
outputJiraTransition: true,
outputTelegram: true
})
JIRA automations also create Kanban tasks automatically in the backlog, allowing agents to pick them up via the auto-assignment system.
Kanban Task Management
A task board integrated with the agent system. Tasks flow through columns and can be automatically assigned to agents based on skill matching.

Workflow
Backlog β Planned β Ongoing β Done
- Priority levels: Low, Medium, High
- Progress tracking: 0-100% per task
- Agent assignment: Assign tasks to specific agents or let the system auto-assign
- Labels and tags: Organize and filter tasks
- Skill requirements: Define required skills β the system matches tasks to capable agents
Automatic Agent Assignment
The kanban-automation service continuously watches for new tasks and:
- Matches task skill requirements against available agents
- Creates new agents if no matching agent exists
- Assigns the task and moves it to `ongoin
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
.agents/skills/component-refactoring/SKILL.md7.9 KBupstream β
--- name: component-refactoring description: Refactor high-complexity React components in Dify frontend. Use when `pnpm analyze-component --json` shows complexity > 50 or lineCount > 300, when the user asks for code splitting, hook extraction, or complexity reduction, or when `pnpm analyze-component` warns to refactor before testing; avoid for simple/well-structured components, third-party wrappers, or when the user explicitly wants testing without refactoring. --- # Dify Component Refactoring Skill Refactor high-complexity React components in the Dify frontend codebase with the patterns and workflow below. > **Complexity Threshold**: Components with complexity > 50 (measured by `pnpm analyze-component`) should be refactored before testing. ## Quick Reference ### Commands (run from `web/`) Use paths relative to `web/` (e.g., `app/components/...`). Use `refactor-component` for refactoring prompts and `analyze-component` for testing prompts and metrics. ```bash cd web # Generate refactoring prompt pnpm refactor-component <path> # Output refactoring analysis as JSON pnpm refactor-component <path> --json # Generate testing prompt (after refactoring) pnpm analyze-component <path> # Output testing analysis as JSON pnpm analyze-component <path> --json ``` ### Complexity Analysis ```bash # Analyze component complexity pnpm analyze-component <path> --json # Key metrics to check: # - complexity: normalized score 0-100 (target < 50) # - maxComplexity: highest single function complexity # - lineCount: total lines (target < 300) ``` ### Complexity Score Interpretation | Score | Level | Action | |-------|-------|--------| | 0-25 | π’ Simple | Ready for testing | | 26-50 | π‘ Medium | Consider minor refactoring | | 51-75 | π Complex | **Refactor before testing** | | 76-100 | π΄ Very Complex | **Must refactor** | ## Core Refactoring Patterns ### Pattern 1: Extract Custom Hooks **When**: Component has complex state management, multiple `useState`/`useEffect`, or business logic mixed with UI. **Dify Convention**: Place hooks in a `hooks/` subdirectory or alongside the component as `use-<feature>.ts`. ```typescript // β Before: Complex state logic in component const Configuration: FC = () => { const [modelConfig, setModelConfig] = useState<ModelConfig>(...) const [datasetConfigs, setDatasetConfigs] = useState<DatasetConfigs>(...) const [completionParams, setCompletionParams] = useState<FormValue>({}) // 50+ lines of state management logic... return <div>...</div> } // β After: Extract to custom hook // hooks/use-model-config.ts export const useModelConfig = (appId: string) => { const [modelConfig, setModelConfig] = useState<ModelConfig>(...) const [completionParams, setCompletionParams] = useState<FormValue>({}) // Related state management logic here return { modelConfig, setModelConfig, completionParams, setCompletionParams } } // Component becomes cleaner const Configuration: FC = () => { const { modelConfig, setModelConfig } = useModelConfig(appId) return <div>...</div> } ``` **Dify Examples**: - `web/app/components/app/configuration/hooks/use-advanced-prompt-config.ts` - `web/app/components/app/configuration/debug/hooks.tsx` - `web/app/components/workflow/hooks/use-workflow.ts` ### Pattern 2: Extract Sub-Components **When**: Single component has multiple UI sections, conditional rendering blocks, or repeated patterns. **Dify Convention**: Place sub-components in subdirectories or as separate files in the same directory. ```typescript // β Before: Monolithic JSX with multiple sections const AppInfo = () => { return ( <div> {/* 100 lines of header UI */} {/* 100 lines of operations UI */} {/* 100 lines of modals */} </div> ) } // β After: Split into focused components // app-info/ // βββ index.tsx (orchestration only) // βββ app-header.tsx (header UI) // βββ app-operations.tsx (operations UI) // βββ app-modals.tsx (modal management) const AppInfo = () => { const { showModal, setShowModal } = useAppInfoModals() return ( <div> <AppHeader appDetail={appDetail} /> <AppOperations onAction={handleAction} /> <AppModals show={showModal} onClose={() => setShowModal(null)} /> </div> ) } ``` **Dify Examples**: - `web/app/components/app/configuration/` directory structure - `web/app/components/workflow/nodes/` per-node organization ### Pattern 3: Simplify Conditional Logic **When**: Deep nesting (> 3 levels), complex ternaries, or multiple `if/else` chains. ```typescript // β Before: Deeply nested conditionals const Template = useMemo(() => { if (appDetail?.mode === AppModeEnum.CHAT) { switch (locale) { case LanguagesSupported[1]: return <TemplateChatZh /> case LanguagesSupported[7]: return <TemplateChatJa /> default: return <TemplateChatEn /> } } if (appDetail?.mode === AppModeEnum.ADVANCED_CHAT) { // Another 15 lines... } // More conditions... }, [appDetail, locale]) // β After: Use lookup tables + early returns const TEMPLATE_MAP = { [AppModeEnum.CHAT]: { [LanguagesSupported[1]]: TemplateChatZh, [LanguagesSupported[7]]: TemplateChatJa, default: TemplateChatEn, }, [AppModeEnum.ADVANCED_CHAT]: { [LanguagesSupported[1]]: TemplateAdvancedChatZh, // ... }, } const Template = useMemo(() => { const modeTemplates = TEMPLATE_MAP[appDetail?.mode] if (!modeTemplates) return null const TemplateComponent = modeTemplates[locale] || modeTemplates.default return <TemplateComponent appDetail={appDetail} /> }, [appDetail, locale]) ``` ### Pattern 4: Extract API/Data Logic **When**: Component directly handles API calls, data transformation, or complex async operations. **Dify Convention**: Use `@tanstack/react-query` hooks from `web/service/use-*.ts` or create custom data hooks. ```typescript // β Before: API logic in component const MCPServiceCard = () => { const [basicAppConfig, setBasicAppConfig] = useState({}) useEffect(() => { if (isBasicApp && appId) { (async () => { const res = await fetchAppDetail({ url: '/apps', id: appId }) setBasicAppConfig(res?.model_config || {}) })() } }, [appId, isBasicApp]) // More API-related logic... } // β After: Extract to data hook using React Query // use-app-config.ts import { useQuery } from '@tanstack/react-query' import { get } from '@/service/base' const NAME_SPACE = 'appConfig' export const useAppConfig = (appId: string, isBasicApp: boolean) => { return useQuery({ enabled: isBasicApp && !!appId, queryKey: [NAME_SPACE, 'detail', appId], queryFn: () => get<AppDetailResponse>(`/apps/${appId}`), select: data => data?.model_config || {}, }) } // Component becomes cleaner const MCPServiceCard = () => { const { data: config, isLoading } = useAppConfig(appId, isBasicApp) // UI only } ``` **React Query Best Practices in Dify**: - Define `NAME_SPACE` for query key organization - Use `enabled` option for conditional fetching - Use `select` for data transformation - Export invalidation hooks: `useInvalidXxx` **Dify Examples**: - `web/service/use-workflow.ts` - `web/service/use-common.ts` - `web/service/knowledge/use-dataset.ts` - `web/service/knowledge/use-document.ts` ### Pattern 5: Extract Modal/Dialog Management **When**: Component manages multiple modals with complex open/close states. **Dify Convention**: Modals should be extracted with their state management. ```typescript // β Before: Multiple modal states in component const AppInfo = () => { const [showEditModal, setShowEditModal] = useState(false) const [showDuplicateModal, setShowDuplicateModal] = useState(false) const [showConfirmDelete, setShowConfirmDelete] = useState(false) const [showSwitchModal, setShowSwitchModal] = useState(false) const [showImportDSLModal, setShowImportDSLModal] = useState(false) // 5+ more modal states... } // β AftREADME.mdupstream β
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/charlie85270-dorothy-agents-skills-component-refactoring.md