mcp-ticketer 0.4.4__tar.gz → 0.6.2__tar.gz

{mcp_ticketer-0.4.4 → mcp_ticketer-0.6.2}/.github/workflows/publish.yml

@@ -57,7 +57,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: ['3.9', '3.11', '3.13']
+        python-version: ['3.10', '3.11', '3.12', '3.13']
 
     steps:
     - uses: actions/checkout@v4

mcp_ticketer-0.6.2/BEFORE_AFTER_COMPARISON.md

@@ -0,0 +1,271 @@
+# Before/After Code Comparison - Linear Init Fix
+
+## The Bug
+
+When running `mcp-ticketer init` and selecting Linear from the interactive menu without environment variables, users would get an error instead of being prompted for credentials.
+
+## Code Changes
+
+### BEFORE (Lines 652-743) - BROKEN
+
+```python
+elif adapter_type == "linear":
+    # If not auto-discovered, build from CLI params or prompt
+    if adapter_type not in config["adapters"]:
+        linear_config = {}  # ❌ Build dict too early
+
+        # API Key
+        linear_api_key = api_key or os.getenv("LINEAR_API_KEY")
+        if not linear_api_key and not discovered:
+            # ... prompt ...
+            linear_api_key = typer.prompt("Enter your Linear API key", hide_input=True)
+
+        if linear_api_key:  # ❌ Only add if exists
+            linear_config["api_key"] = linear_api_key
+
+        # Team info collection...
+        linear_team_key = os.getenv("LINEAR_TEAM_KEY")
+        linear_team_id = team_id or os.getenv("LINEAR_TEAM_ID")
+
+        if not linear_team_key and not linear_team_id and not discovered:
+            # ... prompt ...
+            team_input = typer.prompt("Team URL, key, or ID")
+            # ... URL derivation logic ...
+
+        # Save whichever was provided
+        if linear_team_key:
+            linear_config["team_key"] = linear_team_key
+        if linear_team_id:
+            linear_config["team_id"] = linear_team_id
+
+        # ❌ EARLY VALIDATION - This would exit before saving!
+        if not linear_config.get("api_key") or (
+            not linear_config.get("team_id") and not linear_config.get("team_key")
+        ):
+            console.print("[red]Error:[/red] Linear requires both API key and team ID/key")
+            console.print("Run 'mcp-ticketer init --adapter linear' with proper credentials")
+            raise typer.Exit(1)
+
+        linear_config["type"] = "linear"
+        config["adapters"]["linear"] = linear_config  # Never reached if validation failed
+```
+
+### AFTER (Lines 652-741) - FIXED
+
+```python
+elif adapter_type == "linear":
+    # If not auto-discovered, build from CLI params or prompt
+    if adapter_type not in config["adapters"]:
+        # ✅ Collect variables first, no dict yet
+
+        # API Key
+        linear_api_key = api_key or os.getenv("LINEAR_API_KEY")
+        if not linear_api_key and not discovered:
+            console.print("\n[bold]Linear Configuration[/bold]")
+            console.print("You need a Linear API key to connect to Linear.")
+            console.print("[dim]Get your API key at: https://linear.app/settings/api[/dim]\n")
+
+            linear_api_key = typer.prompt("Enter your Linear API key", hide_input=True)
+
+        # Team ID or Team Key or Team URL
+        linear_team_key = os.getenv("LINEAR_TEAM_KEY")
+        linear_team_id = team_id or os.getenv("LINEAR_TEAM_ID")
+
+        if not linear_team_key and not linear_team_id and not discovered:
+            console.print("\n[bold]Linear Team Configuration[/bold]")
+            console.print("You can provide either:")
+            console.print("  1. Team URL (e.g., https://linear.app/workspace/team/TEAMKEY/active)")
+            console.print("  2. Team key (e.g., 'ENG', 'DESIGN', 'PRODUCT')")
+            console.print("  3. Team ID (UUID)")
+            console.print("[dim]Find team URL or key in: Linear → Your Team → Team Issues Page[/dim]\n")
+
+            team_input = typer.prompt("Team URL, key, or ID")
+
+            # Check if input is a URL
+            if team_input.startswith("https://linear.app/"):
+                # ... URL derivation logic (unchanged) ...
+            else:
+                # Input is team key or ID
+                if len(team_input) > 20:  # Likely a UUID
+                    linear_team_id = team_input
+                else:
+                    linear_team_key = team_input
+
+        # ✅ Validate AFTER collection (JIRA pattern)
+        if not linear_api_key:
+            console.print("[red]Error:[/red] Linear API key is required")
+            raise typer.Exit(1)
+
+        if not linear_team_id and not linear_team_key:
+            console.print("[red]Error:[/red] Linear requires either team ID or team key")
+            raise typer.Exit(1)
+
+        # ✅ Build config dict AFTER validation passes
+        linear_config = {
+            "api_key": linear_api_key,
+            "type": "linear",
+        }
+
+        # Save whichever was provided
+        if linear_team_key:
+            linear_config["team_key"] = linear_team_key
+        if linear_team_id:
+            linear_config["team_id"] = linear_team_id
+
+        # ✅ Save config (only reached if validation passed)
+        config["adapters"]["linear"] = linear_config
+```
+
+## Key Differences
+
+| Aspect | BEFORE (Broken) | AFTER (Fixed) |
+|--------|-----------------|---------------|
+| Dict Creation | Created `linear_config = {}` immediately | Created after validation passes |
+| Validation Timing | Validated partial dict (line 731) | Validates collected variables (line 721) |
+| Error Handling | Could exit before prompts completed | Exits only after all prompts run |
+| Config Building | Built incrementally with `if` checks | Built once with all validated values |
+| Pattern Match | Different from JIRA adapter | Matches JIRA adapter pattern |
+
+## Execution Flow Comparison
+
+### BEFORE - Broken Flow
+```
+1. User selects Linear from menu
+2. linear_config = {} (empty dict created)
+3. Prompt for API key
+   → User enters key
+   → linear_config["api_key"] = key
+4. Prompt for team info
+   → User enters team
+   → linear_config["team_key"] = team
+5. ❌ Validation checks linear_config
+   → If any field missing: EXIT with error
+   → Never saves config
+```
+
+**Problem:** Validation happened on a partially-built dict that might be incomplete due to prompt logic.
+
+### AFTER - Fixed Flow
+```
+1. User selects Linear from menu
+2. Collect API key → linear_api_key variable
+3. Prompt if needed → linear_api_key = "user_input"
+4. Collect team info → linear_team_id/key variables
+5. Prompt if needed → linear_team_key = "user_input"
+6. ✅ Validate collected variables
+   → If missing: EXIT with clear error
+   → If present: Continue
+7. Build linear_config dict
+8. Save config to adapters
+```
+
+**Solution:** Validation happens on collected variables, then config dict is built only if valid.
+
+## Why This Pattern Works
+
+The JIRA adapter (lines 745-803) demonstrates the correct pattern:
+
+```python
+# 1. Collect into variables
+server = jira_server or os.getenv("JIRA_SERVER")
+email = jira_email or os.getenv("JIRA_EMAIL")
+token = api_key or os.getenv("JIRA_API_TOKEN")
+
+# 2. Prompt for missing values
+if not server and not discovered:
+    server = typer.prompt("JIRA server URL")
+if not email and not discovered:
+    email = typer.prompt("Your JIRA email address")
+
+# 3. Validate collected variables
+if not server:
+    console.print("[red]Error:[/red] JIRA server URL is required")
+    raise typer.Exit(1)
+
+# 4. Build config dict (only if valid)
+jira_config = {
+    "server": server,
+    "email": email,
+    "api_token": token,
+    "type": "jira",
+}
+
+# 5. Save config
+config["adapters"]["jira"] = jira_config
+```
+
+Linear now follows the same pattern.
+
+## Impact
+
+### User Experience
+- **Before:** Confusing error message immediately after menu selection
+- **After:** Smooth interactive prompting experience
+
+### Code Consistency
+- **Before:** Linear used different pattern than JIRA
+- **After:** All adapters follow the same pattern
+
+### Test Coverage
+- No existing tests for this functionality (manual testing required)
+- Future improvement: Add unit tests for init command
+
+## Testing the Fix
+
+### Manual Test 1: Interactive Selection
+```bash
+# Clean environment
+unset LINEAR_API_KEY LINEAR_TEAM_KEY LINEAR_TEAM_ID
+rm -rf ~/.mcp_ticketer
+
+# Run init
+mcp-ticketer init
+
+# Expected:
+# - No adapter detected
+# - Shows menu: "1. Linear, 2. JIRA, 3. AitRackdown"
+# - Select 1 (Linear)
+# - Prompts: "Enter your Linear API key"
+# - Prompts: "Team URL, key, or ID"
+# - Success message
+# - Config saved to ~/.mcp_ticketer/config.json
+```
+
+### Manual Test 2: Partial Credentials
+```bash
+# Set only API key
+export LINEAR_API_KEY="test_key_123"
+unset LINEAR_TEAM_KEY LINEAR_TEAM_ID
+
+# Run init
+mcp-ticketer init
+
+# Expected:
+# - Detects Linear from environment
+# - Prompts ONLY for team info (not API key)
+# - Success
+```
+
+### Manual Test 3: Validation Works
+```bash
+# Try to bypass prompts (hit Enter without input)
+# This should fail with clear error message
+```
+
+## Verification Checklist
+
+- [x] Code compiles (Python syntax valid)
+- [x] Follows JIRA adapter pattern
+- [x] Validation moved after collection
+- [x] Config dict built after validation
+- [x] Error messages are clear
+- [x] All features preserved (URL derivation, discovery)
+- [x] No regressions in CLI parameters
+- [ ] Manual testing completed (requires user interaction)
+- [ ] Unit tests added (future work)
+
+## Related Documentation
+
+- See `LINEAR_INIT_FIX_SUMMARY.md` for detailed implementation notes
+- See `/src/mcp_ticketer/cli/main.py` lines 652-741 for actual code
+- Compare with JIRA adapter (lines 743-803) for reference pattern

