taskgraph-ai 0.52.23 → 0.54.12

package/dist/assets/claude/TM_COMMANDS_GUIDE.md

@@ -1,147 +0,0 @@
-# TaskGraph Commands for Claude Code
-
-Complete guide to using TaskGraph through Claude Code's slash commands.
-
-## Overview
-
-All TaskGraph functionality is available through the `/project:tm/` namespace with natural language support and intelligent features.
-
-## Quick Start
-
-```bash
-# Install TaskGraph
-/project:tm/setup/quick-install
-
-# Initialize project
-/project:tm/init/quick
-
-# Parse requirements
-/project:tm/parse-prd requirements.md
-
-# Start working
-/project:tm/next
-```
-
-## Command Structure
-
-Commands are organized hierarchically to match TaskGraph's CLI:
-- Main commands at `/project:tm/[command]`
-- Subcommands for specific operations `/project:tm/[command]/[subcommand]`
-- Natural language arguments accepted throughout
-
-## Complete Command Reference
-
-### Setup & Configuration
-- `/project:tm/setup/install` - Full installation guide
-- `/project:tm/setup/quick-install` - One-line install
-- `/project:tm/init` - Initialize project
-- `/project:tm/init/quick` - Quick init with -y
-- `/project:tm/models` - View AI config
-- `/project:tm/models/setup` - Configure AI
-
-### Task Generation
-- `/project:tm/parse-prd` - Generate from PRD
-- `/project:tm/parse-prd/with-research` - Enhanced parsing
-- `/project:tm/generate` - Create task files
-
-### Task Management
-- `/project:tm/list` - List with natural language filters
-- `/project:tm/list/with-subtasks` - Hierarchical view
-- `/project:tm/list/by-status <status>` - Filter by status
-- `/project:tm/show <id>` - Task details
-- `/project:tm/add-task` - Create task
-- `/project:tm/update` - Update tasks
-- `/project:tm/remove-task` - Delete task
-
-### Status Management
-- `/project:tm/set-status/to-pending <id>`
-- `/project:tm/set-status/to-in-progress <id>`
-- `/project:tm/set-status/to-done <id>`
-- `/project:tm/set-status/to-review <id>`
-- `/project:tm/set-status/to-deferred <id>`
-- `/project:tm/set-status/to-cancelled <id>`
-
-### Task Analysis
-- `/project:tm/analyze-complexity` - AI analysis
-- `/project:tm/complexity-report` - View report
-- `/project:tm/expand <id>` - Break down task
-- `/project:tm/expand/all` - Expand all complex
-
-### Dependencies
-- `/project:tm/add-dependency` - Add dependency
-- `/project:tm/remove-dependency` - Remove dependency
-- `/project:tm/validate-dependencies` - Check issues
-- `/project:tm/fix-dependencies` - Auto-fix
-
-### Workflows
-- `/project:tm/workflows/smart-flow` - Adaptive workflows
-- `/project:tm/workflows/pipeline` - Chain commands
-- `/project:tm/workflows/auto-implement` - AI implementation
-
-### Utilities
-- `/project:tm/status` - Project dashboard
-- `/project:tm/next` - Next task recommendation
-- `/project:tm/utils/analyze` - Project analysis
-- `/project:tm/learn` - Interactive help
-
-## Key Features
-
-### Natural Language Support
-All commands understand natural language:
-```
-/project:tm/list pending high priority
-/project:tm/update mark 23 as done
-/project:tm/add-task implement OAuth login
-```
-
-### Smart Context
-Commands analyze project state and provide intelligent suggestions based on:
-- Current task status
-- Dependencies
-- Team patterns
-- Project phase
-
-### Visual Enhancements
-- Progress bars and indicators
-- Status badges
-- Organized displays
-- Clear hierarchies
-
-## Common Workflows
-
-### Daily Development
-```
-/project:tm/workflows/smart-flow morning
-/project:tm/next
-/project:tm/set-status/to-in-progress <id>
-/project:tm/set-status/to-done <id>
-```
-
-### Task Breakdown
-```
-/project:tm/show <id>
-/project:tm/expand <id>
-/project:tm/list/with-subtasks
-```
-
-### Sprint Planning
-```
-/project:tm/analyze-complexity
-/project:tm/workflows/pipeline init → expand/all → status
-```
-
-## Migration from Old Commands
-
-| Old | New |
-|-----|-----|
-| `/project:taskgraph:list` | `/project:tm/list` |
-| `/project:taskgraph:complete` | `/project:tm/set-status/to-done` |
-| `/project:workflows:auto-implement` | `/project:tm/workflows/auto-implement` |
-
-## Tips
-
-1. Use `/project:tm/` + Tab for command discovery
-2. Natural language is supported everywhere
-3. Commands provide smart defaults
-4. Chain commands for automation
-5. Check `/project:tm/learn` for interactive help

