demo
/
clean-tracks
1
0
Fork 0
Code Issues 13 Pull Requests Packages Projects Releases Wiki Activity

Initial commit: Clean-Tracks audio censorship project setup 

- Created project structure with src/, data/, tests/, docs/ directories
- Initialized Task Master with 25 comprehensive tasks from PRD
- Set up Python requirements with audio processing dependencies
- Added Flask web framework and CLI structure
- Configured development environment with .env.example
- Created comprehensive README with project overview
- Added .gitignore for Python/audio files

Project ready for development with Task Master tracking
This commit is contained in:
S 2025-08-18 18:39:09 -04:00
commit 7440cbda66
16 changed files with 2112 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
.cursor/mcp.json Normal file
View File

@ -0,0 +1,19 @@
{
"mcpServers": {
"task-master-ai": {
"command": "npx",
"args": ["-y", "--package=task-master-ai", "task-master-ai"],
"env": {
"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
"OPENAI_API_KEY": "YOUR_OPENAI_KEY_HERE",
"GOOGLE_API_KEY": "YOUR_GOOGLE_KEY_HERE",
"XAI_API_KEY": "YOUR_XAI_KEY_HERE",
"OPENROUTER_API_KEY": "YOUR_OPENROUTER_KEY_HERE",
"MISTRAL_API_KEY": "YOUR_MISTRAL_KEY_HERE",
"AZURE_OPENAI_API_KEY": "YOUR_AZURE_KEY_HERE",
"OLLAMA_API_KEY": "YOUR_OLLAMA_API_KEY_HERE"
}
}
}
}

53
.cursor/rules/cursor_rules.mdc Normal file
View File