{mcp_ticketer-0.4.4 → mcp_ticketer-0.6.2}/CHANGELOG.md

@@ -4,6 +4,83 @@ All notable changes to MCP Ticketer will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.15] - 2025-11-07
+
+### Fixed
+- **Linear Task Creation with Parent Issues**: Fixed Linear adapter to resolve issue identifiers to UUIDs
+  - Task creation with `parent_issue` parameter now works with both issue identifiers (e.g., "ENG-842") and UUIDs
+  - Added automatic identifier resolution via GraphQL query
+  - Eliminates "Variable '$issueId' of non-null type 'UUID!' must not be null" errors
+  - Resolves validation failures when creating tasks under parent issues
+
+### Added
+- **Linear Issue Resolution Method**: Added `_resolve_issue_id()` for automatic identifier resolution
+  - Resolves issue identifiers (like "ENG-842") to UUIDs via GraphQL
+  - Provides clear error messages when issues cannot be found
+  - Enables flexible parent issue specification in task creation
+  - Comprehensive test coverage with 13 new tests
+
+### Changed
+- **Code Quality**: Import formatting standardization across codebase
+  - Applied consistent import ordering to 38 files
+  - Improved code consistency and maintainability
+  - No functional changes to core logic
+
+### Testing
+- **Issue Resolution Tests**: Added comprehensive test suite for Linear issue resolution
+  - Created `tests/adapters/linear/test_issue_resolution.py` with 13 tests
+  - Tests cover identifier resolution, UUID handling, and error cases
+  - Validates task creation with parent issues
+  - 100% test coverage for new resolution functionality
+
+### Documentation
+- **Linear Parent Issue Fix**: Added detailed documentation in `docs/linear_parent_issue_fix.md`
+  - Explains the root cause of the issue
+  - Documents the resolution approach
+  - Provides examples and testing guidance
+
+## [0.4.11] - 2025-10-28
+
+### Fixed
+- **CRITICAL: MCP Installer Command Structure**: Fixed all MCP installers to use Python module invocation pattern
+  - Changed from: `command: {venv}/bin/mcp-ticketer`, `args: ["mcp", project_path]`
+  - Changed to: `command: {venv}/bin/python`, `args: ["-m", "mcp_ticketer.mcp.server", project_path]`
+  - Affects: Claude Code, Auggie CLI, Gemini CLI, and Codex CLI installers
+  - Impact: Installer now works with any Python environment (pip, pipx, editable installs)
+  - Matches established pattern from mcp-vector-search and other MCP servers
+
+### Files Modified
+- `src/mcp_ticketer/cli/mcp_configure.py` - Claude Code/Desktop installer
+- `src/mcp_ticketer/cli/auggie_configure.py` - Auggie CLI installer
+- `src/mcp_ticketer/cli/gemini_configure.py` - Gemini CLI installer
+- `src/mcp_ticketer/cli/codex_configure.py` - Codex CLI installer
+
+### Technical Details
+- Uses Python executable directly with `-m` module flag
+- No longer depends on `mcp-ticketer` binary existing in target venv
+- Works across all installation methods and Python environments
+- Provides consistent behavior with other MCP ecosystem tools
+
+## [0.4.10] - 2025-10-28
+
+### Fixed
+- **CRITICAL: MCP Installer Configuration**: Fixed Claude Code MCP installer to write to correct config location
+  - Changed config path from `.claude/settings.local.json` to `~/.claude.json`
+  - Updated to use project-specific structure: `.projects[path].mcpServers["mcp-ticketer"]`
+  - Added backward compatibility with `.claude/mcp.local.json`
+  - Enhanced error handling for invalid JSON and empty config files
+  - Added `type: "stdio"` field required by Claude Code
+  - Uses absolute project paths with `Path.cwd().resolve()`
+  - Matches working pattern from mcp-vector-search installation
+  - Resolves issue where mcp-ticketer server failed to connect in Claude Code
+
+### Technical Details
+- Updated `find_claude_mcp_config()` to return `~/.claude.json` for Claude Code
+- Enhanced `load_claude_mcp_config()` with platform-specific structure support
+- Refactored `configure_claude_mcp()` to write to both primary and legacy locations
+- Updated `remove_claude_mcp()` to clean up both config locations
+- Added comprehensive JSON parsing and empty file handling
+
 ## [0.4.4] - 2025-10-27
 
 ### Changed