package/dist/assets/scripts_README.md

@@ -1,443 +0,0 @@
-# Meta-Development Script
-
-This folder contains a **meta-development script** (`dev.js`) and related utilities that manage tasks for an AI-driven or traditional software development workflow. The script revolves around a `tasks.json` file, which holds an up-to-date list of development tasks.
-
-## Overview
-
-In an AI-driven development process—particularly with tools like [Cursor](https://www.cursor.so/)—it's beneficial to have a **single source of truth** for tasks. This script allows you to:
-
-1. **Parse** a PRD or requirements document (`.txt`) to initialize a set of tasks (`tasks.json`).
-2. **List** all existing tasks (IDs, statuses, titles).
-3. **Update** tasks to accommodate new prompts or architecture changes (useful if you discover "implementation drift").
-4. **Generate** individual task files (e.g., `task_001.txt`) for easy reference or to feed into an AI coding workflow.
-5. **Set task status**—mark tasks as `done`, `pending`, or `deferred` based on progress.
-6. **Expand** tasks with subtasks—break down complex tasks into smaller, more manageable subtasks.
-7. **Research-backed subtask generation**—use the research model to generate more informed and contextually relevant subtasks.
-8. **Clear subtasks**—remove subtasks from specified tasks to allow regeneration or restructuring.
-9. **Show task details**—display detailed information about a specific task and its subtasks.
-
-## Configuration (Updated)
-
-TaskGraph configuration is now managed through two primary methods:
-
-1.  **`.taskgraph/config.json` File (Project Root - Primary)**
-
-    - Stores AI model selections (`main`, `research`, `fallback`), model parameters (`maxTokens`, `temperature`), `logLevel`, `defaultSubtasks`, `defaultPriority`, `projectName`, etc.
-    - Managed using the `taskgraph models --setup` command or the `models` MCP tool.
-    - This is the main configuration file for most settings.
-
-2.  **Environment Variables (optional)**
-    - TaskGraph needs no provider API keys; AI calls run through your signed-in Claude Code.
-    - `CLAUDE_CODE_API_KEY` optionally bills calls to a specific Anthropic API key.
-    - See the Configuration page in the TaskGraph docs for the `TASKGRAPH_*` variables.
-
-**Important:** Settings like `MODEL`, `MAX_TOKENS`, `TEMPERATURE`, `TASKGRAPH_LOG_LEVEL`, etc., are **no longer set via `.env`**. Use `taskgraph models --setup` instead.
-
-## How It Works
-
-1. **`tasks.json`**:
-
-   - A JSON file at the project root containing an array of tasks (each with `id`, `title`, `description`, `status`, etc.).
-   - The `meta` field can store additional info like the project's name, version, or reference to the PRD.
-   - Tasks can have `subtasks` for more detailed implementation steps.
-   - Dependencies are displayed with status indicators (✅ for completed, ⏱️ for pending) to easily track progress.
-
-2. **CLI Commands**
-   You can run the commands via:
-
-   ```bash
-   # If installed globally
-   taskgraph [command] [options]
-
-   # If using locally within the project
-   node scripts/dev.js [command] [options]
-   ```
-
-   Available commands:
-
-   - `init`: Initialize a new project
-   - `parse-prd`: Generate tasks from a PRD document
-   - `list`: Display all tasks with their status
-   - `update`: Update tasks based on new information
-   - `generate`: Create individual task files
-   - `set-status`: Change a task's status
-   - `expand`: Add subtasks to a task or all tasks
-   - `clear-subtasks`: Remove subtasks from specified tasks
-   - `next`: Determine the next task to work on based on dependencies
-   - `show`: Display detailed information about a specific task
-   - `analyze-complexity`: Analyze task complexity and generate recommendations
-   - `complexity-report`: Display the complexity analysis in a readable format
-   - `add-dependency`: Add a dependency between tasks
-   - `remove-dependency`: Remove a dependency from a task
-   - `validate-dependencies`: Check for invalid dependencies
-   - `fix-dependencies`: Fix invalid dependencies automatically
-   - `add-task`: Add a new task using AI
-
-   Run `taskgraph --help` or `node scripts/dev.js --help` to see detailed usage information.
-
-## Listing Tasks
-
-The `list` command allows you to view all tasks and their status:
-
-```bash
-# List all tasks
-taskgraph list
-
-# List tasks with a specific status
-taskgraph list --status=pending
-
-# List tasks and include their subtasks
-taskgraph list --with-subtasks
-
-# List tasks with a specific status and include their subtasks
-taskgraph list --status=pending --with-subtasks
-```
-
-## Updating Tasks
-
-The `update` command allows you to update tasks based on new information or implementation changes:
-
-```bash
-# Update tasks starting from ID 4 with a new prompt
-taskgraph update --from=4 --prompt="Refactor tasks from ID 4 onward to use Express instead of Fastify"
-
-# Update all tasks (default from=1)
-taskgraph update --prompt="Add authentication to all relevant tasks"
-
-# Specify a different tasks file
-taskgraph update --file=custom-tasks.json --from=5 --prompt="Change database from MongoDB to PostgreSQL"
-```
-
-Notes:
-
-- The `--prompt` parameter is required and should explain the changes or new context
-- Only tasks that aren't marked as 'done' will be updated
-- Tasks with ID >= the specified --from value will be updated
-
-## Setting Task Status
-
-The `set-status` command allows you to change a task's status:
-
-```bash
-# Mark a task as done
-taskgraph set-status --id=3 --status=done
-
-# Mark a task as pending
-taskgraph set-status --id=4 --status=pending
-
-# Mark a specific subtask as done
-taskgraph set-status --id=3.1 --status=done
-
-# Mark multiple tasks at once
-taskgraph set-status --id=1,2,3 --status=done
-```
-
-Notes:
-
-- When marking a parent task as "done", all of its subtasks will automatically be marked as "done" as well
-- Common status values are 'done', 'pending', and 'deferred', but any string is accepted
-- You can specify multiple task IDs by separating them with commas
-- Subtask IDs are specified using the format `parentId.subtaskId` (e.g., `3.1`)
-- Dependencies are updated to show completion status (✅ for completed, ⏱️ for pending) throughout the system
-
-## Expanding Tasks
-
-The `expand` command allows you to break down tasks into subtasks for more detailed implementation:
-
-```bash
-# Expand a specific task with 3 subtasks (default)
-taskgraph expand --id=3
-
-# Expand a specific task with 5 subtasks
-taskgraph expand --id=3 --num=5
-
-# Expand a task with additional context
-taskgraph expand --id=3 --prompt="Focus on security aspects"
-
-# Expand all pending tasks that don't have subtasks
-taskgraph expand --all
-
-# Force regeneration of subtasks for all pending tasks
-taskgraph expand --all --force
-
-# Use the research model for research-backed subtask generation
-taskgraph expand --id=3 --research
-
-# Use the research model for research-backed generation on all pending tasks
-taskgraph expand --all --research
-```
-
-## Clearing Subtasks
-
-The `clear-subtasks` command allows you to remove subtasks from specified tasks:
-
-```bash
-# Clear subtasks from a specific task
-taskgraph clear-subtasks --id=3
-
-# Clear subtasks from multiple tasks
-taskgraph clear-subtasks --id=1,2,3
-
-# Clear subtasks from all tasks
-taskgraph clear-subtasks --all
-```
-
-Notes:
-
-- After clearing subtasks, task files are automatically regenerated
-- This is useful when you want to regenerate subtasks with a different approach
-- Can be combined with the `expand` command to immediately generate new subtasks
-- Works with both parent tasks and individual subtasks
-
-## AI Integration (Updated)
-
-- The script now uses a unified AI service layer (`ai-services-unified.js`).
-- Model selection (for example `opus`, `sonnet` or `haiku`) is determined by the configuration in `.taskgraph/config.json` based on the requested `role` (`main` or `research`).
-- No provider API keys are needed; calls run through your signed-in Claude Code.
-- To use the research capabilities (for example `expand --research`), configure a model for the `research` role with `taskgraph models --setup`.
-
-## Logging
-
-The script supports different logging levels controlled by the `TASKGRAPH_LOG_LEVEL` environment variable:
-
-- `debug`: Detailed information, typically useful for troubleshooting
-- `info`: Confirmation that things are working as expected (default)
-- `warn`: Warning messages that don't prevent execution
-- `error`: Error messages that might prevent execution
-
-When `DEBUG=true` is set, debug logs are also written to a `dev-debug.log` file in the project root.
-
-## Managing Task Dependencies
-
-The `add-dependency` and `remove-dependency` commands allow you to manage task dependencies:
-
-```bash
-# Add a dependency to a task
-taskgraph add-dependency --id=<id> --depends-on=<id>
-
-# Remove a dependency from a task
-taskgraph remove-dependency --id=<id> --depends-on=<id>
-```
-
-These commands:
-
-1. **Allow precise dependency management**:
-
-   - Add dependencies between tasks with automatic validation
-   - Remove dependencies when they're no longer needed
-   - Update task files automatically after changes
-
-2. **Include validation checks**:
-
-   - Prevent circular dependencies (a task depending on itself)
-   - Prevent duplicate dependencies
-   - Verify that both tasks exist before adding/removing dependencies
-   - Check if dependencies exist before attempting to remove them
-
-3. **Provide clear feedback**:
-
-   - Success messages confirm when dependencies are added/removed
-   - Error messages explain why operations failed (if applicable)
-
-4. **Automatically update task files**:
-   - Regenerates task files to reflect dependency changes
-   - Ensures tasks and their files stay synchronized
-
-## Dependency Validation and Fixing
-
-The script provides two specialized commands to ensure task dependencies remain valid and properly maintained:
-
-### Validating Dependencies
-
-The `validate-dependencies` command allows you to check for invalid dependencies without making changes:
-
-```bash
-# Check for invalid dependencies in tasks.json
-taskgraph validate-dependencies
-
-# Specify a different tasks file
-taskgraph validate-dependencies --file=custom-tasks.json
-```
-
-This command:
-
-- Scans all tasks and subtasks for non-existent dependencies
-- Identifies potential self-dependencies (tasks referencing themselves)
-- Reports all found issues without modifying files
-- Provides a comprehensive summary of dependency state
-- Gives detailed statistics on task dependencies
-
-Use this command to audit your task structure before applying fixes.
-
-### Fixing Dependencies
-
-The `fix-dependencies` command proactively finds and fixes all invalid dependencies:
-
-```bash
-# Find and fix all invalid dependencies
-taskgraph fix-dependencies
-
-# Specify a different tasks file
-taskgraph fix-dependencies --file=custom-tasks.json
-```
-
-This command:
-
-1. **Validates all dependencies** across tasks and subtasks
-2. **Automatically removes**:
-   - References to non-existent tasks and subtasks
-   - Self-dependencies (tasks depending on themselves)
-3. **Fixes issues in both**:
-   - The tasks.json data structure
-   - Individual task files during regeneration
-4. **Provides a detailed report**:
-   - Types of issues fixed (non-existent vs. self-dependencies)
-   - Number of tasks affected (tasks vs. subtasks)
-   - Where fixes were applied (tasks.json vs. task files)
-   - List of all individual fixes made
-
-This is especially useful when tasks have been deleted or IDs have changed, potentially breaking dependency chains.
-
-## Analyzing Task Complexity
-
-The `analyze-complexity` command allows you to automatically assess task complexity and generate expansion recommendations:
-
-```bash
-# Analyze all tasks and generate expansion recommendations
-taskgraph analyze-complexity
-
-# Specify a custom output file
-taskgraph analyze-complexity --output=custom-report.json
-
-# Override the model used for analysis
-taskgraph analyze-complexity --model=claude-3-opus-20240229
-
-# Set a custom complexity threshold (1-10)
-taskgraph analyze-complexity --threshold=6
-
-# Use the research model for research-backed complexity analysis
-taskgraph analyze-complexity --research
-```
-
-Notes:
-
-- The command uses Claude to analyze each task's complexity (or the research model with the --research flag)
-- Tasks are scored on a scale of 1-10
-- Each task receives a recommended number of subtasks based on DEFAULT_SUBTASKS configuration
-- The default output path is `scripts/task-complexity-report.json`
-- Each task in the analysis includes a ready-to-use `expansionCommand` that can be copied directly to the terminal or executed programmatically
-- Tasks with complexity scores below the threshold (default: 5) may not need expansion
-- The research flag provides more contextual and informed complexity assessments
-
-### Integration with Expand Command
-
-The `expand` command automatically checks for and uses complexity analysis if available:
-
-```bash
-# Expand a task, using complexity report recommendations if available
-taskgraph expand --id=8
-
-# Expand all tasks, prioritizing by complexity score if a report exists
-taskgraph expand --all
-
-# Override recommendations with explicit values
-taskgraph expand --id=8 --num=5 --prompt="Custom prompt"
-```
-
-When a complexity report exists:
-
-- The `expand` command will use the recommended subtask count from the report (unless overridden)
-- It will use the tailored expansion prompt from the report (unless a custom prompt is provided)
-- When using `--all`, tasks are sorted by complexity score (highest first)
-- The `--research` flag is preserved from the complexity analysis to expansion
-
-The output report structure is:
-
-```json
-{
-  "meta": {
-    "generatedAt": "2023-06-15T12:34:56.789Z",
-    "tasksAnalyzed": 20,
-    "thresholdScore": 5,
-    "projectName": "Your Project Name",
-    "usedResearch": true
-  },
-  "complexityAnalysis": [
-    {
-      "taskId": 8,
-      "taskTitle": "Develop Implementation Drift Handling",
-      "complexityScore": 9.5,
-      "recommendedSubtasks": 6,
-      "expansionPrompt": "Create subtasks that handle detecting...",
-      "reasoning": "This task requires sophisticated logic...",
-      "expansionCommand": "taskgraph expand --id=8 --num=6 --prompt=\"Create subtasks...\" --research"
-    }
-    // More tasks sorted by complexity score (highest first)
-  ]
-}
-```
-
-## Finding the Next Task
-
-The `next` command helps you determine which task to work on next based on dependencies and status:
-
-```bash
-# Show the next task to work on
-taskgraph next
-
-# Specify a different tasks file
-taskgraph next --file=custom-tasks.json
-```
-
-This command:
-
-1. Identifies all **eligible tasks** - pending or in-progress tasks whose dependencies are all satisfied (marked as done)
-2. **Prioritizes** these eligible tasks by:
-   - Priority level (high > medium > low)
-   - Number of dependencies (fewer dependencies first)
-   - Task ID (lower ID first)
-3. **Displays** comprehensive information about the selected task:
-   - Basic task details (ID, title, priority, dependencies)
-   - Detailed description and implementation details
-   - Subtasks if they exist
-4. Provides **contextual suggested actions**:
-   - Command to mark the task as in-progress
-   - Command to mark the task as done when completed
-   - Commands for working with subtasks (update status or expand)
-
-This feature ensures you're always working on the most appropriate task based on your project's current state and dependency structure.
-
-## Showing Task Details
-
-The `show` command allows you to view detailed information about a specific task:
-
-```bash
-# Show details for a specific task
-taskgraph show 1
-
-# Alternative syntax with --id option
-taskgraph show --id=1
-
-# Show details for a subtask
-taskgraph show --id=1.2
-
-# Specify a different tasks file
-taskgraph show 3 --file=custom-tasks.json
-```
-
-This command:
-
-1. **Displays comprehensive information** about the specified task:
-   - Basic task details (ID, title, priority, dependencies, status)
-   - Full description and implementation details
-   - Test strategy information
-   - Subtasks if they exist
-2. **Handles both regular tasks and subtasks**:
-   - For regular tasks, shows all subtasks and their status
-   - For subtasks, shows the parent task relationship
-3. **Provides contextual suggested actions**:
-   - Commands to update the task status
-   - Commands for working with subtasks
-   - For subtasks, provides a link to view the parent task
-
-This command is particularly useful when you need to examine a specific task in detail before implementing it or when you want to check the status and details of a particular task.