@ -0,0 +1,53 @@
---
description: Guidelines for creating and maintaining Cursor rules to ensure consistency and effectiveness.
globs: .cursor/rules/*.mdc
alwaysApply: true
---
- **Required Rule Structure:**
```markdown
---
description: Clear, one-line description of what the rule enforces
globs: path/to/files/*.ext, other/path/**/*
alwaysApply: boolean
---
- **Main Points in Bold**
- Sub-points with details
- Examples and explanations
```
- **File References:**
- Use `[filename](mdc:path/to/file)` ([filename](mdc:filename)) to reference files
- Example: [prisma.mdc](mdc:.cursor/rules/prisma.mdc) for rule references
- Example: [schema.prisma](mdc:prisma/schema.prisma) for code references
- **Code Examples:**
- Use language-specific code blocks
```typescript
// ✅ DO: Show good examples
const goodExample = true;
// ❌ DON'T: Show anti-patterns
const badExample = false;
```
- **Rule Content Guidelines:**
- Start with high-level overview
- Include specific, actionable requirements
- Show examples of correct implementation
- Reference existing code when possible
- Keep rules DRY by referencing other rules
- **Rule Maintenance:**
- Update rules when new patterns emerge
- Add examples from actual codebase
- Remove outdated patterns
- Cross-reference related rules
- **Best Practices:**
- Use bullet points for clarity
- Keep descriptions concise
- Include both DO and DON'T examples
- Reference actual code over theoretical examples
- Use consistent formatting across rules

72
.cursor/rules/self_improve.mdc Normal file
View File

@ -0,0 +1,72 @@
---
description: Guidelines for continuously improving Cursor rules based on emerging code patterns and best practices.
globs: **/*
alwaysApply: true
---
- **Rule Improvement Triggers:**
- New code patterns not covered by existing rules
- Repeated similar implementations across files
- Common error patterns that could be prevented
- New libraries or tools being used consistently
- Emerging best practices in the codebase
- **Analysis Process:**
- Compare new code with existing rules
- Identify patterns that should be standardized
- Look for references to external documentation
- Check for consistent error handling patterns
- Monitor test patterns and coverage
- **Rule Updates:**
- **Add New Rules When:**
- A new technology/pattern is used in 3+ files
- Common bugs could be prevented by a rule
- Code reviews repeatedly mention the same feedback
- New security or performance patterns emerge
- **Modify Existing Rules When:**
- Better examples exist in the codebase
- Additional edge cases are discovered
- Related rules have been updated
- Implementation details have changed
- **Example Pattern Recognition:**
```typescript
// If you see repeated patterns like:
const data = await prisma.user.findMany({
select: { id: true, email: true },
where: { status: 'ACTIVE' }
});
// Consider adding to [prisma.mdc](mdc:.cursor/rules/prisma.mdc):
// - Standard select fields
// - Common where conditions
// - Performance optimization patterns
```
- **Rule Quality Checks:**
- Rules should be actionable and specific
- Examples should come from actual code
- References should be up to date
- Patterns should be consistently enforced
- **Continuous Improvement:**
- Monitor code review comments
- Track common development questions
- Update rules after major refactors
- Add links to relevant documentation
- Cross-reference related rules
- **Rule Deprecation:**
- Mark outdated patterns as deprecated
- Remove rules that no longer apply
- Update references to deprecated rules
- Document migration paths for old patterns
- **Documentation Updates:**
- Keep examples synchronized with code
- Update references to external docs
- Maintain links between related rules
- Document breaking changes
Follow [cursor_rules.mdc](mdc:.cursor/rules/cursor_rules.mdc) for proper rule formatting and structure.

424
.cursor/rules/taskmaster/dev_workflow.mdc Normal file
View File

@ -0,0 +1,424 @@
---
description: Guide for using Taskmaster to manage task-driven development workflows
globs: **/*
alwaysApply: true
---
# Taskmaster Development Workflow
This guide outlines the standard process for using Taskmaster to manage software development projects. It is written as a set of instructions for you, the AI agent.
- **Your Default Stance**: For most projects, the user can work directly within the `master` task context. Your initial actions should operate on this default context unless a clear pattern for multi-context work emerges.
- **Your Goal**: Your role is to elevate the user's workflow by intelligently introducing advanced features like **Tagged Task Lists** when you detect the appropriate context. Do not force tags on the user; suggest them as a helpful solution to a specific need.
## The Basic Loop
The fundamental development cycle you will facilitate is:
1. **`list`**: Show the user what needs to be done.
2. **`next`**: Help the user decide what to work on.
3. **`show <id>`**: Provide details for a specific task.
4. **`expand <id>`**: Break down a complex task into smaller, manageable subtasks.
5. **Implement**: The user writes the code and tests.
6. **`update-subtask`**: Log progress and findings on behalf of the user.
7. **`set-status`**: Mark tasks and subtasks as `done` as work is completed.
8. **Repeat**.
All your standard command executions should operate on the user's current task context, which defaults to `master`.
---
## Standard Development Workflow Process
### Simple Workflow (Default Starting Point)
For new projects or when users are getting started, operate within the `master` tag context:
- Start new projects by running `initialize_project` tool / `task-master init` or `parse_prd` / `task-master parse-prd --input='<prd-file.txt>'` (see @`taskmaster.mdc`) to generate initial tasks.json with tagged structure
- Configure rule sets during initialization with `--rules` flag (e.g., `task-master init --rules cursor,windsurf`) or manage them later with `task-master rules add/remove` commands
- Begin coding sessions with `get_tasks` / `task-master list` (see @`taskmaster.mdc`) to see current tasks, status, and IDs
- Determine the next task to work on using `next_task` / `task-master next` (see @`taskmaster.mdc`)
- Analyze task complexity with `analyze_project_complexity` / `task-master analyze-complexity --research` (see @`taskmaster.mdc`) before breaking down tasks
- Review complexity report using `complexity_report` / `task-master complexity-report` (see @`taskmaster.mdc`)
- Select tasks based on dependencies (all marked 'done'), priority level, and ID order
- View specific task details using `get_task` / `task-master show <id>` (see @`taskmaster.mdc`) to understand implementation requirements
- Break down complex tasks using `expand_task` / `task-master expand --id=<id> --force --research` (see @`taskmaster.mdc`) with appropriate flags like `--force` (to replace existing subtasks) and `--research`
- Implement code following task details, dependencies, and project standards
- Mark completed tasks with `set_task_status` / `task-master set-status --id=<id> --status=done` (see @`taskmaster.mdc`)
- Update dependent tasks when implementation differs from original plan using `update` / `task-master update --from=<id> --prompt="..."` or `update_task` / `task-master update-task --id=<id> --prompt="..."` (see @`taskmaster.mdc`)
---
## Leveling Up: Agent-Led Multi-Context Workflows
While the basic workflow is powerful, your primary opportunity to add value is by identifying when to introduce **Tagged Task Lists**. These patterns are your tools for creating a more organized and efficient development environment for the user, especially if you detect agentic or parallel development happening across the same session.
**Critical Principle**: Most users should never see a difference in their experience. Only introduce advanced workflows when you detect clear indicators that the project has evolved beyond simple task management.
### When to Introduce Tags: Your Decision Patterns
Here are the patterns to look for. When you detect one, you should propose the corresponding workflow to the user.
#### Pattern 1: Simple Git Feature Branching
This is the most common and direct use case for tags.
- **Trigger**: The user creates a new git branch (e.g., `git checkout -b feature/user-auth`).
- **Your Action**: Propose creating a new tag that mirrors the branch name to isolate the feature's tasks from `master`.
- **Your Suggested Prompt**: *"I see you've created a new branch named 'feature/user-auth'. To keep all related tasks neatly organized and separate from your main list, I can create a corresponding task tag for you. This helps prevent merge conflicts in your `tasks.json` file later. Shall I create the 'feature-user-auth' tag?"*
- **Tool to Use**: `task-master add-tag --from-branch`
#### Pattern 2: Team Collaboration
- **Trigger**: The user mentions working with teammates (e.g., "My teammate Alice is handling the database schema," or "I need to review Bob's work on the API.").
- **Your Action**: Suggest creating a separate tag for the user's work to prevent conflicts with shared master context.
- **Your Suggested Prompt**: *"Since you're working with Alice, I can create a separate task context for your work to avoid conflicts. This way, Alice can continue working with the master list while you have your own isolated context. When you're ready to merge your work, we can coordinate the tasks back to master. Shall I create a tag for your current work?"*
- **Tool to Use**: `task-master add-tag my-work --copy-from-current --description="My tasks while collaborating with Alice"`
#### Pattern 3: Experiments or Risky Refactors
- **Trigger**: The user wants to try something that might not be kept (e.g., "I want to experiment with switching our state management library," or "Let's refactor the old API module, but I want to keep the current tasks as a reference.").
- **Your Action**: Propose creating a sandboxed tag for the experimental work.
- **Your Suggested Prompt**: *"This sounds like a great experiment. To keep these new tasks separate from our main plan, I can create a temporary 'experiment-zustand' tag for this work. If we decide not to proceed, we can simply delete the tag without affecting the main task list. Sound good?"*
- **Tool to Use**: `task-master add-tag experiment-zustand --description="Exploring Zustand migration"`
#### Pattern 4: Large Feature Initiatives (PRD-Driven)
This is a more structured approach for significant new features or epics.
- **Trigger**: The user describes a large, multi-step feature that would benefit from a formal plan.
- **Your Action**: Propose a comprehensive, PRD-driven workflow.
- **Your Suggested Prompt**: *"This sounds like a significant new feature. To manage this effectively, I suggest we create a dedicated task context for it. Here's the plan: I'll create a new tag called 'feature-xyz', then we can draft a Product Requirements Document (PRD) together to scope the work. Once the PRD is ready, I'll automatically generate all the necessary tasks within that new tag. How does that sound?"*
- **Your Implementation Flow**:
1. **Create an empty tag**: `task-master add-tag feature-xyz --description "Tasks for the new XYZ feature"`. You can also start by creating a git branch if applicable, and then create the tag from that branch.
2. **Collaborate & Create PRD**: Work with the user to create a detailed PRD file (e.g., `.taskmaster/docs/feature-xyz-prd.txt`).
3. **Parse PRD into the new tag**: `task-master parse-prd .taskmaster/docs/feature-xyz-prd.txt --tag feature-xyz`
4. **Prepare the new task list**: Follow up by suggesting `analyze-complexity` and `expand-all` for the newly created tasks within the `feature-xyz` tag.
#### Pattern 5: Version-Based Development
Tailor your approach based on the project maturity indicated by tag names.
- **Prototype/MVP Tags** (`prototype`, `mvp`, `poc`, `v0.x`):
- **Your Approach**: Focus on speed and functionality over perfection
- **Task Generation**: Create tasks that emphasize "get it working" over "get it perfect"
- **Complexity Level**: Lower complexity, fewer subtasks, more direct implementation paths
- **Research Prompts**: Include context like "This is a prototype - prioritize speed and basic functionality over optimization"
- **Example Prompt Addition**: *"Since this is for the MVP, I'll focus on tasks that get core functionality working quickly rather than over-engineering."*
- **Production/Mature Tags** (`v1.0+`, `production`, `stable`):
- **Your Approach**: Emphasize robustness, testing, and maintainability
- **Task Generation**: Include comprehensive error handling, testing, documentation, and optimization
- **Complexity Level**: Higher complexity, more detailed subtasks, thorough implementation paths
- **Research Prompts**: Include context like "This is for production - prioritize reliability, performance, and maintainability"
- **Example Prompt Addition**: *"Since this is for production, I'll ensure tasks include proper error handling, testing, and documentation."*
### Advanced Workflow (Tag-Based & PRD-Driven)
**When to Transition**: Recognize when the project has evolved (or has initiated a project which existing code) beyond simple task management. Look for these indicators:
- User mentions teammates or collaboration needs
- Project has grown to 15+ tasks with mixed priorities
- User creates feature branches or mentions major initiatives
- User initializes Taskmaster on an existing, complex codebase
- User describes large features that would benefit from dedicated planning
**Your Role in Transition**: Guide the user to a more sophisticated workflow that leverages tags for organization and PRDs for comprehensive planning.
#### Master List Strategy (High-Value Focus)
Once you transition to tag-based workflows, the `master` tag should ideally contain only:
- **High-level deliverables** that provide significant business value
- **Major milestones** and epic-level features
- **Critical infrastructure** work that affects the entire project
- **Release-blocking** items
**What NOT to put in master**:
- Detailed implementation subtasks (these go in feature-specific tags' parent tasks)
- Refactoring work (create dedicated tags like `refactor-auth`)
- Experimental features (use `experiment-*` tags)
- Team member-specific tasks (use person-specific tags)
#### PRD-Driven Feature Development
**For New Major Features**:
1. **Identify the Initiative**: When user describes a significant feature
2. **Create Dedicated Tag**: `add_tag feature-[name] --description="[Feature description]"`
3. **Collaborative PRD Creation**: Work with user to create comprehensive PRD in `.taskmaster/docs/feature-[name]-prd.txt`
4. **Parse & Prepare**:
- `parse_prd .taskmaster/docs/feature-[name]-prd.txt --tag=feature-[name]`
- `analyze_project_complexity --tag=feature-[name] --research`
- `expand_all --tag=feature-[name] --research`
5. **Add Master Reference**: Create a high-level task in `master` that references the feature tag
**For Existing Codebase Analysis**:
When users initialize Taskmaster on existing projects:
1. **Codebase Discovery**: Use your native tools for producing deep context about the code base. You may use `research` tool with `--tree` and `--files` to collect up to date information using the existing architecture as context.
2. **Collaborative Assessment**: Work with user to identify improvement areas, technical debt, or new features
3. **Strategic PRD Creation**: Co-author PRDs that include:
- Current state analysis (based on your codebase research)
- Proposed improvements or new features
- Implementation strategy considering existing code
4. **Tag-Based Organization**: Parse PRDs into appropriate tags (`refactor-api`, `feature-dashboard`, `tech-debt`, etc.)
5. **Master List Curation**: Keep only the most valuable initiatives in master
The parse-prd's `--append` flag enables the user to parse multiple PRDs within tags or across tags. PRDs should be focused and the number of tasks they are parsed into should be strategically chosen relative to the PRD's complexity and level of detail.
### Workflow Transition Examples
**Example 1: Simple → Team-Based**
```
User: "Alice is going to help with the API work"
Your Response: "Great! To avoid conflicts, I'll create a separate task context for your work. Alice can continue with the master list while you work in your own context. When you're ready to merge, we can coordinate the tasks back together."
Action: add_tag my-api-work --copy-from-current --description="My API tasks while collaborating with Alice"
```
**Example 2: Simple → PRD-Driven**
```
User: "I want to add a complete user dashboard with analytics, user management, and reporting"
Your Response: "This sounds like a major feature that would benefit from detailed planning. Let me create a dedicated context for this work and we can draft a PRD together to ensure we capture all requirements."
Actions:
1. add_tag feature-dashboard --description="User dashboard with analytics and management"
2. Collaborate on PRD creation
3. parse_prd dashboard-prd.txt --tag=feature-dashboard
4. Add high-level "User Dashboard" task to master
```
**Example 3: Existing Project → Strategic Planning**
```
User: "I just initialized Taskmaster on my existing React app. It's getting messy and I want to improve it."
Your Response: "Let me research your codebase to understand the current architecture, then we can create a strategic plan for improvements."
Actions:
1. research "Current React app architecture and improvement opportunities" --tree --files=src/
2. Collaborate on improvement PRD based on findings
3. Create tags for different improvement areas (refactor-components, improve-state-management, etc.)
4. Keep only major improvement initiatives in master
```
---
## Primary Interaction: MCP Server vs. CLI
Taskmaster offers two primary ways to interact:
1. **MCP Server (Recommended for Integrated Tools)**:
- For AI agents and integrated development environments (like Cursor), interacting via the **MCP server is the preferred method**.
- The MCP server exposes Taskmaster functionality through a set of tools (e.g., `get_tasks`, `add_subtask`).
- This method offers better performance, structured data exchange, and richer error handling compared to CLI parsing.
- Refer to @`mcp.mdc` for details on the MCP architecture and available tools.
- A comprehensive list and description of MCP tools and their corresponding CLI commands can be found in @`taskmaster.mdc`.
- **Restart the MCP server** if core logic in `scripts/modules` or MCP tool/direct function definitions change.
- **Note**: MCP tools fully support tagged task lists with complete tag management capabilities.
2. **`task-master` CLI (For Users & Fallback)**:
- The global `task-master` command provides a user-friendly interface for direct terminal interaction.
- It can also serve as a fallback if the MCP server is inaccessible or a specific function isn't exposed via MCP.
- Install globally with `npm install -g task-master-ai` or use locally via `npx task-master-ai ...`.
- The CLI commands often mirror the MCP tools (e.g., `task-master list` corresponds to `get_tasks`).
- Refer to @`taskmaster.mdc` for a detailed command reference.
- **Tagged Task Lists**: CLI fully supports the new tagged system with seamless migration.
## How the Tag System Works (For Your Reference)
- **Data Structure**: Tasks are organized into separate contexts (tags) like "master", "feature-branch", or "v2.0".
- **Silent Migration**: Existing projects automatically migrate to use a "master" tag with zero disruption.
- **Context Isolation**: Tasks in different tags are completely separate. Changes in one tag do not affect any other tag.
- **Manual Control**: The user is always in control. There is no automatic switching. You facilitate switching by using `use-tag <name>`.
- **Full CLI & MCP Support**: All tag management commands are available through both the CLI and MCP tools for you to use. Refer to @`taskmaster.mdc` for a full command list.
---
## Task Complexity Analysis
- Run `analyze_project_complexity` / `task-master analyze-complexity --research` (see @`taskmaster.mdc`) for comprehensive analysis
- Review complexity report via `complexity_report` / `task-master complexity-report` (see @`taskmaster.mdc`) for a formatted, readable version.
- Focus on tasks with highest complexity scores (8-10) for detailed breakdown
- Use analysis results to determine appropriate subtask allocation
- Note that reports are automatically used by the `expand_task` tool/command
## Task Breakdown Process
- Use `expand_task` / `task-master expand --id=<id>`. It automatically uses the complexity report if found, otherwise generates default number of subtasks.
- Use `--num=<number>` to specify an explicit number of subtasks, overriding defaults or complexity report recommendations.
- Add `--research` flag to leverage Perplexity AI for research-backed expansion.
- Add `--force` flag to clear existing subtasks before generating new ones (default is to append).
- Use `--prompt="<context>"` to provide additional context when needed.
- Review and adjust generated subtasks as necessary.
- Use `expand_all` tool or `task-master expand --all` to expand multiple pending tasks at once, respecting flags like `--force` and `--research`.
- If subtasks need complete replacement (regardless of the `--force` flag on `expand`), clear them first with `clear_subtasks` / `task-master clear-subtasks --id=<id>`.
## Implementation Drift Handling
- When implementation differs significantly from planned approach
- When future tasks need modification due to current implementation choices
- When new dependencies or requirements emerge
- Use `update` / `task-master update --from=<futureTaskId> --prompt='<explanation>\nUpdate context...' --research` to update multiple future tasks.
- Use `update_task` / `task-master update-task --id=<taskId> --prompt='<explanation>\nUpdate context...' --research` to update a single specific task.
## Task Status Management
- Use 'pending' for tasks ready to be worked on
- Use 'done' for completed and verified tasks
- Use 'deferred' for postponed tasks
- Add custom status values as needed for project-specific workflows
## Task Structure Fields
- **id**: Unique identifier for the task (Example: `1`, `1.1`)
- **title**: Brief, descriptive title (Example: `"Initialize Repo"`)
- **description**: Concise summary of what the task involves (Example: `"Create a new repository, set up initial structure."`)
- **status**: Current state of the task (Example: `"pending"`, `"done"`, `"deferred"`)
- **dependencies**: IDs of prerequisite tasks (Example: `[1, 2.1]`)
- Dependencies are displayed with status indicators (✅ for completed, ⏱️ for pending)
- This helps quickly identify which prerequisite tasks are blocking work
- **priority**: Importance level (Example: `"high"`, `"medium"`, `"low"`)
- **details**: In-depth implementation instructions (Example: `"Use GitHub client ID/secret, handle callback, set session token."`)
- **testStrategy**: Verification approach (Example: `"Deploy and call endpoint to confirm 'Hello World' response."`)
- **subtasks**: List of smaller, more specific tasks (Example: `[{"id": 1, "title": "Configure OAuth", ...}]`)
- Refer to task structure details (previously linked to `tasks.mdc`).
## Configuration Management (Updated)
Taskmaster configuration is managed through two main mechanisms:
1. **`.taskmaster/config.json` File (Primary):**
* Located in the project root directory.
* Stores most configuration settings: AI model selections (main, research, fallback), parameters (max tokens, temperature), logging level, default subtasks/priority, project name, etc.
* **Tagged System Settings**: Includes `global.defaultTag` (defaults to "master") and `tags` section for tag management configuration.
* **Managed via `task-master models --setup` command.** Do not edit manually unless you know what you are doing.
* **View/Set specific models via `task-master models` command or `models` MCP tool.**
* Created automatically when you run `task-master models --setup` for the first time or during tagged system migration.
2. **Environment Variables (`.env` / `mcp.json`):**
* Used **only** for sensitive API keys and specific endpoint URLs.
* Place API keys (one per provider) in a `.env` file in the project root for CLI usage.
* For MCP/Cursor integration, configure these keys in the `env` section of `.cursor/mcp.json`.
* Available keys/variables: See `assets/env.example` or the Configuration section in the command reference (previously linked to `taskmaster.mdc`).
3. **`.taskmaster/state.json` File (Tagged System State):**
* Tracks current tag context and migration status.
* Automatically created during tagged system migration.
* Contains: `currentTag`, `lastSwitched`, `migrationNoticeShown`.
**Important:** Non-API key settings (like model selections, `MAX_TOKENS`, `TASKMASTER_LOG_LEVEL`) are **no longer configured via environment variables**. Use the `task-master models` command (or `--setup` for interactive configuration) or the `models` MCP tool.
**If AI commands FAIL in MCP** verify that the API key for the selected provider is present in the `env` section of `.cursor/mcp.json`.
**If AI commands FAIL in CLI** verify that the API key for the selected provider is present in the `.env` file in the root of the project.
## Rules Management
Taskmaster supports multiple AI coding assistant rule sets that can be configured during project initialization or managed afterward:
- **Available Profiles**: Claude Code, Cline, Codex, Cursor, Roo Code, Trae, Windsurf (claude, cline, codex, cursor, roo, trae, windsurf)
- **During Initialization**: Use `task-master init --rules cursor,windsurf` to specify which rule sets to include
- **After Initialization**: Use `task-master rules add <profiles>` or `task-master rules remove <profiles>` to manage rule sets
- **Interactive Setup**: Use `task-master rules setup` to launch an interactive prompt for selecting rule profiles
- **Default Behavior**: If no `--rules` flag is specified during initialization, all available rule profiles are included
- **Rule Structure**: Each profile creates its own directory (e.g., `.cursor/rules`, `.roo/rules`) with appropriate configuration files
## Determining the Next Task
- Run `next_task` / `task-master next` to show the next task to work on.
- The command identifies tasks with all dependencies satisfied
- Tasks are prioritized by priority level, dependency count, and ID
- The command shows comprehensive task information including:
- Basic task details and description
- Implementation details
- Subtasks (if they exist)
- Contextual suggested actions
- Recommended before starting any new development work
- Respects your project's dependency structure
- Ensures tasks are completed in the appropriate sequence
- Provides ready-to-use commands for common task actions
## Viewing Specific Task Details
- Run `get_task` / `task-master show <id>` to view a specific task.
- Use dot notation for subtasks: `task-master show 1.2` (shows subtask 2 of task 1)
- Displays comprehensive information similar to the next command, but for a specific task
- For parent tasks, shows all subtasks and their current status
- For subtasks, shows parent task information and relationship
- Provides contextual suggested actions appropriate for the specific task
- Useful for examining task details before implementation or checking status
## Managing Task Dependencies
- Use `add_dependency` / `task-master add-dependency --id=<id> --depends-on=<id>` to add a dependency.
- Use `remove_dependency` / `task-master remove-dependency --id=<id> --depends-on=<id>` to remove a dependency.
- The system prevents circular dependencies and duplicate dependency entries
- Dependencies are checked for existence before being added or removed
- Task files are automatically regenerated after dependency changes
- Dependencies are visualized with status indicators in task listings and files
## Task Reorganization
- Use `move_task` / `task-master move --from=<id> --to=<id>` to move tasks or subtasks within the hierarchy
- This command supports several use cases:
- Moving a standalone task to become a subtask (e.g., `--from=5 --to=7`)
- Moving a subtask to become a standalone task (e.g., `--from=5.2 --to=7`)
- Moving a subtask to a different parent (e.g., `--from=5.2 --to=7.3`)
- Reordering subtasks within the same parent (e.g., `--from=5.2 --to=5.4`)
- Moving a task to a new, non-existent ID position (e.g., `--from=5 --to=25`)
- Moving multiple tasks at once using comma-separated IDs (e.g., `--from=10,11,12 --to=16,17,18`)
- The system includes validation to prevent data loss:
- Allows moving to non-existent IDs by creating placeholder tasks
- Prevents moving to existing task IDs that have content (to avoid overwriting)
- Validates source tasks exist before attempting to move them
- The system maintains proper parent-child relationships and dependency integrity
- Task files are automatically regenerated after the move operation
- This provides greater flexibility in organizing and refining your task structure as project understanding evolves
- This is especially useful when dealing with potential merge conflicts arising from teams creating tasks on separate branches. Solve these conflicts very easily by moving your tasks and keeping theirs.
## Iterative Subtask Implementation
Once a task has been broken down into subtasks using `expand_task` or similar methods, follow this iterative process for implementation:
1. **Understand the Goal (Preparation):**
* Use `get_task` / `task-master show <subtaskId>` (see @`taskmaster.mdc`) to thoroughly understand the specific goals and requirements of the subtask.
2. **Initial Exploration & Planning (Iteration 1):**
* This is the first attempt at creating a concrete implementation plan.
* Explore the codebase to identify the precise files, functions, and even specific lines of code that will need modification.
* Determine the intended code changes (diffs) and their locations.
* Gather *all* relevant details from this exploration phase.
3. **Log the Plan:**
* Run `update_subtask` / `task-master update-subtask --id=<subtaskId> --prompt='<detailed plan>'`.
* Provide the *complete and detailed* findings from the exploration phase in the prompt. Include file paths, line numbers, proposed diffs, reasoning, and any potential challenges identified. Do not omit details. The goal is to create a rich, timestamped log within the subtask's `details`.
4. **Verify the Plan:**
* Run `get_task` / `task-master show <subtaskId>` again to confirm that the detailed implementation plan has been successfully appended to the subtask's details.
5. **Begin Implementation:**
* Set the subtask status using `set_task_status` / `task-master set-status --id=<subtaskId> --status=in-progress`.
* Start coding based on the logged plan.
6. **Refine and Log Progress (Iteration 2+):**
* As implementation progresses, you will encounter challenges, discover nuances, or confirm successful approaches.
* **Before appending new information**: Briefly review the *existing* details logged in the subtask (using `get_task` or recalling from context) to ensure the update adds fresh insights and avoids redundancy.
* **Regularly** use `update_subtask` / `task-master update-subtask --id=<subtaskId> --prompt='<update details>\n- What worked...\n- What didn't work...'` to append new findings.
* **Crucially, log:**
* What worked ("fundamental truths" discovered).
* What didn't work and why (to avoid repeating mistakes).
* Specific code snippets or configurations that were successful.
* Decisions made, especially if confirmed with user input.
* Any deviations from the initial plan and the reasoning.
* The objective is to continuously enrich the subtask's details, creating a log of the implementation journey that helps the AI (and human developers) learn, adapt, and avoid repeating errors.
7. **Review & Update Rules (Post-Implementation):**
* Once the implementation for the subtask is functionally complete, review all code changes and the relevant chat history.
* Identify any new or modified code patterns, conventions, or best practices established during the implementation.
* Create new or update existing rules following internal guidelines (previously linked to `cursor_rules.mdc` and `self_improve.mdc`).
8. **Mark Task Complete:**
* After verifying the implementation and updating any necessary rules, mark the subtask as completed: `set_task_status` / `task-master set-status --id=<subtaskId> --status=done`.
9. **Commit Changes (If using Git):**
* Stage the relevant code changes and any updated/new rule files (`git add .`).
* Craft a comprehensive Git commit message summarizing the work done for the subtask, including both code implementation and any rule adjustments.
* Execute the commit command directly in the terminal (e.g., `git commit -m 'feat(module): Implement feature X for subtask <subtaskId>\n\n- Details about changes...\n- Updated rule Y for pattern Z'`).
* Consider if a Changeset is needed according to internal versioning guidelines (previously linked to `changeset.mdc`). If so, run `npm run changeset`, stage the generated file, and amend the commit or create a new one.
10. **Proceed to Next Subtask:**
* Identify the next subtask (e.g., using `next_task` / `task-master next`).
## Code Analysis & Refactoring Techniques
- **Top-Level Function Search**:
- Useful for understanding module structure or planning refactors.
- Use grep/ripgrep to find exported functions/constants:
`rg "export (async function|function|const) \w+"` or similar patterns.
- Can help compare functions between files during migrations or identify potential naming conflicts.
---
*This workflow provides a general guideline. Adapt it based on your specific project needs and team practices.*

