Jira Task Creator

Create and manage Jira tasks using natural language input, smart user search, batch CSV import, and detailed task analytics with flexible field support.

Security Scan

The skill appears to really be a Jira integration (needs a Jira URL and bearer token), but registry metadata and included files are inconsistent and several claimed features are missing — this looks like sloppy or incomplete packaging rather than clearly malicious code, so proceed with caution.

Purpose & Capability

The code and SKILL.md clearly target Jira (create issues, search users) and legitimately need JIRA_BASE_URL and JIRA_BEARER_TOKEN. That aligns with the stated purpose. However, the registry-level metadata at the top lists no required environment variables or primary credential, which contradicts the documentation and code.

Instruction Scope

SKILL.md describes many features (batch CSV import, BatchTaskCreator, TaskAnalyzer analytics, templates, Feishu-Jira mapping). The provided Python source implements NaturalLanguageParser, UserSearcher, create_issue, and search_user only. References to batch_creator and task_analyzer are present in docs/examples but those modules are not included — a capability mismatch that could confuse users or hide missing functionality.

Install Mechanism

There is no formal install spec in the registry (instruction-only), but SKILL.md instructs users to pip install requests and python-dateutil. That is reasonable for a Python skill. The package.json also documents these dependencies. The inconsistency between 'no install spec' at registry-level and the README/package.json/SKILL.md is noteworthy but not itself high-risk.

Credentials

Requesting JIRA_BASE_URL and JIRA_BEARER_TOKEN is proportionate to a Jira integration. However the registry metadata did not declare these required env vars or a primary credential (contradiction). SKILL.md also shows an example config.json that could include bearerToken on disk; storing tokens in config files or logs (logging.saveToFile true / logDirectory) increases exposure risk if users follow examples carelessly.

Persistence & Privilege

The skill does not request always:true, does not declare system config paths, and does not modify other skills. Default autonomous invocation is allowed (platform default) but not combined here with other high-risk indicators.

What to consider before installing

This skill is plausibly a Jira integration, but there are several mismatches and omissions you should consider before installing: - Source unknown / homepage missing: prefer skills from known authors or repo links. Ask the publisher for a canonical source. - Required credentials: SKILL.md and the Python code require JIRA_BASE_URL and JIRA_BEARER_TOKEN, but registry metadata lists none. Treat the bearer token as sensitive — only use a token with the minimum required scope and consider creating an account/token for testing only. - Missing modules/features: the docs reference batch_creator, TaskAnalyzer, templates, and analytics, but those modules are not present. Expect the published package to be incomplete or rely on external components. Ask the author for the missing code or a complete release. - Secret handling risk: examples show embedding tokens in config.json and enabling file logging. Avoid putting bearer tokens into persistent files or logs unless you control and secure the storage. Prefer environment variables and ephemeral/test tokens. - Test in isolation: run the code in a sandbox or against a non-production Jira instance first to verify behavior and check logs/network calls. Inspect network traffic (hostname/IP) to ensure requests go to your Jira server only. If you decide to proceed, request clarifications or a canonical source (GitHub repo/release) and verify the package contents match the documentation and that required env vars are declared in registry metadata. If the author cannot clarify, treat this as untrusted/incomplete and avoid using production credentials.

Jira Task Creator - Professional Edition

A complete Jira task management skill with natural language parsing, smart user search, batch operations, and intelligent analytics.

Core Features

1. Intelligent Task Creation

• Natural language parsing: Supports Chinese and English task descriptions
• Flexible field configuration: All standard Jira fields supported
• Smart date handling: Relative dates ("tomorrow", "next week", "end of month")

2. Smart User Search

• Multiple search methods: Name, open_id, email
• Assignable user query: Only returns users assignable to specific project
• User cache mechanism: 5-minute TTL, reduces API calls
• User mapping management: Maintains Feishu-Jira user mapping

3. Batch Task Creation

• CSV import: Bulk task creation from CSV files
• Task templates: Bug report, feature request, technical research
• Variable replacement: Dynamic template content filling

4. Task Analytics

