Merge pull request #28 from jpicklyk/feature/2.0.0-beta

Feature/2.0.0 beta

Author: jpicklyk

.claude-plugin/marketplace.json

@@ -0,0 +1,30 @@
+{
+  "name": "task-orchestrator-marketplace",
+  "owner": {
+    "name": "Task Orchestrator",
+    "url": "https://github.com/jpicklyk/task-orchestrator"
+  },
+  "metadata": {
+    "description": "MCP Task Orchestrator - Hierarchical task management with AI workflows",
+    "version": "2.0.0"
+  },
+  "plugins": [
+    {
+      "name": "task-orchestrator",
+      "version": "2.0.0",
+      "description": "Comprehensive task management with Projects → Features → Tasks hierarchy, dependency tracking, templates, and AI workflow automation",
+      "author": {
+        "name": "Jeff Picklyk",
+        "url": "https://github.com/jpicklyk"
+      },
+      "homepage": "https://github.com/jpicklyk/task-orchestrator",
+      "repository": "https://github.com/jpicklyk/task-orchestrator",
+      "license": "MIT",
+      "keywords": ["task-management", "project-management", "workflow", "mcp", "ai-orchestration"],
+      "category": "productivity",
+      "tags": ["tasks", "features", "projects", "dependencies", "templates", "workflows"],
+      "source": "./claude-plugins/task-orchestrator",
+      "strict": true
+    }
+  ]
+}

.claude/commands/check_schema_version.md

@@ -0,0 +1,88 @@
+---
+description: Check the Flyway schema version of the SQLite database on a Docker volume
+---
+
+Check the schema version of the Task Orchestrator database on a Docker volume.
+
+# Instructions
+
+1. Parse the volume name from the user's command, defaulting to "mcp-task-data" if not provided
+2. Create a temporary SQL file with the query
+3. Run the Docker command mounting both the volume and the project directory
+4. Display the results in a clear, formatted way
+5. Clean up the temporary SQL file
+
+# Working Pattern (Windows Git Bash Compatible)
+
+Due to shell escaping issues on Windows, use a mounted SQL file approach:
+
+**Step 1:** Create temporary SQL file in project root:
+```sql
+-- File: .tmp_check_schema.sql (in project root directory)
+.mode box
+.headers on
+
+SELECT
+    installed_rank,
+    version,
+    description,
+    type,
+    script,
+    installed_on,
+    execution_time,
+    success
+FROM flyway_schema_history
+ORDER BY installed_rank DESC
+LIMIT 10;
+```
+
+**Temp File Location:** Create `.tmp_check_schema.sql` in the project root directory (D:\Projects\task-orchestrator\)
+
+**Step 2:** Run via Docker with mounted SQL file:
+```bash
+powershell.exe -Command "docker run --rm -v {{VOLUME_NAME}}:/data -v '${PWD}:/work' alpine sh -c 'apk add --no-cache sqlite >/dev/null 2>&1 && sqlite3 /data/tasks.db < /work/.tmp_check_schema.sql'"
+```
+
+**Step 3:** Clean up:
+```bash
+rm .tmp_check_schema.sql
+```
+
+**Note:** The `alpine/sqlite` image doesn't work well with inline SQL on Windows. Use `alpine` with sqlite installed instead.
+
+# Expected Output Format
+
+Present the results with:
+- Current schema version (the most recent migration)
+- List of recent migrations (up to 10)
+- Success status for each migration
+- Installation timestamps
+
+If the query fails:
+- Explain that the volume may not exist, or
+- The database may not have been initialized with Flyway, or
+- The database file doesn't exist yet
+
+# Additional Helpful Commands
+
+After showing the results, offer these follow-up options:
+
+1. **Show all migrations:** Remove the LIMIT from the SQL query
+2. **Show table structure:** Create SQL file with `.schema flyway_schema_history`
+3. **Show all tables:** Create SQL file with `.tables`
+4. **Check database file:**
+   ```bash
+   docker run --rm -v {{VOLUME_NAME}}:/data alpine ls -lh /data/
+   ```
+
+# Usage Examples
+
+```
+/check_schema_version
+```
+Checks the default `mcp-task-data` volume.
+
+```
+/check_schema_version my-custom-volume
+```
+Checks the `my-custom-volume` Docker volume.

