jira-pilot 1.0.0

package/LICENSE

@@ -0,0 +1,5 @@
+Copyright (c) 2026
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# Jira Pilot ✈️
+
+**The AI-Powered Jira CLI for Humans and Agents.**
+
+`jira-pilot` is a next-generation Command Line Interface for Jira. It bridges the gap between traditional developer tools and modern AI Agents.
+
+- **For Humans:** A beautiful, interactive CLI to manage issues, sprints, and code without leaving your terminal.
+- **For Agents:** A fully compliant **Model Context Protocol (MCP)** server that lets AI assistants (like Claude Desktop (Claude Desktop) or Gemini) interact with your Jira instance safely.
+
+## ✨ Features
+
+### 👤 Human-Centric Features
+- **Interactive Wizards**: Create and transition issues with `enquirer` prompts. No more remembering complex flags.
+- **Git Integration**: Create feature branches directly from issues with smart naming.
+  - `jira git branch PROJ-123` -> `feature/PROJ-123-fix-login-bug`
+- **Rich Visualization**: Beautiful tables and formatted output.
+- **AI Copilot**:
+  - `jira ai summarize PROJ-123`: Get a TL;DR of long issue threads.
+  - `jira ai draft`: Draft descriptions from bullet points (Coming Soon).
+
+### 🤖 Agentic Features (MCP)
+- **Agent Skill**: Run `jira mcp` to start a stdio server.
+- **Standardized Tools**: Exposes `list_issues`, `get_issue`, `create_issue` to any MCP client.
+- **Low-Context Mode**: Optimized JSON outputs for LLM consumption.
+
+---
+
+## 🚀 Installation
+
+### Global Install (Recommended)
+```bash
+npm install -g jira-pilot
+```
+
+### Local Development
+```bash
+git clone https://github.com/yourusername/jira-pilot.git
+cd jira-pilot
+npm install
+npm link
+```
+
+---
+
+## ⚙️ Configuration
+
+Before using the tool, set up your credentials. You can get an API Token from [Atlassian Account Settings](https://id.atlassian.com/manage-profile/security/api-tokens).
+
+```bash
+jira config setup
+```
+
+You will be prompted for:
+1.  **Jira Site URL**: e.g., `https://your-company.atlassian.net`
+2.  **Email**: Your Atlassian account email.
+3.  **API Token**: The token you generated.
+4.  **AI API Key (Optional)**: Your OpenAI API Key (for `jira ai` commands).
+
+To view current config:
+```bash
+jira config view
+```
+
+---
+
+## 📖 Usage
+
+### Issues
+```bash
+# List issues (default: assigned to you, active sprints)
+jira issue list
+
+# List with custom JQL
+jira issue list --jql "project = PROJ AND priority = High"
+
+# Create a new issue (interactive)
+jira issue create
+
+# View details
+jira issue view PROJ-123
+
+# Transition status (interactive)
+jira issue transition PROJ-123
+
+# Export issues to file
+jira issue list --export json  # Creates issues-TIMESTAMP.json
+jira issue list --export md    # Creates issues-TIMESTAMP.md
+
+# Combine filters and export (Power User)
+jira issue list --project TRAIN --assignee <assignee_name> --status Done --export json
+```
+
+### Projects & Sprints
+```bash
+# List projects
+jira project list
+
+# List sprints for a board
+jira sprint list --board 5
+```
+
+### Git Integration
+Create a branch automatically named from the issue summary:
+```bash
+jira git branch PROJ-123
+# Output: Switched to a new branch 'feature/PROJ-123-fix-login-modal'
+```
+
+### AI Features
+Summarize a complex issue thread:
+```bash
+jira ai summarize PROJ-123
+```
+*(Requires OpenAI Key in config)*
+
+---
+
+## 🧠 Using with AI Agents (Claude/Gemini)
+
+`jira-pilot` implements the **Model Context Protocol (MCP)**, making it plug-and-play for AI assistants.
+
+### Claude Desktop Configuration
+Add the following to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "jira": {
+      "command": "node",
+      "args": ["/absolute/path/to/jira-pilot/bin/jira.js", "mcp"]
+    }
+  }
+}
+```
+
+Once connected, you can ask Claude things like:
+> "Check my assigned Jira issues and create a feature branch for the highest priority one."
+
+---
+
+## 🛠️ Project Structure
+- `bin/`: Entry point.
+- `src/commands/`: CLI command definitions (Human UI).
+- `src/server/`: MCP Server implementation (Agent UI).
+- `src/services/`: Core logic (API, AI).
+
+## 📄 License
+ISC

package/bin/jira.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+// Load package.json for version
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+
+const program = new Command();
+
+program
+    .name('jira')
+    .description('AI-powered Jira CLI for humans and agents')
+    .version(pkg.version);
+
+import { registerConfigCommand } from '../src/commands/config.js';
+import { registerIssueCommand } from '../src/commands/issue.js';
+import { registerProjectCommand } from '../src/commands/project.js';
+import { registerSprintCommand } from '../src/commands/sprint.js';
+import { registerGitCommand } from '../src/commands/git.js';
+import { registerAiCommand } from '../src/commands/ai.js';
+import { registerMcpCommand } from '../src/commands/mcp.js';
+
+// Register Commands
+registerConfigCommand(program);
+registerIssueCommand(program);
+registerProjectCommand(program);
+registerSprintCommand(program);
+registerGitCommand(program);
+registerAiCommand(program);
+registerMcpCommand(program);
+
+program.on('command:*', () => {
+    console.error(chalk.red('Invalid command: %s\nSee --help for a list of available commands.'), program.args.join(' '));
+    process.exit(1);
+});
+
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "jira-pilot",
+    "version": "1.0.0",
+    "description": "AI-powered Jira CLI for humans and agents",
+    "main": "src/index.js",
+    "type": "module",
+    "bin": {
+        "jira": "./bin/jira.js"
+    },
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "link": "npm link"
+    },
+    "keywords": [
+        "jira",
+        "cli",
+        "ai",
+        "agent",
+        "mcp"
+    ],
+    "author": "Arul",
+    "license": "ISC",
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^0.6.0",
+        "axios": "^1.6.0",
+        "chalk": "^5.3.0",
+        "commander": "^11.1.0",
+        "conf": "^12.0.0",
+        "enquirer": "^2.4.1",
+        "open": "^10.0.0",
+        "ora": "^8.0.0",
+        "table": "^6.8.0"
+    }
+}

package/src/commands/ai.js

@@ -0,0 +1,51 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../services/api-service.js';
+import { aiService } from '../services/ai-service.js';
+
+export function registerAiCommand(program) {
+    const aiCmd = new Command('ai')
+        .description('AI Helper commands');
+
+    aiCmd
+        .command('summarize')
+        .description('Summarize an issue using AI')
+        .argument('<issueKey>', 'Jira Issue Key')
+        .action(async (issueKey) => {
+            const spinner = ora(`Fetching issue ${issueKey}...`).start();
+            try {
+                // Fetch issue details and comments
+                const issue = await api.get(`/issue/${issueKey}?fields=summary,description,comment`);
+                spinner.text = 'Generating summary...';
+
+                const summary = issue.fields.summary;
+                const description = issue.fields.description || 'No description';
+                const comments = issue.fields.comment.comments.map(c => `${c.author.displayName}: ${c.body}`).join('\n');
+
+                const prompt = `
+            You are a helpful Jira assistant. Please summarize the following Jira issue.
+            
+            Title: ${summary}
+            Description: ${description}
+            
+            Comments:
+            ${comments}
+            
+            Provide a concise summary of the current status, key discussion points, and next steps if clear.
+            `;
+
+                const aiResponse = await aiService.generate(prompt);
+                spinner.stop();
+
+                console.log(chalk.green(`\n🤖 AI Summary for ${issueKey}:\n`));
+                console.log(aiResponse);
+
+            } catch (e) {
+                spinner.fail('Failed to generate summary');
+                console.error(chalk.red(e.message));
+            }
+        });
+
+    program.addCommand(aiCmd);
+}

package/src/commands/config.js

@@ -0,0 +1,91 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import enquirer from 'enquirer';
+import { setCredentials, getCredentials, clearCredentials } from '../utils/config.js';
+import ora from 'ora';
+import { api } from '../services/api-service.js';
+
+export function registerConfigCommand(program) {
+    const configCmd = new Command('config')
+        .description('Configure Jira credentials');
+
+    configCmd
+        .command('setup')
+        .description('Interactive setup of Jira credentials')
+        .action(async () => {
+            console.log(chalk.blue('Configuring jira-pilot...'));
+
+            const current = getCredentials();
+
+            try {
+                const answers = await enquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'jiraUrl',
+                        message: 'Jira Site URL (e.g., https://your-domain.atlassian.net):',
+                        initial: current.jiraUrl
+                    },
+                    {
+                        type: 'input',
+                        name: 'email',
+                        message: 'Jira Email Address:',
+                        initial: current.email
+                    },
+                    {
+                        type: 'password',
+                        name: 'apiToken',
+                        message: 'Jira API Token:',
+                        initial: current.apiToken ? '*****' : undefined
+                    }
+                ]);
+
+                // Keep existing token if user didn't change it (and entered ***** which is not real)
+                // Actually prompt returns text. If they leave it blank?
+                // Let's assume if they type nothing, we keep old? Enquirer behavior depends. 
+                // Better to just save what we get.
+
+                // Validation check
+                const spinner = ora('Verifying credentials...').start();
+
+                // Temporarily set config to test
+                setCredentials(answers);
+                api.init(); // Refresh api client with new creds
+
+                try {
+                    await api.get('/myself');
+                    spinner.succeed(chalk.green('Credentials verified and saved!'));
+                } catch (e) {
+                    spinner.fail(chalk.red('Verification failed! Credentials saved but might be incorrect.'));
+                    console.error(e.message);
+                }
+
+            } catch (e) {
+                console.error(chalk.red('Setup cancelled or failed'), e);
+            }
+        });
+
+    configCmd
+        .command('view')
+        .description('View current configuration')
+        .action(() => {
+            const { jiraUrl, email } = getCredentials();
+            if (jiraUrl) {
+                console.log(chalk.green('Current Configuration:'));
+                console.log(`URL: ${jiraUrl}`);
+                console.log(`Email: ${email}`);
+                console.log(`Token: ************`);
+            } else {
+                console.log(chalk.yellow('No configuration found. Run "jira config setup"'));
+            }
+        });
+
+    configCmd
+        .command('clear')
+        .description('Clear saved credentials')
+        .action(() => {
+            clearCredentials();
+            console.log(chalk.green('Credentials cleared.'));
+        });
+
+    program.addCommand(configCmd);
+}

package/src/commands/git.js

@@ -0,0 +1,60 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { api } from '../services/api-service.js';
+import ora from 'ora';
+import enquirer from 'enquirer';
+
+export function registerGitCommand(program) {
+    const gitCmd = new Command('git')
+        .description('Git integration for Jira');
+
+    gitCmd
+        .command('branch')
+        .description('Create a git branch from a Jira issue')
+        .argument('<issueKey>', 'Jira Issue Key (e.g., PROJ-123)')
+        .option('-t, --type <type>', 'Branch type (feature, bugfix, hotfix)', 'feature')
+        .action(async (issueKey, options) => {
+            const spinner = ora(`Fetching issue ${issueKey}...`).start();
+            try {
+                const issue = await api.get(`/issue/${issueKey}`);
+                spinner.stop();
+
+                const summary = issue.fields.summary;
+                const sanitizedSummary = summary
+                    .toLowerCase()
+                    .replace(/[^a-z0-9]+/g, '-') // Replace non-alphanumeric with hyphen
+                    .replace(/^-+|-+$/g, '');   // Trim leading/trailing hyphens
+
+                const branchName = `${options.type}/${issueKey}-${sanitizedSummary}`;
+
+                console.log(chalk.blue(`Proposed Branch Name: ${chalk.bold(branchName)}`));
+
+                const { confirm } = await enquirer.prompt({
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Create and switch to this branch?',
+                    initial: true
+                });
+
+                if (confirm) {
+                    try {
+                        execSync(`git checkout -b ${branchName}`, { stdio: 'inherit' });
+                        console.log(chalk.green('\nBranch created and checked out!'));
+                    } catch (gitError) {
+                        console.error(chalk.red('\nFailed to create branch. Are you in a git repository?'));
+                    }
+                }
+
+            } catch (e) {
+                spinner.fail('Failed to fetch issue');
+                if (e.response) {
+                    console.error(chalk.red(`Error ${e.response.status}: `), e.response.data);
+                } else {
+                    console.error(chalk.red(e.message));
+                }
+            }
+        });
+
+    program.addCommand(gitCmd);
+}

package/src/commands/issue.js

@@ -0,0 +1,112 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { table } from 'table';
+import { api } from '../services/api-service.js';
+import ora from 'ora';
+
+export function registerIssueCommand(program) {
+    const issueCmd = new Command('issue')
+        .description('Manage Jira issues');
+
+    issueCmd
+        .command('list')
+        .description('List issues')
+        .option('-j, --jql <query>', 'JQL query to filter issues')
+        .option('-l, --limit <number>', 'Limit results', '20')
+        .option('-p, --project <key>', 'Filter by project')
+        .option('-a, --assignee <id>', 'Filter by assignee (use "currentUser" for self)')
+        .option('-s, --status <status>', 'Filter by status')
+        .option('-e, --export <format>', 'Export output (json, md)')
+        .action(async (options) => {
+            const spinner = ora('Fetching issues...').start();
+            try {
+                const jqlParts = [];
+                if (options.project) jqlParts.push(`project = "${options.project}"`);
+                if (options.assignee) jqlParts.push(`assignee = ${options.assignee === 'currentUser' ? 'currentUser()' : `"${options.assignee}"`}`);
+                if (options.status) jqlParts.push(`status = "${options.status}"`);
+                if (options.jql) jqlParts.push(options.jql);
+
+                // Order by updated desc by default if no JQL
+                if (!options.jql && jqlParts.length === 0) {
+                    jqlParts.push('order by updated DESC');
+                } else if (jqlParts.length > 0 && !options.jql) {
+                    // Add order if not custom jql
+                    // jqlParts.push('order by updated DESC');
+                }
+
+                const jql = jqlParts.join(' AND ');
+
+                const searchApi = '/search';
+                const body = {
+                    jql: jql || '',
+                    maxResults: parseInt(options.limit),
+                    fields: ['summary', 'status', 'assignee', 'created', 'updated']
+                };
+
+                const data = await api.post(searchApi, body);
+                spinner.stop();
+
+                if (!data.issues || data.issues.length === 0) {
+                    console.log(chalk.yellow('No issues found.'));
+                    return;
+                }
+
+                // Handling Export
+                if (options.export) {
+                    const fs = await import('fs');
+                    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+
+                    if (options.export === 'json') {
+                        const filename = `issues-${timestamp}.json`;
+                        fs.writeFileSync(filename, JSON.stringify(data.issues, null, 2));
+                        console.log(chalk.green(`\nExported ${data.issues.length} issues to ${chalk.bold(filename)}`));
+                        return;
+                    }
+
+                    if (options.export === 'md') {
+                        const filename = `issues-${timestamp}.md`;
+                        let mdContent = `# Jira Issues Export\nGenerated: ${new Date().toLocaleString()}\n\n`;
+                        mdContent += `| Key | Summary | Status | Assignee |\n`;
+                        mdContent += `|---|---|---|---|\n`;
+
+                        data.issues.forEach(i => {
+                            const key = i.key;
+                            const summary = i.fields.summary || '';
+                            const status = i.fields.status?.name || '';
+                            const assignee = i.fields.assignee?.displayName || 'Unassigned';
+                            mdContent += `| ${key} | ${summary} | ${status} | ${assignee} |\n`;
+                        });
+
+                        fs.writeFileSync(filename, mdContent);
+                        console.log(chalk.green(`\nExported ${data.issues.length} issues to ${chalk.bold(filename)}`));
+                        return;
+                    }
+                }
+
+                const tableData = [
+                    [chalk.bold('Key'), chalk.bold('Summary'), chalk.bold('Status'), chalk.bold('Assignee')]
+                ];
+
+                data.issues.forEach(i => {
+                    tableData.push([
+                        chalk.cyan(i.key),
+                        i.fields.summary ? (i.fields.summary.length > 50 ? i.fields.summary.substring(0, 47) + '...' : i.fields.summary) : '',
+                        i.fields.status ? i.fields.status.name : '',
+                        i.fields.assignee ? i.fields.assignee.displayName : 'Unassigned'
+                    ]);
+                });
+
+                console.log(table(tableData));
+
+            } catch (e) {
+                spinner.fail('Failed to list issues');
+                if (e.response) {
+                    console.error(chalk.red(`Error ${e.response.status}: `), e.response.data);
+                } else {
+                    console.error(chalk.red(e.message));
+                }
+            }
+        });
+
+    program.addCommand(issueCmd);
+}