558
.cursor/rules/taskmaster/taskmaster.mdc Normal file
View File

@ -0,0 +1,558 @@
---
description: Comprehensive reference for Taskmaster MCP tools and CLI commands.
globs: **/*
alwaysApply: true
---
# Taskmaster Tool & Command Reference
This document provides a detailed reference for interacting with Taskmaster, covering both the recommended MCP tools, suitable for integrations like Cursor, and the corresponding `task-master` CLI commands, designed for direct user interaction or fallback.
**Note:** For interacting with Taskmaster programmatically or via integrated tools, using the **MCP tools is strongly recommended** due to better performance, structured data, and error handling. The CLI commands serve as a user-friendly alternative and fallback.
**Important:** Several MCP tools involve AI processing... The AI-powered tools include `parse_prd`, `analyze_project_complexity`, `update_subtask`, `update_task`, `update`, `expand_all`, `expand_task`, and `add_task`.
**🏷️ Tagged Task Lists System:** Task Master now supports **tagged task lists** for multi-context task management. This allows you to maintain separate, isolated lists of tasks for different features, branches, or experiments. Existing projects are seamlessly migrated to use a default "master" tag. Most commands now support a `--tag <name>` flag to specify which context to operate on. If omitted, commands use the currently active tag.
---
## Initialization & Setup
### 1. Initialize Project (`init`)
* **MCP Tool:** `initialize_project`
* **CLI Command:** `task-master init [options]`
* **Description:** `Set up the basic Taskmaster file structure and configuration in the current directory for a new project.`
* **Key CLI Options:**
* `--name <name>`: `Set the name for your project in Taskmaster's configuration.`
* `--description <text>`: `Provide a brief description for your project.`
* `--version <version>`: `Set the initial version for your project, e.g., '0.1.0'.`
* `-y, --yes`: `Initialize Taskmaster quickly using default settings without interactive prompts.`
* **Usage:** Run this once at the beginning of a new project.
* **MCP Variant Description:** `Set up the basic Taskmaster file structure and configuration in the current directory for a new project by running the 'task-master init' command.`
* **Key MCP Parameters/Options:**
* `projectName`: `Set the name for your project.` (CLI: `--name <name>`)
* `projectDescription`: `Provide a brief description for your project.` (CLI: `--description <text>`)
* `projectVersion`: `Set the initial version for your project, e.g., '0.1.0'.` (CLI: `--version <version>`)
* `authorName`: `Author name.` (CLI: `--author <author>`)
* `skipInstall`: `Skip installing dependencies. Default is false.` (CLI: `--skip-install`)
* `addAliases`: `Add shell aliases tm and taskmaster. Default is false.` (CLI: `--aliases`)
* `yes`: `Skip prompts and use defaults/provided arguments. Default is false.` (CLI: `-y, --yes`)
* **Usage:** Run this once at the beginning of a new project, typically via an integrated tool like Cursor. Operates on the current working directory of the MCP server.
* **Important:** Once complete, you *MUST* parse a prd in order to generate tasks. There will be no tasks files until then. The next step after initializing should be to create a PRD using the example PRD in .taskmaster/templates/example_prd.txt.
* **Tagging:** Use the `--tag` option to parse the PRD into a specific, non-default tag context. If the tag doesn't exist, it will be created automatically. Example: `task-master parse-prd spec.txt --tag=new-feature`.
### 2. Parse PRD (`parse_prd`)
* **MCP Tool:** `parse_prd`
* **CLI Command:** `task-master parse-prd [file] [options]`
* **Description:** `Parse a Product Requirements Document, PRD, or text file with Taskmaster to automatically generate an initial set of tasks in tasks.json.`
* **Key Parameters/Options:**
* `input`: `Path to your PRD or requirements text file that Taskmaster should parse for tasks.` (CLI: `[file]` positional or `-i, --input <file>`)
* `output`: `Specify where Taskmaster should save the generated 'tasks.json' file. Defaults to '.taskmaster/tasks/tasks.json'.` (CLI: `-o, --output <file>`)
* `numTasks`: `Approximate number of top-level tasks Taskmaster should aim to generate from the document.` (CLI: `-n, --num-tasks <number>`)
* `force`: `Use this to allow Taskmaster to overwrite an existing 'tasks.json' without asking for confirmation.` (CLI: `-f, --force`)
* **Usage:** Useful for bootstrapping a project from an existing requirements document.
* **Notes:** Task Master will strictly adhere to any specific requirements mentioned in the PRD, such as libraries, database schemas, frameworks, tech stacks, etc., while filling in any gaps where the PRD isn't fully specified. Tasks are designed to provide the most direct implementation path while avoiding over-engineering.
* **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress. If the user does not have a PRD, suggest discussing their idea and then use the example PRD in `.taskmaster/templates/example_prd.txt` as a template for creating the PRD based on their idea, for use with `parse-prd`.
---
## AI Model Configuration
### 2. Manage Models (`models`)
* **MCP Tool:** `models`
* **CLI Command:** `task-master models [options]`
* **Description:** `View the current AI model configuration or set specific models for different roles (main, research, fallback). Allows setting custom model IDs for Ollama and OpenRouter.`
* **Key MCP Parameters/Options:**
* `setMain <model_id>`: `Set the primary model ID for task generation/updates.` (CLI: `--set-main <model_id>`)
* `setResearch <model_id>`: `Set the model ID for research-backed operations.` (CLI: `--set-research <model_id>`)
* `setFallback <model_id>`: `Set the model ID to use if the primary fails.` (CLI: `--set-fallback <model_id>`)
* `ollama <boolean>`: `Indicates the set model ID is a custom Ollama model.` (CLI: `--ollama`)
* `openrouter <boolean>`: `Indicates the set model ID is a custom OpenRouter model.` (CLI: `--openrouter`)
* `listAvailableModels <boolean>`: `If true, lists available models not currently assigned to a role.` (CLI: No direct equivalent; CLI lists available automatically)
* `projectRoot <string>`: `Optional. Absolute path to the project root directory.` (CLI: Determined automatically)
* **Key CLI Options:**
* `--set-main <model_id>`: `Set the primary model.`
* `--set-research <model_id>`: `Set the research model.`
* `--set-fallback <model_id>`: `Set the fallback model.`
* `--ollama`: `Specify that the provided model ID is for Ollama (use with --set-*).`
* `--openrouter`: `Specify that the provided model ID is for OpenRouter (use with --set-*). Validates against OpenRouter API.`
* `--bedrock`: `Specify that the provided model ID is for AWS Bedrock (use with --set-*).`
* `--setup`: `Run interactive setup to configure models, including custom Ollama/OpenRouter IDs.`
* **Usage (MCP):** Call without set flags to get current config. Use `setMain`, `setResearch`, or `setFallback` with a valid model ID to update the configuration. Use `listAvailableModels: true` to get a list of unassigned models. To set a custom model, provide the model ID and set `ollama: true` or `openrouter: true`.
* **Usage (CLI):** Run without flags to view current configuration and available models. Use set flags to update specific roles. Use `--setup` for guided configuration, including custom models. To set a custom model via flags, use `--set-<role>=<model_id>` along with either `--ollama` or `--openrouter`.
* **Notes:** Configuration is stored in `.taskmaster/config.json` in the project root. This command/tool modifies that file. Use `listAvailableModels` or `task-master models` to see internally supported models. OpenRouter custom models are validated against their live API. Ollama custom models are not validated live.
* **API note:** API keys for selected AI providers (based on their model) need to exist in the mcp.json file to be accessible in MCP context. The API keys must be present in the local .env file for the CLI to be able to read them.
* **Model costs:** The costs in supported models are expressed in dollars. An input/output value of 3 is $3.00. A value of 0.8 is $0.80.
* **Warning:** DO NOT MANUALLY EDIT THE .taskmaster/config.json FILE. Use the included commands either in the MCP or CLI format as needed. Always prioritize MCP tools when available and use the CLI as a fallback.
---
## Task Listing & Viewing
### 3. Get Tasks (`get_tasks`)
* **MCP Tool:** `get_tasks`
* **CLI Command:** `task-master list [options]`
* **Description:** `List your Taskmaster tasks, optionally filtering by status and showing subtasks.`
* **Key Parameters/Options:**
* `status`: `Show only Taskmaster tasks matching this status (or multiple statuses, comma-separated), e.g., 'pending' or 'done,in-progress'.` (CLI: `-s, --status <status>`)
* `withSubtasks`: `Include subtasks indented under their parent tasks in the list.` (CLI: `--with-subtasks`)
* `tag`: `Specify which tag context to list tasks from. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Get an overview of the project status, often used at the start of a work session.
### 4. Get Next Task (`next_task`)
* **MCP Tool:** `next_task`
* **CLI Command:** `task-master next [options]`
* **Description:** `Ask Taskmaster to show the next available task you can work on, based on status and completed dependencies.`
* **Key Parameters/Options:**
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* `tag`: `Specify which tag context to use. Defaults to the current active tag.` (CLI: `--tag <name>`)
* **Usage:** Identify what to work on next according to the plan.
### 5. Get Task Details (`get_task`)
* **MCP Tool:** `get_task`
* **CLI Command:** `task-master show [id] [options]`
* **Description:** `Display detailed information for one or more specific Taskmaster tasks or subtasks by ID.`
* **Key Parameters/Options:**
* `id`: `Required. The ID of the Taskmaster task (e.g., '15'), subtask (e.g., '15.2'), or a comma-separated list of IDs ('1,5,10.2') you want to view.` (CLI: `[id]` positional or `-i, --id <id>`)
* `tag`: `Specify which tag context to get the task(s) from. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Understand the full details for a specific task. When multiple IDs are provided, a summary table is shown.
* **CRITICAL INFORMATION** If you need to collect information from multiple tasks, use comma-separated IDs (i.e. 1,2,3) to receive an array of tasks. Do not needlessly get tasks one at a time if you need to get many as that is wasteful.
---
## Task Creation & Modification
### 6. Add Task (`add_task`)
* **MCP Tool:** `add_task`
* **CLI Command:** `task-master add-task [options]`
* **Description:** `Add a new task to Taskmaster by describing it; AI will structure it.`
* **Key Parameters/Options:**
* `prompt`: `Required. Describe the new task you want Taskmaster to create, e.g., "Implement user authentication using JWT".` (CLI: `-p, --prompt <text>`)
* `dependencies`: `Specify the IDs of any Taskmaster tasks that must be completed before this new one can start, e.g., '12,14'.` (CLI: `-d, --dependencies <ids>`)
* `priority`: `Set the priority for the new task: 'high', 'medium', or 'low'. Default is 'medium'.` (CLI: `--priority <priority>`)
* `research`: `Enable Taskmaster to use the research role for potentially more informed task creation.` (CLI: `-r, --research`)
* `tag`: `Specify which tag context to add the task to. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Quickly add newly identified tasks during development.
* **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
### 7. Add Subtask (`add_subtask`)
* **MCP Tool:** `add_subtask`
* **CLI Command:** `task-master add-subtask [options]`
* **Description:** `Add a new subtask to a Taskmaster parent task, or convert an existing task into a subtask.`
* **Key Parameters/Options:**
* `id` / `parent`: `Required. The ID of the Taskmaster task that will be the parent.` (MCP: `id`, CLI: `-p, --parent <id>`)
* `taskId`: `Use this if you want to convert an existing top-level Taskmaster task into a subtask of the specified parent.` (CLI: `-i, --task-id <id>`)
* `title`: `Required if not using taskId. The title for the new subtask Taskmaster should create.` (CLI: `-t, --title <title>`)
* `description`: `A brief description for the new subtask.` (CLI: `-d, --description <text>`)
* `details`: `Provide implementation notes or details for the new subtask.` (CLI: `--details <text>`)
* `dependencies`: `Specify IDs of other tasks or subtasks, e.g., '15' or '16.1', that must be done before this new subtask.` (CLI: `--dependencies <ids>`)
* `status`: `Set the initial status for the new subtask. Default is 'pending'.` (CLI: `-s, --status <status>`)
* `generate`: `Enable Taskmaster to regenerate markdown task files after adding the subtask.` (CLI: `--generate`)
* `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Break down tasks manually or reorganize existing tasks.
### 8. Update Tasks (`update`)
* **MCP Tool:** `update`
* **CLI Command:** `task-master update [options]`
* **Description:** `Update multiple upcoming tasks in Taskmaster based on new context or changes, starting from a specific task ID.`
* **Key Parameters/Options:**
* `from`: `Required. The ID of the first task Taskmaster should update. All tasks with this ID or higher that are not 'done' will be considered.` (CLI: `--from <id>`)
* `prompt`: `Required. Explain the change or new context for Taskmaster to apply to the tasks, e.g., "We are now using React Query instead of Redux Toolkit for data fetching".` (CLI: `-p, --prompt <text>`)
* `research`: `Enable Taskmaster to use the research role for more informed updates. Requires appropriate API key.` (CLI: `-r, --research`)
* `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Handle significant implementation changes or pivots that affect multiple future tasks. Example CLI: `task-master update --from='18' --prompt='Switching to React Query.\nNeed to refactor data fetching...'`
* **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
### 9. Update Task (`update_task`)
* **MCP Tool:** `update_task`
* **CLI Command:** `task-master update-task [options]`
* **Description:** `Modify a specific Taskmaster task by ID, incorporating new information or changes. By default, this replaces the existing task details.`
* **Key Parameters/Options:**
* `id`: `Required. The specific ID of the Taskmaster task, e.g., '15', you want to update.` (CLI: `-i, --id <id>`)
* `prompt`: `Required. Explain the specific changes or provide the new information Taskmaster should incorporate into this task.` (CLI: `-p, --prompt <text>`)
* `append`: `If true, appends the prompt content to the task's details with a timestamp, rather than replacing them. Behaves like update-subtask.` (CLI: `--append`)
* `research`: `Enable Taskmaster to use the research role for more informed updates. Requires appropriate API key.` (CLI: `-r, --research`)
* `tag`: `Specify which tag context the task belongs to. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Refine a specific task based on new understanding. Use `--append` to log progress without creating subtasks.
* **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
### 10. Update Subtask (`update_subtask`)
* **MCP Tool:** `update_subtask`
* **CLI Command:** `task-master update-subtask [options]`
* **Description:** `Append timestamped notes or details to a specific Taskmaster subtask without overwriting existing content. Intended for iterative implementation logging.`
* **Key Parameters/Options:**
* `id`: `Required. The ID of the Taskmaster subtask, e.g., '5.2', to update with new information.` (CLI: `-i, --id <id>`)
* `prompt`: `Required. The information, findings, or progress notes to append to the subtask's details with a timestamp.` (CLI: `-p, --prompt <text>`)
* `research`: `Enable Taskmaster to use the research role for more informed updates. Requires appropriate API key.` (CLI: `-r, --research`)
* `tag`: `Specify which tag context the subtask belongs to. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Log implementation progress, findings, and discoveries during subtask development. Each update is timestamped and appended to preserve the implementation journey.
* **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
### 11. Set Task Status (`set_task_status`)
* **MCP Tool:** `set_task_status`
* **CLI Command:** `task-master set-status [options]`
* **Description:** `Update the status of one or more Taskmaster tasks or subtasks, e.g., 'pending', 'in-progress', 'done'.`
* **Key Parameters/Options:**
* `id`: `Required. The ID(s) of the Taskmaster task(s) or subtask(s), e.g., '15', '15.2', or '16,17.1', to update.` (CLI: `-i, --id <id>`)
* `status`: `Required. The new status to set, e.g., 'done', 'pending', 'in-progress', 'review', 'cancelled'.` (CLI: `-s, --status <status>`)
* `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Mark progress as tasks move through the development cycle.
### 12. Remove Task (`remove_task`)
* **MCP Tool:** `remove_task`
* **CLI Command:** `task-master remove-task [options]`
* **Description:** `Permanently remove a task or subtask from the Taskmaster tasks list.`
* **Key Parameters/Options:**
* `id`: `Required. The ID of the Taskmaster task, e.g., '5', or subtask, e.g., '5.2', to permanently remove.` (CLI: `-i, --id <id>`)
* `yes`: `Skip the confirmation prompt and immediately delete the task.` (CLI: `-y, --yes`)
* `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Permanently delete tasks or subtasks that are no longer needed in the project.
* **Notes:** Use with caution as this operation cannot be undone. Consider using 'blocked', 'cancelled', or 'deferred' status instead if you just want to exclude a task from active planning but keep it for reference. The command automatically cleans up dependency references in other tasks.
---
## Task Structure & Breakdown
### 13. Expand Task (`expand_task`)
* **MCP Tool:** `expand_task`
* **CLI Command:** `task-master expand [options]`
* **Description:** `Use Taskmaster's AI to break down a complex task into smaller, manageable subtasks. Appends subtasks by default.`
* **Key Parameters/Options:**
* `id`: `The ID of the specific Taskmaster task you want to break down into subtasks.` (CLI: `-i, --id <id>`)
* `num`: `Optional: Suggests how many subtasks Taskmaster should aim to create. Uses complexity analysis/defaults otherwise.` (CLI: `-n, --num <number>`)
* `research`: `Enable Taskmaster to use the research role for more informed subtask generation. Requires appropriate API key.` (CLI: `-r, --research`)
* `prompt`: `Optional: Provide extra context or specific instructions to Taskmaster for generating the subtasks.` (CLI: `-p, --prompt <text>`)
* `force`: `Optional: If true, clear existing subtasks before generating new ones. Default is false (append).` (CLI: `--force`)
* `tag`: `Specify which tag context the task belongs to. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Generate a detailed implementation plan for a complex task before starting coding. Automatically uses complexity report recommendations if available and `num` is not specified.
* **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
### 14. Expand All Tasks (`expand_all`)
* **MCP Tool:** `expand_all`
* **CLI Command:** `task-master expand --all [options]` (Note: CLI uses the `expand` command with the `--all` flag)
* **Description:** `Tell Taskmaster to automatically expand all eligible pending/in-progress tasks based on complexity analysis or defaults. Appends subtasks by default.`
* **Key Parameters/Options:**
* `num`: `Optional: Suggests how many subtasks Taskmaster should aim to create per task.` (CLI: `-n, --num <number>`)
* `research`: `Enable research role for more informed subtask generation. Requires appropriate API key.` (CLI: `-r, --research`)
* `prompt`: `Optional: Provide extra context for Taskmaster to apply generally during expansion.` (CLI: `-p, --prompt <text>`)
* `force`: `Optional: If true, clear existing subtasks before generating new ones for each eligible task. Default is false (append).` (CLI: `--force`)
* `tag`: `Specify which tag context to expand. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Useful after initial task generation or complexity analysis to break down multiple tasks at once.
* **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
### 15. Clear Subtasks (`clear_subtasks`)
* **MCP Tool:** `clear_subtasks`
* **CLI Command:** `task-master clear-subtasks [options]`
* **Description:** `Remove all subtasks from one or more specified Taskmaster parent tasks.`
* **Key Parameters/Options:**
* `id`: `The ID(s) of the Taskmaster parent task(s) whose subtasks you want to remove, e.g., '15' or '16,18'. Required unless using 'all'.` (CLI: `-i, --id <ids>`)
* `all`: `Tell Taskmaster to remove subtasks from all parent tasks.` (CLI: `--all`)
* `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Used before regenerating subtasks with `expand_task` if the previous breakdown needs replacement.
### 16. Remove Subtask (`remove_subtask`)
* **MCP Tool:** `remove_subtask`
* **CLI Command:** `task-master remove-subtask [options]`
* **Description:** `Remove a subtask from its Taskmaster parent, optionally converting it into a standalone task.`
* **Key Parameters/Options:**
* `id`: `Required. The ID(s) of the Taskmaster subtask(s) to remove, e.g., '15.2' or '16.1,16.3'.` (CLI: `-i, --id <id>`)
* `convert`: `If used, Taskmaster will turn the subtask into a regular top-level task instead of deleting it.` (CLI: `-c, --convert`)
* `generate`: `Enable Taskmaster to regenerate markdown task files after removing the subtask.` (CLI: `--generate`)
* `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Delete unnecessary subtasks or promote a subtask to a top-level task.
### 17. Move Task (`move_task`)
* **MCP Tool:** `move_task`
* **CLI Command:** `task-master move [options]`
* **Description:** `Move a task or subtask to a new position within the task hierarchy.`
* **Key Parameters/Options:**
* `from`: `Required. ID of the task/subtask to move (e.g., "5" or "5.2"). Can be comma-separated for multiple tasks.` (CLI: `--from <id>`)
* `to`: `Required. ID of the destination (e.g., "7" or "7.3"). Must match the number of source IDs if comma-separated.` (CLI: `--to <id>`)
* `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Reorganize tasks by moving them within the hierarchy. Supports various scenarios like:
* Moving a task to become a subtask
* Moving a subtask to become a standalone task
* Moving a subtask to a different parent
* Reordering subtasks within the same parent
* Moving a task to a new, non-existent ID (automatically creates placeholders)
* Moving multiple tasks at once with comma-separated IDs
* **Validation Features:**
* Allows moving tasks to non-existent destination IDs (creates placeholder tasks)
* Prevents moving to existing task IDs that already have content (to avoid overwriting)
* Validates that source tasks exist before attempting to move them
* Maintains proper parent-child relationships
* **Example CLI:** `task-master move --from=5.2 --to=7.3` to move subtask 5.2 to become subtask 7.3.
* **Example Multi-Move:** `task-master move --from=10,11,12 --to=16,17,18` to move multiple tasks to new positions.
* **Common Use:** Resolving merge conflicts in tasks.json when multiple team members create tasks on different branches.
---
## Dependency Management
### 18. Add Dependency (`add_dependency`)
* **MCP Tool:** `add_dependency`
* **CLI Command:** `task-master add-dependency [options]`
* **Description:** `Define a dependency in Taskmaster, making one task a prerequisite for another.`
* **Key Parameters/Options:**
* `id`: `Required. The ID of the Taskmaster task that will depend on another.` (CLI: `-i, --id <id>`)
* `dependsOn`: `Required. The ID of the Taskmaster task that must be completed first, the prerequisite.` (CLI: `-d, --depends-on <id>`)
* `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <path>`)
* **Usage:** Establish the correct order of execution between tasks.
### 19. Remove Dependency (`remove_dependency`)
* **MCP Tool:** `remove_dependency`
* **CLI Command:** `task-master remove-dependency [options]`
* **Description:** `Remove a dependency relationship between two Taskmaster tasks.`
* **Key Parameters/Options:**
* `id`: `Required. The ID of the Taskmaster task you want to remove a prerequisite from.` (CLI: `-i, --id <id>`)
* `dependsOn`: `Required. The ID of the Taskmaster task that should no longer be a prerequisite.` (CLI: `-d, --depends-on <id>`)
* `tag`: `Specify which tag context to operate on. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Update task relationships when the order of execution changes.
### 20. Validate Dependencies (`validate_dependencies`)
* **MCP Tool:** `validate_dependencies`
* **CLI Command:** `task-master validate-dependencies [options]`
* **Description:** `Check your Taskmaster tasks for dependency issues (like circular references or links to non-existent tasks) without making changes.`
* **Key Parameters/Options:**
* `tag`: `Specify which tag context to validate. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Audit the integrity of your task dependencies.
### 21. Fix Dependencies (`fix_dependencies`)
* **MCP Tool:** `fix_dependencies`
* **CLI Command:** `task-master fix-dependencies [options]`
* **Description:** `Automatically fix dependency issues (like circular references or links to non-existent tasks) in your Taskmaster tasks.`
* **Key Parameters/Options:**
* `tag`: `Specify which tag context to fix dependencies in. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Clean up dependency errors automatically.
---
## Analysis & Reporting
### 22. Analyze Project Complexity (`analyze_project_complexity`)
* **MCP Tool:** `analyze_project_complexity`
* **CLI Command:** `task-master analyze-complexity [options]`
* **Description:** `Have Taskmaster analyze your tasks to determine their complexity and suggest which ones need to be broken down further.`
* **Key Parameters/Options:**
* `output`: `Where to save the complexity analysis report. Default is '.taskmaster/reports/task-complexity-report.json' (or '..._tagname.json' if a tag is used).` (CLI: `-o, --output <file>`)
* `threshold`: `The minimum complexity score (1-10) that should trigger a recommendation to expand a task.` (CLI: `-t, --threshold <number>`)
* `research`: `Enable research role for more accurate complexity analysis. Requires appropriate API key.` (CLI: `-r, --research`)
* `tag`: `Specify which tag context to analyze. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Used before breaking down tasks to identify which ones need the most attention.
* **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
### 23. View Complexity Report (`complexity_report`)
* **MCP Tool:** `complexity_report`
* **CLI Command:** `task-master complexity-report [options]`
* **Description:** `Display the task complexity analysis report in a readable format.`
* **Key Parameters/Options:**
* `tag`: `Specify which tag context to show the report for. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to the complexity report (default: '.taskmaster/reports/task-complexity-report.json').` (CLI: `-f, --file <file>`)
* **Usage:** Review and understand the complexity analysis results after running analyze-complexity.
---
## File Management
### 24. Generate Task Files (`generate`)
* **MCP Tool:** `generate`
* **CLI Command:** `task-master generate [options]`
* **Description:** `Create or update individual Markdown files for each task based on your tasks.json.`
* **Key Parameters/Options:**
* `output`: `The directory where Taskmaster should save the task files (default: in a 'tasks' directory).` (CLI: `-o, --output <directory>`)
* `tag`: `Specify which tag context to generate files for. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* **Usage:** Run this after making changes to tasks.json to keep individual task files up to date. This command is now manual and no longer runs automatically.
---
## AI-Powered Research
### 25. Research (`research`)
* **MCP Tool:** `research`
* **CLI Command:** `task-master research [options]`
* **Description:** `Perform AI-powered research queries with project context to get fresh, up-to-date information beyond the AI's knowledge cutoff.`
* **Key Parameters/Options:**
* `query`: `Required. Research query/prompt (e.g., "What are the latest best practices for React Query v5?").` (CLI: `[query]` positional or `-q, --query <text>`)
* `taskIds`: `Comma-separated list of task/subtask IDs from the current tag context (e.g., "15,16.2,17").` (CLI: `-i, --id <ids>`)
* `filePaths`: `Comma-separated list of file paths for context (e.g., "src/api.js,docs/readme.md").` (CLI: `-f, --files <paths>`)
* `customContext`: `Additional custom context text to include in the research.` (CLI: `-c, --context <text>`)
* `includeProjectTree`: `Include project file tree structure in context (default: false).` (CLI: `--tree`)
* `detailLevel`: `Detail level for the research response: 'low', 'medium', 'high' (default: medium).` (CLI: `--detail <level>`)
* `saveTo`: `Task or subtask ID (e.g., "15", "15.2") to automatically save the research conversation to.` (CLI: `--save-to <id>`)
* `saveFile`: `If true, saves the research conversation to a markdown file in '.taskmaster/docs/research/'.` (CLI: `--save-file`)
* `noFollowup`: `Disables the interactive follow-up question menu in the CLI.` (CLI: `--no-followup`)
* `tag`: `Specify which tag context to use for task-based context gathering. Defaults to the current active tag.` (CLI: `--tag <name>`)
* `projectRoot`: `The directory of the project. Must be an absolute path.` (CLI: Determined automatically)
* **Usage:** **This is a POWERFUL tool that agents should use FREQUENTLY** to:
* Get fresh information beyond knowledge cutoff dates
* Research latest best practices, library updates, security patches
* Find implementation examples for specific technologies
* Validate approaches against current industry standards
* Get contextual advice based on project files and tasks
* **When to Consider Using Research:**
* **Before implementing any task** - Research current best practices
* **When encountering new technologies** - Get up-to-date implementation guidance (libraries, apis, etc)
* **For security-related tasks** - Find latest security recommendations
* **When updating dependencies** - Research breaking changes and migration guides
* **For performance optimization** - Get current performance best practices
* **When debugging complex issues** - Research known solutions and workarounds
* **Research + Action Pattern:**
* Use `research` to gather fresh information
* Use `update_subtask` to commit findings with timestamps
* Use `update_task` to incorporate research into task details
* Use `add_task` with research flag for informed task creation
* **Important:** This MCP tool makes AI calls and can take up to a minute to complete. The research provides FRESH data beyond the AI's training cutoff, making it invaluable for current best practices and recent developments.
---
## Tag Management
This new suite of commands allows you to manage different task contexts (tags).
### 26. List Tags (`tags`)
* **MCP Tool:** `list_tags`
* **CLI Command:** `task-master tags [options]`
* **Description:** `List all available tags with task counts, completion status, and other metadata.`
* **Key Parameters/Options:**
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
* `--show-metadata`: `Include detailed metadata in the output (e.g., creation date, description).` (CLI: `--show-metadata`)
### 27. Add Tag (`add_tag`)
* **MCP Tool:** `add_tag`
* **CLI Command:** `task-master add-tag <tagName> [options]`
* **Description:** `Create a new, empty tag context, or copy tasks from another tag.`
* **Key Parameters/Options:**
* `tagName`: `Name of the new tag to create (alphanumeric, hyphens, underscores).` (CLI: `<tagName>` positional)
* `--from-branch`: `Creates a tag with a name derived from the current git branch, ignoring the <tagName> argument.` (CLI: `--from-branch`)
* `--copy-from-current`: `Copy tasks from the currently active tag to the new tag.` (CLI: `--copy-from-current`)
* `--copy-from <tag>`: `Copy tasks from a specific source tag to the new tag.` (CLI: `--copy-from <tag>`)
* `--description <text>`: `Provide an optional description for the new tag.` (CLI: `-d, --description <text>`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
### 28. Delete Tag (`delete_tag`)
* **MCP Tool:** `delete_tag`
* **CLI Command:** `task-master delete-tag <tagName> [options]`
* **Description:** `Permanently delete a tag and all of its associated tasks.`
* **Key Parameters/Options:**
* `tagName`: `Name of the tag to delete.` (CLI: `<tagName>` positional)
* `--yes`: `Skip the confirmation prompt.` (CLI: `-y, --yes`)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
### 29. Use Tag (`use_tag`)
* **MCP Tool:** `use_tag`
* **CLI Command:** `task-master use-tag <tagName>`
* **Description:** `Switch your active task context to a different tag.`
* **Key Parameters/Options:**
* `tagName`: `Name of the tag to switch to.` (CLI: `<tagName>` positional)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
### 30. Rename Tag (`rename_tag`)
* **MCP Tool:** `rename_tag`
* **CLI Command:** `task-master rename-tag <oldName> <newName>`
* **Description:** `Rename an existing tag.`
* **Key Parameters/Options:**
* `oldName`: `The current name of the tag.` (CLI: `<oldName>` positional)
* `newName`: `The new name for the tag.` (CLI: `<newName>` positional)
* `file`: `Path to your Taskmaster 'tasks.json' file. Default relies on auto-detection.` (CLI: `-f, --file <file>`)
### 31. Copy Tag (`copy_tag`)
* **MCP Tool:** `copy_tag`
* **CLI Command:** `task-master copy-tag <sourceName> <targetName> [options]`
* **Description:** `Copy an entire tag context, including all its tasks and metadata, to a new tag.`
* **Key Parameters/Options:**
* `sourceName`: `Name of the tag to copy from.` (CLI: `<sourceName>` positional)
* `targetName`: `Name of the new tag to create.` (CLI: `<targetName>` positional)
* `--description <text>`: `Optional description for the new tag.` (CLI: `-d, --description <text>`)
---
## Miscellaneous
### 32. Sync Readme (`sync-readme`) -- experimental
* **MCP Tool:** N/A
* **CLI Command:** `task-master sync-readme [options]`
* **Description:** `Exports your task list to your project's README.md file, useful for showcasing progress.`
* **Key Parameters/Options:**
* `status`: `Filter tasks by status (e.g., 'pending', 'done').` (CLI: `-s, --status <status>`)
* `withSubtasks`: `Include subtasks in the export.` (CLI: `--with-subtasks`)
* `tag`: `Specify which tag context to export from. Defaults to the current active tag.` (CLI: `--tag <name>`)
---
## Environment Variables Configuration (Updated)
Taskmaster primarily uses the **`.taskmaster/config.json`** file (in project root) for configuration (models, parameters, logging level, etc.), managed via `task-master models --setup`.
Environment variables are used **only** for sensitive API keys related to AI providers and specific overrides like the Ollama base URL:
* **API Keys (Required for corresponding provider):**
* `ANTHROPIC_API_KEY`
* `PERPLEXITY_API_KEY`
* `OPENAI_API_KEY`
* `GOOGLE_API_KEY`
* `MISTRAL_API_KEY`
* `AZURE_OPENAI_API_KEY` (Requires `AZURE_OPENAI_ENDPOINT` too)
* `OPENROUTER_API_KEY`
* `XAI_API_KEY`
* `OLLAMA_API_KEY` (Requires `OLLAMA_BASE_URL` too)
* **Endpoints (Optional/Provider Specific inside .taskmaster/config.json):**
* `AZURE_OPENAI_ENDPOINT`
* `OLLAMA_BASE_URL` (Default: `http://localhost:11434/api`)
**Set API keys** in your **`.env`** file in the project root (for CLI use) or within the `env` section of your **`.cursor/mcp.json`** file (for MCP/Cursor integration). All other settings (model choice, max tokens, temperature, log level, custom endpoints) are managed in `.taskmaster/config.json` via `task-master models` command or `models` MCP tool.
---
For details on how these commands fit into the development process, see the [dev_workflow.mdc](mdc:.cursor/rules/taskmaster/dev_workflow.mdc).

45
.env.example Normal file
View File

@ -0,0 +1,45 @@
# Flask Configuration
FLASK_APP=src.web.app
FLASK_ENV=development
SECRET_KEY=your-secret-key-here
DEBUG=True
# Server Configuration
HOST=0.0.0.0
PORT=5000
# Database
DATABASE_URL=sqlite:///data/clean_tracks.db
# Audio Processing
WHISPER_MODEL=base # tiny, base, small, medium, large
WHISPER_DEVICE=auto # cpu, cuda, auto
MAX_FILE_SIZE_MB=500
CHUNK_DURATION_SECONDS=1800 # 30 minutes
# Paths
UPLOAD_FOLDER=data/uploads
PROCESSED_FOLDER=data/processed
WORD_LISTS_FOLDER=data/word_lists
# Processing Options
DEFAULT_CENSORSHIP_STYLE=silence # silence, beep, white_noise
DEFAULT_BEEP_FREQUENCY=1000 # Hz
DEFAULT_SEVERITY_THRESHOLD=mild # mild, moderate, severe
# Performance
ENABLE_GPU=True
CACHE_ENABLED=True
REDIS_URL=redis://localhost:6379/0
# Security
MAX_CONTENT_LENGTH=524288000 # 500MB in bytes
ALLOWED_EXTENSIONS=mp3,wav,flac,m4a,ogg,aac,wma
# API Rate Limiting
RATELIMIT_ENABLED=True
RATELIMIT_DEFAULT=100 per hour
# Logging
LOG_LEVEL=INFO
LOG_FILE=clean_tracks.log

100
.gitignore vendored Normal file
View File

@ -0,0 +1,100 @@
# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
env/
venv/
ENV/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
# Virtual Environment
venv/
env/
ENV/
# IDE
.vscode/
.idea/
*.swp
*.swo
.DS_Store
# Project specific
data/uploads/*
data/processed/*
!data/uploads/.gitkeep
!data/processed/.gitkeep
*.mp3
*.wav
*.flac
*.m4a
*.ogg
!tests/fixtures/*.mp3
!tests/fixtures/*.wav
# Environment
.env
.env.local
*.log
# Database
*.db
*.sqlite
*.sqlite3
# Cache
.cache/
*.cache
# Testing
.coverage
htmlcov/
.pytest_cache/
.tox/
# Documentation
docs/_build/
# Temporary files
tmp/
temp/
*.tmp
# Logs
logs
npm-debug.log*
yarn-debug.log*
yarn-error.log*
dev-debug.log
# Dependency directories
node_modules/
# Environment variables
# Editor directories and files
.idea
.vscode
*.suo
*.ntvs*
*.njsproj
*.sln
*.sw?
# OS specific
# Task files
# tasks.json
# tasks/

37
.taskmaster/config.json Normal file
View File

@ -0,0 +1,37 @@
{
"models": {
"main": {
"provider": "anthropic",
"modelId": "claude-3-7-sonnet-20250219",
"maxTokens": 120000,
"temperature": 0.2
},
"research": {
"provider": "perplexity",
"modelId": "sonar-pro",
"maxTokens": 8700,
"temperature": 0.1
},
"fallback": {
"provider": "anthropic",
"modelId": "claude-3-7-sonnet-20250219",
"maxTokens": 120000,
"temperature": 0.2
}
},
"global": {
"logLevel": "info",
"debug": false,
"defaultNumTasks": 10,
"defaultSubtasks": 5,
"defaultPriority": "medium",
"projectName": "Taskmaster",
"ollamaBaseURL": "http://localhost:11434/api",
"bedrockBaseURL": "https://bedrock.us-east-1.amazonaws.com",
"responseLanguage": "English",
"defaultTag": "master",
"azureOpenaiBaseURL": "https://your-endpoint.openai.azure.com/",
"userId": "1234567890"
},
"claudeCode": {}
}

193
.taskmaster/docs/prd.txt Normal file
View File

@ -0,0 +1,193 @@
# Clean-Tracks Audio Censorship System - Product Requirements Document
## Executive Summary
Clean-Tracks is an intelligent audio processing tool that automatically detects and censors explicit content in audio files. It features both a user-friendly web interface and powerful command-line tools, leveraging OpenAI Whisper for accurate speech recognition.
## Project Goals
- Build a reliable audio censorship system that processes files in under 30% of their duration
- Create an intuitive web UI that allows users to process audio with minimal technical knowledge
- Provide customizable word lists that users can manage and control
- Support multiple audio formats (MP3, WAV, FLAC, M4A, OGG)
- Achieve 95%+ accuracy in explicit word detection
- Ensure WCAG AA accessibility compliance
## Target Users
1. Content Creators - Need to quickly clean podcast/video audio for wider distribution
2. Educators - Make educational content appropriate for classroom use
3. Parents - Clean music and media for family consumption
4. Media Professionals - Prepare content for broadcast standards
## Core Features
### 1. Audio Processing Engine
- Integrate OpenAI Whisper for speech-to-text with word-level timestamps
- Support multiple Whisper model sizes (tiny, base, small, medium, large)
- Process audio files up to 500MB
- Handle long-form content with intelligent chunking
- Preserve audio quality during processing
- Support GPU acceleration for faster processing
### 2. Word Detection System
- Implement exact and fuzzy word matching using Levenshtein distance
- Add phonetic matching for similar-sounding words
- Context-aware detection to reduce false positives
- Confidence scoring for each detection
- Support for multiple languages (initially English)
### 3. Censorship Methods
- Silence insertion (mute detected words)
- Beep tone generation (customizable frequency)
- White noise replacement
- Fade in/out transitions for smooth audio
- Reversible censorship with undo capability
### 4. Word List Management
- User-controlled explicit word lists
- Severity levels (mild, moderate, severe)
- Category organization (profanity, slurs, custom)
- Import/export functionality (CSV, JSON)
- Shareable community word lists
- Default word lists for common use cases
### 5. Web User Interface
- Drag-and-drop file upload with Dropzone.js
- Real-time processing progress with WebSocket updates
- Audio waveform visualization showing detected words
- Interactive word list management interface
- Mobile-responsive design with touch optimization
- First-time user onboarding with tutorial
- Before/after preview player
### 6. Command-Line Interface
- Process single files: clean-tracks process <file>
- Batch processing: clean-tracks batch <pattern>
- Word list management: clean-tracks words <command>
- Configuration: clean-tracks config <setting>
- Server mode: clean-tracks server
### 7. Batch Processing
- Queue management for multiple files
- Priority system for processing order
- Parallel processing capability
- Progress tracking for all jobs
- Automatic retry on failures
### 8. Performance & Optimization
- Result caching to avoid reprocessing
- GPU acceleration support
- Lazy loading for web interface
- CDN for static assets
- Code splitting for faster initial load
## Technical Requirements
### Backend Stack
- Python 3.11+ for core processing
- Flask web framework
- SQLAlchemy for database ORM
- OpenAI Whisper for transcription
- PyDub and FFmpeg for audio manipulation
- Librosa for audio analysis
- Socket.io for real-time updates
### Frontend Stack
- HTML5 with semantic markup
- Bootstrap 5 for responsive design
- Vanilla JavaScript with modern ES6+
- WaveSurfer.js for waveform visualization
- DataTables.js for word list management
- Dropzone.js for file uploads
### Infrastructure
- SQLite database for word lists and history
- Redis for caching (optional)
- Celery for background jobs (optional)
- Docker for containerization
- GitHub Actions for CI/CD
## User Experience Requirements
### Onboarding Flow
1. Welcome modal with 3-step visual guide
2. Sample audio file for testing
3. Interactive tooltip tour
4. Quick start guide
### Key User Journeys
1. Upload → Process → Review → Download (< 3 minutes)
2. Manage Word Lists → Add/Edit/Remove words
3. Configure Settings → Choose censorship style
4. Batch Process → Queue multiple files
### Design Principles
- Simplicity first - complex features hidden by default
- Visual feedback for all actions
- Clear error messages with solutions
- Progressive disclosure of advanced features
- Mobile-first responsive design
## Success Metrics
- Processing speed: < 30% of audio duration
- Detection accuracy: > 95%
- User task completion: > 90%
- Time to first success: < 3 minutes
- System uptime: 99.9%
- Page load time: < 2 seconds
- User satisfaction: > 4.5/5 stars
## Constraints & Limitations
- Initial release English-only
- Maximum file size: 500MB
- Requires FFmpeg installation
- Internet connection needed for first model download
- 4GB RAM minimum, 8GB recommended
## Security & Privacy
- All processing done locally (no cloud uploads)
- Optional incognito mode
- One-click data clearing
- No user tracking without consent
- Secure API with rate limiting
## Testing Requirements
- Unit tests for all components (pytest)
- Integration tests for API endpoints
- End-to-end tests with Playwright
- Visual regression testing
- Accessibility testing (WCAG AA)
- Performance benchmarking
- Cross-browser testing
## Documentation Needs
- User guide with screenshots
- API documentation with examples
- CLI command reference
- Word list management guide
- Deployment instructions
- Contributing guidelines
## Future Enhancements (Post-MVP)
- Multi-language support
- Cloud processing option
- Mobile native apps
- Real-time streaming audio processing
- AI-powered context understanding
- Collaborative word list editing
- Advanced analytics dashboard
- Plugin system for custom processors
## Project Timeline
- Week 1: Foundation and setup
- Week 2: Core engine development
- Week 3: Word list management
- Week 4: Web UI implementation
- Week 5: Advanced features
- Week 6: CLI and API
- Week 7: Testing and deployment
## Risks & Mitigation
- Whisper accuracy: Provide multiple model options
- Processing speed: Implement GPU support and caching
- Large file handling: Use chunking and streaming
- Browser compatibility: Progressive enhancement approach
- User adoption: Focus on intuitive UX and onboarding

6
.taskmaster/state.json Normal file
View File

@ -0,0 +1,6 @@
{
"currentTag": "master",
"lastSwitched": "2025-08-18T22:34:27.418Z",
"branchTagMapping": {},
"migrationNoticeShown": false
}

407
.taskmaster/tasks/tasks.json Normal file
View File

@ -0,0 +1,407 @@
{
"master": {
"tasks": [
{
"id": 1,
"title": "Setup Project Repository and Environment",
"description": "Initialize the project repository with Python 3.11+, set up virtual environment, and install core dependencies.",
"details": "1. Create a new GitHub repository named 'clean-tracks'\n2. Initialize Python project with Poetry or pip requirements\n3. Set up virtual environment with Python 3.11+\n4. Install core dependencies: Flask, SQLAlchemy, PyDub, FFmpeg, Librosa, Socket.io\n5. Create basic project structure with directories for backend, frontend, tests, and docs\n6. Configure .gitignore for Python, virtual environments, and IDE files\n7. Set up pre-commit hooks for code quality\n8. Create initial README.md with project overview",
"testStrategy": "Verify all dependencies install correctly and project structure is created. Run basic smoke tests to ensure environment is properly configured.",
"priority": "high",
"dependencies": [],
"status": "pending",
"subtasks": []
},
{
"id": 2,
"title": "Integrate OpenAI Whisper for Speech Recognition",
"description": "Implement the core speech recognition functionality using OpenAI Whisper with support for multiple model sizes.",
"details": "1. Install OpenAI Whisper and its dependencies\n2. Create a WhisperTranscriber class that handles:\n - Loading different model sizes (tiny, base, small, medium, large)\n - Transcribing audio with word-level timestamps\n - Handling model caching\n3. Implement model download functionality for first-time use\n4. Add GPU detection and acceleration if available\n5. Create a configuration system for model selection\n6. Implement intelligent chunking for long audio files\n7. Add error handling for transcription failures",
"testStrategy": "Test with sample audio files of varying lengths and qualities. Verify word-level timestamps accuracy. Measure transcription speed and memory usage across different model sizes.",
"priority": "high",
"dependencies": [
1
],
"status": "pending",
"subtasks": []
},
{
"id": 3,
"title": "Develop Audio Processing Core Engine",
"description": "Create the core audio processing engine that handles loading, manipulating, and saving audio files in multiple formats.",
"details": "1. Use PyDub and FFmpeg to create an AudioProcessor class\n2. Implement support for multiple formats (MP3, WAV, FLAC, M4A, OGG)\n3. Add functions for:\n - Loading audio files up to 500MB\n - Extracting audio properties (duration, channels, sample rate)\n - Splitting audio into chunks for processing\n - Recombining processed chunks\n - Saving processed audio with quality preservation\n4. Implement error handling for corrupt or unsupported files\n5. Add progress tracking for long operations",
"testStrategy": "Test with various audio formats and file sizes. Verify audio quality is preserved during processing. Measure processing speed and memory usage. Test with corrupt files to ensure proper error handling.",
"priority": "high",
"dependencies": [
1
],
"status": "pending",
"subtasks": []
},
{
"id": 4,
"title": "Implement Word Detection System",
"description": "Create a system to detect explicit words in transcribed text using exact, fuzzy, and phonetic matching techniques.",
"details": "1. Create a WordDetector class with the following features:\n - Exact word matching\n - Fuzzy matching using Levenshtein distance\n - Phonetic matching for similar-sounding words\n - Context-aware detection to reduce false positives\n2. Implement confidence scoring for each detection\n3. Add support for word boundaries and partial matches\n4. Create a detection result object with word, timestamp, confidence, and match type\n5. Optimize for performance with large word lists\n6. Add initial support for English language",
"testStrategy": "Test with various word lists and transcriptions. Measure accuracy, false positive rate, and false negative rate. Benchmark performance with large word lists. Test edge cases like homonyms and near-matches.",
"priority": "high",
"dependencies": [
2
],
"status": "pending",
"subtasks": []
},
{
"id": 5,
"title": "Develop Word List Management System",
"description": "Create a system for managing user-controlled explicit word lists with severity levels and categories.",
"details": "1. Design SQLite database schema for word lists\n2. Implement WordListManager class with CRUD operations\n3. Add support for severity levels (mild, moderate, severe)\n4. Implement category organization (profanity, slurs, custom)\n5. Create import/export functionality for CSV and JSON formats\n6. Add default word lists for common use cases\n7. Implement word list versioning\n8. Create functions to share and merge word lists",
"testStrategy": "Test CRUD operations on word lists. Verify import/export functionality with various formats. Test performance with large word lists. Ensure proper categorization and severity assignment.",
"priority": "medium",
"dependencies": [
1
],
"status": "pending",
"subtasks": []
},
{
"id": 6,
"title": "Implement Censorship Methods",
"description": "Develop various audio censorship techniques including silence insertion, beep tones, white noise, and fade transitions.",
"details": "1. Create a CensorshipProcessor class with the following methods:\n - silence_insertion: Replace detected words with silence\n - beep_tone: Replace with customizable frequency beep\n - white_noise: Replace with white noise\n - fade_transition: Add smooth fade in/out around censored sections\n2. Implement reversible censorship with metadata for undo capability\n3. Ensure audio timing remains synchronized after censorship\n4. Add configuration options for each censorship method\n5. Optimize for minimal audio quality degradation",
"testStrategy": "Test each censorship method with various audio samples. Verify audio quality and timing accuracy. Test reversibility of censorship. Measure processing speed for each method.",
"priority": "high",
"dependencies": [
3,
4
],
"status": "pending",
"subtasks": []
},
{
"id": 7,
"title": "Create Database Models and ORM",
"description": "Design and implement database models using SQLAlchemy for word lists, processing history, and user settings.",
"details": "1. Create SQLAlchemy models for:\n - WordList: Store word lists with metadata\n - Word: Individual words with severity and category\n - ProcessingJob: Track processing history\n - UserSettings: Store user preferences\n2. Implement database migrations system\n3. Create repository classes for each model\n4. Add indexing for performance optimization\n5. Implement data validation and sanitization\n6. Add backup and restore functionality",
"testStrategy": "Test CRUD operations for all models. Verify relationships between models. Test migrations and schema updates. Benchmark query performance with large datasets.",
"priority": "medium",
"dependencies": [
1,
5
],
"status": "pending",
"subtasks": []
},
{
"id": 8,
"title": "Develop Flask Backend API",
"description": "Create a RESTful API using Flask to expose core functionality to the web interface and CLI.",
"details": "1. Set up Flask application structure\n2. Implement RESTful endpoints for:\n - /api/process: Process audio files\n - /api/wordlists: Manage word lists\n - /api/settings: User settings\n - /api/jobs: Processing job management\n3. Add request validation and error handling\n4. Implement authentication (optional)\n5. Add rate limiting and security headers\n6. Create Swagger/OpenAPI documentation\n7. Implement WebSocket support for real-time updates",
"testStrategy": "Test all API endpoints with various inputs. Verify error handling and validation. Test WebSocket connections for real-time updates. Measure API performance under load.",
"priority": "high",
"dependencies": [
2,
3,
4,
5,
6,
7
],
"status": "pending",
"subtasks": []
},
{
"id": 9,
"title": "Implement Batch Processing System",
"description": "Create a queue management system for processing multiple files with priority and parallel processing.",
"details": "1. Design a JobQueue class for managing multiple processing jobs\n2. Implement priority system for processing order\n3. Add parallel processing capability with configurable worker count\n4. Create progress tracking for all jobs\n5. Implement automatic retry on failures\n6. Add job cancellation functionality\n7. Create job persistence for recovery after restart\n8. Implement resource monitoring to prevent overload",
"testStrategy": "Test queue management with multiple files of varying sizes. Verify priority system works correctly. Test parallel processing performance. Verify progress tracking accuracy. Test failure recovery and job persistence.",
"priority": "medium",
"dependencies": [
3,
6,
8
],
"status": "pending",
"subtasks": []
},
{
"id": 10,
"title": "Develop Frontend Foundation",
"description": "Set up the frontend foundation with HTML5, Bootstrap 5, and modern JavaScript.",
"details": "1. Create HTML5 structure with semantic markup\n2. Integrate Bootstrap 5 for responsive design\n3. Set up modern JavaScript with ES6+ features\n4. Implement basic page routing\n5. Create reusable UI components\n6. Set up asset pipeline for CSS and JavaScript\n7. Implement responsive design for mobile and desktop\n8. Add basic accessibility features (ARIA attributes, keyboard navigation)",
"testStrategy": "Test responsive design across different screen sizes. Verify accessibility with automated tools. Test JavaScript functionality across modern browsers. Measure page load performance.",
"priority": "high",
"dependencies": [
1
],
"status": "pending",
"subtasks": []
},
{
"id": 11,
"title": "Implement File Upload with Dropzone.js",
"description": "Create a drag-and-drop file upload interface using Dropzone.js with validation and progress tracking.",
"details": "1. Integrate Dropzone.js library\n2. Implement drag-and-drop file upload area\n3. Add file type validation for supported audio formats\n4. Implement file size validation (max 500MB)\n5. Create upload progress indicator\n6. Add error handling for failed uploads\n7. Implement multiple file selection\n8. Create thumbnail/preview for uploaded audio files",
"testStrategy": "Test file uploads with various file types and sizes. Verify validation works correctly. Test drag-and-drop functionality across browsers. Test error handling for invalid files.",
"priority": "high",
"dependencies": [
8,
10
],
"status": "pending",
"subtasks": []
},
{
"id": 12,
"title": "Develop Audio Waveform Visualization",
"description": "Implement audio waveform visualization using WaveSurfer.js with markers for detected explicit words.",
"details": "1. Integrate WaveSurfer.js library\n2. Create audio waveform visualization component\n3. Implement playback controls (play, pause, seek)\n4. Add markers for detected explicit words\n5. Create interactive timeline with zoom capability\n6. Implement before/after comparison view\n7. Add highlighting for currently playing section\n8. Create custom styling for waveform and markers",
"testStrategy": "Test waveform rendering with various audio files. Verify marker placement accuracy. Test playback controls and seeking. Test zoom functionality and performance with long audio files.",
"priority": "medium",
"dependencies": [
6,
10,
11
],
"status": "pending",
"subtasks": []
},
{
"id": 13,
"title": "Create Word List Management Interface",
"description": "Develop an interactive interface for managing word lists using DataTables.js.",
"details": "1. Integrate DataTables.js library\n2. Create word list management page\n3. Implement CRUD operations for word lists\n4. Add filtering and sorting capabilities\n5. Create category and severity level management\n6. Implement import/export functionality\n7. Add bulk operations (add, delete, change category/severity)\n8. Create shareable word list links",
"testStrategy": "Test all CRUD operations on word lists. Verify filtering and sorting functionality. Test import/export with various formats. Test performance with large word lists.",
"priority": "medium",
"dependencies": [
5,
7,
10
],
"status": "pending",
"subtasks": []
},
{
"id": 14,
"title": "Implement Real-time Processing Updates",
"description": "Create a real-time update system using WebSockets to show processing progress and results.",
"details": "1. Implement Socket.io client integration\n2. Create progress bar component for processing status\n3. Add real-time updates for processing stages\n4. Implement error notifications\n5. Create completion notification with summary\n6. Add automatic refresh of results\n7. Implement reconnection handling for dropped connections\n8. Create debug mode for detailed progress information",
"testStrategy": "Test WebSocket connection and updates with various processing scenarios. Verify progress accuracy. Test reconnection handling. Measure performance impact of real-time updates.",
"priority": "medium",
"dependencies": [
8,
9,
10
],
"status": "pending",
"subtasks": []
},
{
"id": 15,
"title": "Develop Command-Line Interface",
"description": "Create a comprehensive CLI for processing files, managing word lists, and configuring the application.",
"details": "1. Use argparse or click library to create CLI structure\n2. Implement commands:\n - clean-tracks process <file>: Process single file\n - clean-tracks batch <pattern>: Batch processing\n - clean-tracks words <command>: Word list management\n - clean-tracks config <setting>: Configuration\n - clean-tracks server: Start web server\n3. Add progress bars for CLI operations\n4. Implement colorized output\n5. Create help documentation for each command\n6. Add verbose mode for debugging\n7. Implement configuration file support",
"testStrategy": "Test all CLI commands with various inputs. Verify error handling and help documentation. Test batch processing with file patterns. Test configuration management.",
"priority": "medium",
"dependencies": [
2,
3,
4,
5,
6,
9
],
"status": "pending",
"subtasks": []
},
{
"id": 16,
"title": "Implement User Onboarding Experience",
"description": "Create an onboarding flow for first-time users with tutorial, tooltips, and sample files.",
"details": "1. Design welcome modal with 3-step visual guide\n2. Create sample audio files for testing\n3. Implement interactive tooltip tour\n4. Develop quick start guide with screenshots\n5. Add persistent flag for first-time users\n6. Create dismissible help panels\n7. Implement guided walkthrough for key features\n8. Add progress tracking for onboarding completion",
"testStrategy": "Test onboarding flow with new users. Verify all tooltips and guides display correctly. Test sample file processing. Measure time to complete onboarding.",
"priority": "low",
"dependencies": [
10,
11,
12,
13,
14
],
"status": "pending",
"subtasks": []
},
{
"id": 17,
"title": "Implement Performance Optimizations",
"description": "Optimize application performance with caching, lazy loading, and resource management.",
"details": "1. Implement result caching to avoid reprocessing\n2. Add lazy loading for web interface components\n3. Set up CDN configuration for static assets\n4. Implement code splitting for faster initial load\n5. Add resource monitoring and management\n6. Optimize database queries with proper indexing\n7. Implement client-side caching strategies\n8. Add performance metrics collection",
"testStrategy": "Benchmark application performance before and after optimizations. Test caching effectiveness. Measure page load times and resource usage. Test performance under load.",
"priority": "medium",
"dependencies": [
8,
9,
10,
12,
14
],
"status": "pending",
"subtasks": []
},
{
"id": 18,
"title": "Implement Security and Privacy Features",
"description": "Add security and privacy features including local processing, incognito mode, and data clearing.",
"details": "1. Ensure all processing is done locally (no cloud uploads)\n2. Implement optional incognito mode\n3. Create one-click data clearing functionality\n4. Remove user tracking by default\n5. Add secure API with rate limiting\n6. Implement secure storage for sensitive data\n7. Add privacy policy and terms of service\n8. Create data retention controls",
"testStrategy": "Verify all processing is done locally. Test incognito mode functionality. Verify data clearing removes all user data. Test API security with penetration testing tools.",
"priority": "high",
"dependencies": [
7,
8,
10
],
"status": "pending",
"subtasks": []
},
{
"id": 19,
"title": "Develop Accessibility Compliance",
"description": "Ensure the application meets WCAG AA accessibility standards.",
"details": "1. Implement proper semantic HTML throughout\n2. Add ARIA attributes for interactive elements\n3. Ensure proper color contrast ratios\n4. Implement keyboard navigation for all features\n5. Add screen reader support\n6. Create focus management for modals and dialogs\n7. Implement skip navigation links\n8. Add text alternatives for non-text content",
"testStrategy": "Test with accessibility audit tools (Lighthouse, axe). Verify keyboard navigation works for all features. Test with screen readers. Validate WCAG AA compliance with automated and manual testing.",
"priority": "high",
"dependencies": [
10,
11,
12,
13,
14,
16
],
"status": "pending",
"subtasks": []
},
{
"id": 20,
"title": "Implement Comprehensive Testing Suite",
"description": "Create a comprehensive testing suite with unit, integration, and end-to-end tests.",
"details": "1. Set up pytest for unit testing\n2. Create unit tests for all components\n3. Implement integration tests for API endpoints\n4. Set up Playwright for end-to-end testing\n5. Create visual regression tests\n6. Implement accessibility testing\n7. Add performance benchmarking tests\n8. Set up cross-browser testing",
"testStrategy": "Verify test coverage across all components. Run tests in CI/CD pipeline. Measure code coverage and test quality. Test across multiple browsers and environments.",
"priority": "high",
"dependencies": [
1,
2,
3,
4,
5,
6,
7,
8
],
"status": "pending",
"subtasks": []
},
{
"id": 21,
"title": "Create User Documentation",
"description": "Develop comprehensive user documentation including guides, API docs, and CLI reference.",
"details": "1. Create user guide with screenshots\n2. Write API documentation with examples\n3. Develop CLI command reference\n4. Create word list management guide\n5. Write deployment instructions\n6. Develop contributing guidelines\n7. Add troubleshooting section\n8. Create FAQ based on common issues",
"testStrategy": "Review documentation for accuracy and completeness. Test following instructions as a new user. Gather feedback on clarity and usefulness. Verify all examples work as described.",
"priority": "medium",
"dependencies": [
8,
15,
16
],
"status": "pending",
"subtasks": []
},
{
"id": 22,
"title": "Implement Docker Containerization",
"description": "Create Docker configuration for easy deployment and containerization.",
"details": "1. Create Dockerfile for application\n2. Set up docker-compose for local development\n3. Configure volume mounting for persistent data\n4. Optimize container size and layers\n5. Add health checks and monitoring\n6. Create production-ready container configuration\n7. Document Docker deployment options\n8. Add container security best practices",
"testStrategy": "Build and test Docker containers in various environments. Verify all features work in containerized setup. Test container performance and resource usage. Validate security configuration.",
"priority": "medium",
"dependencies": [
1,
2,
3,
8
],
"status": "pending",
"subtasks": []
},
{
"id": 23,
"title": "Set Up CI/CD Pipeline",
"description": "Configure GitHub Actions for continuous integration and deployment.",
"details": "1. Create GitHub Actions workflow for CI\n2. Set up automated testing on pull requests\n3. Implement code quality checks\n4. Add security scanning\n5. Configure automated builds\n6. Set up deployment pipeline\n7. Add release automation\n8. Implement version tagging",
"testStrategy": "Verify CI pipeline runs successfully on pull requests. Test deployment process to staging environment. Validate code quality and security checks. Test release process.",
"priority": "medium",
"dependencies": [
1,
20,
22
],
"status": "pending",
"subtasks": []
},
{
"id": 24,
"title": "Implement Analytics and Metrics",
"description": "Add analytics and metrics collection to track system performance and user behavior.",
"details": "1. Implement processing speed metrics\n2. Add detection accuracy tracking\n3. Create user task completion analytics\n4. Measure time to first success\n5. Track system uptime\n6. Monitor page load times\n7. Collect user satisfaction feedback\n8. Create dashboard for metrics visualization",
"testStrategy": "Verify metrics collection accuracy. Test dashboard functionality. Ensure privacy compliance with collected data. Validate metrics against success criteria.",
"priority": "low",
"dependencies": [
8,
10,
17
],
"status": "pending",
"subtasks": []
},
{
"id": 25,
"title": "Conduct Final Integration and System Testing",
"description": "Perform comprehensive integration testing and system validation before release.",
"details": "1. Test complete user journeys end-to-end\n2. Verify all components work together\n3. Conduct performance testing under load\n4. Test with various audio files and formats\n5. Validate against success metrics\n6. Perform security audit\n7. Conduct accessibility compliance testing\n8. Create release candidate and final validation",
"testStrategy": "Execute comprehensive test plan covering all features and integrations. Validate against all requirements in the PRD. Perform user acceptance testing with representatives from target user groups. Document and address any issues found.",
"priority": "high",
"dependencies": [
2,
3,
4,
5,
6,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24
],
"status": "pending",
"subtasks": []
}
],
"metadata": {
"created": "2025-08-18T22:38:27.727Z",
"updated": "2025-08-18T22:38:27.727Z",
"description": "Tasks for master context"
}
}
}

47
.taskmaster/templates/example_prd.txt Normal file
View File

@ -0,0 +1,47 @@
<context>
# Overview
[Provide a high-level overview of your product here. Explain what problem it solves, who it's for, and why it's valuable.]
# Core Features
[List and describe the main features of your product. For each feature, include:
- What it does
- Why it's important
- How it works at a high level]
# User Experience
[Describe the user journey and experience. Include:
- User personas
- Key user flows
- UI/UX considerations]
</context>
<PRD>
# Technical Architecture
[Outline the technical implementation details:
- System components
- Data models
- APIs and integrations
- Infrastructure requirements]
# Development Roadmap
[Break down the development process into phases:
- MVP requirements
- Future enhancements
- Do not think about timelines whatsoever -- all that matters is scope and detailing exactly what needs to be build in each phase so it can later be cut up into tasks]
# Logical Dependency Chain
[Define the logical order of development:
- Which features need to be built first (foundation)
- Getting as quickly as possible to something usable/visible front end that works
- Properly pacing and scoping each feature so it is atomic but can also be built upon and improved as development approaches]
# Risks and Mitigations
[Identify potential risks and how they'll be addressed:
- Technical challenges
- Figuring out the MVP that we can build upon
- Resource constraints]
# Appendix
[Include any additional information:
- Research findings
- Technical specifications]
</PRD>

108
README.md Normal file
View File

@ -0,0 +1,108 @@
# Clean-Tracks - Audio Censorship System
An intelligent audio processing tool that automatically detects and censors explicit content in audio files, featuring both a user-friendly web interface and powerful command-line tools.
## 🎯 Overview
Clean-Tracks uses advanced speech recognition (OpenAI Whisper) to detect and remove explicit words from audio files while preserving audio quality. Perfect for content creators, educators, and parents who need to make audio content appropriate for all audiences.
## ✨ Features
- **🎵 Multi-Format Support**: Process MP3, WAV, FLAC, M4A, OGG, and more
- **🤖 AI-Powered Detection**: Uses Whisper for accurate speech recognition
- **🎨 Web Interface**: Intuitive drag-and-drop interface with real-time progress
- **⚡ Command Line**: Powerful CLI for batch processing and automation
- **📝 Customizable Word Lists**: Manage your own explicit word lists with severity levels
- **🔊 Multiple Censorship Styles**: Choose between silence, beep, or white noise
- **📊 Visual Feedback**: See waveforms with detected words highlighted
- **🚀 Batch Processing**: Process multiple files simultaneously
- **📱 Mobile Responsive**: Works on desktop, tablet, and mobile devices
## 🚀 Quick Start
### Installation
```bash
# Clone the repository
git clone https://github.com/yourusername/clean-tracks.git
cd clean-tracks
# Create virtual environment
python3 -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
# Install dependencies
pip install -r requirements.txt
# Run setup
python setup.py install
```
### Web Interface
```bash
# Start the web server
python -m clean_tracks.web
# Open browser to http://localhost:5000
```
### Command Line
```bash
# Process a single file
clean-tracks process audio.mp3 --output clean_audio.mp3
# Batch process files
clean-tracks batch *.mp3 --output-dir cleaned/
# Manage word lists
clean-tracks words add "example" --severity high
clean-tracks words list
clean-tracks words export my_words.csv
```
## 📋 Requirements
- Python 3.11+
- FFmpeg (for audio processing)
- 4GB RAM minimum (8GB recommended for large files)
- GPU optional but recommended for faster processing
## 🛠️ Technology Stack
- **Backend**: Python, Flask, OpenAI Whisper
- **Audio Processing**: PyDub, Librosa, FFmpeg
- **Frontend**: HTML5, Bootstrap 5, JavaScript
- **Real-time**: WebSocket (Socket.io)
- **Database**: SQLite
- **Testing**: Pytest, Playwright
## 📖 Documentation
- [User Guide](docs/user-guide.md)
- [API Documentation](docs/api.md)
- [Development Guide](docs/development.md)
- [Word List Management](docs/word-lists.md)
## 🤝 Contributing
We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
## 📄 License
This project is licensed under the MIT License - see [LICENSE](LICENSE) file for details.
## 🙏 Acknowledgments
- Built on top of OpenAI's Whisper for speech recognition
- Uses components adapted from the Personal AI Assistant project
- Inspired by the need for family-friendly content creation tools
## 📧 Support
For issues, questions, or suggestions, please open an issue on GitHub or contact the maintainers.
---
**Note**: This project is in active development. Features and API may change.

0
data/processed/.gitkeep Normal file
View File

0
data/uploads/.gitkeep Normal file
View File

43
requirements.txt Normal file
View File

@ -0,0 +1,43 @@
# Core Dependencies
Flask==3.0.0
Flask-CORS==4.0.0
Flask-SocketIO==5.3.5
python-socketio==5.10.0
# Audio Processing
openai-whisper==20231117
torch>=2.0.0
pydub==0.25.1
librosa==0.10.1
soundfile==0.12.1
numpy==1.24.3
# Database
SQLAlchemy==2.0.23
alembic==1.13.0
# Web UI
python-dotenv==1.0.0
Werkzeug==3.0.1
# CLI
click==8.1.7
rich==13.7.0
# Utilities
requests==2.31.0
tqdm==4.66.1
python-Levenshtein==0.23.0
fuzzywuzzy==0.18.0
# Development & Testing
pytest==7.4.3
pytest-cov==4.1.0
black==23.11.0
ruff==0.1.6
mypy==1.7.1
# Optional but recommended
accelerate==0.24.1 # For faster Whisper inference
redis==5.0.1 # For caching
celery==5.3.4 # For background jobs