This is page 6 of 69. Use http://codebase.md/eyaltoledano/claude-task-master?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .changeset
│ ├── config.json
│ └── README.md
├── .claude
│ ├── commands
│ │ └── dedupe.md
│ └── TM_COMMANDS_GUIDE.md
├── .claude-plugin
│ └── marketplace.json
├── .coderabbit.yaml
├── .cursor
│ ├── mcp.json
│ └── rules
│ ├── ai_providers.mdc
│ ├── ai_services.mdc
│ ├── architecture.mdc
│ ├── changeset.mdc
│ ├── commands.mdc
│ ├── context_gathering.mdc
│ ├── cursor_rules.mdc
│ ├── dependencies.mdc
│ ├── dev_workflow.mdc
│ ├── git_workflow.mdc
│ ├── glossary.mdc
│ ├── mcp.mdc
│ ├── new_features.mdc
│ ├── self_improve.mdc
│ ├── tags.mdc
│ ├── taskmaster.mdc
│ ├── tasks.mdc
│ ├── telemetry.mdc
│ ├── test_workflow.mdc
│ ├── tests.mdc
│ ├── ui.mdc
│ └── utilities.mdc
├── .cursorignore
├── .env.example
├── .github
│ ├── ISSUE_TEMPLATE
│ │ ├── bug_report.md
│ │ ├── enhancements---feature-requests.md
│ │ └── feedback.md
│ ├── PULL_REQUEST_TEMPLATE
│ │ ├── bugfix.md
│ │ ├── config.yml
│ │ ├── feature.md
│ │ └── integration.md
│ ├── PULL_REQUEST_TEMPLATE.md
│ ├── scripts
│ │ ├── auto-close-duplicates.mjs
│ │ ├── backfill-duplicate-comments.mjs
│ │ ├── check-pre-release-mode.mjs
│ │ ├── parse-metrics.mjs
│ │ ├── release.mjs
│ │ ├── tag-extension.mjs
│ │ ├── utils.mjs
│ │ └── validate-changesets.mjs
│ └── workflows
│ ├── auto-close-duplicates.yml
│ ├── backfill-duplicate-comments.yml
│ ├── ci.yml
│ ├── claude-dedupe-issues.yml
│ ├── claude-docs-trigger.yml
│ ├── claude-docs-updater.yml
│ ├── claude-issue-triage.yml
│ ├── claude.yml
│ ├── extension-ci.yml
│ ├── extension-release.yml
│ ├── log-issue-events.yml
│ ├── pre-release.yml
│ ├── release-check.yml
│ ├── release.yml
│ ├── update-models-md.yml
│ └── weekly-metrics-discord.yml
├── .gitignore
├── .kiro
│ ├── hooks
│ │ ├── tm-code-change-task-tracker.kiro.hook
│ │ ├── tm-complexity-analyzer.kiro.hook
│ │ ├── tm-daily-standup-assistant.kiro.hook
│ │ ├── tm-git-commit-task-linker.kiro.hook
│ │ ├── tm-pr-readiness-checker.kiro.hook
│ │ ├── tm-task-dependency-auto-progression.kiro.hook
│ │ └── tm-test-success-task-completer.kiro.hook
│ ├── settings
│ │ └── mcp.json
│ └── steering
│ ├── dev_workflow.md
│ ├── kiro_rules.md
│ ├── self_improve.md
│ ├── taskmaster_hooks_workflow.md
│ └── taskmaster.md
├── .manypkg.json
├── .mcp.json
├── .npmignore
├── .nvmrc
├── .taskmaster
│ ├── CLAUDE.md
│ ├── config.json
│ ├── docs
│ │ ├── autonomous-tdd-git-workflow.md
│ │ ├── MIGRATION-ROADMAP.md
│ │ ├── prd-tm-start.txt
│ │ ├── prd.txt
│ │ ├── README.md
│ │ ├── research
│ │ │ ├── 2025-06-14_how-can-i-improve-the-scope-up-and-scope-down-comm.md
│ │ │ ├── 2025-06-14_should-i-be-using-any-specific-libraries-for-this.md
│ │ │ ├── 2025-06-14_test-save-functionality.md
│ │ │ ├── 2025-06-14_test-the-fix-for-duplicate-saves-final-test.md
│ │ │ └── 2025-08-01_do-we-need-to-add-new-commands-or-can-we-just-weap.md
│ │ ├── task-template-importing-prd.txt
│ │ ├── tdd-workflow-phase-0-spike.md
│ │ ├── tdd-workflow-phase-1-core-rails.md
│ │ ├── tdd-workflow-phase-1-orchestrator.md
│ │ ├── tdd-workflow-phase-2-pr-resumability.md
│ │ ├── tdd-workflow-phase-3-extensibility-guardrails.md
│ │ ├── test-prd.txt
│ │ └── tm-core-phase-1.txt
│ ├── reports
│ │ ├── task-complexity-report_autonomous-tdd-git-workflow.json
│ │ ├── task-complexity-report_cc-kiro-hooks.json
│ │ ├── task-complexity-report_tdd-phase-1-core-rails.json
│ │ ├── task-complexity-report_tdd-workflow-phase-0.json
│ │ ├── task-complexity-report_test-prd-tag.json
│ │ ├── task-complexity-report_tm-core-phase-1.json
│ │ ├── task-complexity-report.json
│ │ └── tm-core-complexity.json
│ ├── state.json
│ ├── tasks
│ │ ├── task_001_tm-start.txt
│ │ ├── task_002_tm-start.txt
│ │ ├── task_003_tm-start.txt
│ │ ├── task_004_tm-start.txt
│ │ ├── task_007_tm-start.txt
│ │ └── tasks.json
│ └── templates
│ ├── example_prd_rpg.md
│ └── example_prd.md
├── .vscode
│ ├── extensions.json
│ └── settings.json
├── apps
│ ├── cli
│ │ ├── CHANGELOG.md
│ │ ├── package.json
│ │ ├── src
│ │ │ ├── command-registry.ts
│ │ │ ├── commands
│ │ │ │ ├── auth.command.ts
│ │ │ │ ├── autopilot
│ │ │ │ │ ├── abort.command.ts
│ │ │ │ │ ├── commit.command.ts
│ │ │ │ │ ├── complete.command.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── next.command.ts
│ │ │ │ │ ├── resume.command.ts
│ │ │ │ │ ├── shared.ts
│ │ │ │ │ ├── start.command.ts
│ │ │ │ │ └── status.command.ts
│ │ │ │ ├── briefs.command.ts
│ │ │ │ ├── context.command.ts
│ │ │ │ ├── export.command.ts
│ │ │ │ ├── list.command.ts
│ │ │ │ ├── models
│ │ │ │ │ ├── custom-providers.ts
│ │ │ │ │ ├── fetchers.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── prompts.ts
│ │ │ │ │ ├── setup.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── next.command.ts
│ │ │ │ ├── set-status.command.ts
│ │ │ │ ├── show.command.ts
│ │ │ │ ├── start.command.ts
│ │ │ │ └── tags.command.ts
│ │ │ ├── index.ts
│ │ │ ├── lib
│ │ │ │ └── model-management.ts
│ │ │ ├── types
│ │ │ │ └── tag-management.d.ts
│ │ │ ├── ui
│ │ │ │ ├── components
│ │ │ │ │ ├── cardBox.component.ts
│ │ │ │ │ ├── dashboard.component.ts
│ │ │ │ │ ├── header.component.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ ├── next-task.component.ts
│ │ │ │ │ ├── suggested-steps.component.ts
│ │ │ │ │ └── task-detail.component.ts
│ │ │ │ ├── display
│ │ │ │ │ ├── messages.ts
│ │ │ │ │ └── tables.ts
│ │ │ │ ├── formatters
│ │ │ │ │ ├── complexity-formatters.ts
│ │ │ │ │ ├── dependency-formatters.ts
│ │ │ │ │ ├── priority-formatters.ts
│ │ │ │ │ ├── status-formatters.spec.ts
│ │ │ │ │ └── status-formatters.ts
│ │ │ │ ├── index.ts
│ │ │ │ └── layout
│ │ │ │ ├── helpers.spec.ts
│ │ │ │ └── helpers.ts
│ │ │ └── utils
│ │ │ ├── auth-helpers.ts
│ │ │ ├── auto-update.ts
│ │ │ ├── brief-selection.ts
│ │ │ ├── display-helpers.ts
│ │ │ ├── error-handler.ts
│ │ │ ├── index.ts
│ │ │ ├── project-root.ts
│ │ │ ├── task-status.ts
│ │ │ ├── ui.spec.ts
│ │ │ └── ui.ts
│ │ ├── tests
│ │ │ ├── integration
│ │ │ │ └── commands
│ │ │ │ └── autopilot
│ │ │ │ └── workflow.test.ts
│ │ │ └── unit
│ │ │ ├── commands
│ │ │ │ ├── autopilot
│ │ │ │ │ └── shared.test.ts
│ │ │ │ ├── list.command.spec.ts
│ │ │ │ └── show.command.spec.ts
│ │ │ └── ui
│ │ │ └── dashboard.component.spec.ts
│ │ ├── tsconfig.json
│ │ └── vitest.config.ts
│ ├── docs
│ │ ├── archive
│ │ │ ├── ai-client-utils-example.mdx
│ │ │ ├── ai-development-workflow.mdx
│ │ │ ├── command-reference.mdx
│ │ │ ├── configuration.mdx
│ │ │ ├── cursor-setup.mdx
│ │ │ ├── examples.mdx
│ │ │ └── Installation.mdx
│ │ ├── best-practices
│ │ │ ├── advanced-tasks.mdx
│ │ │ ├── configuration-advanced.mdx
│ │ │ └── index.mdx
│ │ ├── capabilities
│ │ │ ├── cli-root-commands.mdx
│ │ │ ├── index.mdx
│ │ │ ├── mcp.mdx
│ │ │ ├── rpg-method.mdx
│ │ │ └── task-structure.mdx
│ │ ├── CHANGELOG.md
│ │ ├── command-reference.mdx
│ │ ├── configuration.mdx
│ │ ├── docs.json
│ │ ├── favicon.svg
│ │ ├── getting-started
│ │ │ ├── api-keys.mdx
│ │ │ ├── contribute.mdx
│ │ │ ├── faq.mdx
│ │ │ └── quick-start
│ │ │ ├── configuration-quick.mdx
│ │ │ ├── execute-quick.mdx
│ │ │ ├── installation.mdx
│ │ │ ├── moving-forward.mdx
│ │ │ ├── prd-quick.mdx
│ │ │ ├── quick-start.mdx
│ │ │ ├── requirements.mdx
│ │ │ ├── rules-quick.mdx
│ │ │ └── tasks-quick.mdx
│ │ ├── introduction.mdx
│ │ ├── licensing.md
│ │ ├── logo
│ │ │ ├── dark.svg
│ │ │ ├── light.svg
│ │ │ └── task-master-logo.png
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── style.css
│ │ ├── tdd-workflow
│ │ │ ├── ai-agent-integration.mdx
│ │ │ └── quickstart.mdx
│ │ ├── vercel.json
│ │ └── whats-new.mdx
│ ├── extension
│ │ ├── .vscodeignore
│ │ ├── assets
│ │ │ ├── banner.png
│ │ │ ├── icon-dark.svg
│ │ │ ├── icon-light.svg
│ │ │ ├── icon.png
│ │ │ ├── screenshots
│ │ │ │ ├── kanban-board.png
│ │ │ │ └── task-details.png
│ │ │ └── sidebar-icon.svg
│ │ ├── CHANGELOG.md
│ │ ├── components.json
│ │ ├── docs
│ │ │ ├── extension-CI-setup.md
│ │ │ └── extension-development-guide.md
│ │ ├── esbuild.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── package.mjs
│ │ ├── package.publish.json
│ │ ├── README.md
│ │ ├── src
│ │ │ ├── components
│ │ │ │ ├── ConfigView.tsx
│ │ │ │ ├── constants.ts
│ │ │ │ ├── TaskDetails
│ │ │ │ │ ├── AIActionsSection.tsx
│ │ │ │ │ ├── DetailsSection.tsx
│ │ │ │ │ ├── PriorityBadge.tsx
│ │ │ │ │ ├── SubtasksSection.tsx
│ │ │ │ │ ├── TaskMetadataSidebar.tsx
│ │ │ │ │ └── useTaskDetails.ts
│ │ │ │ ├── TaskDetailsView.tsx
│ │ │ │ ├── TaskMasterLogo.tsx
│ │ │ │ └── ui
│ │ │ │ ├── badge.tsx
│ │ │ │ ├── breadcrumb.tsx
│ │ │ │ ├── button.tsx
│ │ │ │ ├── card.tsx
│ │ │ │ ├── collapsible.tsx
│ │ │ │ ├── CollapsibleSection.tsx
│ │ │ │ ├── dropdown-menu.tsx
│ │ │ │ ├── label.tsx
│ │ │ │ ├── scroll-area.tsx
│ │ │ │ ├── separator.tsx
│ │ │ │ ├── shadcn-io
│ │ │ │ │ └── kanban
│ │ │ │ │ └── index.tsx
│ │ │ │ └── textarea.tsx
│ │ │ ├── extension.ts
│ │ │ ├── index.ts
│ │ │ ├── lib
│ │ │ │ └── utils.ts
│ │ │ ├── services
│ │ │ │ ├── config-service.ts
│ │ │ │ ├── error-handler.ts
│ │ │ │ ├── notification-preferences.ts
│ │ │ │ ├── polling-service.ts
│ │ │ │ ├── polling-strategies.ts
│ │ │ │ ├── sidebar-webview-manager.ts
│ │ │ │ ├── task-repository.ts
│ │ │ │ ├── terminal-manager.ts
│ │ │ │ └── webview-manager.ts
│ │ │ ├── test
│ │ │ │ └── extension.test.ts
│ │ │ ├── utils
│ │ │ │ ├── configManager.ts
│ │ │ │ ├── connectionManager.ts
│ │ │ │ ├── errorHandler.ts
│ │ │ │ ├── event-emitter.ts
│ │ │ │ ├── logger.ts
│ │ │ │ ├── mcpClient.ts
│ │ │ │ ├── notificationPreferences.ts
│ │ │ │ └── task-master-api
│ │ │ │ ├── cache
│ │ │ │ │ └── cache-manager.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── mcp-client.ts
│ │ │ │ ├── transformers
│ │ │ │ │ └── task-transformer.ts
│ │ │ │ └── types
│ │ │ │ └── index.ts
│ │ │ └── webview
│ │ │ ├── App.tsx
│ │ │ ├── components
│ │ │ │ ├── AppContent.tsx
│ │ │ │ ├── EmptyState.tsx
│ │ │ │ ├── ErrorBoundary.tsx
│ │ │ │ ├── PollingStatus.tsx
│ │ │ │ ├── PriorityBadge.tsx
│ │ │ │ ├── SidebarView.tsx
│ │ │ │ ├── TagDropdown.tsx
│ │ │ │ ├── TaskCard.tsx
│ │ │ │ ├── TaskEditModal.tsx
│ │ │ │ ├── TaskMasterKanban.tsx
│ │ │ │ ├── ToastContainer.tsx
│ │ │ │ └── ToastNotification.tsx
│ │ │ ├── constants
│ │ │ │ └── index.ts
│ │ │ ├── contexts
│ │ │ │ └── VSCodeContext.tsx
│ │ │ ├── hooks
│ │ │ │ ├── useTaskQueries.ts
│ │ │ │ ├── useVSCodeMessages.ts
│ │ │ │ └── useWebviewHeight.ts
│ │ │ ├── index.css
│ │ │ ├── index.tsx
│ │ │ ├── providers
│ │ │ │ └── QueryProvider.tsx
│ │ │ ├── reducers
│ │ │ │ └── appReducer.ts
│ │ │ ├── sidebar.tsx
│ │ │ ├── types
│ │ │ │ └── index.ts
│ │ │ └── utils
│ │ │ ├── logger.ts
│ │ │ └── toast.ts
│ │ └── tsconfig.json
│ └── mcp
│ ├── CHANGELOG.md
│ ├── package.json
│ ├── src
│ │ ├── index.ts
│ │ ├── shared
│ │ │ ├── types.ts
│ │ │ └── utils.ts
│ │ └── tools
│ │ ├── autopilot
│ │ │ ├── abort.tool.ts
│ │ │ ├── commit.tool.ts
│ │ │ ├── complete.tool.ts
│ │ │ ├── finalize.tool.ts
│ │ │ ├── index.ts
│ │ │ ├── next.tool.ts
│ │ │ ├── resume.tool.ts
│ │ │ ├── start.tool.ts
│ │ │ └── status.tool.ts
│ │ ├── README-ZOD-V3.md
│ │ └── tasks
│ │ ├── get-task.tool.ts
│ │ ├── get-tasks.tool.ts
│ │ └── index.ts
│ ├── tsconfig.json
│ └── vitest.config.ts
├── assets
│ ├── .windsurfrules
│ ├── AGENTS.md
│ ├── claude
│ │ └── TM_COMMANDS_GUIDE.md
│ ├── config.json
│ ├── env.example
│ ├── example_prd_rpg.txt
│ ├── example_prd.txt
│ ├── GEMINI.md
│ ├── gitignore
│ ├── kiro-hooks
│ │ ├── tm-code-change-task-tracker.kiro.hook
│ │ ├── tm-complexity-analyzer.kiro.hook
│ │ ├── tm-daily-standup-assistant.kiro.hook
│ │ ├── tm-git-commit-task-linker.kiro.hook
│ │ ├── tm-pr-readiness-checker.kiro.hook
│ │ ├── tm-task-dependency-auto-progression.kiro.hook
│ │ └── tm-test-success-task-completer.kiro.hook
│ ├── roocode
│ │ ├── .roo
│ │ │ ├── rules-architect
│ │ │ │ └── architect-rules
│ │ │ ├── rules-ask
│ │ │ │ └── ask-rules
│ │ │ ├── rules-code
│ │ │ │ └── code-rules
│ │ │ ├── rules-debug
│ │ │ │ └── debug-rules
│ │ │ ├── rules-orchestrator
│ │ │ │ └── orchestrator-rules
│ │ │ └── rules-test
│ │ │ └── test-rules
│ │ └── .roomodes
│ ├── rules
│ │ ├── cursor_rules.mdc
│ │ ├── dev_workflow.mdc
│ │ ├── self_improve.mdc
│ │ ├── taskmaster_hooks_workflow.mdc
│ │ └── taskmaster.mdc
│ └── scripts_README.md
├── bin
│ └── task-master.js
├── biome.json
├── CHANGELOG.md
├── CLAUDE_CODE_PLUGIN.md
├── CLAUDE.md
├── context
│ ├── chats
│ │ ├── add-task-dependencies-1.md
│ │ └── max-min-tokens.txt.md
│ ├── fastmcp-core.txt
│ ├── fastmcp-docs.txt
│ ├── MCP_INTEGRATION.md
│ ├── mcp-js-sdk-docs.txt
│ ├── mcp-protocol-repo.txt
│ ├── mcp-protocol-schema-03262025.json
│ └── mcp-protocol-spec.txt
├── CONTRIBUTING.md
├── docs
│ ├── claude-code-integration.md
│ ├── CLI-COMMANDER-PATTERN.md
│ ├── command-reference.md
│ ├── configuration.md
│ ├── contributor-docs
│ │ ├── testing-roo-integration.md
│ │ └── worktree-setup.md
│ ├── cross-tag-task-movement.md
│ ├── examples
│ │ ├── claude-code-usage.md
│ │ └── codex-cli-usage.md
│ ├── examples.md
│ ├── licensing.md
│ ├── mcp-provider-guide.md
│ ├── mcp-provider.md
│ ├── migration-guide.md
│ ├── models.md
│ ├── providers
│ │ ├── codex-cli.md
│ │ └── gemini-cli.md
│ ├── README.md
│ ├── scripts
│ │ └── models-json-to-markdown.js
│ ├── task-structure.md
│ └── tutorial.md
├── images
│ ├── hamster-hiring.png
│ └── logo.png
├── index.js
├── jest.config.js
├── jest.resolver.cjs
├── LICENSE
├── llms-install.md
├── mcp-server
│ ├── server.js
│ └── src
│ ├── core
│ │ ├── __tests__
│ │ │ └── context-manager.test.js
│ │ ├── context-manager.js
│ │ ├── direct-functions
│ │ │ ├── add-dependency.js
│ │ │ ├── add-subtask.js
│ │ │ ├── add-tag.js
│ │ │ ├── add-task.js
│ │ │ ├── analyze-task-complexity.js
│ │ │ ├── cache-stats.js
│ │ │ ├── clear-subtasks.js
│ │ │ ├── complexity-report.js
│ │ │ ├── copy-tag.js
│ │ │ ├── create-tag-from-branch.js
│ │ │ ├── delete-tag.js
│ │ │ ├── expand-all-tasks.js
│ │ │ ├── expand-task.js
│ │ │ ├── fix-dependencies.js
│ │ │ ├── generate-task-files.js
│ │ │ ├── initialize-project.js
│ │ │ ├── list-tags.js
│ │ │ ├── models.js
│ │ │ ├── move-task-cross-tag.js
│ │ │ ├── move-task.js
│ │ │ ├── next-task.js
│ │ │ ├── parse-prd.js
│ │ │ ├── remove-dependency.js
│ │ │ ├── remove-subtask.js
│ │ │ ├── remove-task.js
│ │ │ ├── rename-tag.js
│ │ │ ├── research.js
│ │ │ ├── response-language.js
│ │ │ ├── rules.js
│ │ │ ├── scope-down.js
│ │ │ ├── scope-up.js
│ │ │ ├── set-task-status.js
│ │ │ ├── update-subtask-by-id.js
│ │ │ ├── update-task-by-id.js
│ │ │ ├── update-tasks.js
│ │ │ ├── use-tag.js
│ │ │ └── validate-dependencies.js
│ │ ├── task-master-core.js
│ │ └── utils
│ │ ├── env-utils.js
│ │ └── path-utils.js
│ ├── custom-sdk
│ │ ├── errors.js
│ │ ├── index.js
│ │ ├── json-extractor.js
│ │ ├── language-model.js
│ │ ├── message-converter.js
│ │ └── schema-converter.js
│ ├── index.js
│ ├── logger.js
│ ├── providers
│ │ └── mcp-provider.js
│ └── tools
│ ├── add-dependency.js
│ ├── add-subtask.js
│ ├── add-tag.js
│ ├── add-task.js
│ ├── analyze.js
│ ├── clear-subtasks.js
│ ├── complexity-report.js
│ ├── copy-tag.js
│ ├── delete-tag.js
│ ├── expand-all.js
│ ├── expand-task.js
│ ├── fix-dependencies.js
│ ├── generate.js
│ ├── get-operation-status.js
│ ├── index.js
│ ├── initialize-project.js
│ ├── list-tags.js
│ ├── models.js
│ ├── move-task.js
│ ├── next-task.js
│ ├── parse-prd.js
│ ├── README-ZOD-V3.md
│ ├── remove-dependency.js
│ ├── remove-subtask.js
│ ├── remove-task.js
│ ├── rename-tag.js
│ ├── research.js
│ ├── response-language.js
│ ├── rules.js
│ ├── scope-down.js
│ ├── scope-up.js
│ ├── set-task-status.js
│ ├── tool-registry.js
│ ├── update-subtask.js
│ ├── update-task.js
│ ├── update.js
│ ├── use-tag.js
│ ├── utils.js
│ └── validate-dependencies.js
├── mcp-test.js
├── output.json
├── package-lock.json
├── package.json
├── packages
│ ├── ai-sdk-provider-grok-cli
│ │ ├── CHANGELOG.md
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── src
│ │ │ ├── errors.test.ts
│ │ │ ├── errors.ts
│ │ │ ├── grok-cli-language-model.ts
│ │ │ ├── grok-cli-provider.test.ts
│ │ │ ├── grok-cli-provider.ts
│ │ │ ├── index.ts
│ │ │ ├── json-extractor.test.ts
│ │ │ ├── json-extractor.ts
│ │ │ ├── message-converter.test.ts
│ │ │ ├── message-converter.ts
│ │ │ └── types.ts
│ │ └── tsconfig.json
│ ├── build-config
│ │ ├── CHANGELOG.md
│ │ ├── package.json
│ │ ├── src
│ │ │ └── tsdown.base.ts
│ │ └── tsconfig.json
│ ├── claude-code-plugin
│ │ ├── .claude-plugin
│ │ │ └── plugin.json
│ │ ├── .gitignore
│ │ ├── agents
│ │ │ ├── task-checker.md
│ │ │ ├── task-executor.md
│ │ │ └── task-orchestrator.md
│ │ ├── CHANGELOG.md
│ │ ├── commands
│ │ │ ├── add-dependency.md
│ │ │ ├── add-subtask.md
│ │ │ ├── add-task.md
│ │ │ ├── analyze-complexity.md
│ │ │ ├── analyze-project.md
│ │ │ ├── auto-implement-tasks.md
│ │ │ ├── command-pipeline.md
│ │ │ ├── complexity-report.md
│ │ │ ├── convert-task-to-subtask.md
│ │ │ ├── expand-all-tasks.md
│ │ │ ├── expand-task.md
│ │ │ ├── fix-dependencies.md
│ │ │ ├── generate-tasks.md
│ │ │ ├── help.md
│ │ │ ├── init-project-quick.md
│ │ │ ├── init-project.md
│ │ │ ├── install-taskmaster.md
│ │ │ ├── learn.md
│ │ │ ├── list-tasks-by-status.md
│ │ │ ├── list-tasks-with-subtasks.md
│ │ │ ├── list-tasks.md
│ │ │ ├── next-task.md
│ │ │ ├── parse-prd-with-research.md
│ │ │ ├── parse-prd.md
│ │ │ ├── project-status.md
│ │ │ ├── quick-install-taskmaster.md
│ │ │ ├── remove-all-subtasks.md
│ │ │ ├── remove-dependency.md
│ │ │ ├── remove-subtask.md
│ │ │ ├── remove-subtasks.md
│ │ │ ├── remove-task.md
│ │ │ ├── setup-models.md
│ │ │ ├── show-task.md
│ │ │ ├── smart-workflow.md
│ │ │ ├── sync-readme.md
│ │ │ ├── tm-main.md
│ │ │ ├── to-cancelled.md
│ │ │ ├── to-deferred.md
│ │ │ ├── to-done.md
│ │ │ ├── to-in-progress.md
│ │ │ ├── to-pending.md
│ │ │ ├── to-review.md
│ │ │ ├── update-single-task.md
│ │ │ ├── update-task.md
│ │ │ ├── update-tasks-from-id.md
│ │ │ ├── validate-dependencies.md
│ │ │ └── view-models.md
│ │ ├── mcp.json
│ │ └── package.json
│ ├── tm-bridge
│ │ ├── CHANGELOG.md
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── src
│ │ │ ├── add-tag-bridge.ts
│ │ │ ├── bridge-types.ts
│ │ │ ├── bridge-utils.ts
│ │ │ ├── expand-bridge.ts
│ │ │ ├── index.ts
│ │ │ ├── tags-bridge.ts
│ │ │ ├── update-bridge.ts
│ │ │ └── use-tag-bridge.ts
│ │ └── tsconfig.json
│ └── tm-core
│ ├── .gitignore
│ ├── CHANGELOG.md
│ ├── docs
│ │ └── listTasks-architecture.md
│ ├── package.json
│ ├── POC-STATUS.md
│ ├── README.md
│ ├── src
│ │ ├── common
│ │ │ ├── constants
│ │ │ │ ├── index.ts
│ │ │ │ ├── paths.ts
│ │ │ │ └── providers.ts
│ │ │ ├── errors
│ │ │ │ ├── index.ts
│ │ │ │ └── task-master-error.ts
│ │ │ ├── interfaces
│ │ │ │ ├── configuration.interface.ts
│ │ │ │ ├── index.ts
│ │ │ │ └── storage.interface.ts
│ │ │ ├── logger
│ │ │ │ ├── factory.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── logger.spec.ts
│ │ │ │ └── logger.ts
│ │ │ ├── mappers
│ │ │ │ ├── TaskMapper.test.ts
│ │ │ │ └── TaskMapper.ts
│ │ │ ├── types
│ │ │ │ ├── database.types.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── legacy.ts
│ │ │ │ └── repository-types.ts
│ │ │ └── utils
│ │ │ ├── git-utils.ts
│ │ │ ├── id-generator.ts
│ │ │ ├── index.ts
│ │ │ ├── path-helpers.ts
│ │ │ ├── path-normalizer.spec.ts
│ │ │ ├── path-normalizer.ts
│ │ │ ├── project-root-finder.spec.ts
│ │ │ ├── project-root-finder.ts
│ │ │ ├── run-id-generator.spec.ts
│ │ │ └── run-id-generator.ts
│ │ ├── index.ts
│ │ ├── modules
│ │ │ ├── ai
│ │ │ │ ├── index.ts
│ │ │ │ ├── interfaces
│ │ │ │ │ └── ai-provider.interface.ts
│ │ │ │ └── providers
│ │ │ │ ├── base-provider.ts
│ │ │ │ └── index.ts
│ │ │ ├── auth
│ │ │ │ ├── auth-domain.spec.ts
│ │ │ │ ├── auth-domain.ts
│ │ │ │ ├── config.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── managers
│ │ │ │ │ ├── auth-manager.spec.ts
│ │ │ │ │ └── auth-manager.ts
│ │ │ │ ├── services
│ │ │ │ │ ├── context-store.ts
│ │ │ │ │ ├── oauth-service.ts
│ │ │ │ │ ├── organization.service.ts
│ │ │ │ │ ├── supabase-session-storage.spec.ts
│ │ │ │ │ └── supabase-session-storage.ts
│ │ │ │ └── types.ts
│ │ │ ├── briefs
│ │ │ │ ├── briefs-domain.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── services
│ │ │ │ │ └── brief-service.ts
│ │ │ │ ├── types.ts
│ │ │ │ └── utils
│ │ │ │ └── url-parser.ts
│ │ │ ├── commands
│ │ │ │ └── index.ts
│ │ │ ├── config
│ │ │ │ ├── config-domain.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── managers
│ │ │ │ │ ├── config-manager.spec.ts
│ │ │ │ │ └── config-manager.ts
│ │ │ │ └── services
│ │ │ │ ├── config-loader.service.spec.ts
│ │ │ │ ├── config-loader.service.ts
│ │ │ │ ├── config-merger.service.spec.ts
│ │ │ │ ├── config-merger.service.ts
│ │ │ │ ├── config-persistence.service.spec.ts
│ │ │ │ ├── config-persistence.service.ts
│ │ │ │ ├── environment-config-provider.service.spec.ts
│ │ │ │ ├── environment-config-provider.service.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── runtime-state-manager.service.spec.ts
│ │ │ │ └── runtime-state-manager.service.ts
│ │ │ ├── dependencies
│ │ │ │ └── index.ts
│ │ │ ├── execution
│ │ │ │ ├── executors
│ │ │ │ │ ├── base-executor.ts
│ │ │ │ │ ├── claude-executor.ts
│ │ │ │ │ └── executor-factory.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── services
│ │ │ │ │ └── executor-service.ts
│ │ │ │ └── types.ts
│ │ │ ├── git
│ │ │ │ ├── adapters
│ │ │ │ │ ├── git-adapter.test.ts
│ │ │ │ │ └── git-adapter.ts
│ │ │ │ ├── git-domain.ts
│ │ │ │ ├── index.ts
│ │ │ │ └── services
│ │ │ │ ├── branch-name-generator.spec.ts
│ │ │ │ ├── branch-name-generator.ts
│ │ │ │ ├── commit-message-generator.test.ts
│ │ │ │ ├── commit-message-generator.ts
│ │ │ │ ├── scope-detector.test.ts
│ │ │ │ ├── scope-detector.ts
│ │ │ │ ├── template-engine.test.ts
│ │ │ │ └── template-engine.ts
│ │ │ ├── integration
│ │ │ │ ├── clients
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── supabase-client.ts
│ │ │ │ ├── integration-domain.ts
│ │ │ │ └── services
│ │ │ │ ├── export.service.ts
│ │ │ │ ├── task-expansion.service.ts
│ │ │ │ └── task-retrieval.service.ts
│ │ │ ├── reports
│ │ │ │ ├── index.ts
│ │ │ │ ├── managers
│ │ │ │ │ └── complexity-report-manager.ts
│ │ │ │ └── types.ts
│ │ │ ├── storage
│ │ │ │ ├── adapters
│ │ │ │ │ ├── activity-logger.ts
│ │ │ │ │ ├── api-storage.ts
│ │ │ │ │ └── file-storage
│ │ │ │ │ ├── file-operations.ts
│ │ │ │ │ ├── file-storage.ts
│ │ │ │ │ ├── format-handler.ts
│ │ │ │ │ ├── index.ts
│ │ │ │ │ └── path-resolver.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── services
│ │ │ │ │ └── storage-factory.ts
│ │ │ │ └── utils
│ │ │ │ └── api-client.ts
│ │ │ ├── tasks
│ │ │ │ ├── entities
│ │ │ │ │ └── task.entity.ts
│ │ │ │ ├── parser
│ │ │ │ │ └── index.ts
│ │ │ │ ├── repositories
│ │ │ │ │ ├── supabase
│ │ │ │ │ │ ├── dependency-fetcher.ts
│ │ │ │ │ │ ├── index.ts
│ │ │ │ │ │ └── supabase-repository.ts
│ │ │ │ │ └── task-repository.interface.ts
│ │ │ │ ├── services
│ │ │ │ │ ├── preflight-checker.service.ts
│ │ │ │ │ ├── tag.service.ts
│ │ │ │ │ ├── task-execution-service.ts
│ │ │ │ │ ├── task-loader.service.ts
│ │ │ │ │ └── task-service.ts
│ │ │ │ └── tasks-domain.ts
│ │ │ ├── ui
│ │ │ │ └── index.ts
│ │ │ └── workflow
│ │ │ ├── managers
│ │ │ │ ├── workflow-state-manager.spec.ts
│ │ │ │ └── workflow-state-manager.ts
│ │ │ ├── orchestrators
│ │ │ │ ├── workflow-orchestrator.test.ts
│ │ │ │ └── workflow-orchestrator.ts
│ │ │ ├── services
│ │ │ │ ├── test-result-validator.test.ts
│ │ │ │ ├── test-result-validator.ts
│ │ │ │ ├── test-result-validator.types.ts
│ │ │ │ ├── workflow-activity-logger.ts
│ │ │ │ └── workflow.service.ts
│ │ │ ├── types.ts
│ │ │ └── workflow-domain.ts
│ │ ├── subpath-exports.test.ts
│ │ ├── tm-core.ts
│ │ └── utils
│ │ └── time.utils.ts
│ ├── tests
│ │ ├── auth
│ │ │ └── auth-refresh.test.ts
│ │ ├── integration
│ │ │ ├── auth-token-refresh.test.ts
│ │ │ ├── list-tasks.test.ts
│ │ │ └── storage
│ │ │ └── activity-logger.test.ts
│ │ ├── mocks
│ │ │ └── mock-provider.ts
│ │ ├── setup.ts
│ │ └── unit
│ │ ├── base-provider.test.ts
│ │ ├── executor.test.ts
│ │ └── smoke.test.ts
│ ├── tsconfig.json
│ └── vitest.config.ts
├── README-task-master.md
├── README.md
├── scripts
│ ├── create-worktree.sh
│ ├── dev.js
│ ├── init.js
│ ├── list-worktrees.sh
│ ├── modules
│ │ ├── ai-services-unified.js
│ │ ├── bridge-utils.js
│ │ ├── commands.js
│ │ ├── config-manager.js
│ │ ├── dependency-manager.js
│ │ ├── index.js
│ │ ├── prompt-manager.js
│ │ ├── supported-models.json
│ │ ├── sync-readme.js
│ │ ├── task-manager
│ │ │ ├── add-subtask.js
│ │ │ ├── add-task.js
│ │ │ ├── analyze-task-complexity.js
│ │ │ ├── clear-subtasks.js
│ │ │ ├── expand-all-tasks.js
│ │ │ ├── expand-task.js
│ │ │ ├── find-next-task.js
│ │ │ ├── generate-task-files.js
│ │ │ ├── is-task-dependent.js
│ │ │ ├── list-tasks.js
│ │ │ ├── migrate.js
│ │ │ ├── models.js
│ │ │ ├── move-task.js
│ │ │ ├── parse-prd
│ │ │ │ ├── index.js
│ │ │ │ ├── parse-prd-config.js
│ │ │ │ ├── parse-prd-helpers.js
│ │ │ │ ├── parse-prd-non-streaming.js
│ │ │ │ ├── parse-prd-streaming.js
│ │ │ │ └── parse-prd.js
│ │ │ ├── remove-subtask.js
│ │ │ ├── remove-task.js
│ │ │ ├── research.js
│ │ │ ├── response-language.js
│ │ │ ├── scope-adjustment.js
│ │ │ ├── set-task-status.js
│ │ │ ├── tag-management.js
│ │ │ ├── task-exists.js
│ │ │ ├── update-single-task-status.js
│ │ │ ├── update-subtask-by-id.js
│ │ │ ├── update-task-by-id.js
│ │ │ └── update-tasks.js
│ │ ├── task-manager.js
│ │ ├── ui.js
│ │ ├── update-config-tokens.js
│ │ ├── utils
│ │ │ ├── contextGatherer.js
│ │ │ ├── fuzzyTaskSearch.js
│ │ │ └── git-utils.js
│ │ └── utils.js
│ ├── task-complexity-report.json
│ ├── test-claude-errors.js
│ └── test-claude.js
├── sonar-project.properties
├── src
│ ├── ai-providers
│ │ ├── anthropic.js
│ │ ├── azure.js
│ │ ├── base-provider.js
│ │ ├── bedrock.js
│ │ ├── claude-code.js
│ │ ├── codex-cli.js
│ │ ├── gemini-cli.js
│ │ ├── google-vertex.js
│ │ ├── google.js
│ │ ├── grok-cli.js
│ │ ├── groq.js
│ │ ├── index.js
│ │ ├── lmstudio.js
│ │ ├── ollama.js
│ │ ├── openai-compatible.js
│ │ ├── openai.js
│ │ ├── openrouter.js
│ │ ├── perplexity.js
│ │ ├── xai.js
│ │ ├── zai-coding.js
│ │ └── zai.js
│ ├── constants
│ │ ├── commands.js
│ │ ├── paths.js
│ │ ├── profiles.js
│ │ ├── rules-actions.js
│ │ ├── task-priority.js
│ │ └── task-status.js
│ ├── profiles
│ │ ├── amp.js
│ │ ├── base-profile.js
│ │ ├── claude.js
│ │ ├── cline.js
│ │ ├── codex.js
│ │ ├── cursor.js
│ │ ├── gemini.js
│ │ ├── index.js
│ │ ├── kilo.js
│ │ ├── kiro.js
│ │ ├── opencode.js
│ │ ├── roo.js
│ │ ├── trae.js
│ │ ├── vscode.js
│ │ ├── windsurf.js
│ │ └── zed.js
│ ├── progress
│ │ ├── base-progress-tracker.js
│ │ ├── cli-progress-factory.js
│ │ ├── parse-prd-tracker.js
│ │ ├── progress-tracker-builder.js
│ │ └── tracker-ui.js
│ ├── prompts
│ │ ├── add-task.json
│ │ ├── analyze-complexity.json
│ │ ├── expand-task.json
│ │ ├── parse-prd.json
│ │ ├── README.md
│ │ ├── research.json
│ │ ├── schemas
│ │ │ ├── parameter.schema.json
│ │ │ ├── prompt-template.schema.json
│ │ │ ├── README.md
│ │ │ └── variant.schema.json
│ │ ├── update-subtask.json
│ │ ├── update-task.json
│ │ └── update-tasks.json
│ ├── provider-registry
│ │ └── index.js
│ ├── schemas
│ │ ├── add-task.js
│ │ ├── analyze-complexity.js
│ │ ├── base-schemas.js
│ │ ├── expand-task.js
│ │ ├── parse-prd.js
│ │ ├── registry.js
│ │ ├── update-subtask.js
│ │ ├── update-task.js
│ │ └── update-tasks.js
│ ├── task-master.js
│ ├── ui
│ │ ├── confirm.js
│ │ ├── indicators.js
│ │ └── parse-prd.js
│ └── utils
│ ├── asset-resolver.js
│ ├── create-mcp-config.js
│ ├── format.js
│ ├── getVersion.js
│ ├── logger-utils.js
│ ├── manage-gitignore.js
│ ├── path-utils.js
│ ├── profiles.js
│ ├── rule-transformer.js
│ ├── stream-parser.js
│ └── timeout-manager.js
├── test-clean-tags.js
├── test-config-manager.js
├── test-prd.txt
├── test-tag-functions.js
├── test-version-check-full.js
├── test-version-check.js
├── tests
│ ├── e2e
│ │ ├── e2e_helpers.sh
│ │ ├── parse_llm_output.cjs
│ │ ├── run_e2e.sh
│ │ ├── run_fallback_verification.sh
│ │ └── test_llm_analysis.sh
│ ├── fixtures
│ │ ├── .taskmasterconfig
│ │ ├── sample-claude-response.js
│ │ ├── sample-prd.txt
│ │ └── sample-tasks.js
│ ├── helpers
│ │ └── tool-counts.js
│ ├── integration
│ │ ├── claude-code-error-handling.test.js
│ │ ├── claude-code-optional.test.js
│ │ ├── cli
│ │ │ ├── commands.test.js
│ │ │ ├── complex-cross-tag-scenarios.test.js
│ │ │ └── move-cross-tag.test.js
│ │ ├── manage-gitignore.test.js
│ │ ├── mcp-server
│ │ │ └── direct-functions.test.js
│ │ ├── move-task-cross-tag.integration.test.js
│ │ ├── move-task-simple.integration.test.js
│ │ ├── profiles
│ │ │ ├── amp-init-functionality.test.js
│ │ │ ├── claude-init-functionality.test.js
│ │ │ ├── cline-init-functionality.test.js
│ │ │ ├── codex-init-functionality.test.js
│ │ │ ├── cursor-init-functionality.test.js
│ │ │ ├── gemini-init-functionality.test.js
│ │ │ ├── opencode-init-functionality.test.js
│ │ │ ├── roo-files-inclusion.test.js
│ │ │ ├── roo-init-functionality.test.js
│ │ │ ├── rules-files-inclusion.test.js
│ │ │ ├── trae-init-functionality.test.js
│ │ │ ├── vscode-init-functionality.test.js
│ │ │ └── windsurf-init-functionality.test.js
│ │ └── providers
│ │ └── temperature-support.test.js
│ ├── manual
│ │ ├── progress
│ │ │ ├── parse-prd-analysis.js
│ │ │ ├── test-parse-prd.js
│ │ │ └── TESTING_GUIDE.md
│ │ └── prompts
│ │ ├── prompt-test.js
│ │ └── README.md
│ ├── README.md
│ ├── setup.js
│ └── unit
│ ├── ai-providers
│ │ ├── base-provider.test.js
│ │ ├── claude-code.test.js
│ │ ├── codex-cli.test.js
│ │ ├── gemini-cli.test.js
│ │ ├── lmstudio.test.js
│ │ ├── mcp-components.test.js
│ │ ├── openai-compatible.test.js
│ │ ├── openai.test.js
│ │ ├── provider-registry.test.js
│ │ ├── zai-coding.test.js
│ │ ├── zai-provider.test.js
│ │ ├── zai-schema-introspection.test.js
│ │ └── zai.test.js
│ ├── ai-services-unified.test.js
│ ├── commands.test.js
│ ├── config-manager.test.js
│ ├── config-manager.test.mjs
│ ├── dependency-manager.test.js
│ ├── init.test.js
│ ├── initialize-project.test.js
│ ├── kebab-case-validation.test.js
│ ├── manage-gitignore.test.js
│ ├── mcp
│ │ └── tools
│ │ ├── __mocks__
│ │ │ └── move-task.js
│ │ ├── add-task.test.js
│ │ ├── analyze-complexity.test.js
│ │ ├── expand-all.test.js
│ │ ├── get-tasks.test.js
│ │ ├── initialize-project.test.js
│ │ ├── move-task-cross-tag-options.test.js
│ │ ├── move-task-cross-tag.test.js
│ │ ├── remove-task.test.js
│ │ └── tool-registration.test.js
│ ├── mcp-providers
│ │ ├── mcp-components.test.js
│ │ └── mcp-provider.test.js
│ ├── parse-prd.test.js
│ ├── profiles
│ │ ├── amp-integration.test.js
│ │ ├── claude-integration.test.js
│ │ ├── cline-integration.test.js
│ │ ├── codex-integration.test.js
│ │ ├── cursor-integration.test.js
│ │ ├── gemini-integration.test.js
│ │ ├── kilo-integration.test.js
│ │ ├── kiro-integration.test.js
│ │ ├── mcp-config-validation.test.js
│ │ ├── opencode-integration.test.js
│ │ ├── profile-safety-check.test.js
│ │ ├── roo-integration.test.js
│ │ ├── rule-transformer-cline.test.js
│ │ ├── rule-transformer-cursor.test.js
│ │ ├── rule-transformer-gemini.test.js
│ │ ├── rule-transformer-kilo.test.js
│ │ ├── rule-transformer-kiro.test.js
│ │ ├── rule-transformer-opencode.test.js
│ │ ├── rule-transformer-roo.test.js
│ │ ├── rule-transformer-trae.test.js
│ │ ├── rule-transformer-vscode.test.js
│ │ ├── rule-transformer-windsurf.test.js
│ │ ├── rule-transformer-zed.test.js
│ │ ├── rule-transformer.test.js
│ │ ├── selective-profile-removal.test.js
│ │ ├── subdirectory-support.test.js
│ │ ├── trae-integration.test.js
│ │ ├── vscode-integration.test.js
│ │ ├── windsurf-integration.test.js
│ │ └── zed-integration.test.js
│ ├── progress
│ │ └── base-progress-tracker.test.js
│ ├── prompt-manager.test.js
│ ├── prompts
│ │ ├── expand-task-prompt.test.js
│ │ └── prompt-migration.test.js
│ ├── scripts
│ │ └── modules
│ │ ├── commands
│ │ │ ├── move-cross-tag.test.js
│ │ │ └── README.md
│ │ ├── dependency-manager
│ │ │ ├── circular-dependencies.test.js
│ │ │ ├── cross-tag-dependencies.test.js
│ │ │ └── fix-dependencies-command.test.js
│ │ ├── task-manager
│ │ │ ├── add-subtask.test.js
│ │ │ ├── add-task.test.js
│ │ │ ├── analyze-task-complexity.test.js
│ │ │ ├── clear-subtasks.test.js
│ │ │ ├── complexity-report-tag-isolation.test.js
│ │ │ ├── expand-all-tasks.test.js
│ │ │ ├── expand-task.test.js
│ │ │ ├── find-next-task.test.js
│ │ │ ├── generate-task-files.test.js
│ │ │ ├── list-tasks.test.js
│ │ │ ├── models-baseurl.test.js
│ │ │ ├── move-task-cross-tag.test.js
│ │ │ ├── move-task.test.js
│ │ │ ├── parse-prd-schema.test.js
│ │ │ ├── parse-prd.test.js
│ │ │ ├── remove-subtask.test.js
│ │ │ ├── remove-task.test.js
│ │ │ ├── research.test.js
│ │ │ ├── scope-adjustment.test.js
│ │ │ ├── set-task-status.test.js
│ │ │ ├── setup.js
│ │ │ ├── update-single-task-status.test.js
│ │ │ ├── update-subtask-by-id.test.js
│ │ │ ├── update-task-by-id.test.js
│ │ │ └── update-tasks.test.js
│ │ ├── ui
│ │ │ └── cross-tag-error-display.test.js
│ │ └── utils-tag-aware-paths.test.js
│ ├── task-finder.test.js
│ ├── task-manager
│ │ ├── clear-subtasks.test.js
│ │ ├── move-task.test.js
│ │ ├── tag-boundary.test.js
│ │ └── tag-management.test.js
│ ├── task-master.test.js
│ ├── ui
│ │ └── indicators.test.js
│ ├── ui.test.js
│ ├── utils-strip-ansi.test.js
│ └── utils.test.js
├── tsconfig.json
├── tsdown.config.ts
├── turbo.json
└── update-task-migration-plan.md
```
# Files
--------------------------------------------------------------------------------
/mcp-server/src/providers/mcp-provider.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * mcp-server/src/providers/mcp-provider.js
3 | *
4 | * Implementation for MCP custom AI SDK provider that integrates with
5 | * the existing MCP server infrastructure and provider registry.
6 | * Follows the Claude Code provider pattern for session-based providers.
7 | */
8 |
9 | import { createMCP } from '../custom-sdk/index.js';
10 | import { BaseAIProvider } from '../../../src/ai-providers/base-provider.js';
11 |
12 | export class MCPProvider extends BaseAIProvider {
13 | constructor() {
14 | super();
15 | this.name = 'mcp';
16 | this.session = null; // MCP server session object
17 | }
18 |
19 | getRequiredApiKeyName() {
20 | return 'MCP_API_KEY';
21 | }
22 |
23 | isRequiredApiKey() {
24 | return false;
25 | }
26 |
27 | /**
28 | * Override validateAuth to validate MCP session instead of API key
29 | * @param {object} params - Parameters to validate
30 | */
31 | validateAuth(params) {
32 | // Validate MCP session instead of API key
33 | if (!this.session) {
34 | throw new Error('MCP Provider requires active MCP session');
35 | }
36 |
37 | if (!this.session.clientCapabilities?.sampling) {
38 | throw new Error('MCP session must have client sampling capabilities');
39 | }
40 | }
41 |
42 | /**
43 | * Creates and returns an MCP AI SDK client instance.
44 | * @param {object} params - Parameters for client initialization
45 | * @returns {Function} MCP AI SDK client function
46 | * @throws {Error} If initialization fails
47 | */
48 | getClient(params) {
49 | try {
50 | // Pass MCP session to AI SDK implementation
51 | return createMCP({
52 | session: this.session,
53 | defaultSettings: {
54 | temperature: params.temperature,
55 | maxTokens: params.maxTokens
56 | }
57 | });
58 | } catch (error) {
59 | this.handleError('client initialization', error);
60 | }
61 | }
62 |
63 | /**
64 | * Method called by MCP server on connect events
65 | * @param {object} session - MCP session object
66 | */
67 | setSession(session) {
68 | this.session = session;
69 |
70 | if (!session) {
71 | this.logger?.warn('Set null session on MCP Provider');
72 | } else {
73 | this.logger?.debug('Updated MCP Provider session');
74 | }
75 | }
76 |
77 | /**
78 | * Get current session status
79 | * @returns {boolean} True if session is available and valid
80 | */
81 | hasValidSession() {
82 | return !!(this.session && this.session.clientCapabilities?.sampling);
83 | }
84 | }
85 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/auto-implement-tasks.md:
--------------------------------------------------------------------------------
```markdown
1 | Enhanced auto-implementation with intelligent code generation and testing.
2 |
3 | Arguments: $ARGUMENTS
4 |
5 | ## Intelligent Auto-Implementation
6 |
7 | Advanced implementation with context awareness and quality checks.
8 |
9 | ### 1. **Pre-Implementation Analysis**
10 |
11 | Before starting:
12 | - Analyze task complexity and requirements
13 | - Check codebase patterns and conventions
14 | - Identify similar completed tasks
15 | - Assess test coverage needs
16 | - Detect potential risks
17 |
18 | ### 2. **Smart Implementation Strategy**
19 |
20 | Based on task type and context:
21 |
22 | **Feature Tasks**
23 | 1. Research existing patterns
24 | 2. Design component architecture
25 | 3. Implement with tests
26 | 4. Integrate with system
27 | 5. Update documentation
28 |
29 | **Bug Fix Tasks**
30 | 1. Reproduce issue
31 | 2. Identify root cause
32 | 3. Implement minimal fix
33 | 4. Add regression tests
34 | 5. Verify side effects
35 |
36 | **Refactoring Tasks**
37 | 1. Analyze current structure
38 | 2. Plan incremental changes
39 | 3. Maintain test coverage
40 | 4. Refactor step-by-step
41 | 5. Verify behavior unchanged
42 |
43 | ### 3. **Code Intelligence**
44 |
45 | **Pattern Recognition**
46 | - Learn from existing code
47 | - Follow team conventions
48 | - Use preferred libraries
49 | - Match style guidelines
50 |
51 | **Test-Driven Approach**
52 | - Write tests first when possible
53 | - Ensure comprehensive coverage
54 | - Include edge cases
55 | - Performance considerations
56 |
57 | ### 4. **Progressive Implementation**
58 |
59 | Step-by-step with validation:
60 | ```
61 | Step 1/5: Setting up component structure ✓
62 | Step 2/5: Implementing core logic ✓
63 | Step 3/5: Adding error handling ⚡ (in progress)
64 | Step 4/5: Writing tests ⏳
65 | Step 5/5: Integration testing ⏳
66 |
67 | Current: Adding try-catch blocks and validation...
68 | ```
69 |
70 | ### 5. **Quality Assurance**
71 |
72 | Automated checks:
73 | - Linting and formatting
74 | - Test execution
75 | - Type checking
76 | - Dependency validation
77 | - Performance analysis
78 |
79 | ### 6. **Smart Recovery**
80 |
81 | If issues arise:
82 | - Diagnostic analysis
83 | - Suggestion generation
84 | - Fallback strategies
85 | - Manual intervention points
86 | - Learning from failures
87 |
88 | ### 7. **Post-Implementation**
89 |
90 | After completion:
91 | - Generate PR description
92 | - Update documentation
93 | - Log lessons learned
94 | - Suggest follow-up tasks
95 | - Update task relationships
96 |
97 | Result: High-quality, production-ready implementations.
```
--------------------------------------------------------------------------------
/tests/integration/profiles/trae-init-functionality.test.js:
--------------------------------------------------------------------------------
```javascript
1 | import fs from 'fs';
2 | import path from 'path';
3 | import { traeProfile } from '../../../src/profiles/trae.js';
4 |
5 | describe('Trae Profile Initialization Functionality', () => {
6 | let traeProfileContent;
7 |
8 | beforeAll(() => {
9 | const traeJsPath = path.join(process.cwd(), 'src', 'profiles', 'trae.js');
10 | traeProfileContent = fs.readFileSync(traeJsPath, 'utf8');
11 | });
12 |
13 | test('trae.js uses factory pattern with correct configuration', () => {
14 | // Check for explicit, non-default values in the source file
15 | expect(traeProfileContent).toContain("name: 'trae'");
16 | expect(traeProfileContent).toContain("displayName: 'Trae'");
17 | expect(traeProfileContent).toContain("url: 'trae.ai'");
18 | expect(traeProfileContent).toContain("docsUrl: 'docs.trae.ai'");
19 | expect(traeProfileContent).toContain('mcpConfig: false');
20 |
21 | // Check the final computed properties on the profile object
22 | expect(traeProfile.profileName).toBe('trae');
23 | expect(traeProfile.displayName).toBe('Trae');
24 | expect(traeProfile.profileDir).toBe('.trae'); // default
25 | expect(traeProfile.rulesDir).toBe('.trae/rules'); // default
26 | expect(traeProfile.mcpConfig).toBe(false); // non-default
27 | expect(traeProfile.mcpConfigName).toBe(null); // computed from mcpConfig
28 | });
29 |
30 | test('trae.js configures .mdc to .md extension mapping', () => {
31 | // Check that the profile object has the correct file mapping behavior (trae converts to .md)
32 | expect(traeProfile.fileMap['rules/cursor_rules.mdc']).toBe('trae_rules.md');
33 | });
34 |
35 | test('trae.js uses standard tool mappings', () => {
36 | // Check that the profile uses default tool mappings (equivalent to COMMON_TOOL_MAPPINGS.STANDARD)
37 | // This verifies the architectural pattern: no custom toolMappings = standard tool names
38 | expect(traeProfileContent).not.toContain('toolMappings:');
39 | expect(traeProfileContent).not.toContain('apply_diff');
40 | expect(traeProfileContent).not.toContain('search_files');
41 |
42 | // Verify the result: default mappings means tools keep their original names
43 | expect(traeProfile.conversionConfig.toolNames.edit_file).toBe('edit_file');
44 | expect(traeProfile.conversionConfig.toolNames.search).toBe('search');
45 | });
46 | });
47 |
```
--------------------------------------------------------------------------------
/packages/tm-core/src/modules/git/services/branch-name-generator.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Branch Name Generator - Generates valid git branch names from patterns
3 | * @module branch-name-generator
4 | */
5 |
6 | /**
7 | * Sanitizes a string to be a valid git branch name.
8 | * Removes invalid characters, converts to lowercase, replaces spaces with hyphens.
9 | *
10 | * @param {string} name - Name to sanitize
11 | * @returns {string} Sanitized branch name
12 | */
13 | export function sanitizeBranchName(name: string): string {
14 | if (!name || name.trim() === '') {
15 | return 'branch';
16 | }
17 |
18 | return name
19 | .toLowerCase()
20 | .replace(/[^a-z0-9-_.\/]/g, '-') // Replace invalid chars with hyphens
21 | .replace(/\//g, '-') // Replace slashes with hyphens
22 | .replace(/-+/g, '-') // Remove consecutive hyphens
23 | .replace(/^-+|-+$/g, ''); // Remove leading/trailing hyphens
24 | }
25 |
26 | /**
27 | * Generates a branch name from a pattern and variables.
28 | *
29 | * @param {Object} options - Generation options
30 | * @param {string} options.taskId - Task ID to include
31 | * @param {string} [options.description] - Description to include
32 | * @param {string} [options.pattern] - Custom pattern (default: 'task-{taskId}-{description}')
33 | * @param {number} [options.maxLength=50] - Maximum branch name length
34 | * @returns {string} Generated branch name
35 | */
36 | export function generateBranchName(options: {
37 | taskId: string;
38 | description?: string;
39 | pattern?: string;
40 | maxLength?: number;
41 | }): string {
42 | const maxLength = options.maxLength || 50;
43 | const pattern = options.pattern || 'task-{taskId}-{description}';
44 |
45 | // Sanitize task ID (replace dots with hyphens)
46 | const sanitizedTaskId = sanitizeBranchName(
47 | options.taskId.replace(/\./g, '-')
48 | );
49 |
50 | // Sanitize description if provided
51 | const sanitizedDescription = options.description
52 | ? sanitizeBranchName(options.description)
53 | : sanitizeBranchName(Date.now().toString());
54 |
55 | // Replace pattern variables
56 | let branchName = pattern
57 | .replace(/{taskId}/g, sanitizedTaskId)
58 | .replace(/{description}/g, sanitizedDescription);
59 |
60 | // Sanitize the final result
61 | branchName = sanitizeBranchName(branchName);
62 |
63 | // Truncate if too long
64 | if (branchName.length > maxLength) {
65 | branchName = branchName.substring(0, maxLength).replace(/-+$/, '');
66 | }
67 |
68 | return branchName;
69 | }
70 |
```
--------------------------------------------------------------------------------
/.kiro/steering/taskmaster_hooks_workflow.md:
--------------------------------------------------------------------------------
```markdown
1 | ---
2 | inclusion: always
3 | ---
4 |
5 | # Taskmaster Hook-Driven Workflow
6 |
7 | ## Core Principle: Hooks Automate Task Management
8 |
9 | When working with Taskmaster in Kiro, **avoid manually marking tasks as done**. The hook system automatically handles task completion based on:
10 |
11 | - **Test Success**: `[TM] Test Success Task Completer` detects passing tests and prompts for task completion
12 | - **Code Changes**: `[TM] Code Change Task Tracker` monitors implementation progress
13 | - **Dependency Chains**: `[TM] Task Dependency Auto-Progression` auto-starts dependent tasks
14 |
15 | ## AI Assistant Workflow
16 |
17 | Follow this pattern when implementing features:
18 |
19 | 1. **Implement First**: Write code, create tests, make changes
20 | 2. **Save Frequently**: Hooks trigger on file saves to track progress automatically
21 | 3. **Let Hooks Decide**: Allow hooks to detect completion rather than manually setting status
22 | 4. **Respond to Prompts**: Confirm when hooks suggest task completion
23 |
24 | ## Key Rules for AI Assistants
25 |
26 | - **Never use `tm set-status --status=done`** unless hooks fail to detect completion
27 | - **Always write tests** - they provide the most reliable completion signal
28 | - **Save files after implementation** - this triggers progress tracking
29 | - **Trust hook suggestions** - if no completion prompt appears, more work may be needed
30 |
31 | ## Automatic Behaviors
32 |
33 | The hook system provides:
34 |
35 | - **Progress Logging**: Implementation details automatically added to task notes
36 | - **Evidence-Based Completion**: Tasks marked done only when criteria are met
37 | - **Dependency Management**: Next tasks auto-started when dependencies complete
38 | - **Natural Flow**: Focus on coding, not task management overhead
39 |
40 | ## Manual Override Cases
41 |
42 | Only manually set task status for:
43 |
44 | - Documentation-only tasks
45 | - Tasks without testable outcomes
46 | - Emergency fixes without proper test coverage
47 |
48 | Use `tm set-status` sparingly - prefer hook-driven completion.
49 |
50 | ## Implementation Pattern
51 |
52 | ```
53 | 1. Implement feature → Save file
54 | 2. Write tests → Save test file
55 | 3. Tests pass → Hook prompts completion
56 | 4. Confirm completion → Next task auto-starts
57 | ```
58 |
59 | This workflow ensures proper task tracking while maintaining development flow.
```
--------------------------------------------------------------------------------
/apps/cli/src/ui/display/messages.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Display message utilities
3 | * Provides formatted message boxes for errors, success, warnings, info, and banners
4 | */
5 |
6 | import boxen from 'boxen';
7 | import chalk from 'chalk';
8 | import { getBoxWidth } from '../layout/helpers.js';
9 |
10 | /**
11 | * Display a fancy banner
12 | */
13 | export function displayBanner(title: string = 'Task Master'): void {
14 | console.log(
15 | boxen(chalk.white.bold(title), {
16 | padding: 1,
17 | margin: { top: 1, bottom: 1 },
18 | borderStyle: 'round',
19 | borderColor: 'blue',
20 | textAlignment: 'center'
21 | })
22 | );
23 | }
24 |
25 | /**
26 | * Display an error message in a boxed format (matches scripts/modules/ui.js style)
27 | * Note: For general CLI error handling, use displayError from utils/error-handler.ts
28 | * This function is for displaying formatted error messages as part of UI output.
29 | */
30 | export function displayErrorBox(message: string, details?: string): void {
31 | const boxWidth = getBoxWidth();
32 |
33 | console.error(
34 | boxen(
35 | chalk.red.bold('X Error: ') +
36 | chalk.white(message) +
37 | (details ? '\n\n' + chalk.gray(details) : ''),
38 | {
39 | padding: 1,
40 | borderStyle: 'round',
41 | borderColor: 'red',
42 | width: boxWidth
43 | }
44 | )
45 | );
46 | }
47 |
48 | /**
49 | * Alias for displayErrorBox
50 | */
51 | export const displayError = displayErrorBox;
52 |
53 | /**
54 | * Display a success message
55 | */
56 | export function displaySuccess(message: string): void {
57 | const boxWidth = getBoxWidth();
58 |
59 | console.log(
60 | boxen(
61 | chalk.green.bold(String.fromCharCode(8730) + ' ') + chalk.white(message),
62 | {
63 | padding: 1,
64 | borderStyle: 'round',
65 | borderColor: 'green',
66 | width: boxWidth
67 | }
68 | )
69 | );
70 | }
71 |
72 | /**
73 | * Display a warning message
74 | */
75 | export function displayWarning(message: string): void {
76 | const boxWidth = getBoxWidth();
77 |
78 | console.log(
79 | boxen(chalk.yellow.bold('⚠️ ') + chalk.white(message), {
80 | padding: 1,
81 | borderStyle: 'round',
82 | borderColor: 'yellow',
83 | width: boxWidth
84 | })
85 | );
86 | }
87 |
88 | /**
89 | * Display info message
90 | */
91 | export function displayInfo(message: string): void {
92 | const boxWidth = getBoxWidth();
93 |
94 | console.log(
95 | boxen(chalk.blue.bold('i ') + chalk.white(message), {
96 | padding: 1,
97 | borderStyle: 'round',
98 | borderColor: 'blue',
99 | width: boxWidth
100 | })
101 | );
102 | }
103 |
```
--------------------------------------------------------------------------------
/mcp-server/src/tools/delete-tag.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * tools/delete-tag.js
3 | * Tool to delete an existing tag
4 | */
5 |
6 | import { z } from 'zod';
7 | import {
8 | createErrorResponse,
9 | handleApiResult,
10 | withNormalizedProjectRoot
11 | } from './utils.js';
12 | import { deleteTagDirect } from '../core/task-master-core.js';
13 | import { findTasksPath } from '../core/utils/path-utils.js';
14 |
15 | /**
16 | * Register the deleteTag tool with the MCP server
17 | * @param {Object} server - FastMCP server instance
18 | */
19 | export function registerDeleteTagTool(server) {
20 | server.addTool({
21 | name: 'delete_tag',
22 | description: 'Delete an existing tag and all its tasks',
23 | parameters: z.object({
24 | name: z.string().describe('Name of the tag to delete'),
25 | yes: z
26 | .boolean()
27 | .optional()
28 | .describe('Skip confirmation prompts (default: true for MCP)'),
29 | file: z
30 | .string()
31 | .optional()
32 | .describe('Path to the tasks file (default: tasks/tasks.json)'),
33 | projectRoot: z
34 | .string()
35 | .describe('The directory of the project. Must be an absolute path.')
36 | }),
37 | execute: withNormalizedProjectRoot(async (args, { log, session }) => {
38 | try {
39 | log.info(`Starting delete-tag with args: ${JSON.stringify(args)}`);
40 |
41 | // Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
42 | let tasksJsonPath;
43 | try {
44 | tasksJsonPath = findTasksPath(
45 | { projectRoot: args.projectRoot, file: args.file },
46 | log
47 | );
48 | } catch (error) {
49 | log.error(`Error finding tasks.json: ${error.message}`);
50 | return createErrorResponse(
51 | `Failed to find tasks.json: ${error.message}`
52 | );
53 | }
54 |
55 | // Call the direct function (always skip confirmation for MCP)
56 | const result = await deleteTagDirect(
57 | {
58 | tasksJsonPath: tasksJsonPath,
59 | name: args.name,
60 | yes: args.yes !== undefined ? args.yes : true, // Default to true for MCP
61 | projectRoot: args.projectRoot
62 | },
63 | log,
64 | { session }
65 | );
66 |
67 | return handleApiResult(
68 | result,
69 | log,
70 | 'Error deleting tag',
71 | undefined,
72 | args.projectRoot
73 | );
74 | } catch (error) {
75 | log.error(`Error in delete-tag tool: ${error.message}`);
76 | return createErrorResponse(error.message);
77 | }
78 | })
79 | });
80 | }
81 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/analyze-project.md:
--------------------------------------------------------------------------------
```markdown
1 | Advanced project analysis with actionable insights and recommendations.
2 |
3 | Arguments: $ARGUMENTS
4 |
5 | ## Comprehensive Project Analysis
6 |
7 | Multi-dimensional analysis based on requested focus area.
8 |
9 | ### 1. **Analysis Modes**
10 |
11 | Based on $ARGUMENTS:
12 | - "velocity" → Sprint velocity and trends
13 | - "quality" → Code quality metrics
14 | - "risk" → Risk assessment and mitigation
15 | - "dependencies" → Dependency graph analysis
16 | - "team" → Workload and skill distribution
17 | - "architecture" → System design coherence
18 | - Default → Full spectrum analysis
19 |
20 | ### 2. **Velocity Analytics**
21 |
22 | ```
23 | 📊 Velocity Analysis
24 | ━━━━━━━━━━━━━━━━━━━
25 | Current Sprint: 24 points/week ↗️ +20%
26 | Rolling Average: 20 points/week
27 | Efficiency: 85% (17/20 tasks on time)
28 |
29 | Bottlenecks Detected:
30 | - Code review delays (avg 4h wait)
31 | - Test environment availability
32 | - Dependency on external team
33 |
34 | Recommendations:
35 | 1. Implement parallel review process
36 | 2. Add staging environment
37 | 3. Mock external dependencies
38 | ```
39 |
40 | ### 3. **Risk Assessment**
41 |
42 | **Technical Risks**
43 | - High complexity tasks without backup assignee
44 | - Single points of failure in architecture
45 | - Insufficient test coverage in critical paths
46 | - Technical debt accumulation rate
47 |
48 | **Project Risks**
49 | - Critical path dependencies
50 | - Resource availability gaps
51 | - Deadline feasibility analysis
52 | - Scope creep indicators
53 |
54 | ### 4. **Dependency Intelligence**
55 |
56 | Visual dependency analysis:
57 | ```
58 | Critical Path:
59 | #12 → #15 → #23 → #45 → #50 (20 days)
60 | ↘ #24 → #46 ↗
61 |
62 | Optimization: Parallelize #15 and #24
63 | Time Saved: 3 days
64 | ```
65 |
66 | ### 5. **Quality Metrics**
67 |
68 | **Code Quality**
69 | - Test coverage trends
70 | - Complexity scores
71 | - Technical debt ratio
72 | - Review feedback patterns
73 |
74 | **Process Quality**
75 | - Rework frequency
76 | - Bug introduction rate
77 | - Time to resolution
78 | - Knowledge distribution
79 |
80 | ### 6. **Predictive Insights**
81 |
82 | Based on patterns:
83 | - Completion probability by deadline
84 | - Resource needs projection
85 | - Risk materialization likelihood
86 | - Suggested interventions
87 |
88 | ### 7. **Executive Dashboard**
89 |
90 | High-level summary with:
91 | - Health score (0-100)
92 | - Top 3 risks
93 | - Top 3 opportunities
94 | - Recommended actions
95 | - Success probability
96 |
97 | Result: Data-driven decisions with clear action paths.
```
--------------------------------------------------------------------------------
/apps/cli/src/commands/autopilot/index.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Autopilot CLI Commands for AI Agent Orchestration
3 | * Provides subcommands for starting, resuming, and advancing the TDD workflow
4 | * with JSON output for machine parsing.
5 | */
6 |
7 | import { Command } from 'commander';
8 | import { AbortCommand } from './abort.command.js';
9 | import { CommitCommand } from './commit.command.js';
10 | import { CompleteCommand } from './complete.command.js';
11 | import { NextCommand } from './next.command.js';
12 | import { ResumeCommand } from './resume.command.js';
13 | import { StartCommand } from './start.command.js';
14 | import { StatusCommand } from './status.command.js';
15 |
16 | /**
17 | * Shared command options for all autopilot commands
18 | */
19 | export interface AutopilotBaseOptions {
20 | json?: boolean;
21 | verbose?: boolean;
22 | projectRoot?: string;
23 | }
24 |
25 | /**
26 | * AutopilotCommand with subcommands for TDD workflow orchestration
27 | */
28 | export class AutopilotCommand extends Command {
29 | constructor() {
30 | super('autopilot');
31 |
32 | // Configure main command
33 | this.description('AI agent orchestration for TDD workflow execution')
34 | .alias('ap')
35 | // Global options for all subcommands
36 | .option('--json', 'Output in JSON format for machine parsing')
37 | .option('-v, --verbose', 'Enable verbose output')
38 | .option(
39 | '-p, --project-root <path>',
40 | 'Project root directory (auto-detected if not specified)'
41 | );
42 |
43 | // Register subcommands
44 | this.registerSubcommands();
45 | }
46 |
47 | /**
48 | * Register all autopilot subcommands
49 | */
50 | private registerSubcommands(): void {
51 | // Start new TDD workflow
52 | this.addCommand(new StartCommand());
53 |
54 | // Resume existing workflow
55 | this.addCommand(new ResumeCommand());
56 |
57 | // Get next action
58 | this.addCommand(new NextCommand());
59 |
60 | // Complete current phase
61 | this.addCommand(new CompleteCommand());
62 |
63 | // Create commit
64 | this.addCommand(new CommitCommand());
65 |
66 | // Show status
67 | this.addCommand(new StatusCommand());
68 |
69 | // Abort workflow
70 | this.addCommand(new AbortCommand());
71 | }
72 |
73 | /**
74 | * Register this command on an existing program
75 | */
76 | static register(program: Command): AutopilotCommand {
77 | const autopilotCommand = new AutopilotCommand();
78 | program.addCommand(autopilotCommand);
79 | return autopilotCommand;
80 | }
81 | }
82 |
```
--------------------------------------------------------------------------------
/mcp-server/src/core/direct-functions/validate-dependencies.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * Direct function wrapper for validateDependenciesCommand
3 | */
4 |
5 | import { validateDependenciesCommand } from '../../../../scripts/modules/dependency-manager.js';
6 | import {
7 | enableSilentMode,
8 | disableSilentMode
9 | } from '../../../../scripts/modules/utils.js';
10 | import fs from 'fs';
11 |
12 | /**
13 | * Validate dependencies in tasks.json
14 | * @param {Object} args - Function arguments
15 | * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
16 | * @param {string} args.projectRoot - Project root path (for MCP/env fallback)
17 | * @param {string} args.tag - Tag for the task (optional)
18 | * @param {Object} log - Logger object
19 | * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
20 | */
21 | export async function validateDependenciesDirect(args, log) {
22 | // Destructure the explicit tasksJsonPath
23 | const { tasksJsonPath, projectRoot, tag } = args;
24 |
25 | if (!tasksJsonPath) {
26 | log.error('validateDependenciesDirect called without tasksJsonPath');
27 | return {
28 | success: false,
29 | error: {
30 | code: 'MISSING_ARGUMENT',
31 | message: 'tasksJsonPath is required'
32 | }
33 | };
34 | }
35 |
36 | try {
37 | log.info(`Validating dependencies in tasks: ${tasksJsonPath}`);
38 |
39 | // Use the provided tasksJsonPath
40 | const tasksPath = tasksJsonPath;
41 |
42 | // Verify the file exists
43 | if (!fs.existsSync(tasksPath)) {
44 | return {
45 | success: false,
46 | error: {
47 | code: 'FILE_NOT_FOUND',
48 | message: `Tasks file not found at ${tasksPath}`
49 | }
50 | };
51 | }
52 |
53 | // Enable silent mode to prevent console logs from interfering with JSON response
54 | enableSilentMode();
55 |
56 | const options = { projectRoot, tag };
57 | // Call the original command function using the provided tasksPath
58 | await validateDependenciesCommand(tasksPath, options);
59 |
60 | // Restore normal logging
61 | disableSilentMode();
62 |
63 | return {
64 | success: true,
65 | data: {
66 | message: 'Dependencies validated successfully',
67 | tasksPath
68 | }
69 | };
70 | } catch (error) {
71 | // Make sure to restore normal logging even if there's an error
72 | disableSilentMode();
73 |
74 | log.error(`Error validating dependencies: ${error.message}`);
75 | return {
76 | success: false,
77 | error: {
78 | code: 'VALIDATION_ERROR',
79 | message: error.message
80 | }
81 | };
82 | }
83 | }
84 |
```
--------------------------------------------------------------------------------
/tests/integration/profiles/codex-init-functionality.test.js:
--------------------------------------------------------------------------------
```javascript
1 | import fs from 'fs';
2 | import path from 'path';
3 | import { codexProfile } from '../../../src/profiles/codex.js';
4 |
5 | describe('Codex Profile Initialization Functionality', () => {
6 | let codexProfileContent;
7 |
8 | beforeAll(() => {
9 | const codexJsPath = path.join(process.cwd(), 'src', 'profiles', 'codex.js');
10 | codexProfileContent = fs.readFileSync(codexJsPath, 'utf8');
11 | });
12 |
13 | test('codex.js has correct asset-only profile configuration', () => {
14 | // Check for explicit, non-default values in the source file
15 | expect(codexProfileContent).toContain("name: 'codex'");
16 | expect(codexProfileContent).toContain("displayName: 'Codex'");
17 | expect(codexProfileContent).toContain("profileDir: '.'"); // non-default
18 | expect(codexProfileContent).toContain("rulesDir: '.'"); // non-default
19 | expect(codexProfileContent).toContain('mcpConfig: false'); // non-default
20 | expect(codexProfileContent).toContain('includeDefaultRules: false'); // non-default
21 | expect(codexProfileContent).toContain("'AGENTS.md': 'AGENTS.md'");
22 |
23 | // Check the final computed properties on the profile object
24 | expect(codexProfile.profileName).toBe('codex');
25 | expect(codexProfile.displayName).toBe('Codex');
26 | expect(codexProfile.profileDir).toBe('.');
27 | expect(codexProfile.rulesDir).toBe('.');
28 | expect(codexProfile.mcpConfig).toBe(false);
29 | expect(codexProfile.mcpConfigName).toBe(null); // computed
30 | expect(codexProfile.includeDefaultRules).toBe(false);
31 | expect(codexProfile.fileMap['AGENTS.md']).toBe('AGENTS.md');
32 | });
33 |
34 | test('codex.js has no lifecycle functions', () => {
35 | // Codex has been simplified - no lifecycle functions
36 | expect(codexProfileContent).not.toContain('function onAddRulesProfile');
37 | expect(codexProfileContent).not.toContain('function onRemoveRulesProfile');
38 | expect(codexProfileContent).not.toContain(
39 | 'function onPostConvertRulesProfile'
40 | );
41 | expect(codexProfileContent).not.toContain('log(');
42 | });
43 |
44 | test('codex.js has minimal implementation', () => {
45 | // Should just use createProfile factory
46 | expect(codexProfileContent).toContain('createProfile({');
47 | expect(codexProfileContent).toContain("name: 'codex'");
48 | expect(codexProfileContent).toContain("'AGENTS.md': 'AGENTS.md'");
49 | });
50 | });
51 |
```
--------------------------------------------------------------------------------
/tests/unit/ai-providers/zai-coding.test.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * Tests for ZAICodingProvider
3 | */
4 |
5 | import { ZAICodingProvider } from '../../../src/ai-providers/zai-coding.js';
6 |
7 | describe('ZAICodingProvider', () => {
8 | let provider;
9 |
10 | beforeEach(() => {
11 | provider = new ZAICodingProvider();
12 | });
13 |
14 | describe('constructor', () => {
15 | it('should initialize with correct name', () => {
16 | expect(provider.name).toBe('Z.ai (Coding Plan)');
17 | });
18 |
19 | it('should initialize with correct coding endpoint baseURL', () => {
20 | expect(provider.defaultBaseURL).toBe(
21 | 'https://api.z.ai/api/coding/paas/v4/'
22 | );
23 | });
24 |
25 | it('should inherit from OpenAICompatibleProvider', () => {
26 | expect(provider).toHaveProperty('generateText');
27 | expect(provider).toHaveProperty('streamText');
28 | expect(provider).toHaveProperty('generateObject');
29 | });
30 | });
31 |
32 | describe('getRequiredApiKeyName', () => {
33 | it('should return ZAI_API_KEY environment variable name', () => {
34 | expect(provider.getRequiredApiKeyName()).toBe('ZAI_API_KEY');
35 | });
36 | });
37 |
38 | describe('isRequiredApiKey', () => {
39 | it('should return true as API key is required', () => {
40 | expect(provider.isRequiredApiKey()).toBe(true);
41 | });
42 | });
43 |
44 | describe('getClient', () => {
45 | it('should create client with API key', () => {
46 | const params = { apiKey: 'test-key' };
47 | const client = provider.getClient(params);
48 | expect(client).toBeDefined();
49 | });
50 |
51 | it('should use coding endpoint by default', () => {
52 | const params = {
53 | apiKey: 'test-key'
54 | };
55 | const client = provider.getClient(params);
56 | expect(client).toBeDefined();
57 | // The provider should use the coding endpoint
58 | });
59 |
60 | it('should create client even without API key (validation deferred to SDK)', () => {
61 | // getClient() no longer validates API key - validation is deferred to SDK initialization
62 | const client = provider.getClient({});
63 | expect(typeof client).toBe('function');
64 | });
65 | });
66 |
67 | describe('validateAuth', () => {
68 | it('should validate API key is present', () => {
69 | expect(() => {
70 | provider.validateAuth({});
71 | }).toThrow('Z.ai (Coding Plan) API key is required');
72 | });
73 |
74 | it('should pass with valid API key', () => {
75 | expect(() => {
76 | provider.validateAuth({ apiKey: 'test-key' });
77 | }).not.toThrow();
78 | });
79 | });
80 | });
81 |
```
--------------------------------------------------------------------------------
/packages/tm-core/src/modules/workflow/workflow-domain.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Workflow Domain Facade
3 | * Public API for TDD workflow operations
4 | */
5 |
6 | import type { ConfigManager } from '../config/managers/config-manager.js';
7 | import { WorkflowService } from './services/workflow.service.js';
8 | import type {
9 | NextAction,
10 | StartWorkflowOptions,
11 | WorkflowStatus
12 | } from './services/workflow.service.js';
13 | import type { TestResult, WorkflowContext } from './types.js';
14 |
15 | /**
16 | * Workflow Domain - Unified API for TDD workflow operations
17 | */
18 | export class WorkflowDomain {
19 | private workflowService: WorkflowService;
20 |
21 | constructor(configManager: ConfigManager) {
22 | this.workflowService = new WorkflowService(configManager.getProjectRoot());
23 | }
24 |
25 | // ========== Workflow Lifecycle ==========
26 |
27 | /**
28 | * Start a new TDD workflow for a task
29 | */
30 | async start(options: StartWorkflowOptions): Promise<WorkflowStatus> {
31 | return this.workflowService.startWorkflow(options);
32 | }
33 |
34 | /**
35 | * Resume an existing workflow
36 | */
37 | async resume(): Promise<WorkflowStatus> {
38 | return this.workflowService.resumeWorkflow();
39 | }
40 |
41 | /**
42 | * Get current workflow status
43 | */
44 | getStatus(): WorkflowStatus {
45 | return this.workflowService.getStatus();
46 | }
47 |
48 | /**
49 | * Get workflow context
50 | */
51 | getContext(): WorkflowContext {
52 | return this.workflowService.getContext();
53 | }
54 |
55 | /**
56 | * Get next action to perform in workflow
57 | */
58 | getNextAction(): NextAction {
59 | return this.workflowService.getNextAction();
60 | }
61 |
62 | /**
63 | * Complete current phase with test results
64 | */
65 | async completePhase(testResults: TestResult): Promise<WorkflowStatus> {
66 | return this.workflowService.completePhase(testResults);
67 | }
68 |
69 | /**
70 | * Commit changes with auto-generated message
71 | */
72 | async commit(): Promise<WorkflowStatus> {
73 | return this.workflowService.commit();
74 | }
75 |
76 | /**
77 | * Finalize and complete the workflow
78 | */
79 | async finalize(): Promise<WorkflowStatus> {
80 | return this.workflowService.finalizeWorkflow();
81 | }
82 |
83 | /**
84 | * Abort the current workflow
85 | */
86 | async abort(): Promise<void> {
87 | return this.workflowService.abortWorkflow();
88 | }
89 |
90 | // ========== Workflow Information ==========
91 |
92 | /**
93 | * Check if a workflow currently exists
94 | */
95 | async hasWorkflow(): Promise<boolean> {
96 | return this.workflowService.hasWorkflow();
97 | }
98 | }
99 |
```
--------------------------------------------------------------------------------
/tests/unit/profiles/subdirectory-support.test.js:
--------------------------------------------------------------------------------
```javascript
1 | // Test for supportsRulesSubdirectories feature
2 | import { getRulesProfile } from '../../../src/utils/rule-transformer.js';
3 |
4 | describe('Rules Subdirectory Support Feature', () => {
5 | it('should support taskmaster subdirectories only for Cursor profile', () => {
6 | // Test Cursor profile - should use subdirectories
7 | const cursorProfile = getRulesProfile('cursor');
8 | expect(cursorProfile.supportsRulesSubdirectories).toBe(true);
9 |
10 | // Verify that Cursor uses taskmaster subdirectories in its file mapping
11 | expect(cursorProfile.fileMap['rules/dev_workflow.mdc']).toBe(
12 | 'taskmaster/dev_workflow.mdc'
13 | );
14 | expect(cursorProfile.fileMap['rules/taskmaster.mdc']).toBe(
15 | 'taskmaster/taskmaster.mdc'
16 | );
17 | });
18 |
19 | it('should not use taskmaster subdirectories for other profiles', () => {
20 | // Test profiles that should NOT use subdirectories (new default)
21 | const profiles = ['roo', 'vscode', 'cline', 'windsurf', 'trae'];
22 |
23 | profiles.forEach((profileName) => {
24 | const profile = getRulesProfile(profileName);
25 | expect(profile.supportsRulesSubdirectories).toBe(false);
26 |
27 | // Verify that these profiles do NOT use taskmaster subdirectories in their file mapping
28 | const expectedExt = profile.targetExtension || '.md';
29 | expect(profile.fileMap['rules/dev_workflow.mdc']).toBe(
30 | `dev_workflow${expectedExt}`
31 | );
32 | expect(profile.fileMap['rules/taskmaster.mdc']).toBe(
33 | `taskmaster${expectedExt}`
34 | );
35 | });
36 | });
37 |
38 | it('should have supportsRulesSubdirectories property accessible on all profiles', () => {
39 | const allProfiles = [
40 | 'cursor',
41 | 'roo',
42 | 'vscode',
43 | 'cline',
44 | 'windsurf',
45 | 'trae'
46 | ];
47 |
48 | allProfiles.forEach((profileName) => {
49 | const profile = getRulesProfile(profileName);
50 | expect(profile).toBeDefined();
51 | expect(typeof profile.supportsRulesSubdirectories).toBe('boolean');
52 | });
53 | });
54 |
55 | it('should default to false for supportsRulesSubdirectories when not specified', () => {
56 | // Most profiles should now default to NOT supporting subdirectories
57 | const profiles = ['roo', 'windsurf', 'trae', 'vscode', 'cline'];
58 |
59 | profiles.forEach((profileName) => {
60 | const profile = getRulesProfile(profileName);
61 | expect(profile.supportsRulesSubdirectories).toBe(false);
62 | });
63 | });
64 | });
65 |
```
--------------------------------------------------------------------------------
/mcp-server/src/core/direct-functions/fix-dependencies.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * Direct function wrapper for fixDependenciesCommand
3 | */
4 |
5 | import { fixDependenciesCommand } from '../../../../scripts/modules/dependency-manager.js';
6 | import {
7 | enableSilentMode,
8 | disableSilentMode
9 | } from '../../../../scripts/modules/utils.js';
10 | import fs from 'fs';
11 |
12 | /**
13 | * Fix invalid dependencies in tasks.json automatically
14 | * @param {Object} args - Function arguments
15 | * @param {string} args.tasksJsonPath - Explicit path to the tasks.json file.
16 | * @param {string} args.projectRoot - Project root directory
17 | * @param {string} args.tag - Tag for the project
18 | * @param {Object} log - Logger object
19 | * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
20 | */
21 | export async function fixDependenciesDirect(args, log) {
22 | // Destructure expected args
23 | const { tasksJsonPath, projectRoot, tag } = args;
24 | try {
25 | log.info(`Fixing invalid dependencies in tasks: ${tasksJsonPath}`);
26 |
27 | // Check if tasksJsonPath was provided
28 | if (!tasksJsonPath) {
29 | log.error('fixDependenciesDirect called without tasksJsonPath');
30 | return {
31 | success: false,
32 | error: {
33 | code: 'MISSING_ARGUMENT',
34 | message: 'tasksJsonPath is required'
35 | }
36 | };
37 | }
38 |
39 | // Use provided path
40 | const tasksPath = tasksJsonPath;
41 |
42 | // Verify the file exists
43 | if (!fs.existsSync(tasksPath)) {
44 | return {
45 | success: false,
46 | error: {
47 | code: 'FILE_NOT_FOUND',
48 | message: `Tasks file not found at ${tasksPath}`
49 | }
50 | };
51 | }
52 |
53 | // Enable silent mode to prevent console logs from interfering with JSON response
54 | enableSilentMode();
55 |
56 | const options = { projectRoot, tag };
57 | // Call the original command function using the provided path and proper context
58 | await fixDependenciesCommand(tasksPath, options);
59 |
60 | // Restore normal logging
61 | disableSilentMode();
62 |
63 | return {
64 | success: true,
65 | data: {
66 | message: 'Dependencies fixed successfully',
67 | tasksPath,
68 | tag: tag || 'master'
69 | }
70 | };
71 | } catch (error) {
72 | // Make sure to restore normal logging even if there's an error
73 | disableSilentMode();
74 |
75 | log.error(`Error fixing dependencies: ${error.message}`);
76 | return {
77 | success: false,
78 | error: {
79 | code: 'FIX_DEPENDENCIES_ERROR',
80 | message: error.message
81 | }
82 | };
83 | }
84 | }
85 |
```
--------------------------------------------------------------------------------
/apps/extension/src/components/ui/breadcrumb.tsx:
--------------------------------------------------------------------------------
```typescript
1 | import { Slot } from '@radix-ui/react-slot';
2 | import { ChevronRight, MoreHorizontal } from 'lucide-react';
3 | import type * as React from 'react';
4 |
5 | import { cn } from '@/lib/utils';
6 |
7 | function Breadcrumb({ ...props }: React.ComponentProps<'nav'>) {
8 | return <nav aria-label="breadcrumb" data-slot="breadcrumb" {...props} />;
9 | }
10 |
11 | function BreadcrumbList({ className, ...props }: React.ComponentProps<'ol'>) {
12 | return (
13 | <ol
14 | data-slot="breadcrumb-list"
15 | className={cn(
16 | 'text-muted-foreground flex flex-wrap items-center gap-1.5 text-sm break-words sm:gap-2.5',
17 | className
18 | )}
19 | {...props}
20 | />
21 | );
22 | }
23 |
24 | function BreadcrumbItem({ className, ...props }: React.ComponentProps<'li'>) {
25 | return (
26 | <li
27 | data-slot="breadcrumb-item"
28 | className={cn('inline-flex items-center gap-1.5', className)}
29 | {...props}
30 | />
31 | );
32 | }
33 |
34 | function BreadcrumbLink({
35 | asChild,
36 | className,
37 | ...props
38 | }: React.ComponentProps<'a'> & {
39 | asChild?: boolean;
40 | }) {
41 | const Comp = asChild ? Slot : 'a';
42 |
43 | return (
44 | <Comp
45 | data-slot="breadcrumb-link"
46 | className={cn('hover:text-foreground transition-colors', className)}
47 | {...props}
48 | />
49 | );
50 | }
51 |
52 | function BreadcrumbPage({ className, ...props }: React.ComponentProps<'span'>) {
53 | return (
54 | <span
55 | data-slot="breadcrumb-page"
56 | role="link"
57 | aria-disabled="true"
58 | aria-current="page"
59 | className={cn('text-foreground font-normal', className)}
60 | {...props}
61 | />
62 | );
63 | }
64 |
65 | function BreadcrumbSeparator({
66 | children,
67 | className,
68 | ...props
69 | }: React.ComponentProps<'li'>) {
70 | return (
71 | <li
72 | data-slot="breadcrumb-separator"
73 | role="presentation"
74 | aria-hidden="true"
75 | className={cn('[&>svg]:size-3.5', className)}
76 | {...props}
77 | >
78 | {children ?? <ChevronRight />}
79 | </li>
80 | );
81 | }
82 |
83 | function BreadcrumbEllipsis({
84 | className,
85 | ...props
86 | }: React.ComponentProps<'span'>) {
87 | return (
88 | <span
89 | data-slot="breadcrumb-ellipsis"
90 | role="presentation"
91 | aria-hidden="true"
92 | className={cn('flex size-9 items-center justify-center', className)}
93 | {...props}
94 | >
95 | <MoreHorizontal className="size-4" />
96 | <span className="sr-only">More</span>
97 | </span>
98 | );
99 | }
100 |
101 | export {
102 | Breadcrumb,
103 | BreadcrumbList,
104 | BreadcrumbItem,
105 | BreadcrumbLink,
106 | BreadcrumbPage,
107 | BreadcrumbSeparator,
108 | BreadcrumbEllipsis
109 | };
110 |
```
--------------------------------------------------------------------------------
/scripts/modules/task-manager.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * task-manager.js
3 | * Task management functions for the Task Master CLI
4 | */
5 |
6 | import { findTaskById } from './utils.js';
7 | import parsePRD from './task-manager/parse-prd/index.js';
8 | import updateTasks from './task-manager/update-tasks.js';
9 | import updateTaskById from './task-manager/update-task-by-id.js';
10 | import generateTaskFiles from './task-manager/generate-task-files.js';
11 | import setTaskStatus from './task-manager/set-task-status.js';
12 | import updateSingleTaskStatus from './task-manager/update-single-task-status.js';
13 | import listTasks from './task-manager/list-tasks.js';
14 | import expandTask from './task-manager/expand-task.js';
15 | import expandAllTasks from './task-manager/expand-all-tasks.js';
16 | import clearSubtasks from './task-manager/clear-subtasks.js';
17 | import addTask from './task-manager/add-task.js';
18 | import analyzeTaskComplexity from './task-manager/analyze-task-complexity.js';
19 | import findNextTask from './task-manager/find-next-task.js';
20 | import addSubtask from './task-manager/add-subtask.js';
21 | import removeSubtask from './task-manager/remove-subtask.js';
22 | import updateSubtaskById from './task-manager/update-subtask-by-id.js';
23 | import removeTask from './task-manager/remove-task.js';
24 | import taskExists from './task-manager/task-exists.js';
25 | import isTaskDependentOn from './task-manager/is-task-dependent.js';
26 | import setResponseLanguage from './task-manager/response-language.js';
27 | import moveTask from './task-manager/move-task.js';
28 | import { migrateProject } from './task-manager/migrate.js';
29 | import { performResearch } from './task-manager/research.js';
30 | import { readComplexityReport } from './utils.js';
31 | import {
32 | scopeUpTask,
33 | scopeDownTask,
34 | validateStrength
35 | } from './task-manager/scope-adjustment.js';
36 |
37 | // Export task manager functions
38 | export {
39 | parsePRD,
40 | updateTasks,
41 | updateTaskById,
42 | updateSubtaskById,
43 | generateTaskFiles,
44 | setTaskStatus,
45 | updateSingleTaskStatus,
46 | listTasks,
47 | expandTask,
48 | expandAllTasks,
49 | clearSubtasks,
50 | addTask,
51 | addSubtask,
52 | removeSubtask,
53 | findNextTask,
54 | analyzeTaskComplexity,
55 | removeTask,
56 | findTaskById,
57 | taskExists,
58 | isTaskDependentOn,
59 | setResponseLanguage,
60 | moveTask,
61 | readComplexityReport,
62 | migrateProject,
63 | performResearch,
64 | scopeUpTask,
65 | scopeDownTask,
66 | validateStrength
67 | };
68 |
```
--------------------------------------------------------------------------------
/mcp-server/src/tools/copy-tag.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * tools/copy-tag.js
3 | * Tool to copy an existing tag to a new tag
4 | */
5 |
6 | import { z } from 'zod';
7 | import {
8 | createErrorResponse,
9 | handleApiResult,
10 | withNormalizedProjectRoot
11 | } from './utils.js';
12 | import { copyTagDirect } from '../core/task-master-core.js';
13 | import { findTasksPath } from '../core/utils/path-utils.js';
14 |
15 | /**
16 | * Register the copyTag tool with the MCP server
17 | * @param {Object} server - FastMCP server instance
18 | */
19 | export function registerCopyTagTool(server) {
20 | server.addTool({
21 | name: 'copy_tag',
22 | description:
23 | 'Copy an existing tag to create a new tag with all tasks and metadata',
24 | parameters: z.object({
25 | sourceName: z.string().describe('Name of the source tag to copy from'),
26 | targetName: z.string().describe('Name of the new tag to create'),
27 | description: z
28 | .string()
29 | .optional()
30 | .describe('Optional description for the new tag'),
31 | file: z
32 | .string()
33 | .optional()
34 | .describe('Path to the tasks file (default: tasks/tasks.json)'),
35 | projectRoot: z
36 | .string()
37 | .describe('The directory of the project. Must be an absolute path.')
38 | }),
39 | execute: withNormalizedProjectRoot(async (args, { log, session }) => {
40 | try {
41 | log.info(`Starting copy-tag with args: ${JSON.stringify(args)}`);
42 |
43 | // Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
44 | let tasksJsonPath;
45 | try {
46 | tasksJsonPath = findTasksPath(
47 | { projectRoot: args.projectRoot, file: args.file },
48 | log
49 | );
50 | } catch (error) {
51 | log.error(`Error finding tasks.json: ${error.message}`);
52 | return createErrorResponse(
53 | `Failed to find tasks.json: ${error.message}`
54 | );
55 | }
56 |
57 | // Call the direct function
58 | const result = await copyTagDirect(
59 | {
60 | tasksJsonPath: tasksJsonPath,
61 | sourceName: args.sourceName,
62 | targetName: args.targetName,
63 | description: args.description,
64 | projectRoot: args.projectRoot
65 | },
66 | log,
67 | { session }
68 | );
69 |
70 | return handleApiResult(
71 | result,
72 | log,
73 | 'Error copying tag',
74 | undefined,
75 | args.projectRoot
76 | );
77 | } catch (error) {
78 | log.error(`Error in copy-tag tool: ${error.message}`);
79 | return createErrorResponse(error.message);
80 | }
81 | })
82 | });
83 | }
84 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/remove-task.md:
--------------------------------------------------------------------------------
```markdown
1 | Remove a task permanently from the project.
2 |
3 | Arguments: $ARGUMENTS (task ID)
4 |
5 | Delete a task and handle all its relationships properly.
6 |
7 | ## Task Removal
8 |
9 | Permanently removes a task while maintaining project integrity.
10 |
11 | ## Argument Parsing
12 |
13 | - "remove task 5"
14 | - "delete 5"
15 | - "5" → remove task 5
16 | - Can include "-y" for auto-confirm
17 |
18 | ## Execution
19 |
20 | ```bash
21 | task-master remove-task --id=<id> [-y]
22 | ```
23 |
24 | ## Pre-Removal Analysis
25 |
26 | 1. **Task Details**
27 | - Current status
28 | - Work completed
29 | - Time invested
30 | - Associated data
31 |
32 | 2. **Relationship Check**
33 | - Tasks that depend on this
34 | - Dependencies this task has
35 | - Subtasks that will be removed
36 | - Blocking implications
37 |
38 | 3. **Impact Assessment**
39 | ```
40 | Task Removal Impact
41 | ━━━━━━━━━━━━━━━━━━
42 | Task: #5 "Implement authentication" (in-progress)
43 | Status: 60% complete (~8 hours work)
44 |
45 | Will affect:
46 | - 3 tasks depend on this (will be blocked)
47 | - Has 4 subtasks (will be deleted)
48 | - Part of critical path
49 |
50 | ⚠️ This action cannot be undone
51 | ```
52 |
53 | ## Smart Warnings
54 |
55 | - Warn if task is in-progress
56 | - Show dependent tasks that will be blocked
57 | - Highlight if part of critical path
58 | - Note any completed work being lost
59 |
60 | ## Removal Process
61 |
62 | 1. Show comprehensive impact
63 | 2. Require confirmation (unless -y)
64 | 3. Update dependent task references
65 | 4. Remove task and subtasks
66 | 5. Clean up orphaned dependencies
67 | 6. Log removal with timestamp
68 |
69 | ## Alternative Actions
70 |
71 | Suggest before deletion:
72 | - Mark as cancelled instead
73 | - Convert to documentation
74 | - Archive task data
75 | - Transfer work to another task
76 |
77 | ## Post-Removal
78 |
79 | - List affected tasks
80 | - Show broken dependencies
81 | - Update project statistics
82 | - Suggest dependency fixes
83 | - Recalculate timeline
84 |
85 | ## Example Flows
86 |
87 | ```
88 | /taskmaster:remove-task 5
89 | → Task #5 is in-progress with 8 hours logged
90 | → 3 other tasks depend on this
91 | → Suggestion: Mark as cancelled instead?
92 | Remove anyway? (y/n)
93 |
94 | /taskmaster:remove-task 5 -y
95 | → Removed: Task #5 and 4 subtasks
96 | → Updated: 3 task dependencies
97 | → Warning: Tasks #7, #8, #9 now have missing dependency
98 | → Run /taskmaster:fix-dependencies to resolve
99 | ```
100 |
101 | ## Safety Features
102 |
103 | - Confirmation required
104 | - Impact preview
105 | - Removal logging
106 | - Suggest alternatives
107 | - No cascade delete of dependents
```
--------------------------------------------------------------------------------
/tests/integration/profiles/windsurf-init-functionality.test.js:
--------------------------------------------------------------------------------
```javascript
1 | import fs from 'fs';
2 | import path from 'path';
3 | import { windsurfProfile } from '../../../src/profiles/windsurf.js';
4 |
5 | describe('Windsurf Profile Initialization Functionality', () => {
6 | let windsurfProfileContent;
7 |
8 | beforeAll(() => {
9 | const windsurfJsPath = path.join(
10 | process.cwd(),
11 | 'src',
12 | 'profiles',
13 | 'windsurf.js'
14 | );
15 | windsurfProfileContent = fs.readFileSync(windsurfJsPath, 'utf8');
16 | });
17 |
18 | test('windsurf.js uses factory pattern with correct configuration', () => {
19 | // Check for explicit, non-default values in the source file
20 | expect(windsurfProfileContent).toContain("name: 'windsurf'");
21 | expect(windsurfProfileContent).toContain("displayName: 'Windsurf'");
22 | expect(windsurfProfileContent).toContain("url: 'windsurf.com'");
23 | expect(windsurfProfileContent).toContain("docsUrl: 'docs.windsurf.com'");
24 |
25 | // Check the final computed properties on the profile object
26 | expect(windsurfProfile.profileName).toBe('windsurf');
27 | expect(windsurfProfile.displayName).toBe('Windsurf');
28 | expect(windsurfProfile.profileDir).toBe('.windsurf'); // default
29 | expect(windsurfProfile.rulesDir).toBe('.windsurf/rules'); // default
30 | expect(windsurfProfile.mcpConfig).toBe(true); // default
31 | expect(windsurfProfile.mcpConfigName).toBe('mcp.json'); // default
32 | });
33 |
34 | test('windsurf.js configures .mdc to .md extension mapping', () => {
35 | // Check that the profile object has the correct file mapping behavior (windsurf converts to .md)
36 | expect(windsurfProfile.fileMap['rules/cursor_rules.mdc']).toBe(
37 | 'windsurf_rules.md'
38 | );
39 | });
40 |
41 | test('windsurf.js uses standard tool mappings', () => {
42 | // Check that the profile uses default tool mappings (equivalent to COMMON_TOOL_MAPPINGS.STANDARD)
43 | // This verifies the architectural pattern: no custom toolMappings = standard tool names
44 | expect(windsurfProfileContent).not.toContain('toolMappings:');
45 | expect(windsurfProfileContent).not.toContain('apply_diff');
46 | expect(windsurfProfileContent).not.toContain('search_files');
47 |
48 | // Verify the result: default mappings means tools keep their original names
49 | expect(windsurfProfile.conversionConfig.toolNames.edit_file).toBe(
50 | 'edit_file'
51 | );
52 | expect(windsurfProfile.conversionConfig.toolNames.search).toBe('search');
53 | });
54 | });
55 |
```
--------------------------------------------------------------------------------
/apps/cli/src/ui/components/header.component.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Task Master header component
3 | * Displays the banner, version, project info, and file path
4 | */
5 |
6 | import chalk from 'chalk';
7 |
8 | /**
9 | * Brief information for API storage
10 | */
11 | export interface BriefInfo {
12 | briefId: string;
13 | briefName: string;
14 | orgSlug?: string;
15 | webAppUrl?: string;
16 | }
17 |
18 | /**
19 | * Header configuration options
20 | */
21 | export interface HeaderOptions {
22 | title?: string;
23 | tag?: string;
24 | filePath?: string;
25 | storageType?: 'api' | 'file';
26 | briefInfo?: BriefInfo;
27 | }
28 |
29 | /**
30 | * Display the Task Master header with project info
31 | */
32 | export function displayHeader(options: HeaderOptions = {}): void {
33 | const { filePath, tag, storageType, briefInfo } = options;
34 |
35 | // Display different header based on storage type
36 | if (storageType === 'api' && briefInfo) {
37 | // API storage: Show brief information
38 | const briefDisplay = `🏷 Brief: ${chalk.cyan(briefInfo.briefName)} ${chalk.gray(`(${briefInfo.briefId})`)}`;
39 | console.log(briefDisplay);
40 |
41 | // Construct and display the brief URL or ID
42 | if (briefInfo.webAppUrl && briefInfo.orgSlug) {
43 | const briefUrl = `${briefInfo.webAppUrl}/home/${briefInfo.orgSlug}/briefs/${briefInfo.briefId}/plan`;
44 | console.log(`Listing tasks from: ${chalk.dim(briefUrl)}`);
45 | } else if (briefInfo.webAppUrl) {
46 | // Show web app URL and brief ID if org slug is missing
47 | console.log(
48 | `Listing tasks from: ${chalk.dim(`${briefInfo.webAppUrl} (Brief: ${briefInfo.briefId})`)}`
49 | );
50 | console.log(
51 | chalk.yellow(
52 | `💡 Tip: Run ${chalk.cyan('tm context select')} to set your organization and see the full URL`
53 | )
54 | );
55 | } else {
56 | // Fallback: just show the brief ID if we can't get web app URL
57 | console.log(
58 | `Listing tasks from: ${chalk.dim(`API (Brief ID: ${briefInfo.briefId})`)}`
59 | );
60 | }
61 | } else if (tag) {
62 | // File storage: Show tag information
63 | let tagInfo = '';
64 |
65 | if (tag && tag !== 'master') {
66 | tagInfo = `🏷 tag: ${chalk.cyan(tag)}`;
67 | } else {
68 | tagInfo = `🏷 tag: ${chalk.cyan('master')}`;
69 | }
70 |
71 | console.log(tagInfo);
72 |
73 | if (filePath) {
74 | // Convert to absolute path if it's relative
75 | const absolutePath = filePath.startsWith('/')
76 | ? filePath
77 | : `${process.cwd()}/${filePath}`;
78 | console.log(`Listing tasks from: ${chalk.dim(absolutePath)}`);
79 | }
80 | }
81 | }
82 |
```
--------------------------------------------------------------------------------
/packages/tm-core/tests/unit/executor.test.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Tests for executor functionality
3 | */
4 |
5 | import { beforeEach, describe, expect, it, vi } from 'vitest';
6 | import {
7 | ClaudeExecutor,
8 | ExecutorFactory,
9 | type ExecutorOptions
10 | } from '../../src/executors/index.js';
11 |
12 | describe('ExecutorFactory', () => {
13 | const mockProjectRoot = '/test/project';
14 |
15 | it('should create a Claude executor', () => {
16 | const options: ExecutorOptions = {
17 | type: 'claude',
18 | projectRoot: mockProjectRoot
19 | };
20 |
21 | const executor = ExecutorFactory.create(options);
22 | expect(executor).toBeInstanceOf(ClaudeExecutor);
23 | });
24 |
25 | it('should throw error for unimplemented executor types', () => {
26 | const options: ExecutorOptions = {
27 | type: 'shell',
28 | projectRoot: mockProjectRoot
29 | };
30 |
31 | expect(() => ExecutorFactory.create(options)).toThrow(
32 | 'Shell executor not yet implemented'
33 | );
34 | });
35 |
36 | it('should get available executor types', () => {
37 | const types = ExecutorFactory.getAvailableTypes();
38 | expect(types).toContain('claude');
39 | expect(types).toContain('shell');
40 | expect(types).toContain('custom');
41 | });
42 | });
43 |
44 | describe('ClaudeExecutor', () => {
45 | const mockProjectRoot = '/test/project';
46 | let executor: ClaudeExecutor;
47 |
48 | beforeEach(() => {
49 | executor = new ClaudeExecutor(mockProjectRoot);
50 | });
51 |
52 | it('should return claude as executor type', () => {
53 | expect(executor.getType()).toBe('claude');
54 | });
55 |
56 | it('should format task prompt correctly', () => {
57 | const mockTask = {
58 | id: '1',
59 | title: 'Test Task',
60 | description: 'Test description',
61 | status: 'pending' as const,
62 | priority: 'high' as const,
63 | dependencies: [],
64 | details: 'Implementation details',
65 | testStrategy: 'Unit tests',
66 | subtasks: []
67 | };
68 |
69 | // Access protected method through any type assertion for testing
70 | const formattedPrompt = (executor as any).formatTaskPrompt(mockTask);
71 |
72 | expect(formattedPrompt).toContain('Task ID: 1');
73 | expect(formattedPrompt).toContain('Title: Test Task');
74 | expect(formattedPrompt).toContain('Description:\nTest description');
75 | expect(formattedPrompt).toContain(
76 | 'Implementation Details:\nImplementation details'
77 | );
78 | expect(formattedPrompt).toContain('Test Strategy:\nUnit tests');
79 | expect(formattedPrompt).toContain('Status: pending');
80 | expect(formattedPrompt).toContain('Priority: high');
81 | });
82 | });
83 |
```
--------------------------------------------------------------------------------
/docs/contributor-docs/testing-roo-integration.md:
--------------------------------------------------------------------------------
```markdown
1 | # Testing Roo Integration
2 |
3 | This document provides instructions for testing the Roo integration in the Task Master package.
4 |
5 | ## Running Tests
6 |
7 | To run the tests for the Roo integration:
8 |
9 | ```bash
10 | # Run all tests
11 | npm test
12 |
13 | # Run only Roo integration tests
14 | npm test -- -t "Roo"
15 |
16 | # Run specific test file
17 | npm test -- tests/integration/roo-files-inclusion.test.js
18 | ```
19 |
20 | ## Manual Testing
21 |
22 | To manually verify that the Roo files are properly included in the package:
23 |
24 | 1. Create a test directory:
25 |
26 | ```bash
27 | mkdir test-tm
28 | cd test-tm
29 | ```
30 |
31 | 2. Create a package.json file:
32 |
33 | ```bash
34 | npm init -y
35 | ```
36 |
37 | 3. Install the task-master-ai package locally:
38 |
39 | ```bash
40 | # From the root of the claude-task-master repository
41 | cd ..
42 | npm pack
43 | # This will create a file like task-master-ai-0.12.0.tgz
44 |
45 | # Move back to the test directory
46 | cd test-tm
47 | npm install ../task-master-ai-0.12.0.tgz
48 | ```
49 |
50 | 4. Initialize a new Task Master project:
51 |
52 | ```bash
53 | npx task-master init --yes
54 | ```
55 |
56 | 5. Verify that all Roo files and directories are created:
57 |
58 | ```bash
59 | # Check that .roomodes file exists
60 | ls -la | grep .roomodes
61 |
62 | # Check that .roo directory exists and contains all mode directories
63 | ls -la .roo
64 | ls -la .roo/rules
65 | ls -la .roo/rules-architect
66 | ls -la .roo/rules-ask
67 | ls -la .roo/rules-orchestrator
68 | ls -la .roo/rules-code
69 | ls -la .roo/rules-debug
70 | ls -la .roo/rules-test
71 | ```
72 |
73 | ## What to Look For
74 |
75 | When running the tests or performing manual verification, ensure that:
76 |
77 | 1. The package includes `.roo/**` and `.roomodes` in the `files` array in package.json
78 | 2. The `prepare-package.js` script verifies the existence of all required Roo files
79 | 3. The `init.js` script creates all necessary .roo directories and copies .roomodes file
80 | 4. All source files for Roo integration exist in `assets/roocode/.roo` and `assets/roocode/.roomodes`
81 |
82 | ## Compatibility
83 |
84 | Ensure that the Roo integration works alongside existing Cursor functionality:
85 |
86 | 1. Initialize a new project that uses both Cursor and Roo:
87 |
88 | ```bash
89 | npx task-master init --yes
90 | ```
91 |
92 | 2. Verify that both `.cursor` and `.roo` directories are created
93 | 3. Verify that both `.windsurfrules` and `.roomodes` files are created
94 | 4. Confirm that existing functionality continues to work as expected
95 |
```
--------------------------------------------------------------------------------
/.kiro/steering/self_improve.md:
--------------------------------------------------------------------------------
```markdown
1 | ---
2 | inclusion: always
3 | ---
4 |
5 | - **Rule Improvement Triggers:**
6 | - New code patterns not covered by existing rules
7 | - Repeated similar implementations across files
8 | - Common error patterns that could be prevented
9 | - New libraries or tools being used consistently
10 | - Emerging best practices in the codebase
11 |
12 | - **Analysis Process:**
13 | - Compare new code with existing rules
14 | - Identify patterns that should be standardized
15 | - Look for references to external documentation
16 | - Check for consistent error handling patterns
17 | - Monitor test patterns and coverage
18 |
19 | - **Rule Updates:**
20 | - **Add New Rules When:**
21 | - A new technology/pattern is used in 3+ files
22 | - Common bugs could be prevented by a rule
23 | - Code reviews repeatedly mention the same feedback
24 | - New security or performance patterns emerge
25 |
26 | - **Modify Existing Rules When:**
27 | - Better examples exist in the codebase
28 | - Additional edge cases are discovered
29 | - Related rules have been updated
30 | - Implementation details have changed
31 |
32 | - **Example Pattern Recognition:**
33 | ```typescript
34 | // If you see repeated patterns like:
35 | const data = await prisma.user.findMany({
36 | select: { id: true, email: true },
37 | where: { status: 'ACTIVE' }
38 | });
39 |
40 | // Consider adding to [prisma.md](.kiro/steering/prisma.md):
41 | // - Standard select fields
42 | // - Common where conditions
43 | // - Performance optimization patterns
44 | ```
45 |
46 | - **Rule Quality Checks:**
47 | - Rules should be actionable and specific
48 | - Examples should come from actual code
49 | - References should be up to date
50 | - Patterns should be consistently enforced
51 |
52 | - **Continuous Improvement:**
53 | - Monitor code review comments
54 | - Track common development questions
55 | - Update rules after major refactors
56 | - Add links to relevant documentation
57 | - Cross-reference related rules
58 |
59 | - **Rule Deprecation:**
60 | - Mark outdated patterns as deprecated
61 | - Remove rules that no longer apply
62 | - Update references to deprecated rules
63 | - Document migration paths for old patterns
64 |
65 | - **Documentation Updates:**
66 | - Keep examples synchronized with code
67 | - Update references to external docs
68 | - Maintain links between related rules
69 | - Document breaking changes
70 | Follow [kiro_rules.md](.kiro/steering/kiro_rules.md) for proper rule formatting and structure.
71 |
```
--------------------------------------------------------------------------------
/apps/mcp/src/tools/autopilot/status.tool.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview autopilot-status MCP tool
3 | * Get comprehensive workflow status and progress information
4 | */
5 |
6 | import { z } from 'zod';
7 | import {
8 | handleApiResult,
9 | withNormalizedProjectRoot
10 | } from '../../shared/utils.js';
11 | import type { MCPContext } from '../../shared/types.js';
12 | import { WorkflowService } from '@tm/core';
13 | import type { FastMCP } from 'fastmcp';
14 |
15 | const StatusSchema = z.object({
16 | projectRoot: z
17 | .string()
18 | .describe('Absolute path to the project root directory')
19 | });
20 |
21 | type StatusArgs = z.infer<typeof StatusSchema>;
22 |
23 | /**
24 | * Register the autopilot_status tool with the MCP server
25 | */
26 | export function registerAutopilotStatusTool(server: FastMCP) {
27 | server.addTool({
28 | name: 'autopilot_status',
29 | description:
30 | 'Get comprehensive workflow status including current phase, progress, subtask details, and activity history.',
31 | parameters: StatusSchema,
32 | execute: withNormalizedProjectRoot(
33 | async (args: StatusArgs, context: MCPContext) => {
34 | const { projectRoot } = args;
35 |
36 | try {
37 | context.log.info(`Getting workflow status for ${projectRoot}`);
38 |
39 | const workflowService = new WorkflowService(projectRoot);
40 |
41 | // Check if workflow exists
42 | if (!(await workflowService.hasWorkflow())) {
43 | return handleApiResult({
44 | result: {
45 | success: false,
46 | error: {
47 | message:
48 | 'No active workflow found. Start a workflow with autopilot_start'
49 | }
50 | },
51 | log: context.log,
52 | projectRoot
53 | });
54 | }
55 |
56 | // Resume to load state
57 | await workflowService.resumeWorkflow();
58 |
59 | // Get status
60 | const status = workflowService.getStatus();
61 |
62 | context.log.info(
63 | `Workflow status retrieved for task ${status.taskId}`
64 | );
65 |
66 | return handleApiResult({
67 | result: {
68 | success: true,
69 | data: status
70 | },
71 | log: context.log,
72 | projectRoot
73 | });
74 | } catch (error: any) {
75 | context.log.error(`Error in autopilot-status: ${error.message}`);
76 | if (error.stack) {
77 | context.log.debug(error.stack);
78 | }
79 | return handleApiResult({
80 | result: {
81 | success: false,
82 | error: {
83 | message: `Failed to get workflow status: ${error.message}`
84 | }
85 | },
86 | log: context.log,
87 | projectRoot
88 | });
89 | }
90 | }
91 | )
92 | });
93 | }
94 |
```
--------------------------------------------------------------------------------
/mcp-server/src/tools/fix-dependencies.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * tools/fix-dependencies.js
3 | * Tool for automatically fixing invalid task dependencies
4 | */
5 |
6 | import { z } from 'zod';
7 | import {
8 | handleApiResult,
9 | createErrorResponse,
10 | withNormalizedProjectRoot
11 | } from './utils.js';
12 | import { fixDependenciesDirect } from '../core/task-master-core.js';
13 | import { findTasksPath } from '../core/utils/path-utils.js';
14 | import { resolveTag } from '../../../scripts/modules/utils.js';
15 | /**
16 | * Register the fixDependencies tool with the MCP server
17 | * @param {Object} server - FastMCP server instance
18 | */
19 | export function registerFixDependenciesTool(server) {
20 | server.addTool({
21 | name: 'fix_dependencies',
22 | description: 'Fix invalid dependencies in tasks automatically',
23 | parameters: z.object({
24 | file: z.string().optional().describe('Absolute path to the tasks file'),
25 | projectRoot: z
26 | .string()
27 | .describe('The directory of the project. Must be an absolute path.'),
28 | tag: z.string().optional().describe('Tag context to operate on')
29 | }),
30 | execute: withNormalizedProjectRoot(async (args, { log, session }) => {
31 | try {
32 | log.info(`Fixing dependencies with args: ${JSON.stringify(args)}`);
33 |
34 | const resolvedTag = resolveTag({
35 | projectRoot: args.projectRoot,
36 | tag: args.tag
37 | });
38 |
39 | // Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
40 | let tasksJsonPath;
41 | try {
42 | tasksJsonPath = findTasksPath(
43 | { projectRoot: args.projectRoot, file: args.file },
44 | log
45 | );
46 | } catch (error) {
47 | log.error(`Error finding tasks.json: ${error.message}`);
48 | return createErrorResponse(
49 | `Failed to find tasks.json: ${error.message}`
50 | );
51 | }
52 |
53 | const result = await fixDependenciesDirect(
54 | {
55 | tasksJsonPath: tasksJsonPath,
56 | projectRoot: args.projectRoot,
57 | tag: resolvedTag
58 | },
59 | log
60 | );
61 |
62 | if (result.success) {
63 | log.info(`Successfully fixed dependencies: ${result.data.message}`);
64 | } else {
65 | log.error(`Failed to fix dependencies: ${result.error.message}`);
66 | }
67 |
68 | return handleApiResult(
69 | result,
70 | log,
71 | 'Error fixing dependencies',
72 | undefined,
73 | args.projectRoot
74 | );
75 | } catch (error) {
76 | log.error(`Error in fixDependencies tool: ${error.message}`);
77 | return createErrorResponse(error.message);
78 | }
79 | })
80 | });
81 | }
82 |
```
--------------------------------------------------------------------------------
/packages/tm-core/src/modules/config/config-domain.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Config Domain Facade
3 | * Public API for configuration management
4 | */
5 |
6 | import type {
7 | PartialConfiguration,
8 | RuntimeStorageConfig
9 | } from '../../common/interfaces/configuration.interface.js';
10 | import type { ConfigManager } from './managers/config-manager.js';
11 |
12 | /**
13 | * Config Domain - Unified API for configuration operations
14 | */
15 | export class ConfigDomain {
16 | constructor(private configManager: ConfigManager) {}
17 |
18 | // ========== Configuration Access ==========
19 |
20 | /**
21 | * Get the full configuration
22 | */
23 | getConfig(): PartialConfiguration {
24 | return this.configManager.getConfig();
25 | }
26 |
27 | /**
28 | * Get storage configuration
29 | */
30 | getStorageConfig(): RuntimeStorageConfig {
31 | return this.configManager.getStorageConfig();
32 | }
33 |
34 | /**
35 | * Get model configuration
36 | */
37 | getModelConfig() {
38 | return this.configManager.getModelConfig();
39 | }
40 |
41 | /**
42 | * Get response language
43 | */
44 | getResponseLanguage(): string {
45 | return this.configManager.getResponseLanguage();
46 | }
47 |
48 | /**
49 | * Get project root path
50 | */
51 | getProjectRoot(): string {
52 | return this.configManager.getProjectRoot();
53 | }
54 |
55 | /**
56 | * Check if API is explicitly configured
57 | */
58 | isApiExplicitlyConfigured(): boolean {
59 | return this.configManager.isApiExplicitlyConfigured();
60 | }
61 |
62 | // ========== Runtime State ==========
63 |
64 | /**
65 | * Get the currently active tag
66 | */
67 | getActiveTag(): string {
68 | return this.configManager.getActiveTag();
69 | }
70 |
71 | /**
72 | * Set the active tag
73 | */
74 | async setActiveTag(tag: string): Promise<void> {
75 | return this.configManager.setActiveTag(tag);
76 | }
77 |
78 | // ========== Configuration Updates ==========
79 |
80 | /**
81 | * Update configuration
82 | */
83 | async updateConfig(updates: PartialConfiguration): Promise<void> {
84 | return this.configManager.updateConfig(updates);
85 | }
86 |
87 | /**
88 | * Set response language
89 | */
90 | async setResponseLanguage(language: string): Promise<void> {
91 | return this.configManager.setResponseLanguage(language);
92 | }
93 |
94 | /**
95 | * Save current configuration
96 | */
97 | async saveConfig(): Promise<void> {
98 | return this.configManager.saveConfig();
99 | }
100 |
101 | /**
102 | * Reset configuration to defaults
103 | */
104 | async reset(): Promise<void> {
105 | return this.configManager.reset();
106 | }
107 |
108 | // ========== Utilities ==========
109 |
110 | /**
111 | * Get configuration sources for debugging
112 | */
113 | getConfigSources() {
114 | return this.configManager.getConfigSources();
115 | }
116 | }
117 |
```
--------------------------------------------------------------------------------
/tests/unit/profiles/rule-transformer-opencode.test.js:
--------------------------------------------------------------------------------
```javascript
1 | import { jest } from '@jest/globals';
2 | import { getRulesProfile } from '../../../src/utils/rule-transformer.js';
3 | import { opencodeProfile } from '../../../src/profiles/opencode.js';
4 |
5 | describe('Rule Transformer - OpenCode Profile', () => {
6 | test('should have correct profile configuration', () => {
7 | const opencodeProfile = getRulesProfile('opencode');
8 |
9 | expect(opencodeProfile).toBeDefined();
10 | expect(opencodeProfile.profileName).toBe('opencode');
11 | expect(opencodeProfile.displayName).toBe('OpenCode');
12 | expect(opencodeProfile.profileDir).toBe('.');
13 | expect(opencodeProfile.rulesDir).toBe('.');
14 | expect(opencodeProfile.mcpConfig).toBe(true);
15 | expect(opencodeProfile.mcpConfigName).toBe('opencode.json');
16 | expect(opencodeProfile.mcpConfigPath).toBe('opencode.json');
17 | expect(opencodeProfile.includeDefaultRules).toBe(false);
18 | expect(opencodeProfile.fileMap).toEqual({
19 | 'AGENTS.md': 'AGENTS.md'
20 | });
21 | });
22 |
23 | test('should have lifecycle functions for MCP config transformation', () => {
24 | // Verify that opencode.js has lifecycle functions
25 | expect(opencodeProfile.onPostConvertRulesProfile).toBeDefined();
26 | expect(typeof opencodeProfile.onPostConvertRulesProfile).toBe('function');
27 | expect(opencodeProfile.onRemoveRulesProfile).toBeDefined();
28 | expect(typeof opencodeProfile.onRemoveRulesProfile).toBe('function');
29 | });
30 |
31 | test('should use opencode.json instead of mcp.json', () => {
32 | const opencodeProfile = getRulesProfile('opencode');
33 | expect(opencodeProfile.mcpConfigName).toBe('opencode.json');
34 | expect(opencodeProfile.mcpConfigPath).toBe('opencode.json');
35 | });
36 |
37 | test('should not include default rules', () => {
38 | const opencodeProfile = getRulesProfile('opencode');
39 | expect(opencodeProfile.includeDefaultRules).toBe(false);
40 | });
41 |
42 | test('should have correct file mapping', () => {
43 | const opencodeProfile = getRulesProfile('opencode');
44 | expect(opencodeProfile.fileMap).toEqual({
45 | 'AGENTS.md': 'AGENTS.md'
46 | });
47 | });
48 |
49 | test('should use root directory for both profile and rules', () => {
50 | const opencodeProfile = getRulesProfile('opencode');
51 | expect(opencodeProfile.profileDir).toBe('.');
52 | expect(opencodeProfile.rulesDir).toBe('.');
53 | });
54 |
55 | test('should have MCP configuration enabled', () => {
56 | const opencodeProfile = getRulesProfile('opencode');
57 | expect(opencodeProfile.mcpConfig).toBe(true);
58 | });
59 | });
60 |
```
--------------------------------------------------------------------------------
/tests/unit/task-manager/tag-management.test.js:
--------------------------------------------------------------------------------
```javascript
1 | import fs from 'fs';
2 | import path from 'path';
3 | import {
4 | createTag,
5 | deleteTag,
6 | renameTag,
7 | copyTag,
8 | tags as listTags
9 | } from '../../../scripts/modules/task-manager/tag-management.js';
10 |
11 | const TEMP_DIR = path.join(process.cwd(), '.tmp_tag_management_tests');
12 | const TASKS_PATH = path.join(TEMP_DIR, 'tasks.json');
13 |
14 | /**
15 | * Helper to write an initial tagged tasks.json structure
16 | */
17 | function writeInitialFile() {
18 | const initialData = {
19 | master: {
20 | tasks: [{ id: 1, title: 'Initial Task', status: 'pending' }],
21 | metadata: {
22 | created: new Date().toISOString(),
23 | description: 'Master tag'
24 | }
25 | }
26 | };
27 | fs.mkdirSync(TEMP_DIR, { recursive: true });
28 | fs.writeFileSync(TASKS_PATH, JSON.stringify(initialData, null, 2));
29 | }
30 |
31 | describe('Tag Management – writeJSON context preservation', () => {
32 | beforeEach(() => {
33 | writeInitialFile();
34 | });
35 |
36 | afterEach(() => {
37 | fs.rmSync(TEMP_DIR, { recursive: true, force: true });
38 | });
39 |
40 | it('createTag should not corrupt other tags', async () => {
41 | await createTag(
42 | TASKS_PATH,
43 | 'feature',
44 | { copyFromCurrent: true },
45 | { projectRoot: TEMP_DIR },
46 | 'json'
47 | );
48 |
49 | const data = JSON.parse(fs.readFileSync(TASKS_PATH, 'utf8'));
50 | expect(data.master).toBeDefined();
51 | expect(data.feature).toBeDefined();
52 | });
53 |
54 | it('renameTag should keep overall structure intact', async () => {
55 | await createTag(
56 | TASKS_PATH,
57 | 'oldtag',
58 | {},
59 | { projectRoot: TEMP_DIR },
60 | 'json'
61 | );
62 |
63 | await renameTag(
64 | TASKS_PATH,
65 | 'oldtag',
66 | 'newtag',
67 | {},
68 | { projectRoot: TEMP_DIR },
69 | 'json'
70 | );
71 |
72 | const data = JSON.parse(fs.readFileSync(TASKS_PATH, 'utf8'));
73 | expect(data.newtag).toBeDefined();
74 | expect(data.oldtag).toBeUndefined();
75 | });
76 |
77 | it('copyTag then deleteTag preserves other tags', async () => {
78 | await createTag(
79 | TASKS_PATH,
80 | 'source',
81 | {},
82 | { projectRoot: TEMP_DIR },
83 | 'json'
84 | );
85 |
86 | await copyTag(
87 | TASKS_PATH,
88 | 'source',
89 | 'copy',
90 | {},
91 | { projectRoot: TEMP_DIR },
92 | 'json'
93 | );
94 |
95 | await deleteTag(
96 | TASKS_PATH,
97 | 'copy',
98 | { yes: true },
99 | { projectRoot: TEMP_DIR },
100 | 'json'
101 | );
102 |
103 | const tagsList = await listTags(
104 | TASKS_PATH,
105 | {},
106 | { projectRoot: TEMP_DIR },
107 | 'json'
108 | );
109 |
110 | const tagNames = tagsList.tags.map((t) => t.name);
111 | expect(tagNames).toContain('master');
112 | expect(tagNames).toContain('source');
113 | expect(tagNames).not.toContain('copy');
114 | });
115 | });
116 |
```
--------------------------------------------------------------------------------
/mcp-server/src/tools/complexity-report.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * tools/complexity-report.js
3 | * Tool for displaying the complexity analysis report
4 | */
5 |
6 | import { z } from 'zod';
7 | import {
8 | handleApiResult,
9 | createErrorResponse,
10 | withNormalizedProjectRoot
11 | } from './utils.js';
12 | import { complexityReportDirect } from '../core/task-master-core.js';
13 | import { COMPLEXITY_REPORT_FILE } from '../../../src/constants/paths.js';
14 | import { findComplexityReportPath } from '../core/utils/path-utils.js';
15 | import { getCurrentTag } from '../../../scripts/modules/utils.js';
16 |
17 | /**
18 | * Register the complexityReport tool with the MCP server
19 | * @param {Object} server - FastMCP server instance
20 | */
21 | export function registerComplexityReportTool(server) {
22 | server.addTool({
23 | name: 'complexity_report',
24 | description: 'Display the complexity analysis report in a readable format',
25 | parameters: z.object({
26 | file: z
27 | .string()
28 | .optional()
29 | .describe(
30 | `Path to the report file (default: ${COMPLEXITY_REPORT_FILE})`
31 | ),
32 | projectRoot: z
33 | .string()
34 | .describe('The directory of the project. Must be an absolute path.')
35 | }),
36 | execute: withNormalizedProjectRoot(async (args, { log, session }) => {
37 | try {
38 | log.info(
39 | `Getting complexity report with args: ${JSON.stringify(args)}`
40 | );
41 |
42 | const resolvedTag = getCurrentTag(args.projectRoot);
43 |
44 | const pathArgs = {
45 | projectRoot: args.projectRoot,
46 | complexityReport: args.file,
47 | tag: resolvedTag
48 | };
49 |
50 | const reportPath = findComplexityReportPath(pathArgs, log);
51 | log.info('Reading complexity report from path: ', reportPath);
52 |
53 | if (!reportPath) {
54 | return createErrorResponse(
55 | 'No complexity report found. Run task-master analyze-complexity first.'
56 | );
57 | }
58 |
59 | const result = await complexityReportDirect(
60 | {
61 | reportPath: reportPath
62 | },
63 | log
64 | );
65 |
66 | if (result.success) {
67 | log.info('Successfully retrieved complexity report');
68 | } else {
69 | log.error(
70 | `Failed to retrieve complexity report: ${result.error.message}`
71 | );
72 | }
73 |
74 | return handleApiResult(
75 | result,
76 | log,
77 | 'Error retrieving complexity report',
78 | undefined,
79 | args.projectRoot
80 | );
81 | } catch (error) {
82 | log.error(`Error in complexity-report tool: ${error.message}`);
83 | return createErrorResponse(
84 | `Failed to retrieve complexity report: ${error.message}`
85 | );
86 | }
87 | })
88 | });
89 | }
90 |
```
--------------------------------------------------------------------------------
/scripts/create-worktree.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 |
3 | # Create a git worktree for parallel Claude Code development
4 | # Usage: ./scripts/create-worktree.sh [branch-name]
5 |
6 | set -euo pipefail
7 |
8 | SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
9 | PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
10 | WORKTREES_DIR="$(cd "$PROJECT_ROOT/.." && pwd)/claude-task-master-worktrees"
11 | cd "$PROJECT_ROOT"
12 |
13 | # Get branch name (default to current branch with auto/ prefix)
14 | if [ -z "$1" ]; then
15 | CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
16 | if [ "$CURRENT_BRANCH" = "HEAD" ]; then
17 | echo "Detached HEAD detected. Please specify a branch: ./scripts/create-worktree.sh <branch-name>"
18 | exit 1
19 | fi
20 | BRANCH_NAME="auto/$CURRENT_BRANCH"
21 | echo "No branch specified, using: $BRANCH_NAME"
22 | else
23 | BRANCH_NAME="$1"
24 | fi
25 |
26 | # Create worktrees directory if it doesn't exist
27 | mkdir -p "$WORKTREES_DIR"
28 |
29 | # Sanitize branch name for directory (replace / with -)
30 | DIR_NAME=$(echo "$BRANCH_NAME" | sed 's/\//-/g')
31 | WORKTREE_PATH="$WORKTREES_DIR/$DIR_NAME"
32 |
33 | echo "Creating git worktree..."
34 | echo " Branch: $BRANCH_NAME"
35 | echo " Path: $WORKTREE_PATH"
36 |
37 | # Check if worktree already exists
38 | if [ -d "$WORKTREE_PATH" ]; then
39 | echo "❌ Worktree already exists at: $WORKTREE_PATH"
40 | echo " Remove it first with: git worktree remove $WORKTREE_PATH"
41 | exit 1
42 | fi
43 |
44 | # Create worktree (new or existing branch)
45 | if git show-ref --verify --quiet "refs/heads/$BRANCH_NAME"; then
46 | git worktree add "$WORKTREE_PATH" "$BRANCH_NAME"
47 | elif git remote get-url origin >/dev/null 2>&1 && git ls-remote --exit-code --heads origin "$BRANCH_NAME" >/dev/null 2>&1; then
48 | # Create a local branch from the remote and attach worktree
49 | git worktree add -b "$BRANCH_NAME" "$WORKTREE_PATH" "origin/$BRANCH_NAME"
50 | # Ensure the new branch tracks the remote
51 | git -C "$WORKTREE_PATH" branch --set-upstream-to="origin/$BRANCH_NAME" "$BRANCH_NAME"
52 | else
53 | git worktree add -b "$BRANCH_NAME" "$WORKTREE_PATH"
54 | fi
55 |
56 | echo ""
57 | echo "✅ Worktree created successfully!"
58 | echo ""
59 | echo "📂 Location: $WORKTREE_PATH"
60 | echo "🌿 Branch: $BRANCH_NAME"
61 | echo ""
62 | echo "Next steps:"
63 | echo " 1. cd $WORKTREE_PATH"
64 | echo " 2. Open with your AI editor:"
65 | echo " - Cursor: cursor ."
66 | echo " - VS Code: code ."
67 | echo " - Windsurf: windsurf ."
68 | echo " - Claude Code: claude"
69 | echo ""
70 | echo "To remove this worktree later:"
71 | echo " git worktree remove $WORKTREE_PATH"
72 |
```
--------------------------------------------------------------------------------
/apps/docs/archive/configuration.mdx:
--------------------------------------------------------------------------------
```markdown
1 | ---
2 | title: "Configuration"
3 | description: "Configure Task Master through environment variables in a .env file"
4 | ---
5 |
6 | ## Required Configuration
7 |
8 | <Note>
9 | Task Master requires an Anthropic API key to function. Add this to your `.env` file:
10 |
11 | ```bash
12 | ANTHROPIC_API_KEY=sk-ant-api03-your-api-key
13 | ```
14 |
15 | You can obtain an API key from the [Anthropic Console](https://console.anthropic.com/).
16 | </Note>
17 |
18 | ## Optional Configuration
19 |
20 | | Variable | Default Value | Description | Example |
21 | | --- | --- | --- | --- |
22 | | `MODEL` | `"claude-3-7-sonnet-20250219"` | Claude model to use | `MODEL=claude-3-opus-20240229` |
23 | | `MAX_TOKENS` | `"4000"` | Maximum tokens for responses | `MAX_TOKENS=8000` |
24 | | `TEMPERATURE` | `"0.7"` | Temperature for model responses | `TEMPERATURE=0.5` |
25 | | `DEBUG` | `"false"` | Enable debug logging | `DEBUG=true` |
26 | | `LOG_LEVEL` | `"info"` | Console output level | `LOG_LEVEL=debug` |
27 | | `DEFAULT_SUBTASKS` | `"3"` | Default subtask count | `DEFAULT_SUBTASKS=5` |
28 | | `DEFAULT_PRIORITY` | `"medium"` | Default priority | `DEFAULT_PRIORITY=high` |
29 | | `PROJECT_NAME` | `"MCP SaaS MVP"` | Project name in metadata | `PROJECT_NAME=My Awesome Project` |
30 | | `PROJECT_VERSION` | `"1.0.0"` | Version in metadata | `PROJECT_VERSION=2.1.0` |
31 | | `PERPLEXITY_API_KEY` | - | For research-backed features | `PERPLEXITY_API_KEY=pplx-...` |
32 | | `PERPLEXITY_MODEL` | `"sonar-medium-online"` | Perplexity model | `PERPLEXITY_MODEL=sonar-large-online` |
33 |
34 | ## Example .env File
35 |
36 | ```
37 | # Required
38 | ANTHROPIC_API_KEY=sk-ant-api03-your-api-key
39 |
40 | # Optional - Claude Configuration
41 | MODEL=claude-3-7-sonnet-20250219
42 | MAX_TOKENS=4000
43 | TEMPERATURE=0.7
44 |
45 | # Optional - Perplexity API for Research
46 | PERPLEXITY_API_KEY=pplx-your-api-key
47 | PERPLEXITY_MODEL=sonar-medium-online
48 |
49 | # Optional - Project Info
50 | PROJECT_NAME=My Project
51 | PROJECT_VERSION=1.0.0
52 |
53 | # Optional - Application Configuration
54 | DEFAULT_SUBTASKS=3
55 | DEFAULT_PRIORITY=medium
56 | DEBUG=false
57 | LOG_LEVEL=info
58 | ```
59 |
60 | ## Troubleshooting
61 |
62 | ### If `task-master init` doesn't respond:
63 |
64 | Try running it with Node directly:
65 |
66 | ```bash
67 | node node_modules/claude-task-master/scripts/init.js
68 | ```
69 |
70 | Or clone the repository and run:
71 |
72 | ```bash
73 | git clone https://github.com/eyaltoledano/claude-task-master.git
74 | cd claude-task-master
75 | node scripts/init.js
76 | ```
77 |
78 | <Note>
79 | For advanced configuration options and detailed customization, see our [Advanced Configuration Guide] page.
80 | </Note>
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/update-tasks-from-id.md:
--------------------------------------------------------------------------------
```markdown
1 | Update multiple tasks starting from a specific ID.
2 |
3 | Arguments: $ARGUMENTS
4 |
5 | Parse starting task ID and update context.
6 |
7 | ## Bulk Task Updates
8 |
9 | Update multiple related tasks based on new requirements or context changes.
10 |
11 | ## Argument Parsing
12 |
13 | - "from 5: add security requirements"
14 | - "5 onwards: update API endpoints"
15 | - "starting at 5: change to use new framework"
16 |
17 | ## Execution
18 |
19 | ```bash
20 | task-master update --from=<id> --prompt="<context>"
21 | ```
22 |
23 | ## Update Process
24 |
25 | ### 1. **Task Selection**
26 | Starting from specified ID:
27 | - Include the task itself
28 | - Include all dependent tasks
29 | - Include related subtasks
30 | - Smart boundary detection
31 |
32 | ### 2. **Context Application**
33 | AI analyzes the update context and:
34 | - Identifies what needs changing
35 | - Maintains consistency
36 | - Preserves completed work
37 | - Updates related information
38 |
39 | ### 3. **Intelligent Updates**
40 | - Modify descriptions appropriately
41 | - Update test strategies
42 | - Adjust time estimates
43 | - Revise dependencies if needed
44 |
45 | ## Smart Features
46 |
47 | 1. **Scope Detection**
48 | - Find natural task groupings
49 | - Identify related features
50 | - Stop at logical boundaries
51 | - Avoid over-updating
52 |
53 | 2. **Consistency Maintenance**
54 | - Keep naming conventions
55 | - Preserve relationships
56 | - Update cross-references
57 | - Maintain task flow
58 |
59 | 3. **Change Preview**
60 | ```
61 | Bulk Update Preview
62 | ━━━━━━━━━━━━━━━━━━
63 | Starting from: Task #5
64 | Tasks to update: 8 tasks + 12 subtasks
65 |
66 | Context: "add security requirements"
67 |
68 | Changes will include:
69 | - Add security sections to descriptions
70 | - Update test strategies for security
71 | - Add security-related subtasks where needed
72 | - Adjust time estimates (+20% average)
73 |
74 | Continue? (y/n)
75 | ```
76 |
77 | ## Example Updates
78 |
79 | ```
80 | /taskmaster:update/from-id 5: change database to PostgreSQL
81 | → Analyzing impact starting from task #5
82 | → Found 6 related tasks to update
83 | → Updates will maintain consistency
84 | → Preview changes? (y/n)
85 |
86 | Applied updates:
87 | ✓ Task #5: Updated connection logic references
88 | ✓ Task #6: Changed migration approach
89 | ✓ Task #7: Updated query syntax notes
90 | ✓ Task #8: Revised testing strategy
91 | ✓ Task #9: Updated deployment steps
92 | ✓ Task #12: Changed backup procedures
93 | ```
94 |
95 | ## Safety Features
96 |
97 | - Preview all changes
98 | - Selective confirmation
99 | - Rollback capability
100 | - Change logging
101 | - Validation checks
102 |
103 | ## Post-Update
104 |
105 | - Summary of changes
106 | - Consistency verification
107 | - Suggest review tasks
108 | - Update timeline if needed
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/generate-tasks.md:
--------------------------------------------------------------------------------
```markdown
1 | Generate individual task files from tasks.json.
2 |
3 | ## Task File Generation
4 |
5 | Creates separate markdown files for each task, perfect for AI agents or documentation.
6 |
7 | ## Execution
8 |
9 | ```bash
10 | task-master generate
11 | ```
12 |
13 | ## What It Creates
14 |
15 | For each task, generates a file like `task_001.txt`:
16 |
17 | ```
18 | Task ID: 1
19 | Title: Implement user authentication
20 | Status: pending
21 | Priority: high
22 | Dependencies: []
23 | Created: 2024-01-15
24 | Complexity: 7
25 |
26 | ## Description
27 | Create a secure user authentication system with login, logout, and session management.
28 |
29 | ## Details
30 | - Use JWT tokens for session management
31 | - Implement secure password hashing
32 | - Add remember me functionality
33 | - Include password reset flow
34 |
35 | ## Test Strategy
36 | - Unit tests for auth functions
37 | - Integration tests for login flow
38 | - Security testing for vulnerabilities
39 | - Performance tests for concurrent logins
40 |
41 | ## Subtasks
42 | 1.1 Setup authentication framework (pending)
43 | 1.2 Create login endpoints (pending)
44 | 1.3 Implement session management (pending)
45 | 1.4 Add password reset (pending)
46 | ```
47 |
48 | ## File Organization
49 |
50 | Creates structure:
51 | ```
52 | .taskmaster/
53 | └── tasks/
54 | ├── task_001.txt
55 | ├── task_002.txt
56 | ├── task_003.txt
57 | └── ...
58 | ```
59 |
60 | ## Smart Features
61 |
62 | 1. **Consistent Formatting**
63 | - Standardized structure
64 | - Clear sections
65 | - AI-readable format
66 | - Markdown compatible
67 |
68 | 2. **Contextual Information**
69 | - Full task details
70 | - Related task references
71 | - Progress indicators
72 | - Implementation notes
73 |
74 | 3. **Incremental Updates**
75 | - Only regenerate changed tasks
76 | - Preserve custom additions
77 | - Track generation timestamp
78 | - Version control friendly
79 |
80 | ## Use Cases
81 |
82 | - **AI Context**: Provide task context to AI assistants
83 | - **Documentation**: Standalone task documentation
84 | - **Archival**: Task history preservation
85 | - **Sharing**: Send specific tasks to team members
86 | - **Review**: Easier task review process
87 |
88 | ## Generation Options
89 |
90 | Based on arguments:
91 | - Filter by status
92 | - Include/exclude completed
93 | - Custom templates
94 | - Different formats
95 |
96 | ## Post-Generation
97 |
98 | ```
99 | Task File Generation Complete
100 | ━━━━━━━━━━━━━━━━━━━━━━━━━━
101 | Generated: 45 task files
102 | Location: .taskmaster/tasks/
103 | Total size: 156 KB
104 |
105 | New files: 5
106 | Updated files: 12
107 | Unchanged: 28
108 |
109 | Ready for:
110 | - AI agent consumption
111 | - Version control
112 | - Team distribution
113 | ```
114 |
115 | ## Integration Benefits
116 |
117 | - Git-trackable task history
118 | - Easy task sharing
119 | - AI tool compatibility
120 | - Offline task access
121 | - Backup redundancy
```
--------------------------------------------------------------------------------
/mcp-server/src/tools/validate-dependencies.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * tools/validate-dependencies.js
3 | * Tool for validating task dependencies
4 | */
5 |
6 | import { z } from 'zod';
7 | import {
8 | handleApiResult,
9 | createErrorResponse,
10 | withNormalizedProjectRoot
11 | } from './utils.js';
12 | import { validateDependenciesDirect } from '../core/task-master-core.js';
13 | import { findTasksPath } from '../core/utils/path-utils.js';
14 | import { resolveTag } from '../../../scripts/modules/utils.js';
15 |
16 | /**
17 | * Register the validateDependencies tool with the MCP server
18 | * @param {Object} server - FastMCP server instance
19 | */
20 | export function registerValidateDependenciesTool(server) {
21 | server.addTool({
22 | name: 'validate_dependencies',
23 | description:
24 | 'Check tasks for dependency issues (like circular references or links to non-existent tasks) without making changes.',
25 | parameters: z.object({
26 | file: z.string().optional().describe('Absolute path to the tasks file'),
27 | projectRoot: z
28 | .string()
29 | .describe('The directory of the project. Must be an absolute path.'),
30 | tag: z.string().optional().describe('Tag context to operate on')
31 | }),
32 | execute: withNormalizedProjectRoot(async (args, { log, session }) => {
33 | try {
34 | const resolvedTag = resolveTag({
35 | projectRoot: args.projectRoot,
36 | tag: args.tag
37 | });
38 | log.info(`Validating dependencies with args: ${JSON.stringify(args)}`);
39 |
40 | // Use args.projectRoot directly (guaranteed by withNormalizedProjectRoot)
41 | let tasksJsonPath;
42 | try {
43 | tasksJsonPath = findTasksPath(
44 | { projectRoot: args.projectRoot, file: args.file },
45 | log
46 | );
47 | } catch (error) {
48 | log.error(`Error finding tasks.json: ${error.message}`);
49 | return createErrorResponse(
50 | `Failed to find tasks.json: ${error.message}`
51 | );
52 | }
53 |
54 | const result = await validateDependenciesDirect(
55 | {
56 | tasksJsonPath: tasksJsonPath,
57 | projectRoot: args.projectRoot,
58 | tag: resolvedTag
59 | },
60 | log
61 | );
62 |
63 | if (result.success) {
64 | log.info(
65 | `Successfully validated dependencies: ${result.data.message}`
66 | );
67 | } else {
68 | log.error(`Failed to validate dependencies: ${result.error.message}`);
69 | }
70 |
71 | return handleApiResult(
72 | result,
73 | log,
74 | 'Error validating dependencies',
75 | undefined,
76 | args.projectRoot
77 | );
78 | } catch (error) {
79 | log.error(`Error in validateDependencies tool: ${error.message}`);
80 | return createErrorResponse(error.message);
81 | }
82 | })
83 | });
84 | }
85 |
```
--------------------------------------------------------------------------------
/apps/extension/src/webview/components/TaskCard.tsx:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Task Card Component for Kanban Board
3 | */
4 |
5 | import React from 'react';
6 | import { KanbanCard } from '@/components/ui/shadcn-io/kanban';
7 | import { PriorityBadge } from './PriorityBadge';
8 | import type { TaskMasterTask } from '../types';
9 |
10 | interface TaskCardProps {
11 | task: TaskMasterTask;
12 | dragging?: boolean;
13 | onViewDetails?: (taskId: string) => void;
14 | }
15 |
16 | export const TaskCard: React.FC<TaskCardProps> = ({
17 | task,
18 | dragging,
19 | onViewDetails
20 | }) => {
21 | const handleCardClick = (e: React.MouseEvent) => {
22 | e.preventDefault();
23 | onViewDetails?.(task.id);
24 | };
25 |
26 | return (
27 | <KanbanCard
28 | id={task.id}
29 | name={task.title}
30 | index={0} // Index is not used in our implementation
31 | parent={task.status}
32 | className="cursor-pointer p-3 transition-shadow hover:shadow-md bg-vscode-editor-background border-vscode-border group"
33 | onClick={handleCardClick}
34 | >
35 | <div className="space-y-3 h-full flex flex-col">
36 | <div className="flex items-start justify-between gap-2 flex-shrink-0">
37 | <h3 className="font-medium text-sm leading-tight flex-1 min-w-0 text-vscode-foreground">
38 | {task.title}
39 | </h3>
40 | <div className="flex items-center gap-1 flex-shrink-0">
41 | <PriorityBadge priority={task.priority} />
42 | </div>
43 | </div>
44 |
45 | {task.description && (
46 | <p className="text-xs text-vscode-foreground/70 line-clamp-3 leading-relaxed flex-1 min-h-0">
47 | {task.description}
48 | </p>
49 | )}
50 |
51 | <div className="flex items-center justify-between text-xs mt-auto pt-2 flex-shrink-0 border-t border-vscode-border/20">
52 | <span className="font-mono text-vscode-foreground/50 flex-shrink-0">
53 | #{task.id}
54 | </span>
55 | {task.dependencies && task.dependencies.length > 0 && (
56 | <div className="flex items-center gap-1 text-vscode-foreground/50 flex-shrink-0 ml-2">
57 | <span>Deps:</span>
58 | <div className="flex items-center gap-1">
59 | {task.dependencies.map((depId, index) => (
60 | <React.Fragment key={depId}>
61 | <button
62 | className="font-mono hover:text-vscode-link-activeForeground hover:underline transition-colors"
63 | onClick={(e) => {
64 | e.stopPropagation();
65 | onViewDetails?.(depId);
66 | }}
67 | >
68 | #{depId}
69 | </button>
70 | {index < task.dependencies!.length - 1 && <span>,</span>}
71 | </React.Fragment>
72 | ))}
73 | </div>
74 | </div>
75 | )}
76 | </div>
77 | </div>
78 | </KanbanCard>
79 | );
80 | };
81 |
```
--------------------------------------------------------------------------------
/apps/extension/assets/icon-dark.svg:
--------------------------------------------------------------------------------
```
1 | <svg viewBox="0 0 224 291" fill="none" xmlns="http://www.w3.org/2000/svg">
2 | <path d="M101.635 286.568L71.4839 256.414C65.6092 250.539 65.6092 241.03 71.4839 235.155L142.52 164.11C144.474 162.156 147.643 162.156 149.61 164.11L176.216 190.719C178.17 192.673 181.339 192.673 183.305 190.719L189.719 184.305C191.673 182.35 191.673 179.181 189.719 177.214L163.113 150.605C161.159 148.651 161.159 145.481 163.113 143.514L191.26 115.365C193.214 113.41 193.214 110.241 191.26 108.274L182.316 99.3291C180.362 97.3748 177.193 97.3748 175.226 99.3291L55.8638 218.706C49.989 224.581 40.4816 224.581 34.6068 218.706L4.4061 188.501C-1.4687 182.626 -1.4687 173.117 4.4061 167.242L23.8342 147.811C25.7883 145.857 25.7883 142.688 23.8342 140.721L4.78187 121.666C-1.09293 115.791 -1.09293 106.282 4.78187 100.406L34.7195 70.4527C40.5943 64.5772 50.1017 64.5772 55.9765 70.4527L75.555 90.0335C77.5091 91.9879 80.6782 91.9879 82.6448 90.0335L124.144 48.5292C126.098 46.5749 126.098 43.4054 124.144 41.4385L115.463 32.7568C113.509 30.8025 110.34 30.8025 108.374 32.7568L99.8683 41.2632C97.9143 43.2175 94.7451 43.2175 92.7785 41.2632L82.1438 30.6271C80.1897 28.6728 80.1897 25.5033 82.1438 23.5364L101.271 4.40662C107.146 -1.46887 116.653 -1.46887 122.528 4.40662L152.478 34.3604C158.353 40.2359 158.353 49.7444 152.478 55.6199L82.6323 125.474C80.6782 127.429 77.5091 127.429 75.5425 125.474L48.8741 98.8029C46.9201 96.8486 43.7509 96.8486 41.7843 98.8029L33.1036 107.485C31.1496 109.439 31.1496 112.608 33.1036 114.575L59.2458 140.721C61.1999 142.675 61.1999 145.844 59.2458 147.811L32.7404 174.32C30.7863 176.274 30.7863 179.444 32.7404 181.411L41.6841 190.355C43.6382 192.31 46.8073 192.31 48.7739 190.355L168.136 70.9789C174.011 65.1034 183.518 65.1034 189.393 70.9789L219.594 101.183C225.469 107.059 225.469 116.567 219.594 122.443L198.537 143.502C196.583 145.456 196.583 148.626 198.537 150.592L218.053 170.111C223.928 175.986 223.928 185.495 218.053 191.37L190.37 219.056C184.495 224.932 174.988 224.932 169.113 219.056L149.597 199.538C147.643 197.584 144.474 197.584 142.508 199.538L99.8057 242.245C97.8516 244.2 97.8516 247.369 99.8057 249.336L108.699 258.231C110.653 260.185 113.823 260.185 115.789 258.231L122.954 251.065C124.908 249.11 128.077 249.11 130.044 251.065L140.679 261.701C142.633 263.655 142.633 266.825 140.679 268.791L122.879 286.593C117.004 292.469 107.497 292.469 101.622 286.593L101.635 286.568Z" fill="#CCCCCC"/>
3 | </svg>
```
--------------------------------------------------------------------------------
/apps/extension/assets/icon-light.svg:
--------------------------------------------------------------------------------
```
1 | <svg viewBox="0 0 224 291" fill="none" xmlns="http://www.w3.org/2000/svg">
2 | <path d="M101.635 286.568L71.4839 256.414C65.6092 250.539 65.6092 241.03 71.4839 235.155L142.52 164.11C144.474 162.156 147.643 162.156 149.61 164.11L176.216 190.719C178.17 192.673 181.339 192.673 183.305 190.719L189.719 184.305C191.673 182.35 191.673 179.181 189.719 177.214L163.113 150.605C161.159 148.651 161.159 145.481 163.113 143.514L191.26 115.365C193.214 113.41 193.214 110.241 191.26 108.274L182.316 99.3291C180.362 97.3748 177.193 97.3748 175.226 99.3291L55.8638 218.706C49.989 224.581 40.4816 224.581 34.6068 218.706L4.4061 188.501C-1.4687 182.626 -1.4687 173.117 4.4061 167.242L23.8342 147.811C25.7883 145.857 25.7883 142.688 23.8342 140.721L4.78187 121.666C-1.09293 115.791 -1.09293 106.282 4.78187 100.406L34.7195 70.4527C40.5943 64.5772 50.1017 64.5772 55.9765 70.4527L75.555 90.0335C77.5091 91.9879 80.6782 91.9879 82.6448 90.0335L124.144 48.5292C126.098 46.5749 126.098 43.4054 124.144 41.4385L115.463 32.7568C113.509 30.8025 110.34 30.8025 108.374 32.7568L99.8683 41.2632C97.9143 43.2175 94.7451 43.2175 92.7785 41.2632L82.1438 30.6271C80.1897 28.6728 80.1897 25.5033 82.1438 23.5364L101.271 4.40662C107.146 -1.46887 116.653 -1.46887 122.528 4.40662L152.478 34.3604C158.353 40.2359 158.353 49.7444 152.478 55.6199L82.6323 125.474C80.6782 127.429 77.5091 127.429 75.5425 125.474L48.8741 98.8029C46.9201 96.8486 43.7509 96.8486 41.7843 98.8029L33.1036 107.485C31.1496 109.439 31.1496 112.608 33.1036 114.575L59.2458 140.721C61.1999 142.675 61.1999 145.844 59.2458 147.811L32.7404 174.32C30.7863 176.274 30.7863 179.444 32.7404 181.411L41.6841 190.355C43.6382 192.31 46.8073 192.31 48.7739 190.355L168.136 70.9789C174.011 65.1034 183.518 65.1034 189.393 70.9789L219.594 101.183C225.469 107.059 225.469 116.567 219.594 122.443L198.537 143.502C196.583 145.456 196.583 148.626 198.537 150.592L218.053 170.111C223.928 175.986 223.928 185.495 218.053 191.37L190.37 219.056C184.495 224.932 174.988 224.932 169.113 219.056L149.597 199.538C147.643 197.584 144.474 197.584 142.508 199.538L99.8057 242.245C97.8516 244.2 97.8516 247.369 99.8057 249.336L108.699 258.231C110.653 260.185 113.823 260.185 115.789 258.231L122.954 251.065C124.908 249.11 128.077 249.11 130.044 251.065L140.679 261.701C142.633 263.655 142.633 266.825 140.679 268.791L122.879 286.593C117.004 292.469 107.497 292.469 101.622 286.593L101.635 286.568Z" fill="#424242"/>
3 | </svg>
```
--------------------------------------------------------------------------------
/apps/extension/assets/sidebar-icon.svg:
--------------------------------------------------------------------------------
```
1 | <svg viewBox="0 0 224 291" fill="none" xmlns="http://www.w3.org/2000/svg">
2 | <path d="M101.635 286.568L71.4839 256.414C65.6092 250.539 65.6092 241.03 71.4839 235.155L142.52 164.11C144.474 162.156 147.643 162.156 149.61 164.11L176.216 190.719C178.17 192.673 181.339 192.673 183.305 190.719L189.719 184.305C191.673 182.35 191.673 179.181 189.719 177.214L163.113 150.605C161.159 148.651 161.159 145.481 163.113 143.514L191.26 115.365C193.214 113.41 193.214 110.241 191.26 108.274L182.316 99.3291C180.362 97.3748 177.193 97.3748 175.226 99.3291L55.8638 218.706C49.989 224.581 40.4816 224.581 34.6068 218.706L4.4061 188.501C-1.4687 182.626 -1.4687 173.117 4.4061 167.242L23.8342 147.811C25.7883 145.857 25.7883 142.688 23.8342 140.721L4.78187 121.666C-1.09293 115.791 -1.09293 106.282 4.78187 100.406L34.7195 70.4527C40.5943 64.5772 50.1017 64.5772 55.9765 70.4527L75.555 90.0335C77.5091 91.9879 80.6782 91.9879 82.6448 90.0335L124.144 48.5292C126.098 46.5749 126.098 43.4054 124.144 41.4385L115.463 32.7568C113.509 30.8025 110.34 30.8025 108.374 32.7568L99.8683 41.2632C97.9143 43.2175 94.7451 43.2175 92.7785 41.2632L82.1438 30.6271C80.1897 28.6728 80.1897 25.5033 82.1438 23.5364L101.271 4.40662C107.146 -1.46887 116.653 -1.46887 122.528 4.40662L152.478 34.3604C158.353 40.2359 158.353 49.7444 152.478 55.6199L82.6323 125.474C80.6782 127.429 77.5091 127.429 75.5425 125.474L48.8741 98.8029C46.9201 96.8486 43.7509 96.8486 41.7843 98.8029L33.1036 107.485C31.1496 109.439 31.1496 112.608 33.1036 114.575L59.2458 140.721C61.1999 142.675 61.1999 145.844 59.2458 147.811L32.7404 174.32C30.7863 176.274 30.7863 179.444 32.7404 181.411L41.6841 190.355C43.6382 192.31 46.8073 192.31 48.7739 190.355L168.136 70.9789C174.011 65.1034 183.518 65.1034 189.393 70.9789L219.594 101.183C225.469 107.059 225.469 116.567 219.594 122.443L198.537 143.502C196.583 145.456 196.583 148.626 198.537 150.592L218.053 170.111C223.928 175.986 223.928 185.495 218.053 191.37L190.37 219.056C184.495 224.932 174.988 224.932 169.113 219.056L149.597 199.538C147.643 197.584 144.474 197.584 142.508 199.538L99.8057 242.245C97.8516 244.2 97.8516 247.369 99.8057 249.336L108.699 258.231C110.653 260.185 113.823 260.185 115.789 258.231L122.954 251.065C124.908 249.11 128.077 249.11 130.044 251.065L140.679 261.701C142.633 263.655 142.633 266.825 140.679 268.791L122.879 286.593C117.004 292.469 107.497 292.469 101.622 286.593L101.635 286.568Z" fill="currentColor"/>
3 | </svg>
```
--------------------------------------------------------------------------------
/tests/integration/profiles/vscode-init-functionality.test.js:
--------------------------------------------------------------------------------
```javascript
1 | import fs from 'fs';
2 | import path from 'path';
3 | import { vscodeProfile } from '../../../src/profiles/vscode.js';
4 |
5 | describe('VSCode Profile Initialization Functionality', () => {
6 | let vscodeProfileContent;
7 |
8 | beforeAll(() => {
9 | const vscodeJsPath = path.join(
10 | process.cwd(),
11 | 'src',
12 | 'profiles',
13 | 'vscode.js'
14 | );
15 | vscodeProfileContent = fs.readFileSync(vscodeJsPath, 'utf8');
16 | });
17 |
18 | test('vscode.js uses factory pattern with correct configuration', () => {
19 | // Check for explicit, non-default values in the source file
20 | expect(vscodeProfileContent).toContain("name: 'vscode'");
21 | expect(vscodeProfileContent).toContain("displayName: 'VS Code'");
22 | expect(vscodeProfileContent).toContain("url: 'code.visualstudio.com'");
23 | expect(vscodeProfileContent).toContain(
24 | "docsUrl: 'code.visualstudio.com/docs'"
25 | );
26 | expect(vscodeProfileContent).toContain("rulesDir: '.github/instructions'"); // non-default
27 | expect(vscodeProfileContent).toContain('customReplacements'); // non-default
28 |
29 | // Check the final computed properties on the profile object
30 | expect(vscodeProfile.profileName).toBe('vscode');
31 | expect(vscodeProfile.displayName).toBe('VS Code');
32 | expect(vscodeProfile.profileDir).toBe('.vscode'); // default
33 | expect(vscodeProfile.rulesDir).toBe('.github/instructions'); // non-default
34 | expect(vscodeProfile.globalReplacements).toBeDefined(); // computed from customReplacements
35 | expect(Array.isArray(vscodeProfile.globalReplacements)).toBe(true);
36 | });
37 |
38 | test('vscode.js configures .mdc to .instructions.md extension mapping', () => {
39 | // Check that the profile object has the correct file mapping behavior (vscode converts to .md)
40 | expect(vscodeProfile.fileMap['rules/cursor_rules.mdc']).toBe(
41 | 'vscode_rules.instructions.md'
42 | );
43 | });
44 |
45 | test('vscode.js uses standard tool mappings', () => {
46 | // Check that the profile uses default tool mappings (equivalent to COMMON_TOOL_MAPPINGS.STANDARD)
47 | // This verifies the architectural pattern: no custom toolMappings = standard tool names
48 | expect(vscodeProfileContent).not.toContain('toolMappings:');
49 | expect(vscodeProfileContent).not.toContain('apply_diff');
50 | expect(vscodeProfileContent).not.toContain('search_files');
51 |
52 | // Verify the result: default mappings means tools keep their original names
53 | expect(vscodeProfile.conversionConfig.toolNames.edit_file).toBe(
54 | 'edit_file'
55 | );
56 | expect(vscodeProfile.conversionConfig.toolNames.search).toBe('search');
57 | });
58 | });
59 |
```
--------------------------------------------------------------------------------
/mcp-server/src/custom-sdk/errors.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * src/ai-providers/custom-sdk/mcp/errors.js
3 | *
4 | * Error handling utilities for MCP AI SDK provider.
5 | * Maps MCP errors to AI SDK compatible error types.
6 | */
7 |
8 | /**
9 | * MCP-specific error class
10 | */
11 | export class MCPError extends Error {
12 | constructor(message, options = {}) {
13 | super(message);
14 | this.name = 'MCPError';
15 | this.code = options.code;
16 | this.cause = options.cause;
17 | this.mcpResponse = options.mcpResponse;
18 | }
19 | }
20 |
21 | /**
22 | * Session-related error
23 | */
24 | export class MCPSessionError extends MCPError {
25 | constructor(message, options = {}) {
26 | super(message, options);
27 | this.name = 'MCPSessionError';
28 | }
29 | }
30 |
31 | /**
32 | * Sampling-related error
33 | */
34 | export class MCPSamplingError extends MCPError {
35 | constructor(message, options = {}) {
36 | super(message, options);
37 | this.name = 'MCPSamplingError';
38 | }
39 | }
40 |
41 | /**
42 | * Map MCP errors to AI SDK compatible error types
43 | * @param {Error} error - Original error
44 | * @returns {Error} Mapped error
45 | */
46 | export function mapMCPError(error) {
47 | // If already an MCP error, return as-is
48 | if (error instanceof MCPError) {
49 | return error;
50 | }
51 |
52 | const message = error.message || 'Unknown MCP error';
53 | const originalError = error;
54 |
55 | // Map common error patterns
56 | if (message.includes('session') || message.includes('connection')) {
57 | return new MCPSessionError(message, {
58 | cause: originalError,
59 | code: 'SESSION_ERROR'
60 | });
61 | }
62 |
63 | if (message.includes('sampling') || message.includes('timeout')) {
64 | return new MCPSamplingError(message, {
65 | cause: originalError,
66 | code: 'SAMPLING_ERROR'
67 | });
68 | }
69 |
70 | if (message.includes('capabilities') || message.includes('not supported')) {
71 | return new MCPSessionError(message, {
72 | cause: originalError,
73 | code: 'CAPABILITY_ERROR'
74 | });
75 | }
76 |
77 | // Default to generic MCP error
78 | return new MCPError(message, {
79 | cause: originalError,
80 | code: 'UNKNOWN_ERROR'
81 | });
82 | }
83 |
84 | /**
85 | * Check if error is retryable
86 | * @param {Error} error - Error to check
87 | * @returns {boolean} True if error might be retryable
88 | */
89 | export function isRetryableError(error) {
90 | if (error instanceof MCPSamplingError && error.code === 'SAMPLING_ERROR') {
91 | return true;
92 | }
93 |
94 | if (error instanceof MCPSessionError && error.code === 'SESSION_ERROR') {
95 | // Session errors are generally not retryable
96 | return false;
97 | }
98 |
99 | // Check for common retryable patterns
100 | const message = error.message?.toLowerCase() || '';
101 | return (
102 | message.includes('timeout') ||
103 | message.includes('network') ||
104 | message.includes('temporary')
105 | );
106 | }
107 |
```
--------------------------------------------------------------------------------
/tests/unit/mcp-providers/mcp-provider.test.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * tests/unit/mcp-providers/mcp-provider.test.js
3 | * Unit tests for MCP provider
4 | */
5 |
6 | import { jest } from '@jest/globals';
7 |
8 | describe('MCPProvider', () => {
9 | let MCPProvider;
10 | let provider;
11 |
12 | beforeAll(async () => {
13 | // Dynamic import to avoid circular dependency issues
14 | const module = await import(
15 | '../../../mcp-server/src/providers/mcp-provider.js'
16 | );
17 | MCPProvider = module.MCPProvider;
18 | });
19 |
20 | beforeEach(() => {
21 | provider = new MCPProvider();
22 | });
23 |
24 | describe('constructor', () => {
25 | it('should initialize with correct name', () => {
26 | expect(provider.name).toBe('mcp');
27 | });
28 |
29 | it('should initialize with null session', () => {
30 | expect(provider.session).toBeNull();
31 | });
32 | });
33 |
34 | describe('isRequiredApiKey', () => {
35 | it('should return false (no API key required)', () => {
36 | expect(provider.isRequiredApiKey()).toBe(false);
37 | });
38 | });
39 |
40 | describe('validateAuth', () => {
41 | it('should throw error when no session', () => {
42 | expect(() => provider.validateAuth({})).toThrow(
43 | 'MCP Provider requires active MCP session'
44 | );
45 | });
46 |
47 | it('should throw error when session lacks sampling capabilities', () => {
48 | provider.session = {
49 | clientCapabilities: {}
50 | };
51 |
52 | expect(() => provider.validateAuth({})).toThrow(
53 | 'MCP session must have client sampling capabilities'
54 | );
55 | });
56 |
57 | it('should pass validation with valid session', () => {
58 | provider.session = {
59 | clientCapabilities: {
60 | sampling: true
61 | }
62 | };
63 |
64 | expect(() => provider.validateAuth({})).not.toThrow();
65 | });
66 | });
67 |
68 | describe('setSession', () => {
69 | it('should set session when provided', () => {
70 | const mockSession = {
71 | clientCapabilities: { sampling: true }
72 | };
73 |
74 | provider.setSession(mockSession);
75 | expect(provider.session).toBe(mockSession);
76 | });
77 |
78 | it('should handle null session gracefully', () => {
79 | provider.setSession(null);
80 | expect(provider.session).toBeNull();
81 | });
82 | });
83 |
84 | describe('hasValidSession', () => {
85 | it('should return false when no session', () => {
86 | expect(provider.hasValidSession()).toBe(false);
87 | });
88 |
89 | it('should return false when session lacks sampling capabilities', () => {
90 | provider.session = {
91 | clientCapabilities: {}
92 | };
93 |
94 | expect(provider.hasValidSession()).toBe(false);
95 | });
96 |
97 | it('should return true with valid session', () => {
98 | provider.session = {
99 | clientCapabilities: {
100 | sampling: true
101 | }
102 | };
103 |
104 | expect(provider.hasValidSession()).toBe(true);
105 | });
106 | });
107 | });
108 |
```