package/src/commands/mcp.js

@@ -0,0 +1,20 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { startServer } from '../server/mcp-server.js';
+
+export function registerMcpCommand(program) {
+    const mcpCmd = new Command('mcp')
+        .description('Start MCP Agent Server (Stdio)')
+        .action(async () => {
+            // MCP server uses stdio, so we shouldn't log anything else to stdout.
+            // We can log to stderr if needed.
+            try {
+                await startServer();
+            } catch (e) {
+                console.error('MCP Server Error:', e);
+                process.exit(1);
+            }
+        });
+
+    program.addCommand(mcpCmd);
+}

package/src/commands/project.js

@@ -0,0 +1,46 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { table } from 'table';
+import { api } from '../services/api-service.js';
+import ora from 'ora';
+
+export function registerProjectCommand(program) {
+    const projectCmd = new Command('project')
+        .description('Manage Jira projects');
+
+    projectCmd
+        .command('list')
+        .description('List accessible projects')
+        .action(async () => {
+            const spinner = ora('Fetching projects...').start();
+            try {
+                const data = await api.get('/project/search');
+                spinner.stop();
+
+                if (!data.values || data.values.length === 0) {
+                    console.log(chalk.yellow('No projects found.'));
+                    return;
+                }
+
+                const tableData = [
+                    [chalk.bold('Key'), chalk.bold('Name'), chalk.bold('Leader'), chalk.bold('Style')]
+                ];
+
+                data.values.forEach(p => {
+                    tableData.push([
+                        chalk.cyan(p.key),
+                        p.name,
+                        p.lead ? p.lead.displayName : 'N/A',
+                        p.style
+                    ]);
+                });
+
+                console.log(table(tableData));
+            } catch (e) {
+                spinner.fail('Failed to list projects');
+                console.error(e.message);
+            }
+        });
+
+    program.addCommand(projectCmd);
+}