• Multi-dimensional statistics: Status, priority, project, assignee
• Completion rate calculation: Success task ratio
• Overdue task identification: Overdue, due soon (3 days)
• Formatted reports: Markdown statistics reports

Installation

pip install requests python-dateutil

Configuration

Environment Variables

# Required
export JIRA_BASE_URL="http://your-jira.com"
export JIRA_BEARER_TOKEN="your-token-here"

# Optional
export JIRA_DEFAULT_PROJECT="ERP"
export JIRA_DEFAULT_ASSIGNEE="Cloud"
export JIRA_CACHE_ENABLED="true"
export JIRA_CACHE_TTL="300"

Config File (config.json)

{
  "jira": {
    "baseUrl": "http://your-jira.com",
    "bearerToken": "your-token-here",
    "defaultProject": "ERP",
    "defaultAssignee": "Cloud",
    "timeout": 30
  },
  "cache": {
    "enabled": true,
    "ttl": 300,
    "maxSize": 1000
  },
  "logging": {
    "level": "INFO",
    "saveToFile": true,
    "logDirectory": "logs/"
  }
}

Quick Start

Create a Task

from jira_task_creator import create_issue

result = create_issue(
    summary="Fix login bug",
    description="Users cannot login to system",
    project_key="ERP",
    issue_type_name="Bug",
    priority="High"
)

Natural Language Task Creation

from jira_task_creator import create_issue_natural

result = create_issue_natural(
    user_instruction="Complete API development by next Wednesday, high priority",
    project="ERP"
)

Search User

from jira_task_creator import search_user

user = search_user("贾小丽", "ERP")
print(f"Username: {user['name']}")
print(f"Display name: {user['displayName']}")

Batch Creation

from batch_creator import BatchTaskCreator

creator = BatchTaskCreator(base_url, token)
results = creator.create_from_csv("tasks.csv")

Task Analytics

from task_analyzer import TaskAnalyzer

tasks = fetch_tasks("assignee = currentUser() AND status != Done")
analysis = TaskAnalyzer.analyze_tasks(tasks)
report = TaskAnalyzer.generate_report(analysis)
print(report)

API Reference

create_issue()

Creates a Jira issue with specified fields.

Parameters:

• summary (str): Task title (required)
• description (str): Task description
• project_key (str): Project key (e.g., "ERP")
• issue_type_name (str): Issue type (e.g., "Bug", "Story")
• priority (str): Priority (High, Medium, Low)
• assignee (str): Assignee username
• due_date (str): Due date (ISO 8601 format)

Returns:

• dict: Created issue data or error information

search_user()

Searches for users assignable to a project.

Parameters:

• query (str): Search query (name, open_id, email)
• project_key (str): Project key

Returns:

• dict: User information or None if not found

create_issue_natural()

Creates an issue from natural language instruction.

Parameters:

• user_instruction (str): Natural language task description
• project (str): Project key

Returns:

• dict: Creation result

Task Templates

Bug Report Template

from batch_creator import BatchTaskCreator

creator = BatchTaskCreator(base_url, token)
result = creator.create_from_template("bug_report", {
    "title": "Login page error",
    "description": "Error 500 when logging in",
    "priority": "High"
})

Feature Request Template

result = creator.create_from_template("feature_request", {
    "title": "Add dark mode",
    "description": "Support dark mode theme",
    "priority": "Medium"
})

Error Handling

Common Errors

401 Unauthorized:

• Check Bearer Token validity
• Verify token format

404 Not Found:

• Project key is incorrect
• User does not exist

422 Unprocessable Entity:

• Invalid field values
• Missing required fields

Troubleshooting

1. Check connection:

   ping your-jira-server.com
   

2. Verify token:

   import requests
   response = requests.get("https://your-jira.com/rest/api/3/myself",
                        headers={"Authorization": f"Bearer {token}"})
   print(response.status_code)
   

3. Enable debug logging:

   {
     "logging": {
       "level": "DEBUG"
     }
   }
   

License

MIT License

Version

1.0.0 - Initial release