This is page 3 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
--------------------------------------------------------------------------------
/packages/claude-code-plugin/.claude-plugin/plugin.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "taskmaster",
3 | "description": "A task management system for ambitious AI-driven development that doesn't overwhelm and confuse Cursor.",
4 | "author": {
5 | "name": "Hamster",
6 | "url": "https://github.com/eyaltoledano/claude-task-master"
7 | },
8 | "homepage": "https://github.com/eyaltoledano/claude-task-master#readme",
9 | "repository": "https://github.com/eyaltoledano/claude-task-master",
10 | "license": "MIT WITH Commons-Clause",
11 | "keywords": [
12 | "task-management",
13 | "ai",
14 | "workflow",
15 | "orchestration",
16 | "automation",
17 | "mcp",
18 | "development",
19 | "productivity"
20 | ]
21 | }
22 |
```
--------------------------------------------------------------------------------
/.kiro/settings/mcp.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "mcpServers": {
3 | "task-master-ai": {
4 | "command": "npx",
5 | "args": ["-y", "task-master-ai"],
6 | "env": {
7 | "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
8 | "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
9 | "OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
10 | "GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
11 | "XAI_API_KEY": "YOUR_XAI_KEY_HERE",
12 | "OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
13 | "MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
14 | "AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE",
15 | "OLLAMA_API_KEY": "YOUR_OLLAMA_API_KEY_HERE"
16 | }
17 | }
18 | }
19 | }
20 |
```
--------------------------------------------------------------------------------
/apps/mcp/src/shared/types.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Shared types for MCP tools
3 | */
4 |
5 | export interface MCPResponse<T = any> {
6 | success: boolean;
7 | data?: T;
8 | error?: {
9 | code: string;
10 | message: string;
11 | suggestion?: string;
12 | details?: any;
13 | };
14 | version?: {
15 | version: string;
16 | name: string;
17 | };
18 | tag?: {
19 | currentTag: string;
20 | availableTags: string[];
21 | };
22 | }
23 |
24 | export interface MCPContext {
25 | log: {
26 | info: (message: string) => void;
27 | warn: (message: string) => void;
28 | error: (message: string) => void;
29 | debug: (message: string) => void;
30 | };
31 | session: any;
32 | }
33 |
34 | export interface WithProjectRoot {
35 | projectRoot: string;
36 | }
37 |
```
--------------------------------------------------------------------------------
/apps/extension/src/components/ui/label.tsx:
--------------------------------------------------------------------------------
```typescript
1 | import * as LabelPrimitive from '@radix-ui/react-label';
2 | import type * as React from 'react';
3 |
4 | import { cn } from '@/lib/utils';
5 |
6 | function Label({
7 | className,
8 | ...props
9 | }: React.ComponentProps<typeof LabelPrimitive.Root>) {
10 | return (
11 | <LabelPrimitive.Root
12 | data-slot="label"
13 | className={cn(
14 | 'flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50',
15 | className
16 | )}
17 | {...props}
18 | />
19 | );
20 | }
21 |
22 | export { Label };
23 |
```
--------------------------------------------------------------------------------
/src/ai-providers/zai-coding.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * zai-coding.js
3 | * AI provider implementation for Z.ai (GLM) Coding Plan models.
4 | * Uses the exclusive coding API endpoint with OpenAI-compatible API.
5 | */
6 |
7 | import { ZAIProvider } from './zai.js';
8 |
9 | /**
10 | * Z.ai Coding Plan provider supporting GLM models through the dedicated coding endpoint.
11 | * Extends ZAIProvider with only a different base URL.
12 | */
13 | export class ZAICodingProvider extends ZAIProvider {
14 | constructor() {
15 | super();
16 | // Override only the name and base URL
17 | this.name = 'Z.ai (Coding Plan)';
18 | this.defaultBaseURL = 'https://api.z.ai/api/coding/paas/v4/';
19 | }
20 | }
21 |
```
--------------------------------------------------------------------------------
/apps/extension/src/webview/index.tsx:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Webview Entry Point
3 | */
4 |
5 | import React from 'react';
6 | import { createRoot } from 'react-dom/client';
7 | import { App } from './App';
8 | // CSS is built separately by Tailwind
9 |
10 | // VS Code API declaration
11 | declare global {
12 | interface Window {
13 | acquireVsCodeApi?: () => {
14 | postMessage: (message: any) => void;
15 | setState: (state: any) => void;
16 | getState: () => any;
17 | };
18 | }
19 | }
20 |
21 | // Initialize React app
22 | const container = document.getElementById('root');
23 | if (container) {
24 | const root = createRoot(container);
25 | root.render(<App />);
26 | } else {
27 | console.error('❌ Root container not found');
28 | }
29 |
```
--------------------------------------------------------------------------------
/packages/build-config/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "@tm/build-config",
3 | "description": "Shared build configuration for Task Master monorepo",
4 | "type": "module",
5 | "private": true,
6 | "main": "./dist/tsdown.base.js",
7 | "types": "./src/tsdown.base.ts",
8 | "exports": {
9 | ".": {
10 | "types": "./src/tsdown.base.ts",
11 | "import": "./dist/tsdown.base.js"
12 | }
13 | },
14 | "files": ["dist", "src"],
15 | "keywords": ["build-config", "tsup", "monorepo"],
16 | "author": "",
17 | "license": "MIT",
18 | "scripts": {
19 | "build": "tsc",
20 | "typecheck": "tsc --noEmit"
21 | },
22 | "devDependencies": {
23 | "typescript": "^5.9.2"
24 | },
25 | "dependencies": {
26 | "tsup": "^8.5.0"
27 | },
28 | "version": ""
29 | }
30 |
```
--------------------------------------------------------------------------------
/apps/extension/src/webview/components/PriorityBadge.tsx:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Priority Badge Component
3 | */
4 |
5 | import React from 'react';
6 | import { Badge } from '@/components/ui/badge';
7 | import type { TaskMasterTask } from '../types';
8 |
9 | interface PriorityBadgeProps {
10 | priority: TaskMasterTask['priority'];
11 | }
12 |
13 | export const PriorityBadge: React.FC<PriorityBadgeProps> = ({ priority }) => {
14 | if (!priority) return null;
15 |
16 | const variants = {
17 | high: 'destructive' as const,
18 | medium: 'default' as const,
19 | low: 'secondary' as const
20 | };
21 |
22 | return (
23 | <Badge
24 | variant={variants[priority] || 'secondary'}
25 | className="text-xs font-normal px-2 py-0.5"
26 | >
27 | {priority}
28 | </Badge>
29 | );
30 | };
31 |
```
--------------------------------------------------------------------------------
/apps/cli/src/ui/formatters/priority-formatters.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Priority formatting utilities
3 | * Provides colored priority displays for tasks
4 | */
5 |
6 | import type { TaskPriority } from '@tm/core';
7 | import chalk from 'chalk';
8 |
9 | /**
10 | * Module-level priority color map to avoid recreating on every call
11 | */
12 | const PRIORITY_COLORS: Record<TaskPriority, (text: string) => string> = {
13 | critical: chalk.red.bold,
14 | high: chalk.red,
15 | medium: chalk.yellow,
16 | low: chalk.gray
17 | };
18 |
19 | /**
20 | * Get colored priority display
21 | */
22 | export function getPriorityWithColor(priority: TaskPriority): string {
23 | const colorFn = PRIORITY_COLORS[priority] || chalk.white;
24 | return colorFn(priority);
25 | }
26 |
```
--------------------------------------------------------------------------------
/apps/mcp/src/tools/autopilot/index.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Autopilot MCP tools index
3 | * Exports all autopilot tool registration functions
4 | */
5 |
6 | export { registerAutopilotStartTool } from './start.tool.js';
7 | export { registerAutopilotResumeTool } from './resume.tool.js';
8 | export { registerAutopilotNextTool } from './next.tool.js';
9 | export { registerAutopilotStatusTool } from './status.tool.js';
10 | export { registerAutopilotCompleteTool } from './complete.tool.js';
11 | export { registerAutopilotCommitTool } from './commit.tool.js';
12 | export { registerAutopilotFinalizeTool } from './finalize.tool.js';
13 | export { registerAutopilotAbortTool } from './abort.tool.js';
14 |
```
--------------------------------------------------------------------------------
/src/schemas/parse-prd.js:
--------------------------------------------------------------------------------
```javascript
1 | import { z } from 'zod';
2 |
3 | // Schema for a single task from PRD parsing
4 | const PRDSingleTaskSchema = z.object({
5 | id: z.number().int().positive(),
6 | title: z.string().min(1),
7 | description: z.string().min(1),
8 | details: z.string().nullable(),
9 | testStrategy: z.string().nullable(),
10 | priority: z.enum(['high', 'medium', 'low']).nullable(),
11 | dependencies: z.array(z.number().int().positive()).nullable(),
12 | status: z.string().nullable()
13 | });
14 |
15 | // Schema for the AI response - only expects tasks array since metadata is generated by the code
16 | export const ParsePRDResponseSchema = z.object({
17 | tasks: z.array(PRDSingleTaskSchema)
18 | });
19 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "@tm/claude-code-plugin",
3 | "version": "0.0.4",
4 | "description": "Task Master AI plugin for Claude Code - AI-powered task management with commands, agents, and MCP integration",
5 | "type": "module",
6 | "private": true,
7 | "keywords": [
8 | "claude-code",
9 | "plugin",
10 | "task-management",
11 | "ai",
12 | "mcp",
13 | "workflow",
14 | "productivity"
15 | ],
16 | "author": {
17 | "name": "Eyal Toledano",
18 | "url": "https://github.com/eyaltoledano/claude-task-master"
19 | },
20 | "license": "MIT WITH Commons-Clause",
21 | "repository": {
22 | "type": "git",
23 | "url": "git+https://github.com/eyaltoledano/claude-task-master.git",
24 | "directory": "packages/claude-code-plugin"
25 | }
26 | }
27 |
```
--------------------------------------------------------------------------------
/.cursor/mcp.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "mcpServers": {
3 | "task-master-ai": {
4 | "command": "node",
5 | "args": ["./dist/mcp-server.js"],
6 | "env": {
7 | "ANTHROPIC_API_KEY": "ANTHROPIC_API_KEY_HERE",
8 | "PERPLEXITY_API_KEY": "PERPLEXITY_API_KEY_HERE",
9 | "OPENAI_API_KEY": "OPENAI_API_KEY_HERE",
10 | "GOOGLE_API_KEY": "GOOGLE_API_KEY_HERE",
11 | "GROQ_API_KEY": "GROQ_API_KEY_HERE",
12 | "XAI_API_KEY": "XAI_API_KEY_HERE",
13 | "OPENROUTER_API_KEY": "OPENROUTER_API_KEY_HERE",
14 | "MISTRAL_API_KEY": "MISTRAL_API_KEY_HERE",
15 | "AZURE_OPENAI_API_KEY": "AZURE_OPENAI_API_KEY_HERE",
16 | "OLLAMA_API_KEY": "OLLAMA_API_KEY_HERE",
17 | "GITHUB_API_KEY": "GITHUB_API_KEY_HERE"
18 | }
19 | }
20 | }
21 | }
22 |
```
--------------------------------------------------------------------------------
/src/profiles/index.js:
--------------------------------------------------------------------------------
```javascript
1 | // Profile exports for centralized importing
2 | export { ampProfile } from './amp.js';
3 | export { claudeProfile } from './claude.js';
4 | export { clineProfile } from './cline.js';
5 | export { codexProfile } from './codex.js';
6 | export { cursorProfile } from './cursor.js';
7 | export { geminiProfile } from './gemini.js';
8 | export { kiloProfile } from './kilo.js';
9 | export { kiroProfile } from './kiro.js';
10 | export { opencodeProfile } from './opencode.js';
11 | export { rooProfile } from './roo.js';
12 | export { traeProfile } from './trae.js';
13 | export { vscodeProfile } from './vscode.js';
14 | export { windsurfProfile } from './windsurf.js';
15 | export { zedProfile } from './zed.js';
16 |
```
--------------------------------------------------------------------------------
/src/profiles/gemini.js:
--------------------------------------------------------------------------------
```javascript
1 | // Gemini profile for rule-transformer
2 | import { createProfile } from './base-profile.js';
3 |
4 | // Create and export gemini profile using the base factory
5 | export const geminiProfile = createProfile({
6 | name: 'gemini',
7 | displayName: 'Gemini',
8 | url: 'codeassist.google',
9 | docsUrl: 'github.com/google-gemini/gemini-cli',
10 | profileDir: '.gemini', // Keep .gemini for settings.json
11 | rulesDir: '.', // Root directory for GEMINI.md
12 | mcpConfigName: 'settings.json', // Override default 'mcp.json'
13 | includeDefaultRules: false,
14 | fileMap: {
15 | 'AGENT.md': 'AGENTS.md', // Generic base for all AI agents
16 | 'GEMINI.md': 'GEMINI.md' // Gemini-specific features only
17 | }
18 | });
19 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/quick-install-taskmaster.md:
--------------------------------------------------------------------------------
```markdown
1 | Quick install Task Master globally if not already installed.
2 |
3 | Execute this streamlined installation:
4 |
5 | ```bash
6 | # Check and install in one command
7 | task-master --version 2>/dev/null || npm install -g task-master-ai
8 |
9 | # Verify installation
10 | task-master --version
11 |
12 | # Quick setup check
13 | task-master models --status || echo "Note: You'll need to set up an AI provider API key"
14 | ```
15 |
16 | If you see "command not found" after installation, you may need to:
17 | 1. Restart your terminal
18 | 2. Or add npm global bin to PATH: `export PATH=$(npm bin -g):$PATH`
19 |
20 | Once installed, you can use all the Task Master commands!
21 |
22 | Quick test: Run `/project:help` to see all available commands.
```
--------------------------------------------------------------------------------
/src/schemas/add-task.js:
--------------------------------------------------------------------------------
```javascript
1 | import { z } from 'zod';
2 |
3 | // Schema that matches the inline AiTaskDataSchema from add-task.js
4 | export const AddTaskResponseSchema = z.object({
5 | title: z.string().describe('Clear, concise title for the task'),
6 | description: z
7 | .string()
8 | .describe('A one or two sentence description of the task'),
9 | details: z
10 | .string()
11 | .describe('In-depth implementation details, considerations, and guidance'),
12 | testStrategy: z
13 | .string()
14 | .describe('Detailed approach for verifying task completion'),
15 | dependencies: z
16 | .array(z.number())
17 | .nullable()
18 | .describe(
19 | 'Array of task IDs that this task depends on (must be completed before this task can start)'
20 | )
21 | });
22 |
```
--------------------------------------------------------------------------------
/apps/extension/src/components/ui/separator.tsx:
--------------------------------------------------------------------------------
```typescript
1 | 'use client';
2 |
3 | import * as SeparatorPrimitive from '@radix-ui/react-separator';
4 | import type * as React from 'react';
5 |
6 | import { cn } from '@/lib/utils';
7 |
8 | function Separator({
9 | className,
10 | orientation = 'horizontal',
11 | decorative = true,
12 | ...props
13 | }: React.ComponentProps<typeof SeparatorPrimitive.Root>) {
14 | return (
15 | <SeparatorPrimitive.Root
16 | data-slot="separator"
17 | decorative={decorative}
18 | orientation={orientation}
19 | className={cn(
20 | 'bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px',
21 | className
22 | )}
23 | {...props}
24 | />
25 | );
26 | }
27 |
28 | export { Separator };
29 |
```
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feedback.md:
--------------------------------------------------------------------------------
```markdown
1 | ---
2 | name: Feedback
3 | about: Give us specific feedback on the product/approach/tech
4 | title: 'feedback: '
5 | labels: feedback
6 | assignees: ''
7 | ---
8 |
9 | ### Feedback Summary
10 |
11 | Provide a clear summary or direct quote from user feedback.
12 |
13 | ### User Context
14 |
15 | Explain the user's context or scenario in which this feedback was provided.
16 |
17 | ### User Impact
18 |
19 | Describe how this feedback affects the user experience or workflow.
20 |
21 | ### Suggestions
22 |
23 | Provide any initial thoughts, potential solutions, or improvements based on the feedback.
24 |
25 | ### Relevant Screenshots or Examples
26 |
27 | Attach screenshots, logs, or examples that illustrate the feedback.
28 |
29 | ### Additional Notes
30 |
31 | Any additional context or related information.
32 |
```
--------------------------------------------------------------------------------
/apps/extension/src/components/constants.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Shared constants for TaskDetails components
3 | */
4 |
5 | /**
6 | * Status color definitions for visual indicators
7 | */
8 | export const STATUS_DOT_COLORS = {
9 | done: '#22c55e', // Green
10 | 'in-progress': '#3b82f6', // Blue
11 | review: '#a855f7', // Purple
12 | deferred: '#ef4444', // Red
13 | cancelled: '#6b7280', // Gray
14 | pending: '#eab308' // Yellow (default)
15 | } as const;
16 |
17 | export type TaskStatus = keyof typeof STATUS_DOT_COLORS;
18 |
19 | /**
20 | * Get the color for a status dot indicator
21 | * @param status - The task status
22 | * @returns The hex color code for the status
23 | */
24 | export function getStatusDotColor(status: string): string {
25 | return STATUS_DOT_COLORS[status as TaskStatus] || STATUS_DOT_COLORS.pending;
26 | }
27 |
```
--------------------------------------------------------------------------------
/packages/tm-core/src/utils/time.utils.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Time utilities for formatting relative timestamps
3 | * Shared across CLI, MCP, extension, and other interfaces
4 | */
5 |
6 | import { formatDistanceToNow } from 'date-fns';
7 |
8 | /**
9 | * Format a date as relative time from now (e.g., "2 hours ago", "3 days ago")
10 | * @param date - Date string or Date object to format
11 | * @returns Relative time string (e.g., "less than a minute ago", "5 minutes ago", "2 weeks ago")
12 | */
13 | export function formatRelativeTime(date: string | Date): string {
14 | const dateObj = typeof date === 'string' ? new Date(date) : date;
15 |
16 | // Use date-fns for robust formatting with proper edge case handling
17 | return formatDistanceToNow(dateObj, { addSuffix: true });
18 | }
19 |
```
--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE/bugfix.md:
--------------------------------------------------------------------------------
```markdown
1 | ## 🐛 Bug Fix
2 |
3 | ### 🔍 Bug Description
4 | <!-- Describe the bug -->
5 |
6 | ### 🔗 Related Issues
7 | <!-- Fixes #123 -->
8 |
9 | ### ✨ Solution
10 | <!-- How does this PR fix the bug? -->
11 |
12 | ## How to Test
13 |
14 | ### Steps that caused the bug:
15 | 1.
16 | 2.
17 |
18 | **Before fix:**
19 | **After fix:**
20 |
21 | ### Quick verification:
22 | ```bash
23 | # Commands to verify the fix
24 | ```
25 |
26 | ## Contributor Checklist
27 | - [ ] Created changeset: `npm run changeset`
28 | - [ ] Tests pass: `npm test`
29 | - [ ] Format check passes: `npm run format-check`
30 | - [ ] Addressed CodeRabbit comments
31 | - [ ] Added unit tests (if applicable)
32 | - [ ] Manually verified the fix works
33 |
34 | ---
35 |
36 | ### For Maintainers
37 | - [ ] Root cause identified
38 | - [ ] Fix doesn't introduce new issues
39 | - [ ] CI passes
```
--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "json.schemas": [
3 | {
4 | "fileMatch": ["src/prompts/*.json"],
5 | "url": "./src/prompts/schemas/prompt-template.schema.json"
6 | }
7 | ],
8 | "files.associations": {
9 | "src/prompts/*.json": "json"
10 | },
11 |
12 | "json.format.enable": true,
13 | "json.validate.enable": true,
14 | "typescript.tsdk": "node_modules/typescript/lib",
15 | "[typescript]": {
16 | "editor.defaultFormatter": "biomejs.biome"
17 | },
18 | "[typescriptreact]": {
19 | "editor.defaultFormatter": "biomejs.biome"
20 | },
21 | "[javascript]": {
22 | "editor.defaultFormatter": "biomejs.biome"
23 | },
24 | "[json]": {
25 | "editor.defaultFormatter": "biomejs.biome"
26 | },
27 | "editor.codeActionsOnSave": {
28 | "source.organizeImports.biome": "explicit",
29 | "source.fixAll.biome": "explicit"
30 | }
31 | }
32 |
```
--------------------------------------------------------------------------------
/packages/tm-core/src/modules/auth/index.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Authentication module exports
3 | */
4 |
5 | export { AuthDomain, type StorageDisplayInfo } from './auth-domain.js';
6 | export { AuthManager } from './managers/auth-manager.js';
7 | export { ContextStore, type StoredContext } from './services/context-store.js';
8 | export { OAuthService } from './services/oauth-service.js';
9 | export { SupabaseSessionStorage } from './services/supabase-session-storage.js';
10 | export type {
11 | Organization,
12 | RemoteTask
13 | } from './services/organization.service.js';
14 |
15 | export type {
16 | AuthCredentials,
17 | OAuthFlowOptions,
18 | AuthConfig,
19 | CliData,
20 | UserContext
21 | } from './types.js';
22 |
23 | export { AuthenticationError } from './types.js';
24 |
25 | export {
26 | DEFAULT_AUTH_CONFIG,
27 | getAuthConfig
28 | } from './config.js';
29 |
```
--------------------------------------------------------------------------------
/apps/cli/src/utils/index.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview CLI utilities main export
3 | * General-purpose utilities (non-UI)
4 | *
5 | * Note: UI-related utilities have been moved to src/ui/
6 | * For backward compatibility, use src/utils/ui.ts which re-exports from src/ui/
7 | */
8 |
9 | // Authentication helpers
10 | export {
11 | checkAuthentication,
12 | type CheckAuthOptions
13 | } from './auth-helpers.js';
14 |
15 | // Error handling utilities
16 | export { displayError, isDebugMode } from './error-handler.js';
17 |
18 | // Auto-update utilities
19 | export {
20 | checkForUpdate,
21 | performAutoUpdate,
22 | displayUpgradeNotification,
23 | compareVersions,
24 | restartWithNewVersion
25 | } from './auto-update.js';
26 |
27 | // Display helpers (command-specific helpers)
28 | export { displayCommandHeader } from './display-helpers.js';
29 |
```
--------------------------------------------------------------------------------
/apps/extension/src/webview/components/ToastContainer.tsx:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Toast Container Component
3 | */
4 |
5 | import React from 'react';
6 | import { ToastNotification } from './ToastNotification';
7 | import type { ToastNotification as ToastType } from '../types';
8 |
9 | interface ToastContainerProps {
10 | notifications: ToastType[];
11 | onDismiss: (id: string) => void;
12 | }
13 |
14 | export const ToastContainer: React.FC<ToastContainerProps> = ({
15 | notifications,
16 | onDismiss
17 | }) => {
18 | return (
19 | <div className="fixed top-4 right-4 z-50 pointer-events-none">
20 | <div className="flex flex-col items-end pointer-events-auto">
21 | {notifications.map((notification) => (
22 | <ToastNotification
23 | key={notification.id}
24 | notification={notification}
25 | onDismiss={onDismiss}
26 | />
27 | ))}
28 | </div>
29 | </div>
30 | );
31 | };
32 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/to-pending.md:
--------------------------------------------------------------------------------
```markdown
1 | Set a task's status to pending.
2 |
3 | Arguments: $ARGUMENTS (task ID)
4 |
5 | ## Setting Task to Pending
6 |
7 | This moves a task back to the pending state, useful for:
8 | - Resetting erroneously started tasks
9 | - Deferring work that was prematurely begun
10 | - Reorganizing sprint priorities
11 |
12 | ## Execution
13 |
14 | ```bash
15 | task-master set-status --id=$ARGUMENTS --status=pending
16 | ```
17 |
18 | ## Validation
19 |
20 | Before setting to pending:
21 | - Warn if task is currently in-progress
22 | - Check if this will block other tasks
23 | - Suggest documenting why it's being reset
24 | - Preserve any work already done
25 |
26 | ## Smart Actions
27 |
28 | After setting to pending:
29 | - Update sprint planning if needed
30 | - Notify about freed resources
31 | - Suggest priority reassessment
32 | - Log the status change with context
```
--------------------------------------------------------------------------------
/mcp-server/src/core/direct-functions/cache-stats.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * cache-stats.js
3 | * Direct function implementation for retrieving cache statistics
4 | */
5 |
6 | import { contextManager } from '../context-manager.js';
7 |
8 | /**
9 | * Get cache statistics for monitoring
10 | * @param {Object} args - Command arguments
11 | * @param {Object} log - Logger object
12 | * @returns {Object} - Cache statistics
13 | */
14 | export async function getCacheStatsDirect(args, log) {
15 | try {
16 | log.info('Retrieving cache statistics');
17 | const stats = contextManager.getStats();
18 | return {
19 | success: true,
20 | data: stats
21 | };
22 | } catch (error) {
23 | log.error(`Error getting cache stats: ${error.message}`);
24 | return {
25 | success: false,
26 | error: {
27 | code: 'CACHE_STATS_ERROR',
28 | message: error.message || 'Unknown error occurred'
29 | }
30 | };
31 | }
32 | }
33 |
```
--------------------------------------------------------------------------------
/apps/extension/src/components/ui/textarea.tsx:
--------------------------------------------------------------------------------
```typescript
1 | import type * as React from 'react';
2 |
3 | import { cn } from '@/lib/utils';
4 |
5 | function Textarea({ className, ...props }: React.ComponentProps<'textarea'>) {
6 | return (
7 | <textarea
8 | data-slot="textarea"
9 | className={cn(
10 | 'border-input placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:bg-input/30 flex field-sizing-content min-h-16 w-full rounded-md border bg-transparent px-3 py-2 text-base shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
11 | className
12 | )}
13 | {...props}
14 | />
15 | );
16 | }
17 |
18 | export { Textarea };
19 |
```
--------------------------------------------------------------------------------
/packages/ai-sdk-provider-grok-cli/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "@tm/ai-sdk-provider-grok-cli",
3 | "private": true,
4 | "description": "AI SDK provider for Grok CLI integration",
5 | "type": "module",
6 | "types": "./src/index.ts",
7 | "main": "./dist/index.js",
8 | "exports": {
9 | ".": "./src/index.ts"
10 | },
11 | "scripts": {
12 | "test": "vitest run",
13 | "test:watch": "vitest",
14 | "test:ui": "vitest --ui",
15 | "typecheck": "tsc --noEmit"
16 | },
17 | "dependencies": {
18 | "@ai-sdk/provider": "^2.0.0",
19 | "@ai-sdk/provider-utils": "^3.0.10",
20 | "jsonc-parser": "^3.3.1"
21 | },
22 | "devDependencies": {
23 | "@types/node": "^22.18.6",
24 | "typescript": "^5.9.2",
25 | "vitest": "^3.2.4"
26 | },
27 | "engines": {
28 | "node": ">=18"
29 | },
30 | "keywords": ["ai", "grok", "x.ai", "cli", "language-model", "provider"],
31 | "files": ["dist/**/*", "README.md"],
32 | "version": ""
33 | }
34 |
```
--------------------------------------------------------------------------------
/mcp-server/server.js:
--------------------------------------------------------------------------------
```javascript
1 | #!/usr/bin/env node
2 |
3 | import TaskMasterMCPServer from './src/index.js';
4 | import dotenv from 'dotenv';
5 | import logger from './src/logger.js';
6 |
7 | // Load environment variables
8 | dotenv.config();
9 |
10 | // Set MCP mode to silence tm-core console output
11 | process.env.TASK_MASTER_MCP = 'true';
12 |
13 | /**
14 | * Start the MCP server
15 | */
16 | async function startServer() {
17 | const server = new TaskMasterMCPServer();
18 |
19 | // Handle graceful shutdown
20 | process.on('SIGINT', async () => {
21 | await server.stop();
22 | process.exit(0);
23 | });
24 |
25 | process.on('SIGTERM', async () => {
26 | await server.stop();
27 | process.exit(0);
28 | });
29 |
30 | try {
31 | await server.start();
32 | } catch (error) {
33 | logger.error(`Failed to start MCP server: ${error.message}`);
34 | process.exit(1);
35 | }
36 | }
37 |
38 | // Start the server
39 | startServer();
40 |
```
--------------------------------------------------------------------------------
/apps/extension/src/components/ui/collapsible.tsx:
--------------------------------------------------------------------------------
```typescript
1 | import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
2 |
3 | function Collapsible({
4 | ...props
5 | }: React.ComponentProps<typeof CollapsiblePrimitive.Root>) {
6 | return <CollapsiblePrimitive.Root data-slot="collapsible" {...props} />;
7 | }
8 |
9 | function CollapsibleTrigger({
10 | ...props
11 | }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>) {
12 | return (
13 | <CollapsiblePrimitive.CollapsibleTrigger
14 | data-slot="collapsible-trigger"
15 | {...props}
16 | />
17 | );
18 | }
19 |
20 | function CollapsibleContent({
21 | ...props
22 | }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>) {
23 | return (
24 | <CollapsiblePrimitive.CollapsibleContent
25 | data-slot="collapsible-content"
26 | {...props}
27 | />
28 | );
29 | }
30 |
31 | export { Collapsible, CollapsibleTrigger, CollapsibleContent };
32 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/list-tasks-with-subtasks.md:
--------------------------------------------------------------------------------
```markdown
1 | List all tasks including their subtasks in a hierarchical view.
2 |
3 | This command shows all tasks with their nested subtasks, providing a complete project overview.
4 |
5 | ## Execution
6 |
7 | Run the Task Master list command with subtasks flag:
8 | ```bash
9 | task-master list --with-subtasks
10 | ```
11 |
12 | ## Enhanced Display
13 |
14 | I'll organize the output to show:
15 | - Parent tasks with clear indicators
16 | - Nested subtasks with proper indentation
17 | - Status badges for quick scanning
18 | - Dependencies and blockers highlighted
19 | - Progress indicators for tasks with subtasks
20 |
21 | ## Smart Filtering
22 |
23 | Based on the task hierarchy:
24 | - Show completion percentage for parent tasks
25 | - Highlight blocked subtask chains
26 | - Group by functional areas
27 | - Indicate critical path items
28 |
29 | This gives you a complete tree view of your project structure.
```
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
```markdown
1 | ---
2 | name: Bug report
3 | about: Create a report to help us improve
4 | title: 'bug: '
5 | labels: bug
6 | assignees: ''
7 | ---
8 |
9 | ### Description
10 |
11 | Detailed description of the problem, including steps to reproduce the issue.
12 |
13 | ### Steps to Reproduce
14 |
15 | 1. Step-by-step instructions to reproduce the issue
16 | 2. Include command examples or UI interactions
17 |
18 | ### Expected Behavior
19 |
20 | Describe clearly what the expected outcome or behavior should be.
21 |
22 | ### Actual Behavior
23 |
24 | Describe clearly what the actual outcome or behavior is.
25 |
26 | ### Screenshots or Logs
27 |
28 | Provide screenshots, logs, or error messages if applicable.
29 |
30 | ### Environment
31 |
32 | - Task Master version:
33 | - Node.js version:
34 | - Operating system:
35 | - IDE (if applicable):
36 |
37 | ### Additional Context
38 |
39 | Any additional information or context that might help diagnose the issue.
40 |
```
--------------------------------------------------------------------------------
/packages/tm-bridge/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "@tm/bridge",
3 | "private": true,
4 | "description": "TEMPORARY: Bridge layer for legacy code migration. DELETE when legacy scripts are removed.",
5 | "type": "module",
6 | "types": "./src/index.ts",
7 | "main": "./dist/index.js",
8 | "exports": {
9 | ".": "./src/index.ts"
10 | },
11 | "scripts": {
12 | "test": "vitest run",
13 | "test:watch": "vitest",
14 | "lint": "biome check --write",
15 | "lint:check": "biome check",
16 | "typecheck": "tsc --noEmit"
17 | },
18 | "dependencies": {
19 | "@tm/core": "*",
20 | "chalk": "5.6.2",
21 | "boxen": "^8.0.1",
22 | "ora": "^8.1.1",
23 | "cli-table3": "^0.6.5"
24 | },
25 | "devDependencies": {
26 | "@types/node": "^22.10.5",
27 | "typescript": "^5.9.2",
28 | "vitest": "^3.2.4"
29 | },
30 | "files": ["src", "README.md"],
31 | "keywords": ["temporary", "bridge", "migration"],
32 | "author": "Task Master AI",
33 | "version": ""
34 | }
35 |
```
--------------------------------------------------------------------------------
/assets/config.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "models": {
3 | "main": {
4 | "provider": "anthropic",
5 | "modelId": "claude-3-7-sonnet-20250219",
6 | "maxTokens": 100000,
7 | "temperature": 0.2
8 | },
9 | "research": {
10 | "provider": "perplexity",
11 | "modelId": "sonar-pro",
12 | "maxTokens": 8700,
13 | "temperature": 0.1
14 | },
15 | "fallback": {
16 | "provider": "anthropic",
17 | "modelId": "claude-3-7-sonnet-20250219",
18 | "maxTokens": 8192,
19 | "temperature": 0.2
20 | }
21 | },
22 | "global": {
23 | "logLevel": "info",
24 | "debug": false,
25 | "defaultSubtasks": 5,
26 | "defaultPriority": "medium",
27 | "projectName": "Taskmaster",
28 | "defaultTag": "master",
29 | "ollamaBaseURL": "http://localhost:11434/api",
30 | "azureOpenaiBaseURL": "https://your-endpoint.openai.azure.com/",
31 | "bedrockBaseURL": "https://bedrock.us-east-1.amazonaws.com",
32 | "responseLanguage": "English"
33 | }
34 | }
35 |
```
--------------------------------------------------------------------------------
/apps/extension/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "module": "ESNext",
4 | "target": "ES2022",
5 | "outDir": "out",
6 | "lib": ["ES2022", "DOM"],
7 | "sourceMap": true,
8 | "strict": true /* enable all strict type-checking options */,
9 | "moduleResolution": "Node",
10 | "esModuleInterop": true,
11 | "skipLibCheck": true,
12 | "forceConsistentCasingInFileNames": true,
13 | "jsx": "react-jsx",
14 | "allowSyntheticDefaultImports": true,
15 | "resolveJsonModule": true,
16 | "declaration": false,
17 | "declarationMap": false,
18 | "baseUrl": ".",
19 | "paths": {
20 | "@/*": ["./src/*"],
21 | "@/components/*": ["./src/components/*"],
22 | "@/lib/*": ["./src/lib/*"],
23 | "@tm/core": ["../../packages/tm-core/src/index.ts"],
24 | "@tm/core/*": ["../../packages/tm-core/src/*"]
25 | }
26 | },
27 | "include": ["src/**/*"],
28 | "exclude": ["node_modules", ".vscode-test", "out", "dist"]
29 | }
30 |
```
--------------------------------------------------------------------------------
/sonar-project.properties:
--------------------------------------------------------------------------------
```
1 | # SonarQube/SonarCloud Configuration
2 | sonar.projectKey=task-master-ai
3 | sonar.organization=your-org-name
4 | sonar.projectName=Task Master AI
5 | sonar.projectVersion=0.31.2
6 |
7 | # Source code directories
8 | sonar.sources=apps,packages,scripts,src
9 |
10 | # Test directories (excluded from coverage)
11 | sonar.tests=tests
12 | sonar.test.inclusions=**/*.test.js,**/*.spec.js,**/*.test.ts,**/*.spec.ts
13 |
14 | # Exclude test files from source analysis
15 | sonar.coverage.exclusions=**/*.test.js,**/*.spec.js,**/*.test.ts,**/*.spec.ts,**/tests/**,**/__tests__/**,**/node_modules/**,**/dist/**,**/coverage/**
16 |
17 | # Exclude other non-source files
18 | sonar.exclusions=**/node_modules/**,**/dist/**,**/coverage/**,**/*.config.js,**/*.config.ts
19 |
20 | # JavaScript/TypeScript settings
21 | sonar.javascript.lcov.reportPaths=coverage/lcov.info
22 |
23 | # Encoding
24 | sonar.sourceEncoding=UTF-8
25 |
```
--------------------------------------------------------------------------------
/apps/extension/src/utils/event-emitter.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Simple Event Emitter
3 | * Lightweight alternative to complex event bus
4 | */
5 |
6 | export type EventHandler = (...args: any[]) => void | Promise<void>;
7 |
8 | export class EventEmitter {
9 | private handlers = new Map<string, Set<EventHandler>>();
10 |
11 | on(event: string, handler: EventHandler): () => void {
12 | if (!this.handlers.has(event)) {
13 | this.handlers.set(event, new Set());
14 | }
15 | this.handlers.get(event)?.add(handler);
16 |
17 | // Return unsubscribe function
18 | return () => this.off(event, handler);
19 | }
20 |
21 | off(event: string, handler: EventHandler): void {
22 | this.handlers.get(event)?.delete(handler);
23 | }
24 |
25 | emit(event: string, ...args: any[]): void {
26 | this.handlers.get(event)?.forEach((handler) => {
27 | try {
28 | handler(...args);
29 | } catch (error) {
30 | console.error(`Error in event handler for ${event}:`, error);
31 | }
32 | });
33 | }
34 | }
35 |
```
--------------------------------------------------------------------------------
/apps/cli/src/ui/formatters/dependency-formatters.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Dependency formatting utilities
3 | * Provides formatted dependency displays with status indicators
4 | */
5 |
6 | import type { Task } from '@tm/core';
7 | import chalk from 'chalk';
8 |
9 | /**
10 | * Format dependencies with their status
11 | */
12 | export function formatDependenciesWithStatus(
13 | dependencies: string[] | number[],
14 | tasks: Task[]
15 | ): string {
16 | if (!dependencies || dependencies.length === 0) {
17 | return chalk.gray('none');
18 | }
19 |
20 | const taskMap = new Map(tasks.map((t) => [t.id.toString(), t]));
21 |
22 | return dependencies
23 | .map((depId) => {
24 | const task = taskMap.get(depId.toString());
25 | if (!task) {
26 | return chalk.red(`${depId} (not found)`);
27 | }
28 |
29 | const statusIcon =
30 | task.status === 'done'
31 | ? '✓'
32 | : task.status === 'in-progress'
33 | ? '►'
34 | : '○';
35 |
36 | return `${depId}${statusIcon}`;
37 | })
38 | .join(', ');
39 | }
40 |
```
--------------------------------------------------------------------------------
/bin/task-master.js:
--------------------------------------------------------------------------------
```javascript
1 | #!/usr/bin/env node
2 |
3 | /**
4 | * Task Master
5 | * Copyright (c) 2025 Eyal Toledano, Ralph Khreish
6 | *
7 | * This software is licensed under the MIT License with Commons Clause.
8 | * You may use this software for any purpose, including commercial applications,
9 | * and modify and redistribute it freely, subject to the following restrictions:
10 | *
11 | * 1. You may not sell this software or offer it as a service.
12 | * 2. The origin of this software must not be misrepresented.
13 | * 3. Altered source versions must be plainly marked as such.
14 | *
15 | * For the full license text, see the LICENSE file in the root directory.
16 | */
17 |
18 | /**
19 | * Claude Task Master CLI
20 | * Main entry point for globally installed package
21 | */
22 |
23 | // Direct imports instead of spawning child processes
24 | import { runCLI } from '../scripts/modules/commands.js';
25 |
26 | // Simply run the CLI directly
27 | runCLI();
28 |
```
--------------------------------------------------------------------------------
/src/constants/task-status.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * @typedef {'pending' | 'done' | 'in-progress' | 'review' | 'deferred' | 'cancelled'} TaskStatus
3 | */
4 |
5 | /**
6 | * Task status options list
7 | * @type {TaskStatus[]}
8 | * @description Defines possible task statuses:
9 | * - pending: Task waiting to start
10 | * - done: Task completed
11 | * - in-progress: Task in progress
12 | * - review: Task completed and waiting for review
13 | * - deferred: Task postponed or paused
14 | * - cancelled: Task cancelled and will not be completed
15 | */
16 | export const TASK_STATUS_OPTIONS = [
17 | 'pending',
18 | 'done',
19 | 'in-progress',
20 | 'review',
21 | 'deferred',
22 | 'cancelled'
23 | ];
24 |
25 | /**
26 | * Check if a given status is a valid task status
27 | * @param {string} status - The status to check
28 | * @returns {boolean} True if the status is valid, false otherwise
29 | */
30 | export function isValidTaskStatus(status) {
31 | return TASK_STATUS_OPTIONS.includes(status);
32 | }
33 |
```
--------------------------------------------------------------------------------
/.claude-plugin/marketplace.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "taskmaster",
3 | "owner": {
4 | "name": "Hamster",
5 | "email": "[email protected]"
6 | },
7 | "metadata": {
8 | "description": "Official marketplace for Taskmaster AI - AI-powered task management for ambitious development",
9 | "version": "1.0.0"
10 | },
11 | "plugins": [
12 | {
13 | "name": "taskmaster",
14 | "source": "./packages/claude-code-plugin",
15 | "description": "AI-powered task management system for ambitious development workflows with intelligent orchestration, complexity analysis, and automated coordination",
16 | "author": {
17 | "name": "Hamster"
18 | },
19 | "homepage": "https://github.com/eyaltoledano/claude-task-master",
20 | "repository": "https://github.com/eyaltoledano/claude-task-master",
21 | "keywords": [
22 | "task-management",
23 | "ai",
24 | "workflow",
25 | "orchestration",
26 | "automation",
27 | "mcp"
28 | ],
29 | "category": "productivity"
30 | }
31 | ]
32 | }
33 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/init-project-quick.md:
--------------------------------------------------------------------------------
```markdown
1 | Quick initialization with auto-confirmation.
2 |
3 | Arguments: $ARGUMENTS
4 |
5 | Initialize a Task Master project without prompts, accepting all defaults.
6 |
7 | ## Quick Setup
8 |
9 | ```bash
10 | task-master init -y
11 | ```
12 |
13 | ## What It Does
14 |
15 | 1. Creates `.taskmaster/` directory structure
16 | 2. Initializes empty `tasks.json`
17 | 3. Sets up default configuration
18 | 4. Uses directory name as project name
19 | 5. Skips all confirmation prompts
20 |
21 | ## Smart Defaults
22 |
23 | - Project name: Current directory name
24 | - Description: "Task Master Project"
25 | - Model config: Existing environment vars
26 | - Task structure: Standard format
27 |
28 | ## Next Steps
29 |
30 | After quick init:
31 | 1. Configure AI models if needed:
32 | ```
33 | /taskmaster:models/setup
34 | ```
35 |
36 | 2. Parse PRD if available:
37 | ```
38 | /taskmaster:parse-prd <file>
39 | ```
40 |
41 | 3. Or create first task:
42 | ```
43 | /taskmaster:add-task create initial setup
44 | ```
45 |
46 | Perfect for rapid project setup!
```
--------------------------------------------------------------------------------
/apps/extension/src/webview/constants/index.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Application constants
3 | */
4 |
5 | import type { Status } from '@/components/ui/shadcn-io/kanban';
6 |
7 | export const kanbanStatuses = [
8 | {
9 | id: 'pending',
10 | title: 'Pending',
11 | color: 'yellow',
12 | className: 'text-yellow-600 border-yellow-600/20'
13 | },
14 | {
15 | id: 'in-progress',
16 | title: 'In Progress',
17 | color: 'blue',
18 | className: 'text-blue-600 border-blue-600/20'
19 | },
20 | {
21 | id: 'review',
22 | title: 'Review',
23 | color: 'purple',
24 | className: 'text-purple-600 border-purple-600/20'
25 | },
26 | {
27 | id: 'done',
28 | title: 'Done',
29 | color: 'green',
30 | className: 'text-green-600 border-green-600/20'
31 | },
32 | {
33 | id: 'deferred',
34 | title: 'Deferred',
35 | color: 'gray',
36 | className: 'text-gray-600 border-gray-600/20'
37 | }
38 | ] as const;
39 |
40 | export const CACHE_DURATION = 30000; // 30 seconds
41 | export const REQUEST_TIMEOUT = 30000; // 30 seconds
42 | export const HEADER_HEIGHT = 73; // Header with padding and border
43 |
```
--------------------------------------------------------------------------------
/.taskmaster/tasks/task_002_tm-start.txt:
--------------------------------------------------------------------------------
```
1 | # Task ID: 2
2 | # Title: Register start command in CLI
3 | # Status: pending
4 | # Dependencies: 7
5 | # Priority: high
6 | # Description: Register the start command in the CLI application
7 | # Details:
8 | Update the CLI application to register the new start command. This involves importing the StartCommand class and adding it to the commands array in the CLI initialization.
9 |
10 | In `apps/cli/src/index.ts` or the appropriate file where commands are registered:
11 |
12 | ```typescript
13 | import { StartCommand } from './commands/start.command';
14 |
15 | // Add StartCommand to the commands array
16 | const commands = [
17 | // ... existing commands
18 | new StartCommand(),
19 | ];
20 |
21 | // Register all commands
22 | commands.forEach(command => command.register(program));
23 | ```
24 |
25 | # Test Strategy:
26 | Verify the command is correctly registered by running the CLI with --help and checking that the start command appears in the list of available commands.
27 |
```
--------------------------------------------------------------------------------
/.github/workflows/auto-close-duplicates.yml:
--------------------------------------------------------------------------------
```yaml
1 | name: Auto-close duplicate issues
2 | # description: Auto-closes issues that are duplicates of existing issues
3 |
4 | on:
5 | schedule:
6 | - cron: "0 9 * * *" # Runs daily at 9 AM UTC
7 | workflow_dispatch:
8 |
9 | jobs:
10 | auto-close-duplicates:
11 | runs-on: ubuntu-latest
12 | timeout-minutes: 10
13 | permissions:
14 | contents: read
15 | issues: write # Need write permission to close issues and add comments
16 |
17 | steps:
18 | - name: Checkout repository
19 | uses: actions/checkout@v4
20 |
21 | - name: Setup Node.js
22 | uses: actions/setup-node@v4
23 | with:
24 | node-version: 20
25 |
26 | - name: Auto-close duplicate issues
27 | run: node .github/scripts/auto-close-duplicates.mjs
28 | env:
29 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
30 | GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }}
31 | GITHUB_REPOSITORY_NAME: ${{ github.event.repository.name }}
32 |
```
--------------------------------------------------------------------------------
/apps/extension/src/webview/providers/QueryProvider.tsx:
--------------------------------------------------------------------------------
```typescript
1 | import React from 'react';
2 | import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
3 |
4 | // Create a stable query client
5 | const queryClient = new QueryClient({
6 | defaultOptions: {
7 | queries: {
8 | // Don't refetch on window focus by default
9 | refetchOnWindowFocus: false,
10 | // Keep data fresh for 30 seconds
11 | staleTime: 30 * 1000,
12 | // Cache data for 5 minutes
13 | gcTime: 5 * 60 * 1000,
14 | // Retry failed requests 3 times
15 | retry: 3,
16 | // Retry delay exponentially backs off
17 | retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000)
18 | },
19 | mutations: {
20 | // Don't retry mutations by default
21 | retry: false
22 | }
23 | }
24 | });
25 |
26 | interface QueryProviderProps {
27 | children: React.ReactNode;
28 | }
29 |
30 | export const QueryProvider: React.FC<QueryProviderProps> = ({ children }) => {
31 | return (
32 | <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
33 | );
34 | };
35 |
```
--------------------------------------------------------------------------------
/packages/tm-core/src/modules/storage/adapters/file-storage/path-resolver.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Path resolution utilities for single tasks.json file
3 | */
4 |
5 | import path from 'node:path';
6 |
7 | /**
8 | * Handles path resolution for the single tasks.json file storage
9 | */
10 | export class PathResolver {
11 | private readonly basePath: string;
12 | private readonly tasksDir: string;
13 | private readonly tasksFilePath: string;
14 |
15 | constructor(projectPath: string) {
16 | this.basePath = path.join(projectPath, '.taskmaster');
17 | this.tasksDir = path.join(this.basePath, 'tasks');
18 | this.tasksFilePath = path.join(this.tasksDir, 'tasks.json');
19 | }
20 |
21 | /**
22 | * Get the base storage directory path
23 | */
24 | getBasePath(): string {
25 | return this.basePath;
26 | }
27 |
28 | /**
29 | * Get the tasks directory path
30 | */
31 | getTasksDir(): string {
32 | return this.tasksDir;
33 | }
34 |
35 | /**
36 | * Get the path to the single tasks.json file
37 | * All tags are stored in this one file
38 | */
39 | getTasksPath(): string {
40 | return this.tasksFilePath;
41 | }
42 | }
43 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/to-in-progress.md:
--------------------------------------------------------------------------------
```markdown
1 | Start working on a task by setting its status to in-progress.
2 |
3 | Arguments: $ARGUMENTS (task ID)
4 |
5 | ## Starting Work on Task
6 |
7 | This command does more than just change status - it prepares your environment for productive work.
8 |
9 | ## Pre-Start Checks
10 |
11 | 1. Verify dependencies are met
12 | 2. Check if another task is already in-progress
13 | 3. Ensure task details are complete
14 | 4. Validate test strategy exists
15 |
16 | ## Execution
17 |
18 | ```bash
19 | task-master set-status --id=$ARGUMENTS --status=in-progress
20 | ```
21 |
22 | ## Environment Setup
23 |
24 | After setting to in-progress:
25 | 1. Create/checkout appropriate git branch
26 | 2. Open relevant documentation
27 | 3. Set up test watchers if applicable
28 | 4. Display task details and acceptance criteria
29 | 5. Show similar completed tasks for reference
30 |
31 | ## Smart Suggestions
32 |
33 | - Estimated completion time based on complexity
34 | - Related files from similar tasks
35 | - Potential blockers to watch for
36 | - Recommended first steps
```
--------------------------------------------------------------------------------
/packages/tm-core/src/modules/workflow/services/test-result-validator.types.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Test phase in TDD workflow
3 | */
4 | export type TestPhase = 'RED' | 'GREEN' | 'REFACTOR';
5 |
6 | /**
7 | * Code coverage metrics
8 | */
9 | export interface Coverage {
10 | line: number;
11 | branch: number;
12 | function: number;
13 | statement: number;
14 | }
15 |
16 | /**
17 | * Test result data structure
18 | */
19 | export interface TestResult {
20 | total: number;
21 | passed: number;
22 | failed: number;
23 | skipped: number;
24 | phase: TestPhase;
25 | coverage?: Coverage;
26 | }
27 |
28 | /**
29 | * Coverage threshold configuration
30 | */
31 | export interface CoverageThresholds {
32 | line?: number;
33 | branch?: number;
34 | function?: number;
35 | statement?: number;
36 | }
37 |
38 | /**
39 | * Validation result structure
40 | */
41 | export interface ValidationResult {
42 | valid: boolean;
43 | errors: string[];
44 | warnings?: string[];
45 | suggestions?: string[];
46 | }
47 |
48 | /**
49 | * Phase-specific validation options
50 | */
51 | export interface PhaseValidationOptions {
52 | phase: TestPhase;
53 | coverageThresholds?: CoverageThresholds;
54 | previousTestCount?: number;
55 | }
56 |
```
--------------------------------------------------------------------------------
/apps/cli/src/ui/components/suggested-steps.component.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Suggested next steps component
3 | * Displays helpful command suggestions at the end of the list
4 | */
5 |
6 | import boxen from 'boxen';
7 | import chalk from 'chalk';
8 | import { getBoxWidth } from '../../utils/ui.js';
9 |
10 | /**
11 | * Display suggested next steps section
12 | */
13 | export function displaySuggestedNextSteps(): void {
14 | const steps = [
15 | `${chalk.cyan('1.')} Run ${chalk.yellow('task-master next')} to see what to work on next`,
16 | `${chalk.cyan('2.')} Run ${chalk.yellow('task-master expand --id=<id>')} to break down a task into subtasks`,
17 | `${chalk.cyan('3.')} Run ${chalk.yellow('task-master set-status --id=<id> --status=done')} to mark a task as complete`
18 | ];
19 |
20 | console.log(
21 | boxen(
22 | chalk.white.bold('Suggested Next Steps:') + '\n\n' + steps.join('\n'),
23 | {
24 | padding: 1,
25 | margin: { top: 0, bottom: 1 },
26 | borderStyle: 'round',
27 | borderColor: 'gray',
28 | width: getBoxWidth(0.97)
29 | }
30 | )
31 | );
32 | }
33 |
```
--------------------------------------------------------------------------------
/mcp-server/src/core/direct-functions/response-language.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * response-language.js
3 | * Direct function for managing response language via MCP
4 | */
5 |
6 | import { setResponseLanguage } from '../../../../scripts/modules/task-manager.js';
7 | import {
8 | enableSilentMode,
9 | disableSilentMode
10 | } from '../../../../scripts/modules/utils.js';
11 | import { createLogWrapper } from '../../tools/utils.js';
12 |
13 | export async function responseLanguageDirect(args, log, context = {}) {
14 | const { projectRoot, language } = args;
15 | const mcpLog = createLogWrapper(log);
16 |
17 | log.info(
18 | `Executing response-language_direct with args: ${JSON.stringify(args)}`
19 | );
20 | log.info(`Using project root: ${projectRoot}`);
21 |
22 | try {
23 | enableSilentMode();
24 | return setResponseLanguage(language, {
25 | mcpLog,
26 | projectRoot
27 | });
28 | } catch (error) {
29 | return {
30 | success: false,
31 | error: {
32 | code: 'DIRECT_FUNCTION_ERROR',
33 | message: error.message,
34 | details: error.stack
35 | }
36 | };
37 | } finally {
38 | disableSilentMode();
39 | }
40 | }
41 |
```
--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE/integration.md:
--------------------------------------------------------------------------------
```markdown
1 | # 🔌 New Integration
2 |
3 | ## What tool/IDE is being integrated?
4 |
5 | <!-- Name and brief description -->
6 |
7 | ## What can users do with it?
8 |
9 | <!-- Key benefits -->
10 |
11 | ## How to Enable
12 |
13 | ### Setup
14 |
15 | ```bash
16 | task-master rules add [name]
17 | # Any other setup steps
18 | ```
19 |
20 | ### Example Usage
21 |
22 | <!-- Show it in action -->
23 |
24 | ```bash
25 | # Real example
26 | ```
27 |
28 | ### Natural Language Hooks (if applicable)
29 |
30 | ```
31 | "When tests pass, mark task as done"
32 | # Other examples
33 | ```
34 |
35 | ## Contributor Checklist
36 |
37 | - [ ] Created changeset: `npm run changeset`
38 | - [ ] Tests pass: `npm test`
39 | - [ ] Format check passes: `npm run format-check`
40 | - [ ] Addressed CodeRabbit comments
41 | - [ ] Integration fully tested with target tool/IDE
42 | - [ ] Error scenarios tested
43 | - [ ] Added integration tests
44 | - [ ] Documentation includes setup guide
45 | - [ ] Examples are working and clear
46 |
47 | ---
48 |
49 | ## For Maintainers
50 |
51 | - [ ] Integration stability verified
52 | - [ ] Documentation comprehensive
53 | - [ ] Examples working
54 |
```
--------------------------------------------------------------------------------
/scripts/task-complexity-report.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "meta": {
3 | "generatedAt": "2025-06-14T02:15:51.082Z",
4 | "tasksAnalyzed": 2,
5 | "totalTasks": 3,
6 | "analysisCount": 5,
7 | "thresholdScore": 5,
8 | "projectName": "Test Project",
9 | "usedResearch": false
10 | },
11 | "complexityAnalysis": [
12 | {
13 | "id": 1,
14 | "complexity": 3,
15 | "subtaskCount": 2
16 | },
17 | {
18 | "id": 2,
19 | "complexity": 7,
20 | "subtaskCount": 5
21 | },
22 | {
23 | "id": 3,
24 | "complexity": 9,
25 | "subtaskCount": 8
26 | },
27 | {
28 | "taskId": 1,
29 | "taskTitle": "Task 1",
30 | "complexityScore": 5,
31 | "recommendedSubtasks": 3,
32 | "expansionPrompt": "Break down this task with a focus on task 1.",
33 | "reasoning": "Automatically added due to missing analysis in AI response."
34 | },
35 | {
36 | "taskId": 2,
37 | "taskTitle": "Task 2",
38 | "complexityScore": 5,
39 | "recommendedSubtasks": 3,
40 | "expansionPrompt": "Break down this task with a focus on task 2.",
41 | "reasoning": "Automatically added due to missing analysis in AI response."
42 | }
43 | ]
44 | }
45 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/to-done.md:
--------------------------------------------------------------------------------
```markdown
1 | Mark a task as completed.
2 |
3 | Arguments: $ARGUMENTS (task ID)
4 |
5 | ## Completing a Task
6 |
7 | This command validates task completion and updates project state intelligently.
8 |
9 | ## Pre-Completion Checks
10 |
11 | 1. Verify test strategy was followed
12 | 2. Check if all subtasks are complete
13 | 3. Validate acceptance criteria met
14 | 4. Ensure code is committed
15 |
16 | ## Execution
17 |
18 | ```bash
19 | task-master set-status --id=$ARGUMENTS --status=done
20 | ```
21 |
22 | ## Post-Completion Actions
23 |
24 | 1. **Update Dependencies**
25 | - Identify newly unblocked tasks
26 | - Update sprint progress
27 | - Recalculate project timeline
28 |
29 | 2. **Documentation**
30 | - Generate completion summary
31 | - Update CLAUDE.md with learnings
32 | - Log implementation approach
33 |
34 | 3. **Next Steps**
35 | - Show newly available tasks
36 | - Suggest logical next task
37 | - Update velocity metrics
38 |
39 | ## Celebration & Learning
40 |
41 | - Show impact of completion
42 | - Display unblocked work
43 | - Recognize achievement
44 | - Capture lessons learned
```
--------------------------------------------------------------------------------
/apps/docs/logo/dark.svg:
--------------------------------------------------------------------------------
```
1 | <svg width="800" height="240" viewBox="0 0 800 240" xmlns="http://www.w3.org/2000/svg">
2 | <!-- Background -->
3 | <rect width="800" height="240" fill="transparent"/>
4 |
5 | <!-- Curly braces -->
6 | <text x="40" y="156" font-size="140" fill="white" font-family="monospace">{</text>
7 | <text x="230" y="156" font-size="140" fill="white" font-family="monospace">}</text>
8 |
9 | <!-- Blue form with check -->
10 | <rect x="120" y="50" width="120" height="140" rx="16" fill="#3366CC"/>
11 | <polyline points="150,110 164,128 190,84" fill="none" stroke="white" stroke-width="10"/>
12 | <circle cx="150" cy="144" r="7" fill="white"/>
13 | <rect x="168" y="140" width="48" height="10" fill="white"/>
14 | <circle cx="150" cy="168" r="7" fill="white"/>
15 | <rect x="168" y="164" width="48" height="10" fill="white"/>
16 |
17 | <!-- Text -->
18 | <text x="340" y="156" font-family="Arial, sans-serif" font-size="76" font-weight="bold" fill="white">Task Master</text>
19 | </svg>
20 |
```
--------------------------------------------------------------------------------
/apps/extension/src/webview/components/AppContent.tsx:
--------------------------------------------------------------------------------
```typescript
1 | import React from 'react';
2 | import { TaskMasterKanban } from './TaskMasterKanban';
3 | import TaskDetailsView from '@/components/TaskDetailsView';
4 | import { ConfigView } from '@/components/ConfigView';
5 | import { useVSCodeContext } from '../contexts/VSCodeContext';
6 |
7 | export const AppContent: React.FC = () => {
8 | const { state, dispatch, sendMessage } = useVSCodeContext();
9 |
10 | if (state.currentView === 'config') {
11 | return (
12 | <ConfigView
13 | sendMessage={sendMessage}
14 | onNavigateBack={() => dispatch({ type: 'NAVIGATE_TO_KANBAN' })}
15 | />
16 | );
17 | }
18 |
19 | if (state.currentView === 'task-details' && state.selectedTaskId) {
20 | return (
21 | <TaskDetailsView
22 | taskId={state.selectedTaskId}
23 | onNavigateBack={() => dispatch({ type: 'NAVIGATE_TO_KANBAN' })}
24 | onNavigateToTask={(taskId: string) =>
25 | dispatch({ type: 'NAVIGATE_TO_TASK', payload: taskId })
26 | }
27 | />
28 | );
29 | }
30 |
31 | // Default to Kanban view
32 | return <TaskMasterKanban />;
33 | };
34 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/to-review.md:
--------------------------------------------------------------------------------
```markdown
1 | Set a task's status to review.
2 |
3 | Arguments: $ARGUMENTS (task ID)
4 |
5 | ## Marking Task for Review
6 |
7 | This status indicates work is complete but needs verification before final approval.
8 |
9 | ## When to Use Review Status
10 |
11 | - Code complete but needs peer review
12 | - Implementation done but needs testing
13 | - Documentation written but needs proofreading
14 | - Design complete but needs stakeholder approval
15 |
16 | ## Execution
17 |
18 | ```bash
19 | task-master set-status --id=$ARGUMENTS --status=review
20 | ```
21 |
22 | ## Review Preparation
23 |
24 | When setting to review:
25 | 1. **Generate Review Checklist**
26 | - Link to PR/MR if applicable
27 | - Highlight key changes
28 | - Note areas needing attention
29 | - Include test results
30 |
31 | 2. **Documentation**
32 | - Update task with review notes
33 | - Link relevant artifacts
34 | - Specify reviewers if known
35 |
36 | 3. **Smart Actions**
37 | - Create review reminders
38 | - Track review duration
39 | - Suggest reviewers based on expertise
40 | - Prepare rollback plan if needed
```
--------------------------------------------------------------------------------
/apps/docs/logo/light.svg:
--------------------------------------------------------------------------------
```
1 | <svg width="800" height="240" viewBox="0 0 800 240" xmlns="http://www.w3.org/2000/svg">
2 | <!-- Background -->
3 | <rect width="800" height="240" fill="transparent"/>
4 |
5 | <!-- Curly braces -->
6 | <text x="40" y="156" font-size="140" fill="#000000" font-family="monospace">{</text>
7 | <text x="230" y="156" font-size="140" fill="#000000" font-family="monospace">}</text>
8 |
9 | <!-- Blue form with check -->
10 | <rect x="120" y="50" width="120" height="140" rx="16" fill="#3366CC"/>
11 | <polyline points="150,110 164,128 190,84" fill="none" stroke="#FFFFFF" stroke-width="10"/>
12 | <circle cx="150" cy="144" r="7" fill="#FFFFFF"/>
13 | <rect x="168" y="140" width="48" height="10" fill="#FFFFFF"/>
14 | <circle cx="150" cy="168" r="7" fill="#FFFFFF"/>
15 | <rect x="168" y="164" width="48" height="10" fill="#FFFFFF"/>
16 |
17 | <!-- Text -->
18 | <text x="340" y="156" font-family="Arial, sans-serif" font-size="76" font-weight="bold" fill="#000000">Task Master</text>
19 | </svg>
20 |
```
--------------------------------------------------------------------------------
/packages/ai-sdk-provider-grok-cli/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "ESNext",
5 | "lib": ["ES2022"],
6 | "declaration": true,
7 | "declarationMap": true,
8 | "sourceMap": true,
9 | "outDir": "./dist",
10 | "baseUrl": ".",
11 | "rootDir": "./src",
12 | "strict": true,
13 | "noImplicitAny": true,
14 | "strictNullChecks": true,
15 | "strictFunctionTypes": true,
16 | "strictBindCallApply": true,
17 | "strictPropertyInitialization": true,
18 | "noImplicitThis": true,
19 | "alwaysStrict": true,
20 | "noUnusedLocals": true,
21 | "noUnusedParameters": true,
22 | "noImplicitReturns": true,
23 | "noFallthroughCasesInSwitch": true,
24 | "esModuleInterop": true,
25 | "skipLibCheck": true,
26 | "forceConsistentCasingInFileNames": true,
27 | "moduleResolution": "bundler",
28 | "moduleDetection": "force",
29 | "types": ["node"],
30 | "resolveJsonModule": true,
31 | "isolatedModules": true,
32 | "allowImportingTsExtensions": false
33 | },
34 | "include": ["src/**/*"],
35 | "exclude": ["node_modules", "dist", "tests", "**/*.test.ts", "**/*.spec.ts"]
36 | }
37 |
```
--------------------------------------------------------------------------------
/apps/cli/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "NodeNext",
5 | "lib": ["ES2022"],
6 | "declaration": true,
7 | "declarationMap": true,
8 | "sourceMap": true,
9 | "outDir": "./dist",
10 | "baseUrl": ".",
11 | "rootDir": "./src",
12 | "strict": true,
13 | "noImplicitAny": true,
14 | "strictNullChecks": true,
15 | "strictFunctionTypes": true,
16 | "strictBindCallApply": true,
17 | "strictPropertyInitialization": true,
18 | "noImplicitThis": true,
19 | "alwaysStrict": true,
20 | "noUnusedLocals": true,
21 | "noUnusedParameters": true,
22 | "noImplicitReturns": true,
23 | "noFallthroughCasesInSwitch": true,
24 | "esModuleInterop": true,
25 | "skipLibCheck": true,
26 | "forceConsistentCasingInFileNames": true,
27 | "moduleResolution": "NodeNext",
28 | "moduleDetection": "force",
29 | "types": ["node"],
30 | "resolveJsonModule": true,
31 | "isolatedModules": true,
32 | "allowImportingTsExtensions": false
33 | },
34 | "include": ["src/**/*"],
35 | "exclude": ["node_modules", "dist", "tests", "**/*.test.ts", "**/*.spec.ts"]
36 | }
37 |
```
--------------------------------------------------------------------------------
/apps/mcp/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "NodeNext",
5 | "lib": ["ES2022"],
6 | "declaration": true,
7 | "declarationMap": true,
8 | "sourceMap": true,
9 | "outDir": "./dist",
10 | "baseUrl": ".",
11 | "rootDir": "./src",
12 | "strict": true,
13 | "noImplicitAny": true,
14 | "strictNullChecks": true,
15 | "strictFunctionTypes": true,
16 | "strictBindCallApply": true,
17 | "strictPropertyInitialization": true,
18 | "noImplicitThis": true,
19 | "alwaysStrict": true,
20 | "noUnusedLocals": true,
21 | "noUnusedParameters": true,
22 | "noImplicitReturns": true,
23 | "noFallthroughCasesInSwitch": true,
24 | "esModuleInterop": true,
25 | "skipLibCheck": true,
26 | "forceConsistentCasingInFileNames": true,
27 | "moduleResolution": "NodeNext",
28 | "moduleDetection": "force",
29 | "types": ["node"],
30 | "resolveJsonModule": true,
31 | "isolatedModules": true,
32 | "allowImportingTsExtensions": false
33 | },
34 | "include": ["src/**/*"],
35 | "exclude": ["node_modules", "dist", "tests", "**/*.test.ts", "**/*.spec.ts"]
36 | }
37 |
```
--------------------------------------------------------------------------------
/packages/tm-core/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "compilerOptions": {
3 | "target": "ES2022",
4 | "module": "NodeNext",
5 | "lib": ["ES2022"],
6 | "declaration": true,
7 | "declarationMap": true,
8 | "sourceMap": true,
9 | "outDir": "./dist",
10 | "baseUrl": ".",
11 | "rootDir": "./src",
12 | "strict": true,
13 | "noImplicitAny": true,
14 | "strictNullChecks": true,
15 | "strictFunctionTypes": true,
16 | "strictBindCallApply": true,
17 | "strictPropertyInitialization": true,
18 | "noImplicitThis": true,
19 | "alwaysStrict": true,
20 | "noUnusedLocals": true,
21 | "noUnusedParameters": true,
22 | "noImplicitReturns": true,
23 | "noFallthroughCasesInSwitch": true,
24 | "esModuleInterop": true,
25 | "skipLibCheck": true,
26 | "forceConsistentCasingInFileNames": true,
27 | "moduleResolution": "NodeNext",
28 | "moduleDetection": "force",
29 | "types": ["node"],
30 | "resolveJsonModule": true,
31 | "isolatedModules": true,
32 | "allowImportingTsExtensions": false
33 | },
34 | "include": ["src/**/*"],
35 | "exclude": ["node_modules", "dist", "tests", "**/*.test.ts", "**/*.spec.ts"]
36 | }
37 |
```
--------------------------------------------------------------------------------
/turbo.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "$schema": "https://turbo.build/schema.json",
3 | "extends": ["//"],
4 | "tasks": {
5 | "build": {
6 | "dependsOn": ["^build"],
7 | "outputs": ["dist/**"],
8 | "outputLogs": "new-only",
9 | "env": ["NODE_ENV", "TM_PUBLIC_*"]
10 | },
11 | "dev": {
12 | "cache": false,
13 | "persistent": true,
14 | "inputs": [
15 | "$TURBO_DEFAULT$",
16 | "!{packages,apps}/**/dist/**",
17 | "!{packages,apps}/**/node_modules/**"
18 | ]
19 | },
20 | "test:watch": {
21 | "cache": false,
22 | "persistent": true,
23 | "dependsOn": ["^build"]
24 | },
25 | "lint": {
26 | "dependsOn": ["^build"],
27 | "inputs": [
28 | "$TURBO_DEFAULT$",
29 | "!{packages,apps}/**/dist/**",
30 | "!{packages,apps}/**/node_modules/**"
31 | ],
32 | "outputLogs": "new-only"
33 | },
34 | "typecheck": {
35 | "dependsOn": ["^build"],
36 | "inputs": [
37 | "$TURBO_DEFAULT$",
38 | "!{packages,apps}/**/dist/**",
39 | "!{packages,apps}/**/node_modules/**"
40 | ],
41 | "outputLogs": "new-only"
42 | }
43 | },
44 | "globalDependencies": ["turbo.json", "tsconfig.json", ".env*"]
45 | }
46 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/list-tasks-by-status.md:
--------------------------------------------------------------------------------
```markdown
1 | List tasks filtered by a specific status.
2 |
3 | Arguments: $ARGUMENTS
4 |
5 | Parse the status from arguments and list only tasks matching that status.
6 |
7 | ## Status Options
8 | - `pending` - Not yet started
9 | - `in-progress` - Currently being worked on
10 | - `done` - Completed
11 | - `review` - Awaiting review
12 | - `deferred` - Postponed
13 | - `cancelled` - Cancelled
14 |
15 | ## Execution
16 |
17 | Based on $ARGUMENTS, run:
18 | ```bash
19 | task-master list --status=$ARGUMENTS
20 | ```
21 |
22 | ## Enhanced Display
23 |
24 | For the filtered results:
25 | - Group by priority within the status
26 | - Show time in current status
27 | - Highlight tasks approaching deadlines
28 | - Display blockers and dependencies
29 | - Suggest next actions for each status group
30 |
31 | ## Intelligent Insights
32 |
33 | Based on the status filter:
34 | - **Pending**: Show recommended start order
35 | - **In-Progress**: Display idle time warnings
36 | - **Done**: Show newly unblocked tasks
37 | - **Review**: Indicate review duration
38 | - **Deferred**: Show reactivation criteria
39 | - **Cancelled**: Display impact analysis
```
--------------------------------------------------------------------------------
/apps/docs/introduction.mdx:
--------------------------------------------------------------------------------
```markdown
1 | <Tip>
2 | Welcome to v1 of the Task Master Docs. Expect weekly updates as we expand and refine each section.
3 | </Tip>
4 |
5 | We've organized the docs into three sections depending on your experience level and goals:
6 |
7 | ### Getting Started - Jump in to [Quick Start](/getting-started/quick-start)
8 | Designed for first-time users. Get set up, create your first PRD, and run your first task.
9 |
10 | ### Best Practices
11 | Covers common workflows, strategic usage of commands, model configuration tips, and real-world usage patterns. Recommended for active users.
12 |
13 | ### Technical Capabilities
14 | A detailed glossary of every root command and available capability — meant for power users and contributors.
15 |
16 | ---
17 |
18 | Thanks for being here early. If you spot something broken or want to contribute, check out the [GitHub repo](https://github.com/eyaltoledano/claude-task-master).
19 |
20 | Have questions? Join our [Discord community](https://discord.gg/fWJkU7rf) to connect with other users and get help from the team.
```
--------------------------------------------------------------------------------
/apps/docs/getting-started/quick-start/quick-start.mdx:
--------------------------------------------------------------------------------
```markdown
1 | ---
2 | title: Quick Start
3 | sidebarTitle: "Quick Start"
4 | ---
5 |
6 | This guide is for new users who want to start using Task Master with minimal setup time.
7 |
8 | It covers:
9 | - [Requirements](/getting-started/quick-start/requirements): You will need Node.js and an AI model API Key.
10 | - [Installation](/getting-started/quick-start/installation): How to Install Task Master.
11 | - [Configuration](/getting-started/quick-start/configuration-quick): Setting up your API Key, MCP, and more.
12 | - [PRD](/getting-started/quick-start/prd-quick): Writing and parsing your first PRD.
13 | - [Task Setup](/getting-started/quick-start/tasks-quick): Preparing your tasks for execution.
14 | - [Executing Tasks](/getting-started/quick-start/execute-quick): Using Task Master to execute tasks.
15 | - [Rules & Context](/getting-started/quick-start/rules-quick): Learn how and why to build context in your project over time.
16 |
17 | <Tip>
18 | By the end of this guide, you'll have everything you need to begin working productively with Task Master.
19 | </Tip>
```
--------------------------------------------------------------------------------
/packages/tm-bridge/tsconfig.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "extends": "../../tsconfig.json",
3 | "compilerOptions": {
4 | "target": "ES2022",
5 | "module": "NodeNext",
6 | "lib": ["ES2022"],
7 | "declaration": true,
8 | "declarationMap": true,
9 | "sourceMap": true,
10 | "outDir": "./dist",
11 | "baseUrl": ".",
12 | "rootDir": "./src",
13 | "strict": true,
14 | "noImplicitAny": true,
15 | "strictNullChecks": true,
16 | "strictFunctionTypes": true,
17 | "strictBindCallApply": true,
18 | "strictPropertyInitialization": true,
19 | "noImplicitThis": true,
20 | "alwaysStrict": true,
21 | "noUnusedLocals": true,
22 | "noUnusedParameters": true,
23 | "noImplicitReturns": true,
24 | "noFallthroughCasesInSwitch": true,
25 | "esModuleInterop": true,
26 | "skipLibCheck": true,
27 | "forceConsistentCasingInFileNames": true,
28 | "moduleResolution": "NodeNext",
29 | "moduleDetection": "force",
30 | "types": ["node"],
31 | "resolveJsonModule": true,
32 | "isolatedModules": true,
33 | "allowImportingTsExtensions": false
34 | },
35 | "include": ["src/**/*"],
36 | "exclude": ["node_modules", "dist", "tests", "**/*.test.ts", "**/*.spec.ts"]
37 | }
38 |
```
--------------------------------------------------------------------------------
/.github/scripts/tag-extension.mjs:
--------------------------------------------------------------------------------
```
1 | #!/usr/bin/env node
2 | import assert from 'node:assert/strict';
3 | import { readFileSync } from 'node:fs';
4 | import { join, dirname } from 'node:path';
5 | import { fileURLToPath } from 'node:url';
6 | import { findRootDir, createAndPushTag } from './utils.mjs';
7 |
8 | const __filename = fileURLToPath(import.meta.url);
9 | const __dirname = dirname(__filename);
10 |
11 | const rootDir = findRootDir(__dirname);
12 |
13 | // Read the extension's package.json
14 | const extensionDir = join(rootDir, 'apps', 'extension');
15 | const pkgPath = join(extensionDir, 'package.json');
16 |
17 | let pkg;
18 | try {
19 | const pkgContent = readFileSync(pkgPath, 'utf8');
20 | pkg = JSON.parse(pkgContent);
21 | } catch (error) {
22 | console.error('Failed to read package.json:', error.message);
23 | process.exit(1);
24 | }
25 |
26 | // Ensure we have required fields
27 | assert(pkg.name, 'package.json must have a name field');
28 | assert(pkg.version, 'package.json must have a version field');
29 |
30 | const tag = `${pkg.name}@${pkg.version}`;
31 |
32 | // Create and push the tag if it doesn't exist
33 | createAndPushTag(tag);
34 |
```
--------------------------------------------------------------------------------
/packages/tm-core/src/modules/integration/integration-domain.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Integration Domain Facade
3 | * Public API for integration with external systems
4 | */
5 |
6 | import { AuthManager } from '../auth/managers/auth-manager.js';
7 | import type { ConfigManager } from '../config/managers/config-manager.js';
8 | import { ExportService } from './services/export.service.js';
9 | import type {
10 | ExportResult,
11 | ExportTasksOptions
12 | } from './services/export.service.js';
13 |
14 | /**
15 | * Integration Domain - Unified API for external system integration
16 | */
17 | export class IntegrationDomain {
18 | private exportService: ExportService;
19 |
20 | constructor(configManager: ConfigManager) {
21 | // Get singleton AuthManager instance
22 | const authManager = AuthManager.getInstance();
23 | this.exportService = new ExportService(configManager, authManager);
24 | }
25 |
26 | // ========== Export Operations ==========
27 |
28 | /**
29 | * Export tasks to external systems (e.g., Hamster briefs)
30 | */
31 | async exportTasks(options: ExportTasksOptions): Promise<ExportResult> {
32 | return this.exportService.exportTasks(options);
33 | }
34 | }
35 |
```
--------------------------------------------------------------------------------
/src/schemas/base-schemas.js:
--------------------------------------------------------------------------------
```javascript
1 | import { z } from 'zod';
2 |
3 | // Base schemas that will be reused across commands
4 | export const TaskStatusSchema = z.enum([
5 | 'pending',
6 | 'in-progress',
7 | 'blocked',
8 | 'done',
9 | 'cancelled',
10 | 'deferred'
11 | ]);
12 |
13 | export const BaseTaskSchema = z.object({
14 | id: z.number().int().positive(),
15 | title: z.string().min(1).max(200),
16 | description: z.string().min(1),
17 | status: TaskStatusSchema,
18 | dependencies: z.array(z.union([z.number().int(), z.string()])).default([]),
19 | priority: z
20 | .enum(['low', 'medium', 'high', 'critical'])
21 | .nullable()
22 | .default(null),
23 | details: z.string().nullable().default(null),
24 | testStrategy: z.string().nullable().default(null)
25 | });
26 |
27 | export const SubtaskSchema = z.object({
28 | id: z.number().int().positive(),
29 | title: z.string().min(5).max(200),
30 | description: z.string().min(10),
31 | dependencies: z.array(z.number().int()).default([]),
32 | details: z.string().min(20),
33 | status: z.enum(['pending', 'done', 'completed']).default('pending'),
34 | testStrategy: z.string().nullable().default(null)
35 | });
36 |
```
--------------------------------------------------------------------------------
/.taskmaster/config.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "models": {
3 | "main": {
4 | "provider": "anthropic",
5 | "modelId": "claude-sonnet-4-5-20250929",
6 | "maxTokens": 64000,
7 | "temperature": 0.2
8 | },
9 | "research": {
10 | "provider": "perplexity",
11 | "modelId": "sonar-pro",
12 | "maxTokens": 8700,
13 | "temperature": 0.1
14 | },
15 | "fallback": {
16 | "provider": "anthropic",
17 | "modelId": "claude-sonnet-4-20250514",
18 | "maxTokens": 64000,
19 | "temperature": 0.2
20 | }
21 | },
22 | "global": {
23 | "logLevel": "info",
24 | "debug": false,
25 | "defaultNumTasks": 10,
26 | "defaultSubtasks": 5,
27 | "defaultPriority": "medium",
28 | "projectName": "Taskmaster",
29 | "ollamaBaseURL": "http://localhost:11434/api",
30 | "bedrockBaseURL": "https://bedrock.us-east-1.amazonaws.com",
31 | "responseLanguage": "English",
32 | "enableCodebaseAnalysis": true,
33 | "userId": "1234567890",
34 | "azureBaseURL": "https://your-endpoint.azure.com/",
35 | "defaultTag": "master"
36 | },
37 | "claudeCode": {},
38 | "codexCli": {},
39 | "grokCli": {
40 | "timeout": 120000,
41 | "workingDirectory": null,
42 | "defaultModel": "grok-4-latest"
43 | }
44 | }
45 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/expand-all-tasks.md:
--------------------------------------------------------------------------------
```markdown
1 | Expand all pending tasks that need subtasks.
2 |
3 | ## Bulk Task Expansion
4 |
5 | Intelligently expands all tasks that would benefit from breakdown.
6 |
7 | ## Execution
8 |
9 | ```bash
10 | task-master expand --all
11 | ```
12 |
13 | ## Smart Selection
14 |
15 | Only expands tasks that:
16 | - Are marked as pending
17 | - Have high complexity (>5)
18 | - Lack existing subtasks
19 | - Would benefit from breakdown
20 |
21 | ## Expansion Process
22 |
23 | 1. **Analysis Phase**
24 | - Identify expansion candidates
25 | - Group related tasks
26 | - Plan expansion strategy
27 |
28 | 2. **Batch Processing**
29 | - Expand tasks in logical order
30 | - Maintain consistency
31 | - Preserve relationships
32 | - Optimize for parallelism
33 |
34 | 3. **Quality Control**
35 | - Ensure subtask quality
36 | - Avoid over-decomposition
37 | - Maintain task coherence
38 | - Update dependencies
39 |
40 | ## Options
41 |
42 | - Add `force` to expand all regardless of complexity
43 | - Add `research` for enhanced AI analysis
44 |
45 | ## Results
46 |
47 | After bulk expansion:
48 | - Summary of tasks expanded
49 | - New subtask count
50 | - Updated complexity metrics
51 | - Suggested task order
```
--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE/feature.md:
--------------------------------------------------------------------------------
```markdown
1 | ## ✨ New Feature
2 |
3 | ### 📋 Feature Description
4 | <!-- Brief description -->
5 |
6 | ### 🎯 Problem Statement
7 | <!-- What problem does this feature solve? Why is it needed? -->
8 |
9 | ### 💡 Solution
10 | <!-- How does this feature solve the problem? What's the approach? -->
11 |
12 | ### 🔗 Related Issues
13 | <!-- Link related issues: Fixes #123, Part of #456 -->
14 |
15 | ## How to Use It
16 |
17 | ### Quick Start
18 | ```bash
19 | # Basic usage example
20 | ```
21 |
22 | ### Example
23 | <!-- Show a real use case -->
24 | ```bash
25 | # Practical example
26 | ```
27 |
28 | **What you should see:**
29 | <!-- Expected behavior -->
30 |
31 | ## Contributor Checklist
32 | - [ ] Created changeset: `npm run changeset`
33 | - [ ] Tests pass: `npm test`
34 | - [ ] Format check passes: `npm run format-check`
35 | - [ ] Addressed CodeRabbit comments
36 | - [ ] Added tests for new functionality
37 | - [ ] Manually tested in CLI mode
38 | - [ ] Manually tested in MCP mode (if applicable)
39 |
40 | ## Changelog Entry
41 | <!-- One-liner for release notes -->
42 |
43 | ---
44 |
45 | ### For Maintainers
46 |
47 | - [ ] Feature aligns with project vision
48 | - [ ] CIs pass
49 | - [ ] Changeset file exists
50 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/to-deferred.md:
--------------------------------------------------------------------------------
```markdown
1 | Defer a task for later consideration.
2 |
3 | Arguments: $ARGUMENTS (task ID)
4 |
5 | ## Deferring a Task
6 |
7 | This status indicates a task is valid but not currently actionable or prioritized.
8 |
9 | ## Valid Reasons for Deferral
10 |
11 | - Waiting for external dependencies
12 | - Reprioritized for future sprint
13 | - Blocked by technical limitations
14 | - Resource constraints
15 | - Strategic timing considerations
16 |
17 | ## Execution
18 |
19 | ```bash
20 | task-master set-status --id=$ARGUMENTS --status=deferred
21 | ```
22 |
23 | ## Deferral Management
24 |
25 | When deferring:
26 | 1. **Document Reason**
27 | - Capture why it's being deferred
28 | - Set reactivation criteria
29 | - Note any partial work completed
30 |
31 | 2. **Impact Analysis**
32 | - Check dependent tasks
33 | - Update project timeline
34 | - Notify affected stakeholders
35 |
36 | 3. **Future Planning**
37 | - Set review reminders
38 | - Tag for specific milestone
39 | - Preserve context for reactivation
40 | - Link to blocking issues
41 |
42 | ## Smart Tracking
43 |
44 | - Monitor deferral duration
45 | - Alert when criteria met
46 | - Prevent scope creep
47 | - Regular review cycles
```
--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
```markdown
1 | # What type of PR is this?
2 | <!-- Check one -->
3 |
4 | - [ ] 🐛 Bug fix
5 | - [ ] ✨ Feature
6 | - [ ] 🔌 Integration
7 | - [ ] 📝 Docs
8 | - [ ] 🧹 Refactor
9 | - [ ] Other:
10 | ## Description
11 | <!-- What does this PR do? -->
12 |
13 | ## Related Issues
14 | <!-- Link issues: Fixes #123 -->
15 |
16 | ## How to Test This
17 | <!-- Quick steps to verify the changes work -->
18 | ```bash
19 | # Example commands or steps
20 | ```
21 |
22 | **Expected result:**
23 | <!-- What should happen? -->
24 |
25 | ## Contributor Checklist
26 |
27 | - [ ] Created changeset: `npm run changeset`
28 | - [ ] Tests pass: `npm test`
29 | - [ ] Format check passes: `npm run format-check` (or `npm run format` to fix)
30 | - [ ] Addressed CodeRabbit comments (if any)
31 | - [ ] Linked related issues (if any)
32 | - [ ] Manually tested the changes
33 |
34 | ## Changelog Entry
35 | <!-- One line describing the change for users -->
36 | <!-- Example: "Added Kiro IDE integration with automatic task status updates" -->
37 |
38 | ---
39 |
40 | ### For Maintainers
41 |
42 | - [ ] PR title follows conventional commits
43 | - [ ] Target branch correct
44 | - [ ] Labels added
45 | - [ ] Milestone assigned (if applicable)
46 |
```
--------------------------------------------------------------------------------
/apps/cli/src/types/tag-management.d.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Type declarations for legacy tag-management.js
3 | * TODO: Remove when refactored to use @tm/core
4 | */
5 |
6 | declare module '*/tag-management.js' {
7 | export function createTag(
8 | tasksPath: string,
9 | tagName: string,
10 | options?: any,
11 | context?: any,
12 | outputFormat?: string
13 | ): Promise<any>;
14 |
15 | export function deleteTag(
16 | tasksPath: string,
17 | tagName: string,
18 | options?: any,
19 | context?: any,
20 | outputFormat?: string
21 | ): Promise<any>;
22 |
23 | export function tags(
24 | tasksPath: string,
25 | options?: any,
26 | context?: any,
27 | outputFormat?: string
28 | ): Promise<any>;
29 |
30 | export function useTag(
31 | tasksPath: string,
32 | tagName: string,
33 | options?: any,
34 | context?: any,
35 | outputFormat?: string
36 | ): Promise<any>;
37 |
38 | export function renameTag(
39 | tasksPath: string,
40 | oldName: string,
41 | newName: string,
42 | options?: any,
43 | context?: any,
44 | outputFormat?: string
45 | ): Promise<any>;
46 |
47 | export function copyTag(
48 | tasksPath: string,
49 | sourceName: string,
50 | targetName: string,
51 | options?: any,
52 | context?: any,
53 | outputFormat?: string
54 | ): Promise<any>;
55 | }
56 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/init-project.md:
--------------------------------------------------------------------------------
```markdown
1 | Initialize a new Task Master project.
2 |
3 | Arguments: $ARGUMENTS
4 |
5 | Parse arguments to determine initialization preferences.
6 |
7 | ## Initialization Process
8 |
9 | 1. **Parse Arguments**
10 | - PRD file path (if provided)
11 | - Project name
12 | - Auto-confirm flag (-y)
13 |
14 | 2. **Project Setup**
15 | ```bash
16 | task-master init
17 | ```
18 |
19 | 3. **Smart Initialization**
20 | - Detect existing project files
21 | - Suggest project name from directory
22 | - Check for git repository
23 | - Verify AI provider configuration
24 |
25 | ## Configuration Options
26 |
27 | Based on arguments:
28 | - `quick` / `-y` → Skip confirmations
29 | - `<file.md>` → Use as PRD after init
30 | - `--name=<name>` → Set project name
31 | - `--description=<desc>` → Set description
32 |
33 | ## Post-Initialization
34 |
35 | After successful init:
36 | 1. Show project structure created
37 | 2. Verify AI models configured
38 | 3. Suggest next steps:
39 | - Parse PRD if available
40 | - Configure AI providers
41 | - Set up git hooks
42 | - Create first tasks
43 |
44 | ## Integration
45 |
46 | If PRD file provided:
47 | ```
48 | /taskmaster:init my-prd.md
49 | → Automatically runs parse-prd after init
50 | ```
```
--------------------------------------------------------------------------------
/.github/scripts/release.mjs:
--------------------------------------------------------------------------------
```
1 | #!/usr/bin/env node
2 | import { existsSync, unlinkSync } from 'node:fs';
3 | import { join, dirname } from 'node:path';
4 | import { fileURLToPath } from 'node:url';
5 | import { findRootDir, runCommand } from './utils.mjs';
6 |
7 | const __filename = fileURLToPath(import.meta.url);
8 | const __dirname = dirname(__filename);
9 |
10 | const rootDir = findRootDir(__dirname);
11 |
12 | console.log('🚀 Starting release process...');
13 |
14 | // Double-check we're not in pre-release mode (safety net)
15 | const preJsonPath = join(rootDir, '.changeset', 'pre.json');
16 | if (existsSync(preJsonPath)) {
17 | console.log('⚠️ Warning: pre.json still exists. Removing it...');
18 | unlinkSync(preJsonPath);
19 | }
20 |
21 | // Check if the extension version has changed and tag it
22 | // This prevents changeset from trying to publish the private package
23 | runCommand('node', [join(__dirname, 'tag-extension.mjs')]);
24 |
25 | // Run changeset publish for npm packages
26 | runCommand('npx', ['changeset', 'publish']);
27 |
28 | console.log('✅ Release process completed!');
29 |
30 | // The extension tag (if created) will trigger the extension-release workflow
31 |
```
--------------------------------------------------------------------------------
/packages/tm-core/src/modules/config/index.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Configuration module exports
3 | * Exports the main ConfigManager and all configuration services
4 | */
5 |
6 | // Export the main ConfigManager
7 | export { ConfigManager } from './managers/config-manager.js';
8 |
9 | // Export all configuration services for advanced usage
10 | export {
11 | ConfigLoader,
12 | ConfigMerger,
13 | CONFIG_PRECEDENCE,
14 | RuntimeStateManager,
15 | ConfigPersistence,
16 | EnvironmentConfigProvider,
17 | type ConfigSource,
18 | type RuntimeState,
19 | type PersistenceOptions
20 | } from './services/index.js';
21 |
22 | // Re-export configuration interfaces
23 | export type {
24 | IConfiguration,
25 | PartialConfiguration,
26 | ModelConfig,
27 | ProviderConfig,
28 | TaskSettings,
29 | TagSettings,
30 | WorkflowSettings,
31 | StorageSettings,
32 | RetrySettings,
33 | LoggingSettings,
34 | SecuritySettings,
35 | ConfigValidationResult,
36 | EnvironmentConfig,
37 | ConfigSchema,
38 | ConfigProperty,
39 | IConfigurationFactory,
40 | IConfigurationManager
41 | } from '../../common/interfaces/configuration.interface.js';
42 |
43 | // Re-export default values
44 | export { DEFAULT_CONFIG_VALUES } from '../../common/interfaces/configuration.interface.js';
45 |
```
--------------------------------------------------------------------------------
/src/ai-providers/index.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * src/ai-providers/index.js
3 | * Central export point for all AI provider classes
4 | */
5 |
6 | export { AnthropicAIProvider } from './anthropic.js';
7 | export { PerplexityAIProvider } from './perplexity.js';
8 | export { GoogleAIProvider } from './google.js';
9 | export { OpenAIProvider } from './openai.js';
10 | export { XAIProvider } from './xai.js';
11 | export { GroqProvider } from './groq.js';
12 | export { OpenRouterAIProvider } from './openrouter.js';
13 | export { OllamaAIProvider } from './ollama.js';
14 | export { BedrockAIProvider } from './bedrock.js';
15 | export { AzureProvider } from './azure.js';
16 | export { VertexAIProvider } from './google-vertex.js';
17 | export { ClaudeCodeProvider } from './claude-code.js';
18 | export { GeminiCliProvider } from './gemini-cli.js';
19 | export { GrokCliProvider } from './grok-cli.js';
20 | export { CodexCliProvider } from './codex-cli.js';
21 | export { OpenAICompatibleProvider } from './openai-compatible.js';
22 | export { ZAIProvider } from './zai.js';
23 | export { ZAICodingProvider } from './zai-coding.js';
24 | export { LMStudioProvider } from './lmstudio.js';
25 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/expand-task.md:
--------------------------------------------------------------------------------
```markdown
1 | Break down a complex task into subtasks.
2 |
3 | Arguments: $ARGUMENTS (task ID)
4 |
5 | ## Intelligent Task Expansion
6 |
7 | Analyzes a task and creates detailed subtasks for better manageability.
8 |
9 | ## Execution
10 |
11 | ```bash
12 | task-master expand --id=$ARGUMENTS
13 | ```
14 |
15 | ## Expansion Process
16 |
17 | 1. **Task Analysis**
18 | - Review task complexity
19 | - Identify components
20 | - Detect technical challenges
21 | - Estimate time requirements
22 |
23 | 2. **Subtask Generation**
24 | - Create 3-7 subtasks typically
25 | - Each subtask 1-4 hours
26 | - Logical implementation order
27 | - Clear acceptance criteria
28 |
29 | 3. **Smart Breakdown**
30 | - Setup/configuration tasks
31 | - Core implementation
32 | - Testing components
33 | - Integration steps
34 | - Documentation updates
35 |
36 | ## Enhanced Features
37 |
38 | Based on task type:
39 | - **Feature**: Setup → Implement → Test → Integrate
40 | - **Bug Fix**: Reproduce → Diagnose → Fix → Verify
41 | - **Refactor**: Analyze → Plan → Refactor → Validate
42 |
43 | ## Post-Expansion
44 |
45 | After expansion:
46 | 1. Show subtask hierarchy
47 | 2. Update time estimates
48 | 3. Suggest implementation order
49 | 4. Highlight critical path
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/parse-prd.md:
--------------------------------------------------------------------------------
```markdown
1 | Parse a PRD document to generate tasks.
2 |
3 | Arguments: $ARGUMENTS (PRD file path)
4 |
5 | ## Intelligent PRD Parsing
6 |
7 | Analyzes your requirements document and generates a complete task breakdown.
8 |
9 | ## Execution
10 |
11 | ```bash
12 | task-master parse-prd --input=$ARGUMENTS
13 | ```
14 |
15 | ## Parsing Process
16 |
17 | 1. **Document Analysis**
18 | - Extract key requirements
19 | - Identify technical components
20 | - Detect dependencies
21 | - Estimate complexity
22 |
23 | 2. **Task Generation**
24 | - Create 10-15 tasks by default
25 | - Include implementation tasks
26 | - Add testing tasks
27 | - Include documentation tasks
28 | - Set logical dependencies
29 |
30 | 3. **Smart Enhancements**
31 | - Group related functionality
32 | - Set appropriate priorities
33 | - Add acceptance criteria
34 | - Include test strategies
35 |
36 | ## Options
37 |
38 | Parse arguments for modifiers:
39 | - Number after filename → `--num-tasks`
40 | - `research` → Use research mode
41 | - `comprehensive` → Generate more tasks
42 |
43 | ## Post-Generation
44 |
45 | After parsing:
46 | 1. Display task summary
47 | 2. Show dependency graph
48 | 3. Suggest task expansion for complex items
49 | 4. Recommend sprint planning
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/parse-prd-with-research.md:
--------------------------------------------------------------------------------
```markdown
1 | Parse PRD with enhanced research mode for better task generation.
2 |
3 | Arguments: $ARGUMENTS (PRD file path)
4 |
5 | ## Research-Enhanced Parsing
6 |
7 | Uses the research AI provider (typically Perplexity) for more comprehensive task generation with current best practices.
8 |
9 | ## Execution
10 |
11 | ```bash
12 | task-master parse-prd --input=$ARGUMENTS --research
13 | ```
14 |
15 | ## Research Benefits
16 |
17 | 1. **Current Best Practices**
18 | - Latest framework patterns
19 | - Security considerations
20 | - Performance optimizations
21 | - Accessibility requirements
22 |
23 | 2. **Technical Deep Dive**
24 | - Implementation approaches
25 | - Library recommendations
26 | - Architecture patterns
27 | - Testing strategies
28 |
29 | 3. **Comprehensive Coverage**
30 | - Edge cases consideration
31 | - Error handling tasks
32 | - Monitoring setup
33 | - Deployment tasks
34 |
35 | ## Enhanced Output
36 |
37 | Research mode typically:
38 | - Generates more detailed tasks
39 | - Includes industry standards
40 | - Adds compliance considerations
41 | - Suggests modern tooling
42 |
43 | ## When to Use
44 |
45 | - New technology domains
46 | - Complex requirements
47 | - Regulatory compliance needed
48 | - Best practices crucial
```
--------------------------------------------------------------------------------
/apps/extension/src/webview/hooks/useWebviewHeight.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Hook for managing webview height
3 | */
4 |
5 | import { useState, useEffect, useCallback } from 'react';
6 |
7 | export const useWebviewHeight = () => {
8 | const [availableHeight, setAvailableHeight] = useState<number>(
9 | window.innerHeight
10 | );
11 |
12 | const updateAvailableHeight = useCallback(() => {
13 | const height = window.innerHeight;
14 | console.log('📏 Available height updated:', height);
15 | setAvailableHeight(height);
16 | }, []);
17 |
18 | useEffect(() => {
19 | updateAvailableHeight();
20 |
21 | const handleResize = () => {
22 | updateAvailableHeight();
23 | };
24 |
25 | window.addEventListener('resize', handleResize);
26 |
27 | // Also listen for VS Code specific events if available
28 | const handleVisibilityChange = () => {
29 | // Small delay to ensure VS Code has finished resizing
30 | setTimeout(updateAvailableHeight, 100);
31 | };
32 |
33 | document.addEventListener('visibilitychange', handleVisibilityChange);
34 |
35 | return () => {
36 | window.removeEventListener('resize', handleResize);
37 | document.removeEventListener('visibilitychange', handleVisibilityChange);
38 | };
39 | }, [updateAvailableHeight]);
40 |
41 | return availableHeight;
42 | };
43 |
```
--------------------------------------------------------------------------------
/.github/workflows/update-models-md.yml:
--------------------------------------------------------------------------------
```yaml
1 | name: Update models.md from supported-models.json
2 |
3 | on:
4 | push:
5 | branches:
6 | - main
7 | - next
8 | paths:
9 | - 'scripts/modules/supported-models.json'
10 | - 'docs/scripts/models-json-to-markdown.js'
11 |
12 | jobs:
13 | update_markdown:
14 | runs-on: ubuntu-latest
15 | steps:
16 | - name: Checkout repository
17 | uses: actions/checkout@v4
18 |
19 | - name: Set up Node.js
20 | uses: actions/setup-node@v4
21 | with:
22 | node-version: 20
23 |
24 | - name: Run transformation script
25 | run: node docs/scripts/models-json-to-markdown.js
26 |
27 | - name: Format Markdown with Prettier
28 | run: npx prettier --write docs/models.md
29 |
30 | - name: Stage docs/models.md
31 | run: git add docs/models.md
32 |
33 | - name: Commit & Push docs/models.md
34 | uses: actions-js/push@master
35 | with:
36 | github_token: ${{ secrets.GITHUB_TOKEN }}
37 | branch: ${{ github.ref_name }}
38 | message: 'docs: Auto-update and format models.md'
39 | author_name: 'github-actions[bot]'
40 | author_email: 'github-actions[bot]@users.noreply.github.com'
41 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/setup-models.md:
--------------------------------------------------------------------------------
```markdown
1 | Run interactive setup to configure AI models.
2 |
3 | ## Interactive Model Configuration
4 |
5 | Guides you through setting up AI providers for Task Master.
6 |
7 | ## Execution
8 |
9 | ```bash
10 | task-master models --setup
11 | ```
12 |
13 | ## Setup Process
14 |
15 | 1. **Environment Check**
16 | - Detect existing API keys
17 | - Show current configuration
18 | - Identify missing providers
19 |
20 | 2. **Provider Selection**
21 | - Choose main provider (required)
22 | - Select research provider (recommended)
23 | - Configure fallback (optional)
24 |
25 | 3. **API Key Configuration**
26 | - Prompt for missing keys
27 | - Validate key format
28 | - Test connectivity
29 | - Save configuration
30 |
31 | ## Smart Recommendations
32 |
33 | Based on your needs:
34 | - **For best results**: Claude + Perplexity
35 | - **Budget conscious**: GPT-3.5 + Perplexity
36 | - **Maximum capability**: GPT-4 + Perplexity + Claude fallback
37 |
38 | ## Configuration Storage
39 |
40 | Keys can be stored in:
41 | 1. Environment variables (recommended)
42 | 2. `.env` file in project
43 | 3. Global `.taskmaster/config`
44 |
45 | ## Post-Setup
46 |
47 | After configuration:
48 | - Test each provider
49 | - Show usage examples
50 | - Suggest next steps
51 | - Verify parse-prd works
```
--------------------------------------------------------------------------------
/src/prompts/schemas/variant.schema.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "$schema": "http://json-schema.org/draft-07/schema#",
3 | "$id": "https://github.com/eyaltoledano/claude-task-master/blob/main/src/prompts/schemas/variant.schema.json",
4 | "version": "1.0.0",
5 | "title": "Task Master Prompt Variant",
6 | "description": "Schema for prompt template variants",
7 | "type": "object",
8 | "required": ["system", "user"],
9 | "properties": {
10 | "system": {
11 | "type": "string",
12 | "minLength": 1,
13 | "description": "System prompt template with variable placeholders"
14 | },
15 | "user": {
16 | "type": "string",
17 | "minLength": 1,
18 | "description": "User prompt template with variable placeholders"
19 | },
20 | "condition": {
21 | "type": "string",
22 | "description": "JavaScript expression for variant selection (optional, only for non-default variants)"
23 | },
24 | "metadata": {
25 | "type": "object",
26 | "properties": {
27 | "description": {
28 | "type": "string",
29 | "description": "Description of when this variant should be used"
30 | },
31 | "tags": {
32 | "type": "array",
33 | "items": { "type": "string" },
34 | "description": "Tags for categorizing this variant"
35 | }
36 | }
37 | }
38 | }
39 | }
40 |
```
--------------------------------------------------------------------------------
/apps/extension/src/webview/contexts/VSCodeContext.tsx:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * VS Code API Context
3 | * Provides access to VS Code API and webview state
4 | */
5 |
6 | import React, { createContext, useContext } from 'react';
7 | import type { AppState, AppAction, ToastNotification } from '../types';
8 |
9 | export interface VSCodeContextValue {
10 | vscode?: ReturnType<NonNullable<typeof window.acquireVsCodeApi>>;
11 | state: AppState;
12 | dispatch: React.Dispatch<AppAction>;
13 | sendMessage: (message: any) => Promise<any>;
14 | availableHeight: number;
15 | // Toast notification functions
16 | showSuccessToast: (title: string, message: string, duration?: number) => void;
17 | showInfoToast: (title: string, message: string, duration?: number) => void;
18 | showWarningToast: (title: string, message: string, duration?: number) => void;
19 | showErrorToast: (title: string, message: string, duration?: number) => void;
20 | }
21 |
22 | export const VSCodeContext = createContext<VSCodeContextValue | undefined>(
23 | undefined
24 | );
25 |
26 | export const useVSCodeContext = () => {
27 | const context = useContext(VSCodeContext);
28 | if (!context) {
29 | throw new Error('useVSCodeContext must be used within VSCodeProvider');
30 | }
31 | return context;
32 | };
33 |
```
--------------------------------------------------------------------------------
/src/ai-providers/xai.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * xai.js
3 | * AI provider implementation for xAI models using Vercel AI SDK.
4 | */
5 |
6 | import { createXai } from '@ai-sdk/xai';
7 | import { BaseAIProvider } from './base-provider.js';
8 |
9 | export class XAIProvider extends BaseAIProvider {
10 | constructor() {
11 | super();
12 | this.name = 'xAI';
13 | }
14 |
15 | /**
16 | * Returns the environment variable name required for this provider's API key.
17 | * @returns {string} The environment variable name for the xAI API key
18 | */
19 | getRequiredApiKeyName() {
20 | return 'XAI_API_KEY';
21 | }
22 |
23 | /**
24 | * Creates and returns an xAI client instance.
25 | * @param {object} params - Parameters for client initialization
26 | * @param {string} params.apiKey - xAI API key
27 | * @param {string} [params.baseURL] - Optional custom API endpoint
28 | * @returns {Function} xAI client function
29 | * @throws {Error} If API key is missing or initialization fails
30 | */
31 | getClient(params) {
32 | try {
33 | const { apiKey, baseURL } = params;
34 |
35 | return createXai({
36 | apiKey,
37 | baseURL: baseURL || 'https://api.x.ai/v1'
38 | });
39 | } catch (error) {
40 | this.handleError('client initialization', error);
41 | }
42 | }
43 | }
44 |
```
--------------------------------------------------------------------------------
/packages/tm-core/src/common/logger/factory.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @fileoverview Logger factory and singleton management
3 | */
4 |
5 | import { Logger, type LoggerConfig } from './logger.js';
6 |
7 | // Global logger instance
8 | let globalLogger: Logger | null = null;
9 |
10 | // Named logger instances
11 | const loggers = new Map<string, Logger>();
12 |
13 | /**
14 | * Create a new logger instance
15 | */
16 | export function createLogger(config?: LoggerConfig): Logger {
17 | return new Logger(config);
18 | }
19 |
20 | /**
21 | * Get or create a named logger instance
22 | */
23 | export function getLogger(name?: string, config?: LoggerConfig): Logger {
24 | // If no name provided, return global logger
25 | if (!name) {
26 | if (!globalLogger) {
27 | globalLogger = createLogger(config);
28 | }
29 | return globalLogger;
30 | }
31 |
32 | // Check if named logger exists
33 | if (!loggers.has(name)) {
34 | loggers.set(
35 | name,
36 | createLogger({
37 | prefix: name,
38 | ...config
39 | })
40 | );
41 | }
42 |
43 | return loggers.get(name)!;
44 | }
45 |
46 | /**
47 | * Set the global logger instance
48 | */
49 | export function setGlobalLogger(logger: Logger): void {
50 | globalLogger = logger;
51 | }
52 |
53 | /**
54 | * Clear all logger instances (useful for testing)
55 | */
56 | export function clearLoggers(): void {
57 | globalLogger = null;
58 | loggers.clear();
59 | }
60 |
```
--------------------------------------------------------------------------------
/packages/claude-code-plugin/commands/to-cancelled.md:
--------------------------------------------------------------------------------
```markdown
1 | Cancel a task permanently.
2 |
3 | Arguments: $ARGUMENTS (task ID)
4 |
5 | ## Cancelling a Task
6 |
7 | This status indicates a task is no longer needed and won't be completed.
8 |
9 | ## Valid Reasons for Cancellation
10 |
11 | - Requirements changed
12 | - Feature deprecated
13 | - Duplicate of another task
14 | - Strategic pivot
15 | - Technical approach invalidated
16 |
17 | ## Pre-Cancellation Checks
18 |
19 | 1. Confirm no critical dependencies
20 | 2. Check for partial implementation
21 | 3. Verify cancellation rationale
22 | 4. Document lessons learned
23 |
24 | ## Execution
25 |
26 | ```bash
27 | task-master set-status --id=$ARGUMENTS --status=cancelled
28 | ```
29 |
30 | ## Cancellation Impact
31 |
32 | When cancelling:
33 | 1. **Dependency Updates**
34 | - Notify dependent tasks
35 | - Update project scope
36 | - Recalculate timelines
37 |
38 | 2. **Clean-up Actions**
39 | - Remove related branches
40 | - Archive any work done
41 | - Update documentation
42 | - Close related issues
43 |
44 | 3. **Learning Capture**
45 | - Document why cancelled
46 | - Note what was learned
47 | - Update estimation models
48 | - Prevent future duplicates
49 |
50 | ## Historical Preservation
51 |
52 | - Keep for reference
53 | - Tag with cancellation reason
54 | - Link to replacement if any
55 | - Maintain audit trail
```
--------------------------------------------------------------------------------
/src/ai-providers/groq.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * src/ai-providers/groq.js
3 | *
4 | * Implementation for interacting with Groq models
5 | * using the Vercel AI SDK.
6 | */
7 |
8 | import { createGroq } from '@ai-sdk/groq';
9 | import { BaseAIProvider } from './base-provider.js';
10 |
11 | export class GroqProvider extends BaseAIProvider {
12 | constructor() {
13 | super();
14 | this.name = 'Groq';
15 | }
16 |
17 | /**
18 | * Returns the environment variable name required for this provider's API key.
19 | * @returns {string} The environment variable name for the Groq API key
20 | */
21 | getRequiredApiKeyName() {
22 | return 'GROQ_API_KEY';
23 | }
24 |
25 | /**
26 | * Creates and returns a Groq client instance.
27 | * @param {object} params - Parameters for client initialization
28 | * @param {string} params.apiKey - Groq API key
29 | * @param {string} [params.baseURL] - Optional custom API endpoint
30 | * @returns {Function} Groq client function
31 | * @throws {Error} If API key is missing or initialization fails
32 | */
33 | getClient(params) {
34 | try {
35 | const { apiKey, baseURL } = params;
36 |
37 | return createGroq({
38 | apiKey,
39 | ...(baseURL && { baseURL })
40 | });
41 | } catch (error) {
42 | this.handleError('client initialization', error);
43 | }
44 | }
45 | }
46 |
```
--------------------------------------------------------------------------------
/biome.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "files": {
3 | "ignore": [
4 | "build",
5 | "coverage",
6 | ".changeset",
7 | "tasks",
8 | "package-lock.json",
9 | "tests/fixture/*.json",
10 | "dist"
11 | ]
12 | },
13 | "formatter": {
14 | "bracketSpacing": true,
15 | "enabled": true,
16 | "indentStyle": "tab",
17 | "lineWidth": 80
18 | },
19 | "javascript": {
20 | "formatter": {
21 | "arrowParentheses": "always",
22 | "quoteStyle": "single",
23 | "trailingCommas": "none"
24 | }
25 | },
26 | "linter": {
27 | "enabled": true,
28 | "include": ["apps/extension/**/*.ts", "apps/extension/**/*.tsx"],
29 | "ignore": ["**/*", "!apps/extension/**/*"],
30 | "rules": {
31 | "recommended": true,
32 | "complexity": {
33 | "noForEach": "off",
34 | "useOptionalChain": "off",
35 | "useArrowFunction": "off"
36 | },
37 | "correctness": {
38 | "noConstantCondition": "off",
39 | "noUnreachable": "off"
40 | },
41 | "suspicious": {
42 | "noDuplicateTestHooks": "off",
43 | "noPrototypeBuiltins": "off"
44 | },
45 | "style": {
46 | "noUselessElse": "off",
47 | "useNodejsImportProtocol": "off",
48 | "useNumberNamespace": "off",
49 | "noParameterAssign": "off",
50 | "useTemplate": "off",
51 | "noUnusedTemplateLiteral": "off",
52 | "noNonNullAssertion": "warn"
53 | }
54 | }
55 | }
56 | }
57 |
```
--------------------------------------------------------------------------------
/src/schemas/registry.js:
--------------------------------------------------------------------------------
```javascript
1 | import { AddTaskResponseSchema } from './add-task.js';
2 | import { ComplexityAnalysisResponseSchema } from './analyze-complexity.js';
3 | import { ExpandTaskResponseSchema } from './expand-task.js';
4 | import { ParsePRDResponseSchema } from './parse-prd.js';
5 | import { UpdateSubtaskResponseSchema } from './update-subtask.js';
6 | import { UpdateTaskResponseSchema } from './update-task.js';
7 | import { UpdateTasksResponseSchema } from './update-tasks.js';
8 |
9 | export const COMMAND_SCHEMAS = {
10 | 'update-tasks': UpdateTasksResponseSchema,
11 | 'expand-task': ExpandTaskResponseSchema,
12 | 'analyze-complexity': ComplexityAnalysisResponseSchema,
13 | 'update-subtask-by-id': UpdateSubtaskResponseSchema,
14 | 'update-task-by-id': UpdateTaskResponseSchema,
15 | 'add-task': AddTaskResponseSchema,
16 | 'parse-prd': ParsePRDResponseSchema
17 | };
18 |
19 | // Export individual schemas for direct access
20 | export * from './update-tasks.js';
21 | export * from './expand-task.js';
22 | export * from './analyze-complexity.js';
23 | export * from './update-subtask.js';
24 | export * from './update-task.js';
25 | export * from './add-task.js';
26 | export * from './parse-prd.js';
27 | export * from './base-schemas.js';
28 |
```
--------------------------------------------------------------------------------
/packages/tm-bridge/src/index.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * @tm/bridge - Temporary bridge package for legacy code migration
3 | *
4 | * ⚠️ THIS PACKAGE IS TEMPORARY AND WILL BE DELETED ⚠️
5 | *
6 | * This package exists solely to provide shared bridge logic between
7 | * legacy scripts and the new tm-core architecture during migration.
8 | *
9 | * DELETE THIS PACKAGE when legacy scripts are removed.
10 | */
11 |
12 | // Shared types and utilities
13 | export type {
14 | LogLevel,
15 | ReportFunction,
16 | OutputFormat,
17 | BaseBridgeParams,
18 | StorageCheckResult
19 | } from './bridge-types.js';
20 |
21 | export { checkStorageType } from './bridge-utils.js';
22 |
23 | // Bridge functions
24 | export {
25 | tryUpdateViaRemote,
26 | type UpdateBridgeParams,
27 | type RemoteUpdateResult
28 | } from './update-bridge.js';
29 |
30 | export {
31 | tryExpandViaRemote,
32 | type ExpandBridgeParams,
33 | type RemoteExpandResult
34 | } from './expand-bridge.js';
35 |
36 | export {
37 | tryListTagsViaRemote,
38 | type TagsBridgeParams,
39 | type RemoteTagsResult,
40 | type TagInfo
41 | } from './tags-bridge.js';
42 |
43 | export {
44 | tryUseTagViaRemote,
45 | type UseTagBridgeParams,
46 | type RemoteUseTagResult
47 | } from './use-tag-bridge.js';
48 |
49 | export {
50 | tryAddTagViaRemote,
51 | type AddTagBridgeParams,
52 | type RemoteAddTagResult
53 | } from './add-tag-bridge.js';
54 |
```
--------------------------------------------------------------------------------
/.github/workflows/claude.yml:
--------------------------------------------------------------------------------
```yaml
1 | name: Claude Code
2 |
3 | on:
4 | issue_comment:
5 | types: [created]
6 | pull_request_review_comment:
7 | types: [created]
8 | issues:
9 | types: [opened, assigned]
10 | pull_request_review:
11 | types: [submitted]
12 |
13 | jobs:
14 | claude:
15 | if: |
16 | (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
17 | (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
18 | (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
19 | (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
20 | runs-on: ubuntu-latest
21 | permissions:
22 | contents: read
23 | pull-requests: read
24 | issues: read
25 | id-token: write
26 | steps:
27 | - name: Checkout repository
28 | uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
29 | with:
30 | fetch-depth: 1
31 |
32 | - name: Run Claude Code
33 | id: claude
34 | uses: anthropics/claude-code-action@beta
35 | with:
36 | anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
37 |
```
--------------------------------------------------------------------------------
/packages/tm-bridge/src/bridge-types.ts:
--------------------------------------------------------------------------------
```typescript
1 | /**
2 | * Shared types and interfaces for bridge functions
3 | */
4 |
5 | /**
6 | * Log levels used by bridge report functions
7 | */
8 | export type LogLevel = 'info' | 'warn' | 'error' | 'debug' | 'success';
9 |
10 | /**
11 | * Report function signature used by all bridges
12 | */
13 | export type ReportFunction = (level: LogLevel, ...args: unknown[]) => void;
14 |
15 | /**
16 | * Output format for bridge results
17 | */
18 | export type OutputFormat = 'text' | 'json';
19 |
20 | /**
21 | * Common parameters shared by all bridge functions
22 | */
23 | export interface BaseBridgeParams {
24 | /** Project root directory */
25 | projectRoot: string;
26 | /** Whether called from MCP context (default: false) */
27 | isMCP?: boolean;
28 | /** Output format (default: 'text') */
29 | outputFormat?: OutputFormat;
30 | /** Logging function */
31 | report: ReportFunction;
32 | /** Optional tag for task organization */
33 | tag?: string;
34 | }
35 |
36 | /**
37 | * Result from checking if API storage should handle an operation
38 | */
39 | export interface StorageCheckResult {
40 | /** Whether API storage is being used */
41 | isApiStorage: boolean;
42 | /** TmCore instance if initialization succeeded */
43 | tmCore?: import('@tm/core').TmCore;
44 | /** Error message if initialization failed */
45 | error?: string;
46 | }
47 |
```
--------------------------------------------------------------------------------
/src/constants/task-priority.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * @typedef {'high' | 'medium' | 'low'} TaskPriority
3 | */
4 |
5 | /**
6 | * Task priority options
7 | * @type {TaskPriority[]}
8 | * @description Defines possible task priorities:
9 | * - high: Critical tasks that need immediate attention
10 | * - medium: Standard priority tasks (default)
11 | * - low: Tasks that can be deferred or are nice-to-have
12 | */
13 | export const TASK_PRIORITY_OPTIONS = ['high', 'medium', 'low'];
14 |
15 | /**
16 | * Default task priority
17 | * @type {TaskPriority}
18 | */
19 | export const DEFAULT_TASK_PRIORITY = 'medium';
20 |
21 | /**
22 | * Check if a given priority is valid
23 | * @param {string} priority - The priority to check
24 | * @returns {boolean} True if the priority is valid, false otherwise
25 | */
26 | export function isValidTaskPriority(priority) {
27 | return TASK_PRIORITY_OPTIONS.includes(priority?.toLowerCase());
28 | }
29 |
30 | /**
31 | * Normalize a priority value to lowercase
32 | * @param {string} priority - The priority to normalize
33 | * @returns {TaskPriority|null} The normalized priority or null if invalid
34 | */
35 | export function normalizeTaskPriority(priority) {
36 | if (!priority) return null;
37 | const normalized = priority.toLowerCase();
38 | return isValidTaskPriority(normalized) ? normalized : null;
39 | }
40 |
```
--------------------------------------------------------------------------------
/apps/mcp/package.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "@tm/mcp",
3 | "description": "Task Master MCP Tools - TypeScript MCP server tools for AI agent integration",
4 | "type": "module",
5 | "private": true,
6 | "main": "./dist/index.js",
7 | "types": "./src/index.ts",
8 | "exports": {
9 | ".": "./src/index.ts",
10 | "./tools/autopilot": "./src/tools/autopilot/index.ts"
11 | },
12 | "files": ["dist", "README.md"],
13 | "scripts": {
14 | "typecheck": "tsc --noEmit",
15 | "lint": "biome check src",
16 | "format": "biome format --write src",
17 | "test": "vitest run",
18 | "test:watch": "vitest",
19 | "test:coverage": "vitest run --coverage",
20 | "test:unit": "vitest run -t unit",
21 | "test:integration": "vitest run -t integration",
22 | "test:ci": "vitest run --coverage --reporter=dot"
23 | },
24 | "dependencies": {
25 | "@tm/core": "*",
26 | "zod": "^4.1.11",
27 | "fastmcp": "^3.23.0"
28 | },
29 | "devDependencies": {
30 | "@biomejs/biome": "^1.9.4",
31 | "@types/node": "^22.10.5",
32 | "typescript": "^5.9.2",
33 | "vitest": "^3.2.4"
34 | },
35 | "engines": {
36 | "node": ">=18.0.0"
37 | },
38 | "keywords": [
39 | "task-master",
40 | "mcp",
41 | "mcp-server",
42 | "ai-agent",
43 | "workflow",
44 | "tdd"
45 | ],
46 | "author": "",
47 | "license": "MIT",
48 | "typesVersions": {
49 | "*": {
50 | "*": ["src/*"]
51 | }
52 | },
53 | "version": ""
54 | }
55 |
```
--------------------------------------------------------------------------------
/scripts/modules/task-manager/task-exists.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * Checks if a task with the given ID exists
3 | * @param {Array} tasks - Array of tasks to search
4 | * @param {string|number} taskId - ID of task or subtask to check
5 | * @returns {boolean} Whether the task exists
6 | */
7 | function taskExists(tasks, taskId) {
8 | // Handle subtask IDs (e.g., "1.2")
9 | if (typeof taskId === 'string' && taskId.includes('.')) {
10 | const parts = taskId.split('.');
11 | // Validate that it's a proper subtask format (parentId.subtaskId)
12 | if (parts.length !== 2 || !parts[0] || !parts[1]) {
13 | // Invalid format - treat as regular task ID
14 | const id = parseInt(taskId, 10);
15 | return tasks.some((t) => t.id === id);
16 | }
17 |
18 | const [parentIdStr, subtaskIdStr] = parts;
19 | const parentId = parseInt(parentIdStr, 10);
20 | const subtaskId = parseInt(subtaskIdStr, 10);
21 |
22 | // Find the parent task
23 | const parentTask = tasks.find((t) => t.id === parentId);
24 |
25 | // If parent exists, check if subtask exists
26 | return (
27 | parentTask &&
28 | parentTask.subtasks &&
29 | parentTask.subtasks.some((st) => st.id === subtaskId)
30 | );
31 | }
32 |
33 | // Handle regular task IDs
34 | const id = parseInt(taskId, 10);
35 | return tasks.some((t) => t.id === id);
36 | }
37 |
38 | export default taskExists;
39 |
```
--------------------------------------------------------------------------------
/src/ai-providers/openrouter.js:
--------------------------------------------------------------------------------
```javascript
1 | /**
2 | * openrouter.js
3 | * AI provider implementation for OpenRouter models using Vercel AI SDK.
4 | */
5 |
6 | import { createOpenRouter } from '@openrouter/ai-sdk-provider';
7 | import { BaseAIProvider } from './base-provider.js';
8 |
9 | export class OpenRouterAIProvider extends BaseAIProvider {
10 | constructor() {
11 | super();
12 | this.name = 'OpenRouter';
13 | }
14 |
15 | /**
16 | * Returns the environment variable name required for this provider's API key.
17 | * @returns {string} The environment variable name for the OpenRouter API key
18 | */
19 | getRequiredApiKeyName() {
20 | return 'OPENROUTER_API_KEY';
21 | }
22 |
23 | /**
24 | * Creates and returns an OpenRouter client instance.
25 | * @param {object} params - Parameters for client initialization
26 | * @param {string} params.apiKey - OpenRouter API key
27 | * @param {string} [params.baseURL] - Optional custom API endpoint
28 | * @returns {Function} OpenRouter client function
29 | * @throws {Error} If API key is missing or initialization fails
30 | */
31 | getClient(params) {
32 | try {
33 | const { apiKey, baseURL } = params;
34 |
35 | return createOpenRouter({
36 | apiKey,
37 | ...(baseURL && { baseURL })
38 | });
39 | } catch (error) {
40 | this.handleError('client initialization', error);
41 | }
42 | }
43 | }
44 |
```