package/src/commands/sprint.js

@@ -0,0 +1,76 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { table } from 'table';
+import { api } from '../services/api-service.js';
+import ora from 'ora';
+
+export function registerSprintCommand(program) {
+    const sprintCmd = new Command('sprint')
+        .description('Manage Sprints');
+
+    sprintCmd
+        .command('list')
+        .description('List sprints for a board')
+        .requiredOption('-b, --board <id>', 'Board ID')
+        .option('-s, --state <state>', 'State (active, future, closed)', 'active,future')
+        .action(async (options) => {
+            const spinner = ora(`Fetching sprints for board ${options.board}...`).start();
+            try {
+                // Agile API usually involves /rest/agile/1.0
+                // My default ApiService is /rest/api/3. I might need to override or allow full path?
+                // ApiService handles baseURL. I should make it flexible or add Agile support.
+
+                // HACK: ApiService constructor sets base to /rest/api/3. 
+                // I need to use a different client or hack the URL.
+                // Axios allows absolute URLs to override baseURL.
+                // So if I pass full URL it works.
+
+                const { jiraUrl } = (await import('../utils/config.js')).getCredentials();
+                // Assuming api-service exposes client or get method.
+                // But get method prepend baseURL? No, axios usually supports absolute URL.
+
+                // Let's modify ApiService later to support 'type' or just use full path if needed.
+                // Or simpler: /rest/agile/1.0/board/${id}/sprint
+                // But api service baseURL is fixed.
+
+                // To fix this proper: I'll modify ApiService to allow changing API version/path or just use full path.
+                // Using full path:
+                const match = jiraUrl.match(/^https?:\/\/(.+?)(\/|$)/);
+                const domain = match ? match[0].replace(/\/$/, '') : jiraUrl;
+                const fullUrl = `${domain}/rest/agile/1.0/board/${options.board}/sprint?state=${options.state}`;
+
+                const data = await api.get(fullUrl);
+                spinner.stop();
+
+                if (!data.values || data.values.length === 0) {
+                    console.log(chalk.yellow('No sprints found.'));
+                    return;
+                }
+
+                const tableData = [
+                    [chalk.bold('ID'), chalk.bold('Name'), chalk.bold('State'), chalk.bold('Dates')]
+                ];
+
+                data.values.forEach(s => {
+                    tableData.push([
+                        s.id,
+                        s.name,
+                        s.state === 'active' ? chalk.green(s.state) : s.state,
+                        `${s.startDate ? s.startDate.split('T')[0] : ''} -> ${s.endDate ? s.endDate.split('T')[0] : ''}`
+                    ]);
+                });
+
+                console.log(table(tableData));
+
+            } catch (e) {
+                spinner.fail('Failed to list sprints');
+                if (e.response) {
+                    console.error(chalk.red(`Error ${e.response.status}: `), e.response.data);
+                } else {
+                    console.error(chalk.red(e.message));
+                }
+            }
+        });
+
+    program.addCommand(sprintCmd);
+}

