@techwavedev/agi-agent-kit 1.1.7 → 1.2.1

package/templates/skills/ec/jira/scripts/bulk_log_work.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Bulk Log Work Utility
+
+A reusable script to log work across a date range for a specific ticket.
+Automatically handles weekends and European Commission holidays.
+
+Usage:
+    python bulk_log_work.py --ticket <key> --start <YYYY-MM-DD> --end <YYYY-MM-DD> --time <duration> --comment <text>
+
+Arguments:
+    --ticket    Ticket key (required)
+    --start     Start date YYYY-MM-DD (required)
+    --end       End date YYYY-MM-DD (default: today)
+    --time      Time per working day (e.g., "3h", "1h 30m")
+    --comment   Comment for worklogs. If multiple, separate with '|' to rotate.
+    --dry-run   Show what would be logged without making API calls
+
+Example:
+    python bulk_log_work.py --ticket KASP-1241 --start 2026-01-01 --time 2h --comment "Infra check|Alert check"
+"""
+
+import argparse
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import List
+
+sys.path.insert(0, str(Path(__file__).parent))
+from jira_client import get_client
+
+
+def get_ec_holidays(year: int) -> List[str]:
+    """Return a list of EC holidays for a given year (approximate)."""
+    # Standard EC holidays
+    holidays = [
+        f"{year}-01-01", f"{year}-01-02",  # New Year
+        f"{year}-05-01",                   # Labor Day
+        f"{year}-05-09",                   # Europe Day
+        f"{year}-07-21",                   # National Day
+        f"{year}-08-15",                   # Assumption
+        f"{year}-11-01",                   # All Saints
+        f"{year}-11-02",                   # All Souls
+        f"{year}-12-24", f"{year}-12-25", f"{year}-12-26",
+        f"{year}-12-27", f"{year}-12-28", f"{year}-12-29",
+        f"{year}-12-30", f"{year}-12-31"   # Winter break
+    ]
+    
+    # Easter-related (approximate for demonstration, usually fixed per year)
+    if year == 2026:
+        holidays.extend(["2026-04-02", "2026-04-03", "2026-04-06", "2026-05-14", "2026-05-25"])
+        
+    return holidays
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Bulk log work to Jira tickets")
+    parser.add_argument("--ticket", required=True, help="Ticket key")
+    parser.add_argument("--start", required=True, help="Start date (YYYY-MM-DD)")
+    parser.add_argument("--end", help="End date (YYYY-MM-DD, defaults to today)")
+    parser.add_argument("--time", required=True, help="Time per working day (e.g., 2h)")
+    parser.add_argument("--comment", required=True, help="Comment(s) - use | to rotate multiple")
+    parser.add_argument("--dry-run", action="store_true", help="Don't actually log work")
+    args = parser.parse_args()
+
+    client = get_client()
+    ticket = args.ticket.upper()
+    
+    # Parse dates
+    start_date = datetime.strptime(args.start, "%Y-%m-%d")
+    end_date = datetime.strptime(args.end, "%Y-%m-%d") if args.end else datetime.now()
+    
+    # Parse comments
+    comments = [c.strip() for c in args.comment.split('|')]
+    
+    print(f"🚀 {'[DRY RUN] ' if args.dry_run else ''}Bulk logging for {ticket}")
+    print(f"   Period: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}")
+    print(f"   Work: {args.time} per day")
+    print("-" * 50)
+    
+    current_date = start_date
+    working_days_count = 0
+    
+    while current_date <= end_date:
+        date_str = current_date.strftime("%Y-%m-%d")
+        holidays = get_ec_holidays(current_date.year)
+        
+        # Skip weekends and holidays
+        if current_date.weekday() >= 5:
+            # print(f"🏠 {date_str}: Weekend (Skipping)")
+            pass
+        elif date_str in holidays:
+            print(f"🎉 {date_str}: Holiday (Skipping)")
+        else:
+            comment = comments[working_days_count % len(comments)]
+            # 14:00 (2 PM) as a default work check time
+            started = current_date.strftime("%Y-%m-%dT14:00:00.000+0100")
+            
+            print(f"⏱️  {date_str}: Logging {args.time} - {comment}...", end=" ", flush=True)
+            
+            if not args.dry_run:
+                success, result = client.add_worklog(
+                    ticket,
+                    time_spent=args.time,
+                    comment=comment,
+                    started=started
+                )
+                if success:
+                    print("✅ Done")
+                else:
+                    print(f"❌ Failed: {result}")
+            else:
+                print("📝 (Skipped)")
+                
+            working_days_count += 1
+            
+        current_date += timedelta(days=1)
+        
+    print("-" * 50)
+    print(f"🏁 Finished! Processed {working_days_count} working day(s).")
+
+
+if __name__ == "__main__":
+    main()

package/templates/skills/ec/jira/scripts/create_ticket.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""
+Create Jira Ticket
+
+Creates a new issue in Jira with specified fields.
+
+Usage:
+    python create_ticket.py --project <key> --summary <text> [options]
+
+Arguments:
+    --project       Project key (required)
+    --summary       Issue summary (required)
+    --type          Issue type: Bug, Task, Story, Epic (default: Task)
+    --priority      Priority: Highest, High, Medium, Low, Lowest
+    --description   Description text
+    --assignee      Assignee username or email
+    --labels        Comma-separated labels
+    --components    Comma-separated component names
+    --epic          Epic link key
+    --parent        Parent ticket key (for sub-tasks)
+    --custom-fields Custom fields as JSON string
+    --output        Output format: json, key, url (default: json)
+
+Exit Codes:
+    0 - Success
+    1 - Invalid arguments
+    2 - API error
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+# Add scripts directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+from jira_client import get_client
+
+
+def parse_labels(labels_str: str) -> list:
+    """Parse comma-separated labels."""
+    if not labels_str:
+        return []
+    return [l.strip() for l in labels_str.split(',') if l.strip()]
+
+
+def build_fields(args, client) -> dict:
+    """Build the fields dictionary for issue creation."""
+    fields = {
+        'project': {'key': args.project},
+        'summary': args.summary,
+        'issuetype': {'name': args.type}
+    }
+    
+    if args.priority:
+        fields['priority'] = {'name': args.priority}
+    
+    if args.description:
+        fields['description'] = client._format_body(args.description)
+    
+    if args.assignee:
+        # Try to resolve assignee
+        user_id_key = 'name' if client.is_server else 'accountId'
+        
+        if args.assignee.lower() == 'me':
+            success, me = client.get_myself()
+            if success:
+                fields['assignee'] = {user_id_key: me.get(user_id_key)}
+        else:
+            # Search for user
+            success, users = client.search_users(args.assignee, max_results=1)
+            if success and users:
+                fields['assignee'] = {user_id_key: users[0].get(user_id_key)}
+            else:
+                # Fallback to literal name if search fails but we have a candidate
+                fields['assignee'] = {user_id_key: args.assignee}
+    
+    if args.parent:
+        fields['parent'] = {'key': args.parent}
+    
+    if args.epic:
+        # Epic link field varies by project, but 'parent' is often used in newer Jira
+        fields['parent'] = {'key': args.epic}
+    
+    if args.labels:
+        fields['labels'] = parse_labels(args.labels)
+    
+    if args.components:
+        fields['components'] = [{'name': c.strip()} for c in args.components.split(',')]
+    
+    # Custom fields
+    if args.custom_fields:
+        try:
+            custom = json.loads(args.custom_fields)
+            fields.update(custom)
+        except json.JSONDecodeError as e:
+            print(f"⚠️  Warning: Invalid custom-fields JSON: {e}", file=sys.stderr)
+    
+    return fields
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Create a Jira ticket',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__
+    )
+    parser.add_argument('--project', required=True, help='Project key')
+    parser.add_argument('--summary', required=True, help='Issue summary')
+    parser.add_argument('--type', default='Task', help='Issue type')
+    parser.add_argument('--priority', help='Priority level')
+    parser.add_argument('--description', help='Description text')
+    parser.add_argument('--assignee', help='Assignee username/email')
+    parser.add_argument('--labels', help='Comma-separated labels')
+    parser.add_argument('--components', help='Comma-separated components')
+    parser.add_argument('--epic', help='Epic link key')
+    parser.add_argument('--parent', help='Parent ticket key (for sub-tasks)')
+    parser.add_argument('--custom-fields', help='Custom fields as JSON')
+    parser.add_argument('--output', choices=['json', 'key', 'url'], default='json',
+                        help='Output format')
+    args = parser.parse_args()
+    
+    client = get_client()
+    
+    print(f"📝 Creating ticket in project {args.project}...", file=sys.stderr)
+    
+    # Build fields
+    fields = build_fields(args, client)
+    
+    # Create issue
+    success, result = client.create_issue(fields)
+    
+    if not success:
+        print(f"❌ Error creating ticket: {result}", file=sys.stderr)
+        sys.exit(2)
+    
+    issue_key = result.get('key', 'Unknown')
+    issue_url = f"{client.base_url}/browse/{issue_key}"
+    
+    # Output based on format
+    if args.output == 'key':
+        print(issue_key)
+    elif args.output == 'url':
+        print(issue_url)
+    else:
+        output = {
+            'success': True,
+            'key': issue_key,
+            'id': result.get('id'),
+            'url': issue_url,
+            'self': result.get('self')
+        }
+        print(json.dumps(output, indent=2))
+    
+    print(f"✅ Created ticket: {issue_key}", file=sys.stderr)
+    print(f"   URL: {issue_url}", file=sys.stderr)
+    
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

package/templates/skills/ec/jira/scripts/get_ticket.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Get Jira Ticket Details
+
+Retrieve full details for a specific Jira issue.
+
+Usage:
+    python get_ticket.py --ticket <key> [options]
+
+Arguments:
+    --ticket            Ticket key (required)
+    --include-comments  Include comments
+    --include-worklog   Include work logs
+    --include-transitions  Show available transitions
+    --output            Output format: json, summary (default: summary)
+
+Exit Codes:
+    0 - Success
+    1 - Invalid arguments
+    2 - Ticket not found
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from jira_client import get_client
+
+
+def format_summary(issue: dict, transitions: list = None, comments: list = None, 
+                   worklogs: list = None, base_url: str = '') -> str:
+    """Format issue as human-readable summary."""
+    key = issue.get('key', 'Unknown')
+    fields = issue.get('fields', {})
+    
+    lines = [
+        f"# {key}: {fields.get('summary', 'No summary')}",
+        "",
+        f"**URL:** {base_url}/browse/{key}",
+        "",
+        "## Details",
+        "",
+        f"| Field | Value |",
+        f"|-------|-------|",
+        f"| Type | {fields.get('issuetype', {}).get('name', '-')} |",
+        f"| Status | {fields.get('status', {}).get('name', '-')} |",
+        f"| Priority | {fields.get('priority', {}).get('name', '-') if fields.get('priority') else '-'} |",
+    ]
+    
+    assignee = fields.get('assignee')
+    lines.append(f"| Assignee | {assignee.get('displayName', '-') if assignee else 'Unassigned'} |")
+    
+    reporter = fields.get('reporter')
+    lines.append(f"| Reporter | {reporter.get('displayName', '-') if reporter else '-'} |")
+    
+    lines.append(f"| Created | {fields.get('created', '-')[:10] if fields.get('created') else '-'} |")
+    lines.append(f"| Updated | {fields.get('updated', '-')[:10] if fields.get('updated') else '-'} |")
+    
+    if fields.get('labels'):
+        lines.append(f"| Labels | {', '.join(fields['labels'])} |")
+    
+    lines.append("")
+    
+    # Description
+    description = fields.get('description')
+    if description:
+        lines.append("## Description")
+        lines.append("")
+        if isinstance(description, dict):
+            # ADF format - extract text
+            content = description.get('content', [])
+            for block in content:
+                if block.get('type') == 'paragraph':
+                    text_parts = [c.get('text', '') for c in block.get('content', [])]
+                    lines.append(''.join(text_parts))
+        else:
+            lines.append(str(description))
+        lines.append("")
+    
+    # Transitions
+    if transitions:
+        lines.append("## Available Transitions")
+        lines.append("")
+        for t in transitions:
+            lines.append(f"- {t.get('name')} → {t.get('to', {}).get('name', '?')}")
+        lines.append("")
+    
+    # Comments
+    if comments:
+        lines.append(f"## Comments ({len(comments)})")
+        lines.append("")
+        for c in comments[-5:]:  # Last 5 comments
+            author = c.get('author', {}).get('displayName', 'Unknown')
+            created = c.get('created', '')[:10]
+            body = c.get('body', '')
+            if isinstance(body, dict):
+                # ADF format
+                text_parts = []
+                for block in body.get('content', []):
+                    if block.get('type') == 'paragraph':
+                        text_parts.extend([p.get('text', '') for p in block.get('content', [])])
+                body = ' '.join(text_parts)
+            lines.append(f"**{author}** ({created}):")
+            lines.append(f"> {body[:200]}...")
+            lines.append("")
+    
+    # Worklogs
+    if worklogs:
+        lines.append(f"## Work Logs ({len(worklogs)})")
+        lines.append("")
+        total_seconds = sum(w.get('timeSpentSeconds', 0) for w in worklogs)
+        total_hours = total_seconds / 3600
+        lines.append(f"**Total Time Logged:** {total_hours:.1f}h")
+        lines.append("")
+        for w in worklogs[-5:]:  # Last 5 entries
+            author = w.get('author', {}).get('displayName', 'Unknown')
+            time_spent = w.get('timeSpent', '?')
+            lines.append(f"- {author}: {time_spent}")
+        lines.append("")
+    
+    return '\n'.join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Get Jira ticket details',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__
+    )
+    parser.add_argument('--ticket', required=True, help='Ticket key')
+    parser.add_argument('--include-comments', action='store_true', help='Include comments')
+    parser.add_argument('--include-worklog', action='store_true', help='Include work logs')
+    parser.add_argument('--include-transitions', action='store_true', help='Show transitions')
+    parser.add_argument('--output', choices=['json', 'summary'], default='summary',
+                        help='Output format')
+    args = parser.parse_args()
+    
+    client = get_client()
+    ticket = args.ticket.upper()
+    
+    print(f"📋 Getting details for {ticket}...", file=sys.stderr)
+    
+    # Get issue
+    expand = []
+    if args.include_comments:
+        expand.append('renderedFields')
+    
+    success, issue = client.get_issue(ticket, expand=expand if expand else None)
+    if not success:
+        print(f"❌ Error: Could not find ticket {ticket}: {issue}", file=sys.stderr)
+        sys.exit(2)
+    
+    # Get optional data
+    transitions = None
+    comments = None
+    worklogs = None
+    
+    if args.include_transitions:
+        success, trans_data = client.get_transitions(ticket)
+        if success:
+            transitions = trans_data.get('transitions', [])
+    
+    if args.include_comments:
+        success, comment_data = client.get_comments(ticket)
+        if success:
+            comments = comment_data.get('comments', [])
+    
+    if args.include_worklog:
+        success, worklog_data = client.get_worklogs(ticket)
+        if success:
+            worklogs = worklog_data.get('worklogs', [])
+    
+    # Output
+    if args.output == 'json':
+        output = {
+            'issue': issue,
+            'transitions': transitions,
+            'comments': comments,
+            'worklogs': worklogs
+        }
+        print(json.dumps(output, indent=2))
+    else:
+        print(format_summary(issue, transitions, comments, worklogs, client.base_url))
+    
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()