.claude/commands/deploy_to_docker.md

@@ -0,0 +1,238 @@
+# Deploy to Docker
+
+Build and deploy the MCP Task Orchestrator Docker image with the specified tag.
+
+**Usage:** `/deploy_to_docker [image-tag]`
+
+**Examples:**
+- `/deploy_to_docker` (will prompt for tag, default: task-orchestrator:dev)
+- `/deploy_to_docker task-orchestrator:local-test` (use specific tag)
+
+---
+
+## Deployment Workflow
+
+Execute the following steps to build and deploy the Docker image:
+
+### Step 0: Determine Image Tag (If Not Provided)
+
+**If the user did not provide an image tag** (e.g., just `/deploy_to_docker` without arguments), ask them using AskUserQuestion:
+
+```
+AskUserQuestion(
+  questions: [{
+    question: "Which Docker image tag would you like to use?",
+    header: "Image Tag",
+    multiSelect: false,
+    options: [
+      {
+        label: "task-orchestrator:dev",
+        description: "Default development tag (recommended)"
+      }
+    ]
+  }]
+)
+```
+
+**Note:** The AskUserQuestion tool automatically provides an "Other" option where users can type a custom tag name (e.g., `task-orchestrator:local-test`, `task-orchestrator:v2.0`, etc.).
+
+**Based on user choice:**
+- **"task-orchestrator:dev"**: Use the default tag
+- **"Other" with custom input**: Use the custom tag provided by the user
+
+Store the selected tag and use it for the rest of the workflow as `<image-tag>`.
+
+**If the user DID provide a tag** (e.g., `/deploy_to_docker task-orchestrator:local-test`), skip this step and use the provided tag.
+
+### Step 1: Clean Build (Optional but Recommended)
+
+Run a clean build first to ensure all changes are compiled:
+
+```bash
+./gradlew clean build
+```
+
+Wait for confirmation that all tests pass before proceeding.
+
+### Step 2: Build Docker Image
+
+Build the Docker image with the determined tag (from Step 0 if prompted, or from command arguments).
+
+**Command:**
+```bash
+docker build -t <image-tag> .
+```
+
+Where `<image-tag>` is the tag from Step 0 or provided by the user (e.g., `task-orchestrator:dev`, `task-orchestrator:local-test`).
+
+### Step 3: Verify Image Built Successfully
+
+After build completes, verify the image exists:
+
+```bash
+docker images | grep <image-name>
+```
+
+Where `<image-name>` is the base name from the tag (e.g., `task-orchestrator`).
+
+### Step 4: Run Docker Container
+
+**Ask the user about container status** (use AskUserQuestion):
+
+```
+AskUserQuestion(
+  questions: [{
+    question: "Do you want to start a new container with the deployed image?",
+    header: "Container",
+    multiSelect: false,
+    options: [
+      {
+        label: "Start New Container",
+        description: "Run a new container with the deployed image"
+      },
+      {
+        label: "Container Already Running",
+        description: "Skip container startup, proceed to testing"
+      },
+      {
+        label: "Skip Container Startup",
+        description: "Just build the image, don't start a container"
+      }
+    ]
+  }]
+)
+```
+
+**Based on user choice:**
+
+- **"Start New Container"**: Continue to ask about run options below
+- **"Container Already Running"**: Skip to Step 5 (testing)
+- **"Skip Container Startup"**: End deployment workflow
+
+---
+
+**If starting new container**, ask which run option to use (use AskUserQuestion):
+
+```
+AskUserQuestion(
+  questions: [{
+    question: "Which Docker run configuration would you like to use?",
+    header: "Run Mode",
+    multiSelect: false,
+    options: [
+      {
+        label: "Basic Run",
+        description: "Database only (no config file access)"
+      },
+      {
+        label: "With Project Mount",
+        description: "Recommended - Enables config reading (.taskorchestrator/)"
+      },
+      {
+        label: "With Debug Logging",
+        description: "Project mount + MCP_DEBUG=true for detailed logs"
+      }
+    ]
+  }]
+)
+```
+
+**Based on user choice, run the appropriate command:**
+
+**"Basic Run" (Database Only)**
+```bash
+docker run --rm -i -v mcp-task-data:/app/data <image-tag>
+```
+
+**"With Project Mount" (Recommended)**
+```bash
+docker run --rm -i \
+  -v mcp-task-data:/app/data \
+  -v D:/Projects/task-orchestrator:/project \
+  -e AGENT_CONFIG_DIR=/project \
+  <image-tag>
+```
+
+**"With Debug Logging"**
+```bash
+docker run --rm -i \
+  -v mcp-task-data:/app/data \
+  -v D:/Projects/task-orchestrator:/project \
+  -e AGENT_CONFIG_DIR=/project \
+  -e MCP_DEBUG=true \
+  <image-tag>
+```
+
+### Step 5: Test the Deployment
+
+After the container is running, suggest testing basic functionality:
+
+1. Verify server starts without errors
+2. Test a simple MCP tool (e.g., `list_templates`)
+3. Verify configuration files are accessible (if using Option 2)
+
+---
+
+## Important Notes
+
+- **Database Persistence:** The volume `mcp-task-data` persists database between container runs
+- **Config Access:** Option 2 is required for reading `.taskorchestrator/config.yaml` and `agent-mapping.yaml`
+- **Port Mapping:** MCP servers use stdin/stdout, no port mapping needed
+- **Cleanup:** Use `--rm` flag to auto-remove container after stopping
+- **Hot Reload:** If container is already running, rebuild with same tag and restart container to load new image
+
+## Troubleshooting
+
+**If build fails:**
+- Check that `./gradlew build` completed successfully
+- Verify Dockerfile exists in project root
+- Check for sufficient disk space
+
+**If container fails to start:**
+- Check logs with `docker logs <container-id>`
+- Verify volume paths are correct (Windows uses forward slashes in Docker)
+- Try Option 3 (debug mode) for detailed logging
+
+**If config files not found:**
+- Ensure using Option 2 with AGENT_CONFIG_DIR set
+- Verify project path is correct: `D:/Projects/task-orchestrator`
+- Check that `.taskorchestrator/` directory exists in project
+
+---
+
+## Post-Deployment
+
+After successful deployment:
+1. ✅ Confirm container is running (or already was running)
+2. ✅ Verify MCP tools are accessible
+3. ✅ Test configuration file loading (if applicable)
+4. ✅ Inform user of deployment success
+
+Return a summary of what was deployed and how to stop/restart the container:
+
+**Stop container:**
+```bash
+docker stop <container-id>
+```
+
+**Restart container with new image:**
+```bash
+# Stop existing container first
+docker stop <container-id>
+# Then run with same command as Step 4
+```
+
+Or simply press Ctrl+C if running in foreground with `-i` flag.
+
+---
+
+## Final Step: Reconnect MCP Server
+
+**After deployment is complete, reconnect the MCP server to load the new image:**
+
+Use the slash command:
+```
+/mcp reconnect task-orchestrator
+```
+
+This ensures Claude Code is using the newly deployed Docker image with all the latest changes.

.github/workflows/docker-publish.yml

@@ -12,7 +12,39 @@ env:
   IMAGE_NAME: ${{ github.repository }}
 
 jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Needed for version calculation
+
+    - name: Set up JDK 23
+      uses: actions/setup-java@v4
+      with:
+        java-version: '23'
+        distribution: 'temurin'
+
+    - name: Setup Gradle
+      uses: gradle/actions/setup-gradle@v3
+
+    - name: Make gradlew executable
+      run: chmod +x gradlew
+
+    - name: Run tests
+      run: ./gradlew test --no-daemon --tests '*' --tests '!DescriptionFieldMigrationTest'
+
+    - name: Publish Test Report
+      uses: mikepenz/action-junit-report@v4
+      if: always()
+      with:
+        report_paths: '**/build/test-results/test/TEST-*.xml'
+        check_name: 'Test Results'
+
   build:
+    needs: test  # Wait for tests to pass before building Docker
     runs-on: ubuntu-latest
     permissions:
       contents: read