This is page 27 of 50. Use http://codebase.md/eyaltoledano/claude-task-master?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
--------------------------------------------------------------------------------
/tests/unit/scripts/modules/task-manager/analyze-task-complexity.test.js:
--------------------------------------------------------------------------------
```javascript
/**
* Tests for the analyze-task-complexity.js module
*/
import { jest } from '@jest/globals';
import {
createGetTagAwareFilePathMock,
createSlugifyTagForFilePathMock
} from './setup.js';
// Mock the dependencies before importing the module under test
jest.unstable_mockModule('../../../../../scripts/modules/utils.js', () => ({
readJSON: jest.fn(),
writeJSON: jest.fn(),
log: jest.fn(),
CONFIG: {
model: 'mock-claude-model',
maxTokens: 4000,
temperature: 0.7,
debug: false,
defaultSubtasks: 3
},
findTaskById: jest.fn(),
readComplexityReport: jest.fn(),
findTaskInComplexityReport: jest.fn(),
findProjectRoot: jest.fn(() => '/mock/project/root'),
resolveEnvVariable: jest.fn((varName) => `mock_${varName}`),
isSilentMode: jest.fn(() => false),
findCycles: jest.fn(() => []),
formatTaskId: jest.fn((id) => `Task ${id}`),
taskExists: jest.fn((tasks, id) => tasks.some((t) => t.id === id)),
enableSilentMode: jest.fn(),
disableSilentMode: jest.fn(),
truncate: jest.fn((text) => text),
addComplexityToTask: jest.fn((task, complexity) => ({ ...task, complexity })),
aggregateTelemetry: jest.fn((telemetryArray) => telemetryArray[0] || {}),
ensureTagMetadata: jest.fn((tagObj) => tagObj),
getCurrentTag: jest.fn(() => 'master'),
resolveTag: jest.fn(() => 'master'),
flattenTasksWithSubtasks: jest.fn((tasks) => tasks),
getTagAwareFilePath: createGetTagAwareFilePathMock(),
slugifyTagForFilePath: createSlugifyTagForFilePathMock(),
markMigrationForNotice: jest.fn(),
performCompleteTagMigration: jest.fn(),
setTasksForTag: jest.fn(),
getTasksForTag: jest.fn((data, tag) => data[tag]?.tasks || []),
traverseDependencies: jest.fn((tasks, taskId, visited) => [])
}));
jest.unstable_mockModule(
'../../../../../scripts/modules/ai-services-unified.js',
() => ({
generateObjectService: jest.fn().mockResolvedValue({
mainResult: {
complexityAnalysis: []
},
telemetryData: {
timestamp: new Date().toISOString(),
userId: '1234567890',
commandName: 'analyze-complexity',
modelUsed: 'claude-3-5-sonnet',
providerName: 'anthropic',
inputTokens: 1000,
outputTokens: 500,
totalTokens: 1500,
totalCost: 0.012414,
currency: 'USD'
}
}),
generateTextService: jest.fn().mockResolvedValue({
mainResult: '[]',
telemetryData: {
timestamp: new Date().toISOString(),
userId: '1234567890',
commandName: 'analyze-complexity',
modelUsed: 'claude-3-5-sonnet',
providerName: 'anthropic',
inputTokens: 1000,
outputTokens: 500,
totalTokens: 1500,
totalCost: 0.012414,
currency: 'USD'
}
}),
streamTextService: jest.fn().mockResolvedValue({
mainResult: async function* () {
yield '{"tasks":[';
yield '{"id":1,"title":"Test Task","priority":"high"}';
yield ']}';
},
telemetryData: {
timestamp: new Date().toISOString(),
userId: '1234567890',
commandName: 'analyze-complexity',
modelUsed: 'claude-3-5-sonnet',
providerName: 'anthropic',
inputTokens: 1000,
outputTokens: 500,
totalTokens: 1500,
totalCost: 0.012414,
currency: 'USD'
}
}),
streamObjectService: jest.fn().mockImplementation(async () => {
return {
get partialObjectStream() {
return (async function* () {
yield { tasks: [] };
yield { tasks: [{ id: 1, title: 'Test Task', priority: 'high' }] };
})();
},
object: Promise.resolve({
tasks: [{ id: 1, title: 'Test Task', priority: 'high' }]
})
};
})
})
);
jest.unstable_mockModule(
'../../../../../scripts/modules/config-manager.js',
() => ({
// Core config access
getConfig: jest.fn(() => ({
models: { main: { provider: 'anthropic', modelId: 'claude-3-5-sonnet' } },
global: { projectName: 'Test Project' }
})),
writeConfig: jest.fn(() => true),
ConfigurationError: class extends Error {},
isConfigFilePresent: jest.fn(() => true),
// Validation
validateProvider: jest.fn(() => true),
validateProviderModelCombination: jest.fn(() => true),
VALID_PROVIDERS: ['anthropic', 'openai', 'perplexity'],
MODEL_MAP: {
anthropic: [
{
id: 'claude-3-5-sonnet',
cost_per_1m_tokens: { input: 3, output: 15 }
}
],
openai: [{ id: 'gpt-4', cost_per_1m_tokens: { input: 30, output: 60 } }]
},
getAvailableModels: jest.fn(() => [
{
id: 'claude-3-5-sonnet',
name: 'Claude 3.5 Sonnet',
provider: 'anthropic'
},
{ id: 'gpt-4', name: 'GPT-4', provider: 'openai' }
]),
// Role-specific getters
getMainProvider: jest.fn(() => 'anthropic'),
getMainModelId: jest.fn(() => 'claude-3-5-sonnet'),
getMainMaxTokens: jest.fn(() => 4000),
getMainTemperature: jest.fn(() => 0.7),
getResearchProvider: jest.fn(() => 'perplexity'),
getResearchModelId: jest.fn(() => 'sonar-pro'),
getResearchMaxTokens: jest.fn(() => 8700),
getResearchTemperature: jest.fn(() => 0.1),
getFallbackProvider: jest.fn(() => 'anthropic'),
getFallbackModelId: jest.fn(() => 'claude-3-5-sonnet'),
getFallbackMaxTokens: jest.fn(() => 4000),
getFallbackTemperature: jest.fn(() => 0.7),
getBaseUrlForRole: jest.fn(() => undefined),
// Global setting getters
getLogLevel: jest.fn(() => 'info'),
getDebugFlag: jest.fn(() => false),
getDefaultNumTasks: jest.fn(() => 10),
getDefaultSubtasks: jest.fn(() => 5),
getDefaultPriority: jest.fn(() => 'medium'),
getProjectName: jest.fn(() => 'Test Project'),
getOllamaBaseURL: jest.fn(() => 'http://localhost:11434/api'),
getAzureBaseURL: jest.fn(() => undefined),
getBedrockBaseURL: jest.fn(() => undefined),
getParametersForRole: jest.fn(() => ({
maxTokens: 4000,
temperature: 0.7
})),
getUserId: jest.fn(() => '1234567890'),
// API Key Checkers
isApiKeySet: jest.fn(() => true),
getMcpApiKeyStatus: jest.fn(() => true),
// Additional functions
getAllProviders: jest.fn(() => ['anthropic', 'openai', 'perplexity']),
getVertexProjectId: jest.fn(() => undefined),
getVertexLocation: jest.fn(() => undefined),
hasCodebaseAnalysis: jest.fn(() => false)
})
);
// Mock fs module
const mockWriteFileSync = jest.fn();
jest.unstable_mockModule('fs', () => ({
default: {
existsSync: jest.fn(() => false),
readFileSync: jest.fn(),
writeFileSync: mockWriteFileSync,
unlinkSync: jest.fn()
},
existsSync: jest.fn(() => false),
readFileSync: jest.fn(),
writeFileSync: mockWriteFileSync,
unlinkSync: jest.fn()
}));
jest.unstable_mockModule(
'../../../../../scripts/modules/prompt-manager.js',
() => ({
getPromptManager: jest.fn().mockReturnValue({
loadPrompt: jest.fn().mockResolvedValue({
systemPrompt: 'Mocked system prompt',
userPrompt: 'Mocked user prompt'
})
})
})
);
// Import the mocked modules
const { readJSON, writeJSON, log, CONFIG, findTaskById } = await import(
'../../../../../scripts/modules/utils.js'
);
const { generateObjectService, generateTextService, streamTextService } =
await import('../../../../../scripts/modules/ai-services-unified.js');
const fs = await import('fs');
// Import the module under test
const { default: analyzeTaskComplexity } = await import(
'../../../../../scripts/modules/task-manager/analyze-task-complexity.js'
);
describe('analyzeTaskComplexity', () => {
// Sample response structure (simplified for these tests)
const sampleApiResponse = {
mainResult: JSON.stringify({
tasks: [
{ id: 1, complexity: 3, subtaskCount: 2 },
{ id: 2, complexity: 7, subtaskCount: 5 },
{ id: 3, complexity: 9, subtaskCount: 8 }
]
}),
telemetryData: {
timestamp: new Date().toISOString(),
userId: '1234567890',
commandName: 'analyze-complexity',
modelUsed: 'claude-3-5-sonnet',
providerName: 'anthropic',
inputTokens: 1000,
outputTokens: 500,
totalTokens: 1500,
totalCost: 0.012414,
currency: 'USD'
}
};
const sampleTasks = {
master: {
tasks: [
{
id: 1,
title: 'Task 1',
description: 'First task description',
status: 'pending',
dependencies: [],
priority: 'high'
},
{
id: 2,
title: 'Task 2',
description: 'Second task description',
status: 'pending',
dependencies: [1],
priority: 'medium'
},
{
id: 3,
title: 'Task 3',
description: 'Third task description',
status: 'done',
dependencies: [1, 2],
priority: 'high'
}
]
}
};
beforeEach(() => {
jest.clearAllMocks();
// Default mock implementations - readJSON should return the resolved view with tasks at top level
readJSON.mockImplementation((tasksPath, projectRoot, tag) => {
return {
...sampleTasks.master,
tag: tag || 'master',
_rawTaggedData: sampleTasks
};
});
// Mock findTaskById to return the expected structure
findTaskById.mockImplementation((tasks, taskId) => {
const task = tasks?.find((t) => t.id === parseInt(taskId));
return { task: task || null, originalSubtaskCount: null };
});
generateObjectService.mockResolvedValue({
mainResult: {
complexityAnalysis: JSON.parse(sampleApiResponse.mainResult).tasks
},
telemetryData: sampleApiResponse.telemetryData
});
});
test('should call generateObjectService with the correct parameters', async () => {
// Arrange
const options = {
file: 'tasks/tasks.json',
output: 'scripts/task-complexity-report.json',
threshold: '5',
research: false,
projectRoot: '/mock/project/root'
};
// Act
await analyzeTaskComplexity(options, {
projectRoot: '/mock/project/root',
mcpLog: {
info: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
debug: jest.fn(),
success: jest.fn()
}
});
// Assert
expect(readJSON).toHaveBeenCalledWith(
'tasks/tasks.json',
'/mock/project/root',
undefined
);
expect(generateObjectService).toHaveBeenCalledWith(expect.any(Object));
expect(mockWriteFileSync).toHaveBeenCalledWith(
expect.stringContaining('task-complexity-report.json'),
expect.stringContaining('"thresholdScore": 5'),
'utf8'
);
});
test('should use research flag to determine which AI service to use', async () => {
// Arrange
const researchOptions = {
file: 'tasks/tasks.json',
output: 'scripts/task-complexity-report.json',
threshold: '5',
research: true,
projectRoot: '/mock/project/root'
};
// Act
await analyzeTaskComplexity(researchOptions, {
projectRoot: '/mock/project/root',
mcpLog: {
info: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
debug: jest.fn(),
success: jest.fn()
}
});
// Assert
expect(generateObjectService).toHaveBeenCalledWith(
expect.objectContaining({
role: 'research' // This should be present when research is true
})
);
});
test('should handle different threshold parameter types correctly', async () => {
// Test with string threshold
let options = {
file: 'tasks/tasks.json',
output: 'scripts/task-complexity-report.json',
threshold: '7',
projectRoot: '/mock/project/root'
};
await analyzeTaskComplexity(options, {
projectRoot: '/mock/project/root',
mcpLog: {
info: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
debug: jest.fn(),
success: jest.fn()
}
});
expect(mockWriteFileSync).toHaveBeenCalledWith(
expect.stringContaining('task-complexity-report.json'),
expect.stringContaining('"thresholdScore": 7'),
'utf8'
);
// Reset mocks
jest.clearAllMocks();
// Test with number threshold
options = {
file: 'tasks/tasks.json',
output: 'scripts/task-complexity-report.json',
threshold: 8,
projectRoot: '/mock/project/root'
};
await analyzeTaskComplexity(options, {
projectRoot: '/mock/project/root',
mcpLog: {
info: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
debug: jest.fn(),
success: jest.fn()
}
});
expect(mockWriteFileSync).toHaveBeenCalledWith(
expect.stringContaining('task-complexity-report.json'),
expect.stringContaining('"thresholdScore": 8'),
'utf8'
);
});
test('should filter out completed tasks from analysis', async () => {
// Arrange
const options = {
file: 'tasks/tasks.json',
output: 'scripts/task-complexity-report.json',
threshold: '5',
projectRoot: '/mock/project/root'
};
// Act
await analyzeTaskComplexity(options, {
projectRoot: '/mock/project/root',
mcpLog: {
info: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
debug: jest.fn(),
success: jest.fn()
}
});
// Assert
// Check if the prompt sent to AI doesn't include the completed task (id: 3)
expect(generateObjectService).toHaveBeenCalledWith(
expect.objectContaining({
prompt: expect.not.stringContaining('"id": 3')
})
);
});
test('should handle API errors gracefully', async () => {
// Arrange
const options = {
file: 'tasks/tasks.json',
output: 'scripts/task-complexity-report.json',
threshold: '5',
projectRoot: '/mock/project/root'
};
// Force API error
generateObjectService.mockRejectedValueOnce(new Error('API Error'));
const mockMcpLog = {
info: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
debug: jest.fn(),
success: jest.fn()
};
// Act & Assert
await expect(
analyzeTaskComplexity(options, {
projectRoot: '/mock/project/root',
mcpLog: mockMcpLog
})
).rejects.toThrow('API Error');
// Check that the error was logged via mcpLog
expect(mockMcpLog.error).toHaveBeenCalledWith(
expect.stringContaining('API Error')
);
});
});
```
--------------------------------------------------------------------------------
/tests/unit/scripts/modules/task-manager/models-baseurl.test.js:
--------------------------------------------------------------------------------
```javascript
/**
* Tests for models.js baseURL handling
* Verifies that baseURL is only preserved when switching models within the same provider
*/
import { jest } from '@jest/globals';
// Mock the config manager
const mockConfigManager = {
getMainModelId: jest.fn(() => 'claude-3-sonnet-20240229'),
getResearchModelId: jest.fn(
() => 'perplexity-llama-3.1-sonar-large-128k-online'
),
getFallbackModelId: jest.fn(() => 'gpt-4o-mini'),
getMainProvider: jest.fn(),
getResearchProvider: jest.fn(),
getFallbackProvider: jest.fn(),
getBaseUrlForRole: jest.fn(),
getAvailableModels: jest.fn(),
getConfig: jest.fn(),
writeConfig: jest.fn(),
isConfigFilePresent: jest.fn(() => true),
getAllProviders: jest.fn(() => [
'anthropic',
'openai',
'google',
'openrouter'
]),
isApiKeySet: jest.fn(() => true),
getMcpApiKeyStatus: jest.fn(() => true)
};
jest.unstable_mockModule(
'../../../../../scripts/modules/config-manager.js',
() => mockConfigManager
);
// Mock path utils
jest.unstable_mockModule('../../../../../src/utils/path-utils.js', () => ({
findConfigPath: jest.fn(() => '/test/path/.taskmaster/config.json')
}));
// Mock utils
jest.unstable_mockModule('../../../../../scripts/modules/utils.js', () => ({
log: jest.fn()
}));
// Mock core constants
jest.unstable_mockModule('@tm/core', () => ({
CUSTOM_PROVIDERS: {
OLLAMA: 'ollama',
LMSTUDIO: 'lmstudio',
OPENROUTER: 'openrouter',
BEDROCK: 'bedrock',
CLAUDE_CODE: 'claude-code',
AZURE: 'azure',
VERTEX: 'vertex',
GEMINI_CLI: 'gemini-cli',
CODEX_CLI: 'codex-cli',
OPENAI_COMPATIBLE: 'openai-compatible'
}
}));
// Import the module under test after mocks are set up
const { setModel } = await import(
'../../../../../scripts/modules/task-manager/models.js'
);
describe('models.js - baseURL handling for LMSTUDIO', () => {
const mockProjectRoot = '/test/project';
const mockConfig = {
models: {
main: { provider: 'lmstudio', modelId: 'existing-model' },
research: { provider: 'ollama', modelId: 'llama2' },
fallback: { provider: 'anthropic', modelId: 'claude-3-haiku-20240307' }
}
};
beforeEach(() => {
jest.clearAllMocks();
mockConfigManager.getConfig.mockReturnValue(
JSON.parse(JSON.stringify(mockConfig))
);
mockConfigManager.writeConfig.mockReturnValue(true);
mockConfigManager.getAvailableModels.mockReturnValue([]);
});
test('should use provided baseURL when explicitly given', async () => {
const customBaseURL = 'http://192.168.1.100:1234/v1';
mockConfigManager.getMainProvider.mockReturnValue('lmstudio');
const result = await setModel('main', 'custom-model', {
projectRoot: mockProjectRoot,
providerHint: 'lmstudio',
baseURL: customBaseURL
});
// Check if setModel succeeded
expect(result).toHaveProperty('success');
if (!result.success) {
throw new Error(`setModel failed: ${JSON.stringify(result.error)}`);
}
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.baseURL).toBe(customBaseURL);
});
test('should preserve existing baseURL when already using LMSTUDIO', async () => {
const existingBaseURL = 'http://custom-lmstudio:8080/v1';
mockConfigManager.getMainProvider.mockReturnValue('lmstudio');
mockConfigManager.getBaseUrlForRole.mockReturnValue(existingBaseURL);
await setModel('main', 'new-lmstudio-model', {
projectRoot: mockProjectRoot,
providerHint: 'lmstudio'
});
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.baseURL).toBe(existingBaseURL);
});
test('should use default baseURL when switching from OLLAMA to LMSTUDIO', async () => {
const ollamaBaseURL = 'http://ollama-server:11434/api';
mockConfigManager.getMainProvider.mockReturnValue('ollama');
mockConfigManager.getBaseUrlForRole.mockReturnValue(ollamaBaseURL);
await setModel('main', 'lmstudio-model', {
projectRoot: mockProjectRoot,
providerHint: 'lmstudio'
});
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
// Should use default LMSTUDIO baseURL, not OLLAMA's
expect(writtenConfig.models.main.baseURL).toBe('http://localhost:1234/v1');
expect(writtenConfig.models.main.baseURL).not.toBe(ollamaBaseURL);
});
test('should use default baseURL when switching from any other provider to LMSTUDIO', async () => {
mockConfigManager.getMainProvider.mockReturnValue('anthropic');
mockConfigManager.getBaseUrlForRole.mockReturnValue(null);
await setModel('main', 'lmstudio-model', {
projectRoot: mockProjectRoot,
providerHint: 'lmstudio'
});
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.baseURL).toBe('http://localhost:1234/v1');
});
});
// NOTE: OLLAMA tests omitted since they require HTTP mocking for fetchOllamaModels.
// The baseURL preservation logic is identical to LMSTUDIO, so LMSTUDIO tests prove it works.
describe.skip('models.js - baseURL handling for OLLAMA', () => {
const mockProjectRoot = '/test/project';
const mockConfig = {
models: {
main: { provider: 'ollama', modelId: 'existing-model' },
research: { provider: 'lmstudio', modelId: 'some-model' },
fallback: { provider: 'anthropic', modelId: 'claude-3-haiku-20240307' }
}
};
beforeEach(() => {
jest.clearAllMocks();
mockConfigManager.getConfig.mockReturnValue(
JSON.parse(JSON.stringify(mockConfig))
);
mockConfigManager.writeConfig.mockReturnValue(true);
mockConfigManager.getAvailableModels.mockReturnValue([]);
});
test('should use provided baseURL when explicitly given', async () => {
const customBaseURL = 'http://192.168.1.200:11434/api';
mockConfigManager.getMainProvider.mockReturnValue('ollama');
// Mock fetch for Ollama models check
global.fetch = jest.fn(() =>
Promise.resolve({
ok: true,
json: () => Promise.resolve({ models: [{ model: 'custom-model' }] })
})
);
await setModel('main', 'custom-model', {
projectRoot: mockProjectRoot,
providerHint: 'ollama',
baseURL: customBaseURL
});
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.baseURL).toBe(customBaseURL);
});
test('should preserve existing baseURL when already using OLLAMA', async () => {
const existingBaseURL = 'http://custom-ollama:9999/api';
mockConfigManager.getMainProvider.mockReturnValue('ollama');
mockConfigManager.getBaseUrlForRole.mockReturnValue(existingBaseURL);
// Mock fetch for Ollama models check
global.fetch = jest.fn(() =>
Promise.resolve({
ok: true,
json: () => Promise.resolve({ models: [{ model: 'new-ollama-model' }] })
})
);
await setModel('main', 'new-ollama-model', {
projectRoot: mockProjectRoot,
providerHint: 'ollama'
});
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.baseURL).toBe(existingBaseURL);
});
test('should use default baseURL when switching from LMSTUDIO to OLLAMA', async () => {
const lmstudioBaseURL = 'http://lmstudio-server:1234/v1';
mockConfigManager.getMainProvider.mockReturnValue('lmstudio');
mockConfigManager.getBaseUrlForRole.mockReturnValue(lmstudioBaseURL);
// Mock fetch for Ollama models check
global.fetch = jest.fn(() =>
Promise.resolve({
ok: true,
json: () => Promise.resolve({ models: [{ model: 'ollama-model' }] })
})
);
await setModel('main', 'ollama-model', {
projectRoot: mockProjectRoot,
providerHint: 'ollama'
});
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
// Should use default OLLAMA baseURL, not LMSTUDIO's
expect(writtenConfig.models.main.baseURL).toBe(
'http://localhost:11434/api'
);
expect(writtenConfig.models.main.baseURL).not.toBe(lmstudioBaseURL);
});
test('should use default baseURL when switching from any other provider to OLLAMA', async () => {
mockConfigManager.getMainProvider.mockReturnValue('anthropic');
mockConfigManager.getBaseUrlForRole.mockReturnValue(null);
// Mock fetch for Ollama models check
global.fetch = jest.fn(() =>
Promise.resolve({
ok: true,
json: () => Promise.resolve({ models: [{ model: 'ollama-model' }] })
})
);
await setModel('main', 'ollama-model', {
projectRoot: mockProjectRoot,
providerHint: 'ollama'
});
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.baseURL).toBe(
'http://localhost:11434/api'
);
});
});
describe.skip('models.js - cross-provider baseURL isolation', () => {
const mockProjectRoot = '/test/project';
const mockConfig = {
models: {
main: {
provider: 'ollama',
modelId: 'existing-model',
baseURL: 'http://ollama:11434/api'
},
research: {
provider: 'lmstudio',
modelId: 'some-model',
baseURL: 'http://lmstudio:1234/v1'
},
fallback: { provider: 'anthropic', modelId: 'claude-3-haiku-20240307' }
}
};
beforeEach(() => {
jest.clearAllMocks();
mockConfigManager.getConfig.mockReturnValue(
JSON.parse(JSON.stringify(mockConfig))
);
mockConfigManager.writeConfig.mockReturnValue(true);
mockConfigManager.getAvailableModels.mockReturnValue([]);
});
test('OLLAMA baseURL should not leak to LMSTUDIO', async () => {
const ollamaBaseURL = 'http://custom-ollama:11434/api';
mockConfigManager.getMainProvider.mockReturnValue('ollama');
mockConfigManager.getBaseUrlForRole.mockReturnValue(ollamaBaseURL);
await setModel('main', 'lmstudio-model', {
projectRoot: mockProjectRoot,
providerHint: 'lmstudio'
});
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.provider).toBe('lmstudio');
expect(writtenConfig.models.main.baseURL).toBe('http://localhost:1234/v1');
expect(writtenConfig.models.main.baseURL).not.toContain('ollama');
});
test('LMSTUDIO baseURL should not leak to OLLAMA', async () => {
const lmstudioBaseURL = 'http://custom-lmstudio:1234/v1';
mockConfigManager.getMainProvider.mockReturnValue('lmstudio');
mockConfigManager.getBaseUrlForRole.mockReturnValue(lmstudioBaseURL);
// Mock fetch for Ollama models check
global.fetch = jest.fn(() =>
Promise.resolve({
ok: true,
json: () => Promise.resolve({ models: [{ model: 'ollama-model' }] })
})
);
await setModel('main', 'ollama-model', {
projectRoot: mockProjectRoot,
providerHint: 'ollama'
});
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.provider).toBe('ollama');
expect(writtenConfig.models.main.baseURL).toBe(
'http://localhost:11434/api'
);
expect(writtenConfig.models.main.baseURL).not.toContain('lmstudio');
expect(writtenConfig.models.main.baseURL).not.toContain('1234');
});
});
describe('models.js - baseURL handling for OPENAI_COMPATIBLE', () => {
const mockProjectRoot = '/test/project';
const mockConfig = {
models: {
main: {
provider: 'openai-compatible',
modelId: 'existing-model',
baseURL: 'https://api.custom.com/v1'
},
research: { provider: 'anthropic', modelId: 'claude-3-haiku-20240307' },
fallback: { provider: 'openai', modelId: 'gpt-4o-mini' }
}
};
beforeEach(() => {
jest.clearAllMocks();
mockConfigManager.getConfig.mockReturnValue(
JSON.parse(JSON.stringify(mockConfig))
);
mockConfigManager.writeConfig.mockReturnValue(true);
mockConfigManager.getAvailableModels.mockReturnValue([]);
});
test('should preserve existing baseURL when already using OPENAI_COMPATIBLE', async () => {
const existingBaseURL = 'https://api.custom.com/v1';
mockConfigManager.getMainProvider.mockReturnValue('openai-compatible');
mockConfigManager.getBaseUrlForRole.mockReturnValue(existingBaseURL);
const result = await setModel('main', 'new-compatible-model', {
projectRoot: mockProjectRoot,
providerHint: 'openai-compatible'
});
expect(result).toHaveProperty('success');
if (!result.success) {
throw new Error(`setModel failed: ${JSON.stringify(result.error)}`);
}
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.baseURL).toBe(existingBaseURL);
});
test('should require baseURL when switching from another provider to OPENAI_COMPATIBLE', async () => {
mockConfigManager.getMainProvider.mockReturnValue('anthropic');
mockConfigManager.getBaseUrlForRole.mockReturnValue(null);
const result = await setModel('main', 'compatible-model', {
projectRoot: mockProjectRoot,
providerHint: 'openai-compatible'
// No baseURL provided
});
expect(result.success).toBe(false);
expect(result.error?.message).toContain(
'Base URL is required for OpenAI-compatible providers'
);
});
test('should use provided baseURL when switching to OPENAI_COMPATIBLE', async () => {
const newBaseURL = 'https://api.newprovider.com/v1';
mockConfigManager.getMainProvider.mockReturnValue('anthropic');
mockConfigManager.getBaseUrlForRole.mockReturnValue(null);
const result = await setModel('main', 'compatible-model', {
projectRoot: mockProjectRoot,
providerHint: 'openai-compatible',
baseURL: newBaseURL
});
expect(result).toHaveProperty('success');
if (!result.success) {
throw new Error(`setModel failed: ${JSON.stringify(result.error)}`);
}
const writtenConfig = mockConfigManager.writeConfig.mock.calls[0][0];
expect(writtenConfig.models.main.baseURL).toBe(newBaseURL);
});
});
```
--------------------------------------------------------------------------------
/apps/extension/src/services/webview-manager.ts:
--------------------------------------------------------------------------------
```typescript
/**
* Webview Manager - Simplified
* Manages webview panels and message handling
*/
import * as vscode from 'vscode';
import type { EventEmitter } from '../utils/event-emitter';
import type { ExtensionLogger } from '../utils/logger';
import type { ConfigService } from './config-service';
import type { TaskRepository } from './task-repository';
import type { TerminalManager } from './terminal-manager';
export class WebviewManager {
private panels = new Set<vscode.WebviewPanel>();
private configService?: ConfigService;
private mcpClient?: any;
private api?: any;
constructor(
private context: vscode.ExtensionContext,
private repository: TaskRepository,
private events: EventEmitter,
private logger: ExtensionLogger,
private terminalManager: TerminalManager
) {}
setConfigService(configService: ConfigService): void {
this.configService = configService;
}
setMCPClient(mcpClient: any): void {
this.mcpClient = mcpClient;
}
setApi(api: any): void {
this.api = api;
}
async createOrShowPanel(): Promise<void> {
// Find existing panel
const existing = Array.from(this.panels).find(
(p) => p.title === 'TaskMaster Kanban'
);
if (existing) {
existing.reveal();
return;
}
// Create new panel
const panel = vscode.window.createWebviewPanel(
'taskrKanban',
'TaskMaster Kanban',
vscode.ViewColumn.One,
{
enableScripts: true,
retainContextWhenHidden: true,
localResourceRoots: [
vscode.Uri.joinPath(this.context.extensionUri, 'dist')
]
}
);
// Set the icon for the webview tab
panel.iconPath = {
light: vscode.Uri.joinPath(
this.context.extensionUri,
'assets',
'icon-light.svg'
),
dark: vscode.Uri.joinPath(
this.context.extensionUri,
'assets',
'icon-dark.svg'
)
};
this.panels.add(panel);
panel.webview.html = this.getWebviewContent(panel.webview);
// Handle messages
panel.webview.onDidReceiveMessage(async (message) => {
await this.handleMessage(panel, message);
});
// Handle disposal
panel.onDidDispose(() => {
this.panels.delete(panel);
this.events.emit('webview:closed');
});
this.events.emit('webview:opened');
vscode.window.showInformationMessage('TaskMaster Kanban opened!');
}
broadcast(type: string, data: any): void {
this.panels.forEach((panel) => {
panel.webview.postMessage({ type, data });
});
}
getPanelCount(): number {
return this.panels.size;
}
dispose(): void {
this.panels.forEach((panel) => panel.dispose());
this.panels.clear();
}
private async handleMessage(
panel: vscode.WebviewPanel,
message: any
): Promise<void> {
// Validate message structure
if (!message || typeof message !== 'object') {
this.logger.error('Invalid message received:', message);
return;
}
const { type, data, requestId } = message;
this.logger.debug(`Webview message: ${type}`, message);
try {
let response: any;
switch (type) {
case 'ready':
// Webview is ready, send current connection status
const isConnected = this.mcpClient?.getStatus()?.isRunning || false;
panel.webview.postMessage({
type: 'connectionStatus',
data: {
isConnected: isConnected,
status: isConnected ? 'Connected' : 'Disconnected'
}
});
// No response needed for ready message
return;
case 'getTasks':
// Pass options to getAll including tag if specified
response = await this.repository.getAll({
tag: data?.tag,
withSubtasks: data?.withSubtasks ?? true
});
break;
case 'updateTaskStatus':
await this.repository.updateStatus(data.taskId, data.newStatus);
response = { success: true };
break;
case 'getConfig':
if (this.configService) {
response = await this.configService.getSafeConfig();
} else {
response = null;
}
break;
case 'readTaskFileData':
// For now, return the task data from repository
// In the future, this could read from actual task files
const task = await this.repository.getById(data.taskId);
if (task) {
response = {
details: task.details || '',
testStrategy: task.testStrategy || ''
};
} else {
response = {
details: '',
testStrategy: ''
};
}
break;
case 'updateTask':
// Handle task content updates with MCP
if (this.mcpClient) {
try {
const { taskId, updates, options = {} } = data;
// Use the update_task MCP tool
await this.mcpClient.callTool('update_task', {
id: String(taskId),
prompt: updates.description || '',
append: options.append || false,
research: options.research || false,
projectRoot: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
});
response = { success: true };
} catch (error) {
this.logger.error('Failed to update task via MCP:', error);
throw error;
}
} else {
throw new Error('MCP client not initialized');
}
break;
case 'updateSubtask':
// Handle subtask content updates with MCP
if (this.mcpClient) {
try {
const { taskId, prompt, options = {} } = data;
// Use the update_subtask MCP tool
await this.mcpClient.callTool('update_subtask', {
id: String(taskId),
prompt: prompt,
research: options.research || false,
projectRoot: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
});
response = { success: true };
} catch (error) {
this.logger.error('Failed to update subtask via MCP:', error);
throw error;
}
} else {
throw new Error('MCP client not initialized');
}
break;
case 'getComplexity':
// For backward compatibility - redirect to mcpRequest
this.logger.debug(
`getComplexity request for task ${data.taskId}, mcpClient available: ${!!this.mcpClient}`
);
if (this.mcpClient && data.taskId) {
try {
const complexityResult = await this.mcpClient.callTool(
'complexity_report',
{
projectRoot:
vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
}
);
if (complexityResult?.report?.complexityAnalysis?.tasks) {
const task =
complexityResult.report.complexityAnalysis.tasks.find(
(t: any) => t.id === data.taskId
);
response = task ? { score: task.complexityScore } : {};
} else {
response = {};
}
} catch (error) {
this.logger.error('Failed to get complexity', error);
response = {};
}
} else {
this.logger.warn(
`Cannot get complexity: mcpClient=${!!this.mcpClient}, taskId=${data.taskId}`
);
response = {};
}
break;
case 'mcpRequest':
// Handle MCP tool calls
try {
// The tool and params come directly in the message
const tool = message.tool;
const params = message.params || {};
if (!this.mcpClient) {
throw new Error('MCP client not initialized');
}
if (!tool) {
throw new Error('Tool name not specified in mcpRequest');
}
// Add projectRoot if not provided
if (!params.projectRoot) {
params.projectRoot =
vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
}
const result = await this.mcpClient.callTool(tool, params);
response = { data: result };
} catch (error) {
this.logger.error('MCP request failed:', error);
// Re-throw with cleaner error message
throw new Error(
error instanceof Error ? error.message : 'Unknown error'
);
}
break;
case 'getTags':
// Get available tags
if (this.mcpClient) {
try {
const result = await this.mcpClient.callTool('list_tags', {
projectRoot: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath,
showMetadata: false
});
// The MCP response has a specific structure
// Based on the MCP SDK, the response is in result.content[0].text
let parsedData;
if (
result?.content &&
Array.isArray(result.content) &&
result.content[0]?.text
) {
try {
parsedData = JSON.parse(result.content[0].text);
} catch (e) {
this.logger.error('Failed to parse MCP response text:', e);
}
}
// Extract tags data from the parsed response
if (parsedData?.data) {
response = parsedData.data;
} else if (parsedData) {
response = parsedData;
} else if (result?.data) {
response = result.data;
} else {
response = { tags: [], currentTag: 'master' };
}
} catch (error) {
this.logger.error('Failed to get tags:', error);
response = { tags: [], currentTag: 'master' };
}
} else {
response = { tags: [], currentTag: 'master' };
}
break;
case 'switchTag':
// Switch to a different tag
if (this.mcpClient && data.tagName) {
try {
await this.mcpClient.callTool('use_tag', {
name: data.tagName,
projectRoot: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
});
// Clear cache and fetch tasks for the new tag
await this.repository.refresh();
const tasks = await this.repository.getAll({ tag: data.tagName });
this.broadcast('tasksUpdated', { tasks, source: 'tag-switch' });
response = { success: true };
} catch (error) {
this.logger.error('Failed to switch tag:', error);
throw error;
}
} else {
throw new Error('Tag name not provided');
}
break;
case 'openExternal':
// Open external URL
if (message.url) {
vscode.env.openExternal(vscode.Uri.parse(message.url));
}
return;
case 'openTerminal':
// Delegate terminal execution to TerminalManager
const { taskId, taskTitle } = data.data || data; // Handle both nested and direct data
this.logger.log(
`Webview openTerminal - taskId: ${taskId} (type: ${typeof taskId}), taskTitle: ${taskTitle}`
);
// Get current tag to ensure we're working in the right context
let currentTag = 'master'; // default fallback
if (this.mcpClient) {
try {
const tagsResult = await this.mcpClient.callTool('list_tags', {
projectRoot: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath,
showMetadata: false
});
let parsedData;
if (
tagsResult?.content &&
Array.isArray(tagsResult.content) &&
tagsResult.content[0]?.text
) {
try {
parsedData = JSON.parse(tagsResult.content[0].text);
if (parsedData?.data?.currentTag) {
currentTag = parsedData.data.currentTag;
}
} catch (e) {
this.logger.warn(
'Failed to parse tags response for terminal execution'
);
}
}
} catch (error) {
this.logger.warn(
'Failed to get current tag for terminal execution:',
error
);
}
}
const result = await this.terminalManager.executeTask({
taskId,
taskTitle,
tag: currentTag
});
response = result;
// Show user feedback AFTER sending the response (like the working "TaskMaster connected!" example)
setImmediate(() => {
if (result.success) {
// Success: Show info message
vscode.window.showInformationMessage(
`✅ Started Claude session for Task ${taskId}: ${taskTitle}`
);
} else {
// Error: Show VS Code native error notification only
const errorMsg = `Failed to start task: ${result.error}`;
vscode.window.showErrorMessage(errorMsg);
}
});
break;
default:
throw new Error(`Unknown message type: ${type}`);
}
// Send response
if (requestId) {
panel.webview.postMessage({
type: 'response',
requestId,
success: true,
data: response
});
}
} catch (error) {
this.logger.error(`Error handling message ${type}`, error);
if (requestId) {
panel.webview.postMessage({
type: 'error',
requestId,
error: error instanceof Error ? error.message : 'Unknown error'
});
}
}
}
private getWebviewContent(webview: vscode.Webview): string {
const scriptUri = webview.asWebviewUri(
vscode.Uri.joinPath(this.context.extensionUri, 'dist', 'index.js')
);
const styleUri = webview.asWebviewUri(
vscode.Uri.joinPath(this.context.extensionUri, 'dist', 'index.css')
);
const nonce = this.getNonce();
return `<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src ${webview.cspSource} https:; script-src 'nonce-${nonce}'; style-src ${webview.cspSource} 'unsafe-inline';">
<link href="${styleUri}" rel="stylesheet">
<title>TaskMaster Kanban</title>
</head>
<body>
<div id="root"></div>
<script nonce="${nonce}" src="${scriptUri}"></script>
</body>
</html>`;
}
private getNonce(): string {
let text = '';
const possible =
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
for (let i = 0; i < 32; i++) {
text += possible.charAt(Math.floor(Math.random() * possible.length));
}
return text;
}
}
```
--------------------------------------------------------------------------------
/tests/unit/initialize-project.test.js:
--------------------------------------------------------------------------------
```javascript
import { jest } from '@jest/globals';
import fs from 'fs';
import path from 'path';
import os from 'os';
// Reduce noise in test output
process.env.TASKMASTER_LOG_LEVEL = 'error';
// === Mock everything early ===
jest.mock('child_process', () => ({ execSync: jest.fn() }));
jest.mock('fs', () => ({
...jest.requireActual('fs'),
mkdirSync: jest.fn(),
writeFileSync: jest.fn(),
readFileSync: jest.fn(),
appendFileSync: jest.fn(),
existsSync: jest.fn(),
mkdtempSync: jest.requireActual('fs').mkdtempSync,
rmSync: jest.requireActual('fs').rmSync
}));
// Mock console methods to suppress output
const consoleMethods = ['log', 'info', 'warn', 'error', 'clear'];
consoleMethods.forEach((method) => {
global.console[method] = jest.fn();
});
// Mock ES modules using unstable_mockModule
jest.unstable_mockModule('../../scripts/modules/utils.js', () => ({
isSilentMode: jest.fn(() => true),
enableSilentMode: jest.fn(),
log: jest.fn(),
findProjectRoot: jest.fn(() => process.cwd())
}));
// Mock git-utils module
jest.unstable_mockModule('../../scripts/modules/utils/git-utils.js', () => ({
insideGitWorkTree: jest.fn(() => false)
}));
// Mock rule transformer
jest.unstable_mockModule('../../src/utils/rule-transformer.js', () => ({
convertAllRulesToProfileRules: jest.fn(),
getRulesProfile: jest.fn(() => ({
conversionConfig: {},
globalReplacements: []
}))
}));
// Mock any other modules that might output or do real operations
jest.unstable_mockModule('../../scripts/modules/config-manager.js', () => ({
createDefaultConfig: jest.fn(() => ({ models: {}, project: {} })),
saveConfig: jest.fn()
}));
// Mock display libraries
jest.mock('figlet', () => ({ textSync: jest.fn(() => 'MOCKED BANNER') }));
jest.mock('boxen', () => jest.fn(() => 'MOCKED BOX'));
jest.mock('gradient-string', () => jest.fn(() => jest.fn((text) => text)));
jest.mock('chalk', () => ({
blue: jest.fn((text) => text),
green: jest.fn((text) => text),
red: jest.fn((text) => text),
yellow: jest.fn((text) => text),
cyan: jest.fn((text) => text),
white: jest.fn((text) => text),
dim: jest.fn((text) => text),
bold: jest.fn((text) => text),
underline: jest.fn((text) => text)
}));
const { execSync } = jest.requireMock('child_process');
const mockFs = jest.requireMock('fs');
// Import the mocked modules
const mockUtils = await import('../../scripts/modules/utils.js');
const mockGitUtils = await import('../../scripts/modules/utils/git-utils.js');
const mockRuleTransformer = await import('../../src/utils/rule-transformer.js');
// Import after mocks
const { initializeProject } = await import('../../scripts/init.js');
describe('initializeProject – Git / Alias flag logic', () => {
let tmpDir;
const origCwd = process.cwd();
// Standard non-interactive options for all tests
const baseOptions = {
yes: true,
skipInstall: true,
name: 'test-project',
description: 'Test project description',
version: '1.0.0',
author: 'Test Author'
};
beforeEach(() => {
jest.clearAllMocks();
// Set up basic fs mocks
mockFs.mkdirSync.mockImplementation(() => {});
mockFs.writeFileSync.mockImplementation(() => {});
mockFs.readFileSync.mockImplementation((filePath) => {
if (filePath.includes('assets') || filePath.includes('.cursor/rules')) {
return 'mock template content';
}
if (filePath.includes('.zshrc') || filePath.includes('.bashrc')) {
return '# existing config';
}
return '';
});
mockFs.appendFileSync.mockImplementation(() => {});
mockFs.existsSync.mockImplementation((filePath) => {
// Template source files exist
if (filePath.includes('assets') || filePath.includes('.cursor/rules')) {
return true;
}
// Shell config files exist by default
if (filePath.includes('.zshrc') || filePath.includes('.bashrc')) {
return true;
}
return false;
});
// Reset utils mocks
mockUtils.isSilentMode.mockReturnValue(true);
mockGitUtils.insideGitWorkTree.mockReturnValue(false);
// Default execSync mock
execSync.mockImplementation(() => '');
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tm-init-'));
process.chdir(tmpDir);
});
afterEach(() => {
process.chdir(origCwd);
fs.rmSync(tmpDir, { recursive: true, force: true });
});
describe('Git Flag Behavior', () => {
it('completes successfully with git:false in dry run', async () => {
const result = await initializeProject({
...baseOptions,
git: false,
aliases: false,
dryRun: true
});
expect(result.dryRun).toBe(true);
});
it('completes successfully with git:true when not inside repo', async () => {
mockGitUtils.insideGitWorkTree.mockReturnValue(false);
await expect(
initializeProject({
...baseOptions,
git: true,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
it('completes successfully when already inside repo', async () => {
mockGitUtils.insideGitWorkTree.mockReturnValue(true);
await expect(
initializeProject({
...baseOptions,
git: true,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
it('uses default git behavior without errors', async () => {
mockGitUtils.insideGitWorkTree.mockReturnValue(false);
await expect(
initializeProject({
...baseOptions,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
it('handles git command failures gracefully', async () => {
mockGitUtils.insideGitWorkTree.mockReturnValue(false);
execSync.mockImplementation((cmd) => {
if (cmd.includes('git init')) {
throw new Error('git not found');
}
return '';
});
await expect(
initializeProject({
...baseOptions,
git: true,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
});
describe('Alias Flag Behavior', () => {
it('completes successfully when aliases:true and environment is set up', async () => {
const originalShell = process.env.SHELL;
const originalHome = process.env.HOME;
process.env.SHELL = '/bin/zsh';
process.env.HOME = '/mock/home';
await expect(
initializeProject({
...baseOptions,
git: false,
aliases: true,
dryRun: false
})
).resolves.not.toThrow();
process.env.SHELL = originalShell;
process.env.HOME = originalHome;
});
it('completes successfully when aliases:false', async () => {
await expect(
initializeProject({
...baseOptions,
git: false,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
it('handles missing shell gracefully', async () => {
const originalShell = process.env.SHELL;
const originalHome = process.env.HOME;
delete process.env.SHELL; // Remove shell env var
process.env.HOME = '/mock/home';
await expect(
initializeProject({
...baseOptions,
git: false,
aliases: true,
dryRun: false
})
).resolves.not.toThrow();
process.env.SHELL = originalShell;
process.env.HOME = originalHome;
});
it('handles missing shell config file gracefully', async () => {
const originalShell = process.env.SHELL;
const originalHome = process.env.HOME;
process.env.SHELL = '/bin/zsh';
process.env.HOME = '/mock/home';
// Shell config doesn't exist
mockFs.existsSync.mockImplementation((filePath) => {
if (filePath.includes('.zshrc') || filePath.includes('.bashrc')) {
return false;
}
if (filePath.includes('assets') || filePath.includes('.cursor/rules')) {
return true;
}
return false;
});
await expect(
initializeProject({
...baseOptions,
git: false,
aliases: true,
dryRun: false
})
).resolves.not.toThrow();
process.env.SHELL = originalShell;
process.env.HOME = originalHome;
});
});
describe('Flag Combinations', () => {
it.each`
git | aliases | description
${true} | ${true} | ${'git & aliases enabled'}
${true} | ${false} | ${'git enabled, aliases disabled'}
${false} | ${true} | ${'git disabled, aliases enabled'}
${false} | ${false} | ${'git & aliases disabled'}
`('handles $description without errors', async ({ git, aliases }) => {
const originalShell = process.env.SHELL;
const originalHome = process.env.HOME;
if (aliases) {
process.env.SHELL = '/bin/zsh';
process.env.HOME = '/mock/home';
}
if (git) {
mockGitUtils.insideGitWorkTree.mockReturnValue(false);
}
await expect(
initializeProject({
...baseOptions,
git,
aliases,
dryRun: false
})
).resolves.not.toThrow();
process.env.SHELL = originalShell;
process.env.HOME = originalHome;
});
});
describe('Dry Run Mode', () => {
it('returns dry run result and performs no operations', async () => {
const result = await initializeProject({
...baseOptions,
git: true,
aliases: true,
dryRun: true
});
expect(result.dryRun).toBe(true);
});
it.each`
git | aliases | description
${true} | ${false} | ${'git-specific behavior'}
${false} | ${false} | ${'no-git behavior'}
${false} | ${true} | ${'alias behavior'}
`('shows $description in dry run', async ({ git, aliases }) => {
const result = await initializeProject({
...baseOptions,
git,
aliases,
dryRun: true
});
expect(result.dryRun).toBe(true);
});
});
describe('Error Handling', () => {
it('handles npm install failures gracefully', async () => {
execSync.mockImplementation((cmd) => {
if (cmd.includes('npm install')) {
throw new Error('npm failed');
}
return '';
});
await expect(
initializeProject({
...baseOptions,
git: false,
aliases: false,
skipInstall: false,
dryRun: false
})
).resolves.not.toThrow();
});
it('handles git failures gracefully', async () => {
mockGitUtils.insideGitWorkTree.mockReturnValue(false);
execSync.mockImplementation((cmd) => {
if (cmd.includes('git init')) {
throw new Error('git failed');
}
return '';
});
await expect(
initializeProject({
...baseOptions,
git: true,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
it('handles file system errors gracefully', async () => {
mockFs.mkdirSync.mockImplementation(() => {
throw new Error('Permission denied');
});
// Should handle file system errors gracefully
await expect(
initializeProject({
...baseOptions,
git: false,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
});
describe('Non-Interactive Mode', () => {
it('bypasses prompts with yes:true', async () => {
const result = await initializeProject({
...baseOptions,
git: true,
aliases: true,
dryRun: true
});
expect(result).toEqual({ dryRun: true });
});
it('completes without hanging', async () => {
await expect(
initializeProject({
...baseOptions,
git: false,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
it('handles all flag combinations without hanging', async () => {
const flagCombinations = [
{ git: true, aliases: true },
{ git: true, aliases: false },
{ git: false, aliases: true },
{ git: false, aliases: false },
{} // No flags (uses defaults)
];
for (const flags of flagCombinations) {
await expect(
initializeProject({
...baseOptions,
...flags,
dryRun: true // Use dry run for speed
})
).resolves.not.toThrow();
}
});
it('accepts complete project details', async () => {
await expect(
initializeProject({
name: 'test-project',
description: 'test description',
version: '2.0.0',
author: 'Test User',
git: false,
aliases: false,
dryRun: true
})
).resolves.not.toThrow();
});
it('works with skipInstall option', async () => {
await expect(
initializeProject({
...baseOptions,
skipInstall: true,
git: false,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
});
describe('Function Integration', () => {
it('calls utility functions without errors', async () => {
await initializeProject({
...baseOptions,
git: false,
aliases: false,
dryRun: false
});
// Verify that utility functions were called
expect(mockUtils.isSilentMode).toHaveBeenCalled();
expect(
mockRuleTransformer.convertAllRulesToProfileRules
).toHaveBeenCalled();
});
it('handles template operations gracefully', async () => {
// Make file operations throw errors
mockFs.writeFileSync.mockImplementation(() => {
throw new Error('Write failed');
});
// Should complete despite file operation failures
await expect(
initializeProject({
...baseOptions,
git: false,
aliases: false,
dryRun: false
})
).resolves.not.toThrow();
});
it('validates boolean flag conversion', async () => {
// Test the boolean flag handling specifically
await expect(
initializeProject({
...baseOptions,
git: true, // Should convert to initGit: true
aliases: false, // Should convert to addAliases: false
dryRun: true
})
).resolves.not.toThrow();
await expect(
initializeProject({
...baseOptions,
git: false, // Should convert to initGit: false
aliases: true, // Should convert to addAliases: true
dryRun: true
})
).resolves.not.toThrow();
});
});
});
```
--------------------------------------------------------------------------------
/packages/tm-core/src/common/types/database.types.ts:
--------------------------------------------------------------------------------
```typescript
export type Json =
| string
| number
| boolean
| null
| { [key: string]: Json | undefined }
| Json[];
export type Database = {
public: {
Tables: {
accounts: {
Row: {
created_at: string | null;
created_by: string | null;
email: string | null;
id: string;
is_personal_account: boolean;
name: string;
picture_url: string | null;
primary_owner_user_id: string;
public_data: Json;
slug: string | null;
updated_at: string | null;
updated_by: string | null;
};
Insert: {
created_at?: string | null;
created_by?: string | null;
email?: string | null;
id?: string;
is_personal_account?: boolean;
name: string;
picture_url?: string | null;
primary_owner_user_id?: string;
public_data?: Json;
slug?: string | null;
updated_at?: string | null;
updated_by?: string | null;
};
Update: {
created_at?: string | null;
created_by?: string | null;
email?: string | null;
id?: string;
is_personal_account?: boolean;
name?: string;
picture_url?: string | null;
primary_owner_user_id?: string;
public_data?: Json;
slug?: string | null;
updated_at?: string | null;
updated_by?: string | null;
};
Relationships: [];
};
brief: {
Row: {
account_id: string;
created_at: string;
created_by: string;
document_id: string;
id: string;
plan_generation_completed_at: string | null;
plan_generation_error: string | null;
plan_generation_started_at: string | null;
plan_generation_status: Database['public']['Enums']['plan_generation_status'];
status: Database['public']['Enums']['brief_status'];
updated_at: string;
};
Insert: {
account_id: string;
created_at?: string;
created_by: string;
document_id: string;
id?: string;
plan_generation_completed_at?: string | null;
plan_generation_error?: string | null;
plan_generation_started_at?: string | null;
plan_generation_status?: Database['public']['Enums']['plan_generation_status'];
status?: Database['public']['Enums']['brief_status'];
updated_at?: string;
};
Update: {
account_id?: string;
created_at?: string;
created_by?: string;
document_id?: string;
id?: string;
plan_generation_completed_at?: string | null;
plan_generation_error?: string | null;
plan_generation_started_at?: string | null;
plan_generation_status?: Database['public']['Enums']['plan_generation_status'];
status?: Database['public']['Enums']['brief_status'];
updated_at?: string;
};
Relationships: [
{
foreignKeyName: 'brief_account_id_fkey';
columns: ['account_id'];
isOneToOne: false;
referencedRelation: 'accounts';
referencedColumns: ['id'];
},
{
foreignKeyName: 'brief_document_id_fkey';
columns: ['document_id'];
isOneToOne: false;
referencedRelation: 'document';
referencedColumns: ['id'];
}
];
};
document: {
Row: {
account_id: string;
created_at: string;
created_by: string;
description: string | null;
document_name: string;
document_type: Database['public']['Enums']['document_type'];
file_path: string | null;
file_size: number | null;
id: string;
metadata: Json | null;
mime_type: string | null;
processed_at: string | null;
processing_error: string | null;
processing_status:
| Database['public']['Enums']['document_processing_status']
| null;
source_id: string | null;
source_type: string | null;
title: string;
updated_at: string;
};
Insert: {
account_id: string;
created_at?: string;
created_by: string;
description?: string | null;
document_name: string;
document_type?: Database['public']['Enums']['document_type'];
file_path?: string | null;
file_size?: number | null;
id?: string;
metadata?: Json | null;
mime_type?: string | null;
processed_at?: string | null;
processing_error?: string | null;
processing_status?:
| Database['public']['Enums']['document_processing_status']
| null;
source_id?: string | null;
source_type?: string | null;
title: string;
updated_at?: string;
};
Update: {
account_id?: string;
created_at?: string;
created_by?: string;
description?: string | null;
document_name?: string;
document_type?: Database['public']['Enums']['document_type'];
file_path?: string | null;
file_size?: number | null;
id?: string;
metadata?: Json | null;
mime_type?: string | null;
processed_at?: string | null;
processing_error?: string | null;
processing_status?:
| Database['public']['Enums']['document_processing_status']
| null;
source_id?: string | null;
source_type?: string | null;
title?: string;
updated_at?: string;
};
Relationships: [
{
foreignKeyName: 'document_account_id_fkey';
columns: ['account_id'];
isOneToOne: false;
referencedRelation: 'accounts';
referencedColumns: ['id'];
}
];
};
tasks: {
Row: {
account_id: string;
actual_hours: number;
assignee_id: string | null;
brief_id: string | null;
completed_subtasks: number;
complexity: number | null;
created_at: string;
created_by: string;
description: string | null;
display_id: string | null;
document_id: string | null;
due_date: string | null;
estimated_hours: number | null;
id: string;
metadata: Json;
parent_task_id: string | null;
position: number;
priority: Database['public']['Enums']['task_priority'];
status: Database['public']['Enums']['task_status'];
subtask_position: number;
title: string;
total_subtasks: number;
updated_at: string;
updated_by: string;
};
Insert: {
account_id: string;
actual_hours?: number;
assignee_id?: string | null;
brief_id?: string | null;
completed_subtasks?: number;
complexity?: number | null;
created_at?: string;
created_by: string;
description?: string | null;
display_id?: string | null;
document_id?: string | null;
due_date?: string | null;
estimated_hours?: number | null;
id?: string;
metadata?: Json;
parent_task_id?: string | null;
position?: number;
priority?: Database['public']['Enums']['task_priority'];
status?: Database['public']['Enums']['task_status'];
subtask_position?: number;
title: string;
total_subtasks?: number;
updated_at?: string;
updated_by: string;
};
Update: {
account_id?: string;
actual_hours?: number;
assignee_id?: string | null;
brief_id?: string | null;
completed_subtasks?: number;
complexity?: number | null;
created_at?: string;
created_by?: string;
description?: string | null;
display_id?: string | null;
document_id?: string | null;
due_date?: string | null;
estimated_hours?: number | null;
id?: string;
metadata?: Json;
parent_task_id?: string | null;
position?: number;
priority?: Database['public']['Enums']['task_priority'];
status?: Database['public']['Enums']['task_status'];
subtask_position?: number;
title?: string;
total_subtasks?: number;
updated_at?: string;
updated_by?: string;
};
Relationships: [
{
foreignKeyName: 'tasks_account_id_fkey';
columns: ['account_id'];
isOneToOne: false;
referencedRelation: 'accounts';
referencedColumns: ['id'];
},
{
foreignKeyName: 'tasks_brief_id_fkey';
columns: ['brief_id'];
isOneToOne: false;
referencedRelation: 'brief';
referencedColumns: ['id'];
},
{
foreignKeyName: 'tasks_document_id_fkey';
columns: ['document_id'];
isOneToOne: false;
referencedRelation: 'document';
referencedColumns: ['id'];
},
{
foreignKeyName: 'tasks_parent_task_id_fkey';
columns: ['parent_task_id'];
isOneToOne: false;
referencedRelation: 'tasks';
referencedColumns: ['id'];
}
];
};
task_dependencies: {
Row: {
account_id: string;
created_at: string;
depends_on_task_id: string;
id: string;
task_id: string;
};
Insert: {
account_id: string;
created_at?: string;
depends_on_task_id: string;
id?: string;
task_id: string;
};
Update: {
account_id?: string;
created_at?: string;
depends_on_task_id?: string;
id?: string;
task_id?: string;
};
Relationships: [
{
foreignKeyName: 'task_dependencies_account_id_fkey';
columns: ['account_id'];
isOneToOne: false;
referencedRelation: 'accounts';
referencedColumns: ['id'];
},
{
foreignKeyName: 'task_dependencies_depends_on_task_id_fkey';
columns: ['depends_on_task_id'];
isOneToOne: false;
referencedRelation: 'tasks';
referencedColumns: ['id'];
},
{
foreignKeyName: 'task_dependencies_task_id_fkey';
columns: ['task_id'];
isOneToOne: false;
referencedRelation: 'tasks';
referencedColumns: ['id'];
}
];
};
user_accounts: {
Row: {
id: string | null;
name: string | null;
picture_url: string | null;
role: string | null;
slug: string | null;
};
Insert: {
id?: string | null;
name?: string | null;
picture_url?: string | null;
role?: string | null;
slug?: string | null;
};
Update: {
id?: string | null;
name?: string | null;
picture_url?: string | null;
role?: string | null;
slug?: string | null;
};
Relationships: [];
};
};
Views: {
[_ in never]: never;
};
Functions: {
[_ in never]: never;
};
Enums: {
brief_status:
| 'draft'
| 'refining'
| 'aligned'
| 'delivering'
| 'delivered'
| 'done'
| 'archived';
document_processing_status: 'pending' | 'processing' | 'ready' | 'failed';
document_type:
| 'brief'
| 'blueprint'
| 'file'
| 'note'
| 'transcript'
| 'generated_plan'
| 'generated_task'
| 'generated_summary'
| 'method'
| 'task';
plan_generation_status:
| 'not_started'
| 'generating'
| 'completed'
| 'failed';
task_priority: 'low' | 'medium' | 'high' | 'urgent';
task_status: 'todo' | 'in_progress' | 'done';
};
CompositeTypes: {
[_ in never]: never;
};
};
};
export type Tables<
PublicTableNameOrOptions extends
| keyof (Database['public']['Tables'] & Database['public']['Views'])
| { schema: keyof Database },
TableName extends PublicTableNameOrOptions extends { schema: keyof Database }
? keyof (Database[PublicTableNameOrOptions['schema']]['Tables'] &
Database[PublicTableNameOrOptions['schema']]['Views'])
: never = never
> = PublicTableNameOrOptions extends { schema: keyof Database }
? (Database[PublicTableNameOrOptions['schema']]['Tables'] &
Database[PublicTableNameOrOptions['schema']]['Views'])[TableName] extends {
Row: infer R;
}
? R
: never
: PublicTableNameOrOptions extends keyof (Database['public']['Tables'] &
Database['public']['Views'])
? (Database['public']['Tables'] &
Database['public']['Views'])[PublicTableNameOrOptions] extends {
Row: infer R;
}
? R
: never
: never;
export type TablesInsert<
PublicTableNameOrOptions extends
| keyof Database['public']['Tables']
| { schema: keyof Database },
TableName extends PublicTableNameOrOptions extends { schema: keyof Database }
? keyof Database[PublicTableNameOrOptions['schema']]['Tables']
: never = never
> = PublicTableNameOrOptions extends { schema: keyof Database }
? Database[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
Insert: infer I;
}
? I
: never
: PublicTableNameOrOptions extends keyof Database['public']['Tables']
? Database['public']['Tables'][PublicTableNameOrOptions] extends {
Insert: infer I;
}
? I
: never
: never;
export type TablesUpdate<
PublicTableNameOrOptions extends
| keyof Database['public']['Tables']
| { schema: keyof Database },
TableName extends PublicTableNameOrOptions extends { schema: keyof Database }
? keyof Database[PublicTableNameOrOptions['schema']]['Tables']
: never = never
> = PublicTableNameOrOptions extends { schema: keyof Database }
? Database[PublicTableNameOrOptions['schema']]['Tables'][TableName] extends {
Update: infer U;
}
? U
: never
: PublicTableNameOrOptions extends keyof Database['public']['Tables']
? Database['public']['Tables'][PublicTableNameOrOptions] extends {
Update: infer U;
}
? U
: never
: never;
export type Enums<
PublicEnumNameOrOptions extends
| keyof Database['public']['Enums']
| { schema: keyof Database },
EnumName extends PublicEnumNameOrOptions extends { schema: keyof Database }
? keyof Database[PublicEnumNameOrOptions['schema']]['Enums']
: never = never
> = PublicEnumNameOrOptions extends { schema: keyof Database }
? Database[PublicEnumNameOrOptions['schema']]['Enums'][EnumName]
: PublicEnumNameOrOptions extends keyof Database['public']['Enums']
? Database['public']['Enums'][PublicEnumNameOrOptions]
: never;
```
--------------------------------------------------------------------------------
/tests/integration/cli/complex-cross-tag-scenarios.test.js:
--------------------------------------------------------------------------------
```javascript
import { jest } from '@jest/globals';
import { execSync } from 'child_process';
import fs from 'fs';
import path from 'path';
import os from 'os';
import { fileURLToPath } from 'url';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
describe('Complex Cross-Tag Scenarios', () => {
let testDir;
let tasksPath;
// Define binPath once for the entire test suite
const binPath = path.join(
__dirname,
'..',
'..',
'..',
'dist',
'task-master.js'
);
beforeEach(() => {
// Create test directory in OS temp directory to isolate from project
testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tm-test-'));
process.chdir(testDir);
// Keep integration timings deterministic
process.env.TASKMASTER_SKIP_AUTO_UPDATE = '1';
// Initialize task-master
execSync(`node ${binPath} init --yes`, {
stdio: 'pipe'
});
// Create test tasks with complex dependencies in the correct tagged format
const complexTasks = {
master: {
tasks: [
{
id: 1,
title: 'Setup Project',
description: 'Initialize the project structure',
status: 'done',
priority: 'high',
dependencies: [],
details: 'Create basic project structure',
testStrategy: 'Verify project structure exists',
subtasks: []
},
{
id: 2,
title: 'Database Schema',
description: 'Design and implement database schema',
status: 'pending',
priority: 'high',
dependencies: [1],
details: 'Create database tables and relationships',
testStrategy: 'Run database migrations',
subtasks: [
{
id: '2.1',
title: 'User Table',
description: 'Create user table',
status: 'pending',
priority: 'medium',
dependencies: [],
details: 'Design user table schema',
testStrategy: 'Test user creation'
},
{
id: '2.2',
title: 'Product Table',
description: 'Create product table',
status: 'pending',
priority: 'medium',
dependencies: ['2.1'],
details: 'Design product table schema',
testStrategy: 'Test product creation'
}
]
},
{
id: 3,
title: 'API Development',
description: 'Develop REST API endpoints',
status: 'pending',
priority: 'high',
dependencies: [2],
details: 'Create API endpoints for CRUD operations',
testStrategy: 'Test API endpoints',
subtasks: []
},
{
id: 4,
title: 'Frontend Development',
description: 'Develop user interface',
status: 'pending',
priority: 'medium',
dependencies: [3],
details: 'Create React components and pages',
testStrategy: 'Test UI components',
subtasks: []
},
{
id: 5,
title: 'Testing',
description: 'Comprehensive testing',
status: 'pending',
priority: 'medium',
dependencies: [4],
details: 'Write unit and integration tests',
testStrategy: 'Run test suite',
subtasks: []
}
],
metadata: {
created: new Date().toISOString(),
description: 'Test tasks for complex cross-tag scenarios'
}
}
};
// Write tasks to file
tasksPath = path.join(testDir, '.taskmaster', 'tasks', 'tasks.json');
fs.writeFileSync(tasksPath, JSON.stringify(complexTasks, null, 2));
});
afterEach(() => {
// Change back to project root before cleanup
try {
process.chdir(global.projectRoot || path.resolve(__dirname, '../../..'));
} catch (error) {
// If we can't change directory, try a known safe directory
process.chdir(require('os').homedir());
}
// Cleanup test directory
if (testDir && fs.existsSync(testDir)) {
fs.rmSync(testDir, { recursive: true, force: true });
}
delete process.env.TASKMASTER_SKIP_AUTO_UPDATE;
});
describe('Circular Dependency Detection', () => {
it('should detect and prevent circular dependencies', () => {
// Create a circular dependency scenario
const circularTasks = {
backlog: {
tasks: [
{
id: 1,
title: 'Task 1',
status: 'pending',
dependencies: [2],
subtasks: []
},
{
id: 2,
title: 'Task 2',
status: 'pending',
dependencies: [3],
subtasks: []
},
{
id: 3,
title: 'Task 3',
status: 'pending',
dependencies: [1],
subtasks: []
}
],
metadata: {
created: new Date().toISOString(),
description: 'Backlog tasks with circular dependencies'
}
},
'in-progress': {
tasks: [],
metadata: {
created: new Date().toISOString(),
description: 'In-progress tasks'
}
}
};
fs.writeFileSync(tasksPath, JSON.stringify(circularTasks, null, 2));
// Try to move task 1 - should fail due to circular dependency
expect(() => {
execSync(
`node ${binPath} move --from=1 --from-tag=backlog --to-tag=in-progress`,
{ stdio: 'pipe' }
);
}).toThrow();
// Check that the move was not performed
const tasksAfter = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
expect(tasksAfter.backlog.tasks.find((t) => t.id === 1)).toBeDefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === 1)
).toBeUndefined();
});
});
describe('Complex Dependency Chains', () => {
it('should handle deep dependency chains correctly', () => {
// Create a deep dependency chain
const deepChainTasks = {
master: {
tasks: [
{
id: 1,
title: 'Task 1',
status: 'pending',
dependencies: [2],
subtasks: []
},
{
id: 2,
title: 'Task 2',
status: 'pending',
dependencies: [3],
subtasks: []
},
{
id: 3,
title: 'Task 3',
status: 'pending',
dependencies: [4],
subtasks: []
},
{
id: 4,
title: 'Task 4',
status: 'pending',
dependencies: [5],
subtasks: []
},
{
id: 5,
title: 'Task 5',
status: 'pending',
dependencies: [],
subtasks: []
}
],
metadata: {
created: new Date().toISOString(),
description: 'Deep dependency chain tasks'
}
},
'in-progress': {
tasks: [],
metadata: {
created: new Date().toISOString(),
description: 'In-progress tasks'
}
}
};
fs.writeFileSync(tasksPath, JSON.stringify(deepChainTasks, null, 2));
// Move task 1 with dependencies - should move entire chain
execSync(
`node ${binPath} move --from=1 --from-tag=master --to-tag=in-progress --with-dependencies`,
{ stdio: 'pipe' }
);
// Verify all tasks in the chain were moved
const tasksAfter = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
expect(tasksAfter.master.tasks.find((t) => t.id === 1)).toBeUndefined();
expect(tasksAfter.master.tasks.find((t) => t.id === 2)).toBeUndefined();
expect(tasksAfter.master.tasks.find((t) => t.id === 3)).toBeUndefined();
expect(tasksAfter.master.tasks.find((t) => t.id === 4)).toBeUndefined();
expect(tasksAfter.master.tasks.find((t) => t.id === 5)).toBeUndefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === 1)
).toBeDefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === 2)
).toBeDefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === 3)
).toBeDefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === 4)
).toBeDefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === 5)
).toBeDefined();
});
});
describe('Subtask Movement Restrictions', () => {
it('should prevent direct subtask movement between tags', () => {
// Try to move a subtask directly
expect(() => {
execSync(
`node ${binPath} move --from=2.1 --from-tag=master --to-tag=in-progress`,
{ stdio: 'pipe' }
);
}).toThrow();
// Verify subtask was not moved
const tasksAfter = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
const task2 = tasksAfter.master.tasks.find((t) => t.id === 2);
expect(task2).toBeDefined();
expect(task2.subtasks.find((s) => s.id === '2.1')).toBeDefined();
});
it('should allow moving parent task with all subtasks', () => {
// Move parent task with dependencies (includes subtasks)
execSync(
`node ${binPath} move --from=2 --from-tag=master --to-tag=in-progress --with-dependencies`,
{ stdio: 'pipe' }
);
// Verify parent and subtasks were moved
const tasksAfter = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
expect(tasksAfter.master.tasks.find((t) => t.id === 2)).toBeUndefined();
const movedTask2 = tasksAfter['in-progress'].tasks.find(
(t) => t.id === 2
);
expect(movedTask2).toBeDefined();
expect(movedTask2.subtasks).toHaveLength(2);
});
});
describe('Large Task Set Performance', () => {
it('should handle large task sets efficiently', () => {
// Create a large task set (50 tasks)
const largeTaskSet = {
master: {
tasks: [],
metadata: {
created: new Date().toISOString(),
description: 'Large task set for performance testing'
}
},
'in-progress': {
tasks: [],
metadata: {
created: new Date().toISOString(),
description: 'In-progress tasks'
}
}
};
// Add 25 tasks to master with dependencies
for (let i = 1; i <= 25; i++) {
largeTaskSet.master.tasks.push({
id: i,
title: `Task ${i}`,
status: 'pending',
dependencies: i > 1 ? [i - 1] : [],
subtasks: []
});
}
// Add 25 tasks to in-progress (ensure no ID conflict with master)
for (let i = 26; i <= 50; i++) {
largeTaskSet['in-progress'].tasks.push({
id: i,
title: `Task ${i}`,
status: 'in-progress',
dependencies: [],
subtasks: []
});
}
fs.writeFileSync(tasksPath, JSON.stringify(largeTaskSet, null, 2));
// Execute move; correctness is validated below (no timing assertion)
execSync(
`node ${binPath} move --from=25 --from-tag=master --to-tag=in-progress --with-dependencies`,
{ stdio: 'pipe' }
);
// Verify the move was successful
const tasksAfter = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
// Verify all tasks in the dependency chain were moved
for (let i = 1; i <= 25; i++) {
expect(tasksAfter.master.tasks.find((t) => t.id === i)).toBeUndefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === i)
).toBeDefined();
}
// Verify in-progress still has its original tasks (26-50)
for (let i = 26; i <= 50; i++) {
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === i)
).toBeDefined();
}
// Final count check
expect(tasksAfter['in-progress'].tasks).toHaveLength(50); // 25 moved + 25 original
});
});
describe('Error Recovery and Edge Cases', () => {
it('should handle invalid task IDs gracefully', () => {
expect(() => {
execSync(
`node ${binPath} move --from=999 --from-tag=master --to-tag=in-progress`,
{ stdio: 'pipe' }
);
}).toThrow();
});
it('should handle invalid tag names gracefully', () => {
expect(() => {
execSync(
`node ${binPath} move --from=1 --from-tag=invalid-tag --to-tag=in-progress`,
{ stdio: 'pipe' }
);
}).toThrow();
});
it('should handle same source and target tags', () => {
expect(() => {
execSync(
`node ${binPath} move --from=1 --from-tag=master --to-tag=master`,
{ stdio: 'pipe' }
);
}).toThrow();
});
it('should create target tag if it does not exist', () => {
execSync(
`node ${binPath} move --from=1 --from-tag=master --to-tag=new-tag`,
{ stdio: 'pipe' }
);
const tasksAfter = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
expect(tasksAfter['new-tag']).toBeDefined();
expect(tasksAfter['new-tag'].tasks.find((t) => t.id === 1)).toBeDefined();
});
});
describe('Multiple Task Movement', () => {
it('should move multiple tasks simultaneously', () => {
// Create tasks for multiple movement test
const multiTaskSet = {
master: {
tasks: [
{
id: 1,
title: 'Task 1',
status: 'pending',
dependencies: [],
subtasks: []
},
{
id: 2,
title: 'Task 2',
status: 'pending',
dependencies: [],
subtasks: []
},
{
id: 3,
title: 'Task 3',
status: 'pending',
dependencies: [],
subtasks: []
}
],
metadata: {
created: new Date().toISOString(),
description: 'Tasks for multiple movement test'
}
},
'in-progress': {
tasks: [],
metadata: {
created: new Date().toISOString(),
description: 'In-progress tasks'
}
}
};
fs.writeFileSync(tasksPath, JSON.stringify(multiTaskSet, null, 2));
// Move multiple tasks
execSync(
`node ${binPath} move --from=1,2,3 --from-tag=master --to-tag=in-progress`,
{ stdio: 'pipe' }
);
// Verify all tasks were moved
const tasksAfter = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
expect(tasksAfter.master.tasks.find((t) => t.id === 1)).toBeUndefined();
expect(tasksAfter.master.tasks.find((t) => t.id === 2)).toBeUndefined();
expect(tasksAfter.master.tasks.find((t) => t.id === 3)).toBeUndefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === 1)
).toBeDefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === 2)
).toBeDefined();
expect(
tasksAfter['in-progress'].tasks.find((t) => t.id === 3)
).toBeDefined();
});
});
});
```
--------------------------------------------------------------------------------
/docs/providers/codex-cli.md:
--------------------------------------------------------------------------------
```markdown
# Codex CLI Provider
The `codex-cli` provider integrates Task Master with OpenAI's Codex CLI via the community AI SDK provider [`ai-sdk-provider-codex-cli`](https://github.com/ben-vargas/ai-sdk-provider-codex-cli). It uses your ChatGPT subscription (OAuth) via `codex login`, with optional `OPENAI_CODEX_API_KEY` support.
## Why Use Codex CLI?
The primary benefits of using the `codex-cli` provider include:
- **Use Latest OpenAI Models**: Access to cutting-edge models like GPT-5 and GPT-5-Codex via ChatGPT subscription
- **OAuth Authentication**: No API key management needed - authenticate once with `codex login`
- **Built-in Tool Execution**: Native support for command execution, file changes, MCP tools, and web search
- **Native JSON Schema Support**: Structured output generation without post-processing
- **Approval/Sandbox Modes**: Fine-grained control over command execution and filesystem access for safety
## Quickstart
Get up and running with Codex CLI in 3 steps:
```bash
# 1. Install Codex CLI globally
npm install -g @openai/codex
# 2. Authenticate with your ChatGPT account
codex login
# 3. Configure Task Master to use Codex CLI
task-master models --set-main gpt-5-codex --codex-cli
```
## Requirements
- **Node.js**: >= 18.0.0
- **Codex CLI**: >= 0.42.0 (>= 0.44.0 recommended)
- **ChatGPT Subscription**: Required for OAuth access (Plus, Pro, Business, Edu, or Enterprise)
- **Task Master**: >= 0.27.3 (version with Codex CLI support)
### Checking Your Versions
```bash
# Check Node.js version
node --version
# Check Codex CLI version
codex --version
# Check Task Master version
task-master --version
```
## Installation
### Install Codex CLI
```bash
# Install globally via npm
npm install -g @openai/codex
# Verify installation
codex --version
```
Expected output: `v0.44.0` or higher
### Install Task Master (if not already installed)
```bash
# Install globally
npm install -g task-master-ai
# Or install in your project
npm install --save-dev task-master-ai
```
## Authentication
### OAuth Authentication (Primary Method - Recommended)
The Codex CLI provider is designed to use OAuth authentication with your ChatGPT subscription:
```bash
# Launch Codex CLI and authenticate
codex login
```
This will:
1. Open a browser window for OAuth authentication
2. Prompt you to log in with your ChatGPT account
3. Store authentication credentials locally
4. Allow Task Master to automatically use these credentials
To verify your authentication:
```bash
# Open interactive Codex CLI
codex
# Use /about command to see auth status
/about
```
### Optional: API Key Method
While OAuth is the primary and recommended method, you can optionally use an OpenAI API key:
```bash
# In your .env file
OPENAI_CODEX_API_KEY=sk-your-openai-api-key-here
```
**Important Notes**:
- The API key will **only** be injected when explicitly provided
- OAuth authentication is always preferred when available
- Using an API key doesn't provide access to subscription-only models like GPT-5-Codex
- For full OpenAI API access with non-subscription models, consider using the standard `openai` provider instead
- `OPENAI_CODEX_API_KEY` is specific to the codex-cli provider to avoid conflicts with the `openai` provider's `OPENAI_API_KEY`
## Available Models
The Codex CLI provider supports only models available through ChatGPT subscription:
| Model ID | Description | Max Input Tokens | Max Output Tokens |
|----------|-------------|------------------|-------------------|
| `gpt-5` | Latest GPT-5 model | 272K | 128K |
| `gpt-5-codex` | GPT-5 optimized for agentic software engineering | 272K | 128K |
**Note**: These models are only available via OAuth subscription through Codex CLI (ChatGPT Plus, Pro, Business, Edu, or Enterprise plans). For other OpenAI models, use the standard `openai` provider with an API key.
**Research Capabilities**: Both GPT-5 models support web search tools, making them suitable for the `research` role in addition to `main` and `fallback` roles.
## Configuration
### Basic Configuration
Add Codex CLI to your `.taskmaster/config.json`:
```json
{
"models": {
"main": {
"provider": "codex-cli",
"modelId": "gpt-5-codex",
"maxTokens": 128000,
"temperature": 0.2
},
"fallback": {
"provider": "codex-cli",
"modelId": "gpt-5",
"maxTokens": 128000,
"temperature": 0.2
}
}
}
```
### Advanced Configuration with Codex CLI Settings
The `codexCli` section allows you to customize Codex CLI behavior:
```json
{
"models": {
"main": {
"provider": "codex-cli",
"modelId": "gpt-5-codex",
"maxTokens": 128000,
"temperature": 0.2
}
},
"codexCli": {
"allowNpx": true,
"skipGitRepoCheck": true,
"approvalMode": "on-failure",
"sandboxMode": "workspace-write",
"verbose": false
}
}
```
### Codex CLI Settings Reference
#### Core Settings
- **`allowNpx`** (boolean, default: `false`)
- Allow fallback to `npx @openai/codex` if the CLI is not found on PATH
- Useful for CI environments or systems without global npm installations
- Example: `"allowNpx": true`
- **`skipGitRepoCheck`** (boolean, default: `false`)
- Skip git repository safety check before execution
- Recommended for CI environments or non-repository usage
- Example: `"skipGitRepoCheck": true`
#### Execution Control
- **`approvalMode`** (string)
- Controls when to require user approval for command execution
- Options:
- `"untrusted"`: Require approval for all commands
- `"on-failure"`: Only require approval after a command fails (default)
- `"on-request"`: Approve only when explicitly requested
- `"never"`: Never require approval (use with caution)
- Example: `"approvalMode": "on-failure"`
- **`sandboxMode`** (string)
- Controls filesystem access permissions
- Options:
- `"read-only"`: Read-only access to filesystem
- `"workspace-write"`: Allow writes to workspace directory (default)
- `"danger-full-access"`: Full filesystem access (use with extreme caution)
- Example: `"sandboxMode": "workspace-write"`
#### Path and Environment
- **`codexPath`** (string, optional)
- Custom path to Codex CLI executable
- Useful when Codex is installed in a non-standard location
- Example: `"codexPath": "/usr/local/bin/codex"`
- **`cwd`** (string, optional)
- Working directory for Codex CLI execution
- Defaults to current working directory
- Example: `"cwd": "/path/to/project"`
- **`env`** (object, optional)
- Additional environment variables for Codex CLI
- Example: `"env": { "DEBUG": "true" }`
#### Advanced Settings
- **`fullAuto`** (boolean, optional)
- Fully automatic mode (equivalent to `--full-auto` flag)
- Bypasses most approvals for fully automated workflows
- Example: `"fullAuto": true`
- **`dangerouslyBypassApprovalsAndSandbox`** (boolean, optional)
- Bypass all safety checks including approvals and sandbox
- **WARNING**: Use with extreme caution - can execute arbitrary code
- Example: `"dangerouslyBypassApprovalsAndSandbox": false`
- **`color`** (string, optional)
- Force color handling in Codex CLI output
- Options: `"always"`, `"never"`, `"auto"`
- Example: `"color": "auto"`
- **`outputLastMessageFile`** (string, optional)
- Write last agent message to specified file
- Useful for debugging or logging
- Example: `"outputLastMessageFile": "./last-message.txt"`
- **`verbose`** (boolean, optional)
- Enable verbose provider logging
- Helpful for debugging issues
- Example: `"verbose": true`
### Command-Specific Settings
Override settings for specific Task Master commands:
```json
{
"codexCli": {
"allowNpx": true,
"approvalMode": "on-failure",
"commandSpecific": {
"parse-prd": {
"approvalMode": "never",
"verbose": true
},
"expand": {
"sandboxMode": "read-only"
},
"add-task": {
"approvalMode": "untrusted"
}
}
}
}
```
## Usage
### Setting Codex CLI Models
```bash
# Set Codex CLI for main role
task-master models --set-main gpt-5-codex --codex-cli
# Set Codex CLI for fallback role
task-master models --set-fallback gpt-5 --codex-cli
# Set Codex CLI for research role
task-master models --set-research gpt-5 --codex-cli
# Verify configuration
task-master models
```
### Using Codex CLI with Task Master Commands
Once configured, use Task Master commands as normal:
```bash
# Parse a PRD with Codex CLI
task-master parse-prd my-requirements.txt
# Analyze project complexity
task-master analyze-complexity --research
# Expand a task into subtasks
task-master expand --id=1.2
# Add a new task with AI assistance
task-master add-task --prompt="Implement user authentication" --research
```
The provider will automatically use your OAuth credentials when Codex CLI is configured.
## Codebase Features
The Codex CLI provider is **codebase-capable**, meaning it can analyze and interact with your project files. This enables advanced features like:
- **Code Analysis**: Understanding your project structure and dependencies
- **Intelligent Suggestions**: Context-aware task recommendations
- **File Operations**: Reading and analyzing project files for better task generation
- **Pattern Recognition**: Identifying common patterns and best practices in your codebase
### Enabling Codebase Analysis
Codebase analysis is automatically enabled when:
1. Your provider is set to `codex-cli`
2. `enableCodebaseAnalysis` is `true` in your global configuration (default)
To verify or configure:
```json
{
"global": {
"enableCodebaseAnalysis": true
}
}
```
## Troubleshooting
### "codex: command not found" Error
**Symptoms**: Task Master reports that the Codex CLI is not found.
**Solutions**:
1. **Install Codex CLI globally**:
```bash
npm install -g @openai/codex
```
2. **Verify installation**:
```bash
codex --version
```
3. **Alternative: Enable npx fallback**:
```json
{
"codexCli": {
"allowNpx": true
}
}
```
### "Not logged in" Errors
**Symptoms**: Authentication errors when trying to use Codex CLI.
**Solutions**:
1. **Authenticate with OAuth**:
```bash
codex login
```
2. **Verify authentication status**:
```bash
codex
# Then use /about command
```
3. **Re-authenticate if needed**:
```bash
# Logout first
codex
# Use /auth command to change auth method
# Then login again
codex login
```
### "Old version" Warnings
**Symptoms**: Warnings about Codex CLI version being outdated.
**Solutions**:
1. **Check current version**:
```bash
codex --version
```
2. **Upgrade to latest version**:
```bash
npm install -g @openai/codex@latest
```
3. **Verify upgrade**:
```bash
codex --version
```
Should show >= 0.44.0
### "Model not available" Errors
**Symptoms**: Error indicating the requested model is not available.
**Causes and Solutions**:
1. **Using unsupported model**:
- Only `gpt-5` and `gpt-5-codex` are available via Codex CLI
- For other OpenAI models, use the standard `openai` provider
2. **Subscription not active**:
- Verify your ChatGPT subscription is active
- Check subscription status at <https://platform.openai.com>
3. **Wrong provider selected**:
- Verify you're using `--codex-cli` flag when setting models
- Check `.taskmaster/config.json` shows `"provider": "codex-cli"`
### API Key Not Being Used
**Symptoms**: You've set `OPENAI_CODEX_API_KEY` but it's not being used.
**Expected Behavior**:
- OAuth authentication is always preferred
- API key is only injected when explicitly provided
- API key doesn't grant access to subscription-only models
**Solutions**:
1. **Verify OAuth is working**:
```bash
codex
# Check /about for auth status
```
2. **If you want to force API key usage**:
- This is not recommended with Codex CLI
- Consider using the standard `openai` provider instead
3. **Verify .env file is being loaded**:
```bash
# Check if .env exists in project root
ls -la .env
# Verify OPENAI_CODEX_API_KEY is set
grep OPENAI_CODEX_API_KEY .env
```
### Approval/Sandbox Issues
**Symptoms**: Commands are blocked or filesystem access is denied.
**Solutions**:
1. **Adjust approval mode**:
```json
{
"codexCli": {
"approvalMode": "on-request"
}
}
```
2. **Adjust sandbox mode**:
```json
{
"codexCli": {
"sandboxMode": "workspace-write"
}
}
```
3. **For fully automated workflows** (use cautiously):
```json
{
"codexCli": {
"fullAuto": true
}
}
```
## Important Notes
- **OAuth subscription required**: No API key needed for basic operation, but requires active ChatGPT subscription
- **Limited model selection**: Only `gpt-5` and `gpt-5-codex` available via OAuth
- **Pricing information**: Not available for OAuth models (shows as "Unknown" in cost calculations)
- **No automatic dependency**: The `@openai/codex` package is not added to Task Master's dependencies - install it globally or enable `allowNpx`
- **Codebase analysis**: Automatically enabled when using `codex-cli` provider
- **Safety first**: Default settings prioritize safety with `approvalMode: "on-failure"` and `sandboxMode: "workspace-write"`
## See Also
- [Configuration Guide](../configuration.md#codex-cli-provider) - Complete Codex CLI configuration reference
- [Command Reference](../command-reference.md) - Using `--codex-cli` flag with commands
- [Gemini CLI Provider](./gemini-cli.md) - Similar CLI-based provider for Google Gemini
- [Claude Code Integration](../claude-code-integration.md) - Another CLI-based provider
- [ai-sdk-provider-codex-cli](https://github.com/ben-vargas/ai-sdk-provider-codex-cli) - Source code for the provider package
```
--------------------------------------------------------------------------------
/scripts/modules/task-manager/update-subtask-by-id.js:
--------------------------------------------------------------------------------
```javascript
import fs from 'fs';
import path from 'path';
import chalk from 'chalk';
import boxen from 'boxen';
import Table from 'cli-table3';
import {
getStatusWithColor,
startLoadingIndicator,
stopLoadingIndicator,
displayAiUsageSummary
} from '../ui.js';
import {
log as consoleLog,
readJSON,
writeJSON,
truncate,
isSilentMode,
findProjectRoot,
flattenTasksWithSubtasks
} from '../utils.js';
import { generateTextService } from '../ai-services-unified.js';
import { getDebugFlag, hasCodebaseAnalysis } from '../config-manager.js';
import { getPromptManager } from '../prompt-manager.js';
import generateTaskFiles from './generate-task-files.js';
import { ContextGatherer } from '../utils/contextGatherer.js';
import { FuzzyTaskSearch } from '../utils/fuzzyTaskSearch.js';
import { tryUpdateViaRemote } from '@tm/bridge';
/**
* Update a subtask by appending additional timestamped information using the unified AI service.
* @param {string} tasksPath - Path to the tasks.json file
* @param {string} subtaskId - ID of the subtask to update in format "parentId.subtaskId"
* @param {string} prompt - Prompt for generating additional information
* @param {boolean} [useResearch=false] - Whether to use the research AI role.
* @param {Object} context - Context object containing session and mcpLog.
* @param {Object} [context.session] - Session object from MCP server.
* @param {Object} [context.mcpLog] - MCP logger object.
* @param {string} [context.projectRoot] - Project root path (needed for AI service key resolution).
* @param {string} [context.tag] - Tag for the task
* @param {string} [outputFormat='text'] - Output format ('text' or 'json'). Automatically 'json' if mcpLog is present.
* @returns {Promise<Object|null>} - The updated subtask or null if update failed.
*/
async function updateSubtaskById(
tasksPath,
subtaskId,
prompt,
useResearch = false,
context = {},
outputFormat = context.mcpLog ? 'json' : 'text'
) {
const { session, mcpLog, projectRoot: providedProjectRoot, tag } = context;
const logFn = mcpLog || consoleLog;
const isMCP = !!mcpLog;
// Report helper
const report = (level, ...args) => {
if (isMCP) {
if (typeof logFn[level] === 'function') logFn[level](...args);
else logFn.info(...args);
} else if (!isSilentMode()) {
logFn(level, ...args);
}
};
let loadingIndicator = null;
try {
report('info', `Updating subtask ${subtaskId} with prompt: "${prompt}"`);
if (
!subtaskId ||
typeof subtaskId !== 'string' ||
!subtaskId.includes('.')
) {
throw new Error(
`Invalid subtask ID format: ${subtaskId}. Subtask ID must be in format "parentId.subtaskId"`
);
}
if (!prompt || typeof prompt !== 'string' || prompt.trim() === '') {
throw new Error(
'Prompt cannot be empty. Please provide context for the subtask update.'
);
}
if (!fs.existsSync(tasksPath)) {
throw new Error(`Tasks file not found at path: ${tasksPath}`);
}
const projectRoot = providedProjectRoot || findProjectRoot();
if (!projectRoot) {
throw new Error('Could not determine project root directory');
}
// --- BRIDGE: Try remote update first (API storage) ---
// In API storage, subtask IDs like "1.2" or "TAS-49.1" are just regular task IDs
// So update-subtask and update-task work identically
const remoteResult = await tryUpdateViaRemote({
taskId: subtaskId,
prompt,
projectRoot,
tag,
appendMode: true, // Subtask updates are always append mode
useResearch,
isMCP,
outputFormat,
report
});
// If remote handled it, return the result
if (remoteResult) {
return {
updatedSubtask: { id: subtaskId },
telemetryData: remoteResult.telemetryData,
tagInfo: remoteResult.tagInfo
};
}
// Otherwise fall through to file-based logic below
// --- End BRIDGE ---
const data = readJSON(tasksPath, projectRoot, tag);
if (!data || !data.tasks) {
throw new Error(
`No valid tasks found in ${tasksPath}. The file may be corrupted or have an invalid format.`
);
}
const [parentIdStr, subtaskIdStr] = subtaskId.split('.');
const parentId = parseInt(parentIdStr, 10);
const subtaskIdNum = parseInt(subtaskIdStr, 10);
if (
Number.isNaN(parentId) ||
parentId <= 0 ||
Number.isNaN(subtaskIdNum) ||
subtaskIdNum <= 0
) {
throw new Error(
`Invalid subtask ID format: ${subtaskId}. Both parent ID and subtask ID must be positive integers.`
);
}
const parentTask = data.tasks.find((task) => task.id === parentId);
if (!parentTask) {
throw new Error(
`Parent task with ID ${parentId} not found. Please verify the task ID and try again.`
);
}
if (!parentTask.subtasks || !Array.isArray(parentTask.subtasks)) {
throw new Error(`Parent task ${parentId} has no subtasks.`);
}
const subtaskIndex = parentTask.subtasks.findIndex(
(st) => st.id === subtaskIdNum
);
if (subtaskIndex === -1) {
throw new Error(
`Subtask with ID ${subtaskId} not found. Please verify the subtask ID and try again.`
);
}
const subtask = parentTask.subtasks[subtaskIndex];
// --- Context Gathering ---
let gatheredContext = '';
try {
const contextGatherer = new ContextGatherer(projectRoot, tag);
const allTasksFlat = flattenTasksWithSubtasks(data.tasks);
const fuzzySearch = new FuzzyTaskSearch(allTasksFlat, 'update-subtask');
const searchQuery = `${parentTask.title} ${subtask.title} ${prompt}`;
const searchResults = fuzzySearch.findRelevantTasks(searchQuery, {
maxResults: 5,
includeSelf: true
});
const relevantTaskIds = fuzzySearch.getTaskIds(searchResults);
const finalTaskIds = [
...new Set([subtaskId.toString(), ...relevantTaskIds])
];
if (finalTaskIds.length > 0) {
const contextResult = await contextGatherer.gather({
tasks: finalTaskIds,
format: 'research'
});
gatheredContext = contextResult.context || '';
}
} catch (contextError) {
report('warn', `Could not gather context: ${contextError.message}`);
}
// --- End Context Gathering ---
if (outputFormat === 'text') {
const table = new Table({
head: [
chalk.cyan.bold('ID'),
chalk.cyan.bold('Title'),
chalk.cyan.bold('Status')
],
colWidths: [10, 55, 10]
});
table.push([
subtaskId,
truncate(subtask.title, 52),
getStatusWithColor(subtask.status)
]);
console.log(
boxen(chalk.white.bold(`Updating Subtask #${subtaskId}`), {
padding: 1,
borderColor: 'blue',
borderStyle: 'round',
margin: { top: 1, bottom: 0 }
})
);
console.log(table.toString());
loadingIndicator = startLoadingIndicator(
useResearch
? 'Updating subtask with research...'
: 'Updating subtask...'
);
}
let generatedContentString = '';
let newlyAddedSnippet = '';
let aiServiceResponse = null;
try {
const parentContext = {
id: parentTask.id,
title: parentTask.title
};
const prevSubtask =
subtaskIndex > 0
? {
id: `${parentTask.id}.${parentTask.subtasks[subtaskIndex - 1].id}`,
title: parentTask.subtasks[subtaskIndex - 1].title,
status: parentTask.subtasks[subtaskIndex - 1].status
}
: undefined;
const nextSubtask =
subtaskIndex < parentTask.subtasks.length - 1
? {
id: `${parentTask.id}.${parentTask.subtasks[subtaskIndex + 1].id}`,
title: parentTask.subtasks[subtaskIndex + 1].title,
status: parentTask.subtasks[subtaskIndex + 1].status
}
: undefined;
// Build prompts using PromptManager
const promptManager = getPromptManager();
const promptParams = {
parentTask: parentContext,
prevSubtask: prevSubtask,
nextSubtask: nextSubtask,
currentDetails: subtask.details || '(No existing details)',
updatePrompt: prompt,
useResearch: useResearch,
gatheredContext: gatheredContext || '',
hasCodebaseAnalysis: hasCodebaseAnalysis(
useResearch,
projectRoot,
session
),
projectRoot: projectRoot
};
const variantKey = useResearch ? 'research' : 'default';
const { systemPrompt, userPrompt } = await promptManager.loadPrompt(
'update-subtask',
promptParams,
variantKey
);
const role = useResearch ? 'research' : 'main';
report('info', `Using AI text service with role: ${role}`);
aiServiceResponse = await generateTextService({
prompt: userPrompt,
systemPrompt: systemPrompt,
role,
session,
projectRoot,
maxRetries: 2,
commandName: 'update-subtask',
outputType: isMCP ? 'mcp' : 'cli'
});
if (
aiServiceResponse &&
aiServiceResponse.mainResult &&
typeof aiServiceResponse.mainResult === 'string'
) {
generatedContentString = aiServiceResponse.mainResult;
} else {
generatedContentString = '';
report(
'warn',
'AI service response did not contain expected text string.'
);
}
if (outputFormat === 'text' && loadingIndicator) {
stopLoadingIndicator(loadingIndicator);
loadingIndicator = null;
}
} catch (aiError) {
report('error', `AI service call failed: ${aiError.message}`);
if (outputFormat === 'text' && loadingIndicator) {
stopLoadingIndicator(loadingIndicator);
loadingIndicator = null;
}
throw aiError;
}
if (generatedContentString && generatedContentString.trim()) {
// Check if the string is not empty
const timestamp = new Date().toISOString();
const formattedBlock = `<info added on ${timestamp}>\n${generatedContentString.trim()}\n</info added on ${timestamp}>`;
newlyAddedSnippet = formattedBlock; // <--- ADD THIS LINE: Store for display
subtask.details =
(subtask.details ? subtask.details + '\n' : '') + formattedBlock;
} else {
report(
'warn',
'AI response was empty or whitespace after trimming. Original details remain unchanged.'
);
newlyAddedSnippet = 'No new details were added by the AI.';
}
const updatedSubtask = parentTask.subtasks[subtaskIndex];
if (outputFormat === 'text' && getDebugFlag(session)) {
console.log(
'>>> DEBUG: Subtask details AFTER AI update:',
updatedSubtask.details
);
}
if (updatedSubtask.description) {
if (prompt.length < 100) {
if (outputFormat === 'text' && getDebugFlag(session)) {
console.log(
'>>> DEBUG: Subtask description BEFORE append:',
updatedSubtask.description
);
}
updatedSubtask.description += ` [Updated: ${new Date().toLocaleDateString()}]`;
if (outputFormat === 'text' && getDebugFlag(session)) {
console.log(
'>>> DEBUG: Subtask description AFTER append:',
updatedSubtask.description
);
}
}
}
if (outputFormat === 'text' && getDebugFlag(session)) {
console.log('>>> DEBUG: About to call writeJSON with updated data...');
}
writeJSON(tasksPath, data, projectRoot, tag);
if (outputFormat === 'text' && getDebugFlag(session)) {
console.log('>>> DEBUG: writeJSON call completed.');
}
report('success', `Successfully updated subtask ${subtaskId}`);
// Updated function call to make sure if uncommented it will generate the task files for the updated subtask based on the tag
// await generateTaskFiles(tasksPath, path.dirname(tasksPath), {
// tag: tag,
// projectRoot: projectRoot
// });
if (outputFormat === 'text') {
if (loadingIndicator) {
stopLoadingIndicator(loadingIndicator);
loadingIndicator = null;
}
console.log(
boxen(
chalk.green(`Successfully updated subtask #${subtaskId}`) +
'\n\n' +
chalk.white.bold('Title:') +
' ' +
updatedSubtask.title +
'\n\n' +
chalk.white.bold('Newly Added Snippet:') +
'\n' +
chalk.white(newlyAddedSnippet),
{ padding: 1, borderColor: 'green', borderStyle: 'round' }
)
);
}
if (outputFormat === 'text' && aiServiceResponse.telemetryData) {
displayAiUsageSummary(aiServiceResponse.telemetryData, 'cli');
}
return {
updatedSubtask: updatedSubtask,
telemetryData: aiServiceResponse.telemetryData,
tagInfo: aiServiceResponse.tagInfo
};
} catch (error) {
if (outputFormat === 'text' && loadingIndicator) {
stopLoadingIndicator(loadingIndicator);
loadingIndicator = null;
}
report('error', `Error updating subtask: ${error.message}`);
if (outputFormat === 'text') {
console.error(chalk.red(`Error: ${error.message}`));
if (error.message?.includes('ANTHROPIC_API_KEY')) {
console.log(
chalk.yellow('\nTo fix this issue, set your Anthropic API key:')
);
console.log(' export ANTHROPIC_API_KEY=your_api_key_here');
} else if (error.message?.includes('PERPLEXITY_API_KEY')) {
console.log(chalk.yellow('\nTo fix this issue:'));
console.log(
' 1. Set your Perplexity API key: export PERPLEXITY_API_KEY=your_api_key_here'
);
console.log(
' 2. Or run without the research flag: task-master update-subtask --id=<id> --prompt="..."'
);
} else if (error.message?.includes('overloaded')) {
console.log(
chalk.yellow(
'\nAI model overloaded, and fallback failed or was unavailable:'
)
);
console.log(' 1. Try again in a few minutes.');
console.log(' 2. Ensure PERPLEXITY_API_KEY is set for fallback.');
} else if (error.message?.includes('not found')) {
console.log(chalk.yellow('\nTo fix this issue:'));
console.log(
' 1. Run task-master list --with-subtasks to see all available subtask IDs'
);
console.log(
' 2. Use a valid subtask ID with the --id parameter in format "parentId.subtaskId"'
);
} else if (
error.message?.includes('empty stream response') ||
error.message?.includes('AI did not return a valid text string')
) {
console.log(
chalk.yellow(
'\nThe AI model returned an empty or invalid response. This might be due to the prompt or API issues. Try rephrasing or trying again later.'
)
);
}
if (getDebugFlag(session)) {
console.error(error);
}
} else {
throw error;
}
return null;
}
}
export default updateSubtaskById;
```
--------------------------------------------------------------------------------
/.taskmaster/docs/tdd-workflow-phase-3-extensibility-guardrails.md:
--------------------------------------------------------------------------------
```markdown
# Phase 3: Extensibility + Guardrails - Autonomous TDD Workflow
## Objective
Add multi-language/framework support, enhanced safety guardrails, TUI interface, and extensibility for IDE/editor integration.
## Scope
- Multi-language test runner support (pytest, go test, etc.)
- Enhanced safety: diff preview, confirmation gates, minimal-change prompts
- Optional TUI panel with tmux integration
- State-based extension API for IDE integration
- Parallel subtask execution (experimental)
## Deliverables
### 1. Multi-Language Test Runner Support
**Extend TestRunnerAdapter:**
```typescript
class TestRunnerAdapter {
// Existing methods...
async detectLanguage(): Promise<Language>
async detectFramework(language: Language): Promise<Framework>
async getFrameworkAdapter(framework: Framework): Promise<FrameworkAdapter>
}
enum Language {
JavaScript = 'javascript',
TypeScript = 'typescript',
Python = 'python',
Go = 'go',
Rust = 'rust'
}
enum Framework {
Vitest = 'vitest',
Jest = 'jest',
Pytest = 'pytest',
GoTest = 'gotest',
CargoTest = 'cargotest'
}
interface FrameworkAdapter {
runTargeted(pattern: string): Promise<TestResults>
runAll(): Promise<TestResults>
parseCoverage(output: string): Promise<CoverageReport>
getTestFilePattern(): string
getTestFileExtension(): string
}
```
**Framework-specific adapters:**
**PytestAdapter** (`packages/tm-core/src/services/test-adapters/pytest-adapter.ts`):
```typescript
class PytestAdapter implements FrameworkAdapter {
async runTargeted(pattern: string): Promise<TestResults> {
const output = await exec(`pytest ${pattern} --json-report`)
return this.parseResults(output)
}
async runAll(): Promise<TestResults> {
const output = await exec('pytest --cov --json-report')
return this.parseResults(output)
}
parseCoverage(output: string): Promise<CoverageReport> {
// Parse pytest-cov XML output
}
getTestFilePattern(): string {
return '**/test_*.py'
}
getTestFileExtension(): string {
return '.py'
}
}
```
**GoTestAdapter** (`packages/tm-core/src/services/test-adapters/gotest-adapter.ts`):
```typescript
class GoTestAdapter implements FrameworkAdapter {
async runTargeted(pattern: string): Promise<TestResults> {
const output = await exec(`go test ${pattern} -json`)
return this.parseResults(output)
}
async runAll(): Promise<TestResults> {
const output = await exec('go test ./... -coverprofile=coverage.out -json')
return this.parseResults(output)
}
parseCoverage(output: string): Promise<CoverageReport> {
// Parse go test coverage output
}
getTestFilePattern(): string {
return '**/*_test.go'
}
getTestFileExtension(): string {
return '_test.go'
}
}
```
**Detection Logic:**
```typescript
async function detectFramework(): Promise<Framework> {
// Check for package.json
if (await exists('package.json')) {
const pkg = await readJSON('package.json')
if (pkg.devDependencies?.vitest) return Framework.Vitest
if (pkg.devDependencies?.jest) return Framework.Jest
}
// Check for Python files
if (await exists('pytest.ini') || await exists('setup.py')) {
return Framework.Pytest
}
// Check for Go files
if (await exists('go.mod')) {
return Framework.GoTest
}
// Check for Rust files
if (await exists('Cargo.toml')) {
return Framework.CargoTest
}
throw new Error('Could not detect test framework')
}
```
### 2. Enhanced Safety Guardrails
**Diff Preview Mode:**
```bash
$ tm autopilot 42 --preview-diffs
[2/3] Subtask 42.2: Add collection endpoint
RED ✓ Tests created: src/api/__tests__/metrics.test.js
GREEN Implementing code...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Proposed changes (src/api/metrics.js):
+ import { MetricsSchema } from '../models/schema.js'
+
+ export async function createMetric(data) {
+ const validated = MetricsSchema.parse(data)
+ const result = await db.metrics.create(validated)
+ return result
+ }
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Apply these changes? [Y/n/e(dit)/s(kip)]
Y - Apply and continue
n - Reject and retry GREEN phase
e - Open in editor for manual changes
s - Skip this subtask
```
**Minimal Change Enforcement:**
Add to system prompt:
```markdown
CRITICAL: Make MINIMAL changes to pass the failing tests.
- Only modify files directly related to the subtask
- Do not refactor existing code unless absolutely necessary
- Do not add features beyond the acceptance criteria
- Keep changes under 50 lines per file when possible
- Prefer composition over modification
```
**Change Size Warnings:**
```bash
⚠️ Large change detected:
Files modified: 5
Lines changed: +234, -12
This subtask was expected to be small (~50 lines).
Consider:
- Breaking into smaller subtasks
- Reviewing acceptance criteria
- Checking for unintended changes
Continue anyway? [y/N]
```
### 3. TUI Interface with tmux
**Layout:**
```
┌──────────────────────────────────┬─────────────────────────────────┐
│ Task Navigator (left) │ Executor Terminal (right) │
│ │ │
│ Project: my-app │ $ tm autopilot --executor-mode │
│ Branch: analytics/task-42 │ > Running subtask 42.2 GREEN... │
│ Tag: analytics │ > Implementing endpoint... │
│ │ > Tests: 3 passed, 0 failed │
│ Tasks: │ > Ready to commit │
│ → 42 [in-progress] User metrics │ │
│ → 42.1 [done] Schema │ [Live output from executor] │
│ → 42.2 [active] Endpoint ◀ │ │
│ → 42.3 [pending] Dashboard │ │
│ │ │
│ [s] start [p] pause [q] quit │ │
└──────────────────────────────────┴─────────────────────────────────┘
```
**Implementation:**
**TUI Navigator** (`apps/cli/src/ui/tui/navigator.ts`):
```typescript
import blessed from 'blessed'
class AutopilotTUI {
private screen: blessed.Widgets.Screen
private taskList: blessed.Widgets.ListElement
private statusBox: blessed.Widgets.BoxElement
private executorPane: string // tmux pane ID
async start(taskId?: string) {
// Create blessed screen
this.screen = blessed.screen()
// Create task list widget
this.taskList = blessed.list({
label: 'Tasks',
keys: true,
vi: true,
style: { selected: { bg: 'blue' } }
})
// Spawn tmux pane for executor
this.executorPane = await this.spawnExecutorPane()
// Watch state file for updates
this.watchStateFile()
// Handle keybindings
this.setupKeybindings()
}
private async spawnExecutorPane(): Promise<string> {
const paneId = await exec('tmux split-window -h -P -F "#{pane_id}"')
await exec(`tmux send-keys -t ${paneId} "tm autopilot --executor-mode" Enter`)
return paneId.trim()
}
private watchStateFile() {
watch('.taskmaster/state/current-run.json', (event, filename) => {
this.updateDisplay()
})
}
private setupKeybindings() {
this.screen.key(['s'], () => this.startTask())
this.screen.key(['p'], () => this.pauseTask())
this.screen.key(['q'], () => this.quit())
this.screen.key(['up', 'down'], () => this.navigateTasks())
}
}
```
**Executor Mode:**
```bash
$ tm autopilot 42 --executor-mode
# Runs in executor pane, writes state to shared file
# Left pane reads state file and updates display
```
**State File** (`.taskmaster/state/current-run.json`):
```json
{
"runId": "2025-01-15-142033",
"taskId": "42",
"status": "running",
"currentPhase": "green",
"currentSubtask": "42.2",
"lastOutput": "Implementing endpoint...",
"testsStatus": {
"passed": 3,
"failed": 0
}
}
```
### 4. Extension API for IDE Integration
**State-based API:**
Expose run state via JSON files that IDEs can read:
- `.taskmaster/state/current-run.json` - live run state
- `.taskmaster/reports/runs/<runId>/manifest.json` - run metadata
- `.taskmaster/reports/runs/<runId>/log.jsonl` - event stream
**WebSocket API (optional):**
```typescript
// packages/tm-core/src/services/autopilot-server.ts
class AutopilotServer {
private wss: WebSocketServer
start(port: number = 7890) {
this.wss = new WebSocketServer({ port })
this.wss.on('connection', (ws) => {
// Send current state
ws.send(JSON.stringify(this.getCurrentState()))
// Stream events
this.orchestrator.on('*', (event) => {
ws.send(JSON.stringify(event))
})
})
}
}
```
**Usage from IDE extension:**
```typescript
// VS Code extension example
const ws = new WebSocket('ws://localhost:7890')
ws.on('message', (data) => {
const event = JSON.parse(data)
if (event.type === 'subtask:complete') {
vscode.window.showInformationMessage(
`Subtask ${event.subtaskId} completed`
)
}
})
```
### 5. Parallel Subtask Execution (Experimental)
**Dependency Analysis:**
```typescript
class SubtaskScheduler {
async buildDependencyGraph(subtasks: Subtask[]): Promise<DAG> {
const graph = new DAG()
for (const subtask of subtasks) {
graph.addNode(subtask.id)
for (const depId of subtask.dependencies) {
graph.addEdge(depId, subtask.id)
}
}
return graph
}
async getParallelBatches(graph: DAG): Promise<Subtask[][]> {
const batches: Subtask[][] = []
const completed = new Set<string>()
while (completed.size < graph.size()) {
const ready = graph.nodes.filter(node =>
!completed.has(node.id) &&
node.dependencies.every(dep => completed.has(dep))
)
batches.push(ready)
ready.forEach(node => completed.add(node.id))
}
return batches
}
}
```
**Parallel Execution:**
```bash
$ tm autopilot 42 --parallel
[Batch 1] Running 2 subtasks in parallel:
→ 42.1: Add metrics schema
→ 42.4: Add API documentation
42.1 RED ✓ Tests created
42.4 RED ✓ Tests created
42.1 GREEN ✓ Implementation complete
42.4 GREEN ✓ Implementation complete
42.1 COMMIT ✓ Committed: a1b2c3d
42.4 COMMIT ✓ Committed: e5f6g7h
[Batch 2] Running 2 subtasks in parallel (depend on 42.1):
→ 42.2: Add collection endpoint
→ 42.3: Add dashboard widget
...
```
**Conflict Detection:**
```typescript
async function detectConflicts(subtasks: Subtask[]): Promise<Conflict[]> {
const conflicts: Conflict[] = []
for (let i = 0; i < subtasks.length; i++) {
for (let j = i + 1; j < subtasks.length; j++) {
const filesA = await predictAffectedFiles(subtasks[i])
const filesB = await predictAffectedFiles(subtasks[j])
const overlap = filesA.filter(f => filesB.includes(f))
if (overlap.length > 0) {
conflicts.push({
subtasks: [subtasks[i].id, subtasks[j].id],
files: overlap
})
}
}
}
return conflicts
}
```
### 6. Advanced Configuration
**Add to `.taskmaster/config.json`:**
```json
{
"autopilot": {
"safety": {
"previewDiffs": false,
"maxChangeLinesPerFile": 100,
"warnOnLargeChanges": true,
"requireConfirmOnLargeChanges": true
},
"parallel": {
"enabled": false,
"maxConcurrent": 3,
"detectConflicts": true
},
"tui": {
"enabled": false,
"tmuxSession": "taskmaster-autopilot"
},
"api": {
"enabled": false,
"port": 7890,
"allowRemote": false
}
},
"test": {
"frameworks": {
"python": {
"runner": "pytest",
"coverageCommand": "pytest --cov",
"testPattern": "**/test_*.py"
},
"go": {
"runner": "go test",
"coverageCommand": "go test ./... -coverprofile=coverage.out",
"testPattern": "**/*_test.go"
}
}
}
}
```
## CLI Updates
**New commands:**
```bash
tm autopilot <taskId> --tui # Launch TUI interface
tm autopilot <taskId> --parallel # Enable parallel execution
tm autopilot <taskId> --preview-diffs # Show diffs before applying
tm autopilot <taskId> --executor-mode # Run as executor pane
tm autopilot-server start # Start WebSocket API
```
## Success Criteria
- Supports Python projects with pytest
- Supports Go projects with go test
- Diff preview prevents unwanted changes
- TUI provides better visibility for long-running tasks
- IDE extensions can integrate via state files or WebSocket
- Parallel execution reduces total time for independent subtasks
## Out of Scope
- Full Electron/web GUI
- AI executor selection UI (defer to Phase 4)
- Multi-repository support
- Remote execution on cloud runners
## Testing Strategy
- Test with Python project (pytest)
- Test with Go project (go test)
- Test diff preview UI with mock changes
- Test parallel execution with independent subtasks
- Test conflict detection with overlapping file changes
- Test TUI with mock tmux environment
## Dependencies
- Phase 2 completed (PR + resumability)
- tmux installed (for TUI)
- blessed or ink library (for TUI rendering)
## Estimated Effort
3-4 weeks
## Risks & Mitigations
- **Risk:** Parallel execution causes git conflicts
- **Mitigation:** Conservative conflict detection, sequential fallback
- **Risk:** TUI adds complexity and maintenance burden
- **Mitigation:** Keep TUI optional, state-based design allows alternatives
- **Risk:** Framework adapters hard to maintain across versions
- **Mitigation:** Abstract common parsing logic, document adapter interface
- **Risk:** Diff preview slows down workflow
- **Mitigation:** Make optional, use --preview-diffs flag only when needed
## Validation
Test with:
- Python project with pytest and pytest-cov
- Go project with go test
- Large changes requiring confirmation
- Parallel execution with 3+ independent subtasks
- TUI with task selection and live status updates
- VS Code extension reading state files
```