mcp_ticketer-0.6.2/ENV_LOADING_FIX.md

@@ -0,0 +1,134 @@
+# Environment Loading Timing Fix
+
+## Problem
+The `.env.local` file loading was happening at Python module import time, which occurred BEFORE the working directory was changed to the target project directory in `__main__.py`. This caused the MCP server to load environment variables from the wrong directory.
+
+## Root Cause Analysis
+
+### Execution Flow (Before Fix)
+```
+1. claude-code runs: python -m mcp_ticketer.mcp.server /Users/masa/Projects/claude-mpm
+2. Python imports mcp_ticketer.mcp.server.__main__
+3. __main__.py imports from .main (line 16) ← Triggers module load
+4. main.py module-level code (lines 31-46): load_dotenv(Path.cwd() / ".env.local") ← WRONG directory!
+5. THEN __main__.py changes directory (line 43) ← TOO LATE
+```
+
+### The Issue
+- Module-level code runs during `import`, not during function execution
+- `__main__.py` imports `main` before changing directories
+- Environment variables were loaded from the directory where the command was executed, not the target project
+
+## Solution
+
+### Changes Made
+1. **Removed** module-level `load_dotenv()` calls from `src/mcp_ticketer/mcp/server/main.py` (lines 31-46)
+2. **Moved** environment loading INTO the `main()` async function (after logger initialization, line 1034)
+3. **Added** clarifying comments explaining the timing
+4. **Added** debug logging for better visibility
+
+### Execution Flow (After Fix)
+```
+1. claude-code runs: python -m mcp_ticketer.mcp.server /Users/masa/Projects/claude-mpm
+2. Python imports mcp_ticketer.mcp.server.__main__
+3. __main__.py imports from .main (line 16) ← Module loads WITHOUT env loading
+4. __main__.py changes directory (line 43) ← Sets correct working directory
+5. __main__.py calls main() (line 50)
+6. main() loads .env.local from Path.cwd() ← CORRECT directory!
+```
+
+## Testing
+
+### Test Results
+✅ Module import does not trigger environment loading
+✅ Correct `.env.local` file is detected in target project directory
+✅ Working directory is correctly set before `main()` executes
+
+### Test Commands
+```bash
+# From mcp-ticketer directory
+uv run python -m mcp_ticketer.mcp.server /Users/masa/Projects/claude-mpm
+
+# Should output:
+# [MCP Server] Working directory: /Users/masa/Projects/claude-mpm
+# [MCP Server] Loaded environment from: /Users/masa/Projects/claude-mpm/.env.local
+```
+
+## Files Modified
+- `src/mcp_ticketer/mcp/server/main.py`
+
+## Impact
+- **Before**: MCP server loaded `.env.local` from command execution directory
+- **After**: MCP server loads `.env.local` from target project directory
+- **Result**: Environment variables are now correctly loaded for the target project
+
+## Success Criteria
+- ✅ Server loads `.env.local` from target project directory, not from where command is executed
+- ✅ MCP server successfully initializes when called by claude-code
+- ✅ Debug logs show correct `.env.local` path being loaded
+- ✅ No environment loading happens during module import
+
+## Technical Details
+
+### Why Module-Level Code is Problematic
+Python executes module-level code immediately when the module is imported, before any function calls. This means:
+- Module-level code in `main.py` runs when `__main__.py` imports it
+- At that point, the working directory hasn't been changed yet
+- Environment loading happens from the wrong directory
+
+### Why Function-Level Code Works
+By moving the environment loading into the `main()` function:
+- Code only runs when `main()` is explicitly called
+- `__main__.py` has already changed the working directory
+- Environment loading happens from the correct target project directory
+
+## Code Changes
+
+### Before (lines 31-46, module level)
+```python
+# Load environment variables early (prioritize .env.local)
+# Check for .env.local first (takes precedence)
+env_local_file = Path.cwd() / ".env.local"
+if env_local_file.exists():
+    load_dotenv(env_local_file, override=True)
+    sys.stderr.write(f"[MCP Server] Loaded environment from: {env_local_file}\n")
+else:
+    # Fall back to .env
+    env_file = Path.cwd() / ".env"
+    if env_file.exists():
+        load_dotenv(env_file, override=True)
+        sys.stderr.write(f"[MCP Server] Loaded environment from: {env_file}\n")
+    else:
+        # Try default dotenv loading (searches upward)
+        load_dotenv(override=True)
+        sys.stderr.write("[MCP Server] Loaded environment from default search path\n")
+```
+
+### After (inside main() function, around line 1034)
+```python
+# Load environment variables AFTER working directory has been set by __main__.py
+# This ensures we load .env files from the target project directory, not from where the command is executed
+env_local_file = Path.cwd() / ".env.local"
+if env_local_file.exists():
+    load_dotenv(env_local_file, override=True)
+    sys.stderr.write(f"[MCP Server] Loaded environment from: {env_local_file}\n")
+    logger.debug(f"Loaded environment from: {env_local_file}")
+else:
+    # Fall back to .env
+    env_file = Path.cwd() / ".env"
+    if env_file.exists():
+        load_dotenv(env_file, override=True)
+        sys.stderr.write(f"[MCP Server] Loaded environment from: {env_file}\n")
+        logger.debug(f"Loaded environment from: {env_file}")
+    else:
+        # Try default dotenv loading (searches upward)
+        load_dotenv(override=True)
+        sys.stderr.write("[MCP Server] Loaded environment from default search path\n")
+        logger.debug("Loaded environment from default search path")
+```
+
+## LOC Impact
+- **Net LOC**: 0 (moved code, not added)
+- **Lines Removed**: 16 (module-level)
+- **Lines Added**: 20 (function-level with debug logging)
+- **Impact**: +4 LOC (due to additional debug logging)