package/src/server/mcp-server.js

@@ -0,0 +1,119 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { api } from "../services/api-service.js";
+
+// Initialize MCP Server
+const server = new Server(
+    {
+        name: "jira-pilot",
+        version: "1.0.0",
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+// Define Tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "jira_list_issues",
+                description: "List Jira issues using JQL",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        jql: { type: "string", description: "JQL query string" },
+                        limit: { type: "number", description: "Max results", default: 10 }
+                    }
+                }
+            },
+            {
+                name: "jira_get_issue",
+                description: "Get details of a specific Jira issue",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        issueKey: { type: "string", description: "Issue Key (e.g. PROJ-123)" }
+                    },
+                    required: ["issueKey"]
+                }
+            },
+            {
+                name: "jira_create_issue",
+                description: "Create a new Jira issue",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectKey: { type: "string", description: "Project Key" },
+                        summary: { type: "string", description: "Issue Summary" },
+                        description: { type: "string", description: "Issue Description" },
+                        issueType: { type: "string", description: "Issue Type (Bug, Story, etc)", default: "Task" }
+                    },
+                    required: ["projectKey", "summary"]
+                }
+            }
+        ]
+    };
+});
+
+// Handle Tool Calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        if (name === "jira_list_issues") {
+            const jql = args.jql || "";
+            const limit = args.limit || 10;
+            const data = await api.post('/search', {
+                jql,
+                maxResults: limit,
+                fields: ['summary', 'status', 'assignee', 'description']
+            });
+
+            return {
+                content: [{ type: "text", text: JSON.stringify(data.issues, null, 2) }]
+            };
+        }
+
+        if (name === "jira_get_issue") {
+            const data = await api.get(`/issue/${args.issueKey}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+            };
+        }
+
+        if (name === "jira_create_issue") {
+            const body = {
+                fields: {
+                    project: { key: args.projectKey },
+                    summary: args.summary,
+                    description: args.description,
+                    issuetype: { name: args.issueType || 'Task' }
+                }
+            };
+            const data = await api.post('/issue', body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+            };
+        }
+
+        throw new Error(`Unknown tool: ${name}`);
+
+    } catch (e) {
+        const errorMessage = e.response?.data ? JSON.stringify(e.response.data) : e.message;
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            isError: true
+        };
+    }
+});
+
+// Start Server
+export async function startServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/src/services/ai-service.js

@@ -0,0 +1,52 @@
+import axios from 'axios';
+import { getCredentials } from '../utils/config.js';
+
+export class AiService {
+    constructor() { }
+
+    async generate(prompt) {
+        const { aiKey, aiProvider } = getCredentials();
+
+        if (!aiKey) {
+            throw new Error('AI API Key not configured. Run "jira config setup" or manually set it in config.');
+        }
+
+        // Basic implementation for OpenAI - extensible for others
+        if (aiProvider === 'openai' || !aiProvider) {
+            return this.callOpenAI(aiKey, prompt);
+        } else if (aiProvider === 'gemini') {
+            return this.callGemini(aiKey, prompt);
+        } else if (aiProvider === 'anthropic') {
+            return this.callAnthropic(aiKey, prompt);
+        }
+
+        throw new Error(`Unsupported AI Provider: ${aiProvider}`);
+    }
+
+    async callOpenAI(key, prompt) {
+        try {
+            const response = await axios.post('https://api.openai.com/v1/chat/completions', {
+                model: 'gpt-4o', // or gpt-3.5-turbo
+                messages: [{ role: 'user', content: prompt }],
+                temperature: 0.7
+            }, {
+                headers: { 'Authorization': `Bearer ${key}` }
+            });
+            return response.data.choices[0].message.content;
+        } catch (e) {
+            throw new Error(`OpenAI API Error: ${e.response?.data?.error?.message || e.message}`);
+        }
+    }
+
+    async callGemini(key, prompt) {
+        // Placeholder for Gemini implementation
+        throw new Error("Gemini implementation pending.");
+    }
+
+    async callAnthropic(key, prompt) {
+        // Placeholder for Anthropic
+        throw new Error("Anthropic implementation pending.");
+    }
+}
+
+export const aiService = new AiService();

package/src/services/api-service.js

@@ -0,0 +1,94 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import { getCredentials } from '../utils/config.js';
+
+export class ApiService {
+    constructor() {
+        this.init();
+    }
+
+    init() {
+        const { jiraUrl, email, apiToken } = getCredentials();
+
+        if (!jiraUrl || !email || !apiToken) {
+            // Don't throw here, allow initialization for 'config' command usage
+            this.client = null;
+            return;
+        }
+
+        const match = jiraUrl.match(/^https?:\/\/(.+?)(\/|$)/);
+        const domain = match ? match[0] : jiraUrl;
+
+        this.client = axios.create({
+            baseURL: `${domain.replace(/\/$/, '')}/rest/api/3`,
+            headers: {
+                'Authorization': `Basic ${Buffer.from(`${email}:${apiToken}`).toString('base64')}`,
+                'Accept': 'application/json',
+                'Content-Type': 'application/json'
+            }
+        });
+
+        // Response interceptor for error handling
+        this.client.interceptors.response.use(
+            response => response,
+            error => {
+                if (error.response) {
+                    if (error.response.status === 401) {
+                        console.error(chalk.red('Authentication failed. Please check your credentials using "jira config".'));
+                    } else if (error.response.status === 403) {
+                        console.error(chalk.red('Access denied. You may not have permission for this resource.'));
+                    } else if (error.response.status === 404) {
+                        // Sometime 404 is valid (issues not found), let caller handle? 
+                        // Or log generic error? For now rethrow with clean message property if possible.
+                    }
+                }
+                return Promise.reject(error);
+            }
+        );
+    }
+
+    ensureClient() {
+        if (!this.client) {
+            // Try to re-init in case config was just set
+            this.init();
+            if (!this.client) {
+                throw new Error('Jira credentials not configured. Run "jira config" first.');
+            }
+        }
+    }
+
+    async get(url, config = {}) {
+        this.ensureClient();
+        try {
+            const response = await this.client.get(url, config);
+            return response.data;
+        } catch (e) {
+            // Optional: Wrap error
+            throw e;
+        }
+    }
+
+    async post(url, data, config = {}) {
+        this.ensureClient();
+        try {
+            const response = await this.client.post(url, data, config);
+            return response.data;
+        } catch (e) {
+            throw e;
+        }
+    }
+
+    async put(url, data, config = {}) {
+        this.ensureClient();
+        const response = await this.client.put(url, data, config);
+        return response.data;
+    }
+
+    async delete(url, config = {}) {
+        this.ensureClient();
+        const response = await this.client.delete(url, config);
+        return response.data;
+    }
+}
+
+export const api = new ApiService();

package/src/utils/config.js

@@ -0,0 +1,54 @@
+import Conf from 'conf';
+
+const schema = {
+    jiraUrl: {
+        type: 'string',
+        format: 'url'
+    },
+    email: {
+        type: 'string',
+        format: 'email'
+    },
+    apiToken: {
+        type: 'string'
+    },
+    aiKey: {
+        type: 'string'
+    },
+    aiProvider: {
+        type: 'string',
+        default: 'openai'
+    }
+};
+
+const config = new Conf({
+    projectName: 'jira-pilot',
+    schema
+});
+
+export const getCredentials = () => {
+    return {
+        jiraUrl: config.get('jiraUrl'),
+        email: config.get('email'),
+        apiToken: config.get('apiToken'),
+        aiKey: config.get('aiKey'),
+        aiProvider: config.get('aiProvider')
+    };
+};
+
+export const setCredentials = ({ jiraUrl, email, apiToken, aiKey, aiProvider }) => {
+    if (jiraUrl) config.set('jiraUrl', jiraUrl);
+    if (email) config.set('email', email);
+    if (apiToken) config.set('apiToken', apiToken);
+    if (aiKey) config.set('aiKey', aiKey);
+    if (aiProvider) config.set('aiProvider', aiProvider);
+};
+
+export const clearCredentials = () => {
+    config.clear();
+};
+
+export const hasCredentials = () => {
+    const creds = getCredentials();
+    return !!(creds.jiraUrl && creds.email && creds.apiToken);
+};