kspec 1.0.16 → 1.0.18

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/kspec.svg)](https://www.npmjs.com/package/kspec)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Spec-driven development workflow for Kiro CLI with verification at every step.
+Spec-driven development workflow for Kiro CLI with context management, verification at every step, and Jira integration.
 
 ## Installation
 
@@ -17,14 +17,45 @@ npm install -g kspec
 kspec init                    # Interactive setup
 kspec analyse                 # Analyse codebase
 kspec spec "User Auth API"    # Create specification
-kspec verify-spec             # Verify spec is complete
 kspec tasks                   # Generate tasks
-kspec verify-tasks            # Verify tasks cover spec
 kspec build                   # Execute with TDD
 kspec verify                  # Verify implementation
 kspec done                    # Complete & harvest memory
 ```
 
+## Two Ways to Use kspec
+
+### 1. CLI Mode (Outside kiro-cli)
+
+Run kspec commands from your terminal:
+
+```bash
+kspec init
+kspec spec "User Authentication"
+kspec tasks
+kspec build
+```
+
+### 2. Agent Mode (Inside kiro-cli) — Recommended
+
+Stay inside your kiro-cli session and switch between specialized agents:
+
+```
+$ kiro-cli
+
+> /agent swap kspec-spec
+> Build a todo app with categories
+  (agent creates spec.md, spec-lite.md, updates context)
+
+> /agent swap kspec-tasks
+  (reads CONTEXT.md → knows current spec → generates tasks)
+
+> /agent swap kspec-build
+  (reads CONTEXT.md → continues from current task)
+```
+
+This approach solves the **context loss problem** — agents read `.kspec/CONTEXT.md` automatically to restore state after context compression.
+
 ## Workflow
 
 ```
@@ -44,166 +75,155 @@ init → analyse → spec → verify-spec → tasks → verify-tasks → build
 | `kspec build` | Execute tasks with TDD |
 | `kspec verify` | Verify implementation matches spec |
 | `kspec done` | Complete spec, harvest memory |
+| `kspec context` | View/refresh context file |
 | `kspec review` | Code review |
 | `kspec list` | List all specs |
 | `kspec status` | Current status |
+| `kspec agents` | List available agents |
+| `kspec update` | Check for updates |
 | `kspec help` | Show help |
-| `kspec --help, -h` | Show help (standard flag) |
-| `kspec --version, -v` | Show version (standard flag) |
+
+### Jira Integration (requires Atlassian MCP)
+
+| Command | Description |
+|---------|-------------|
+| `kspec spec --jira PROJ-123,PROJ-456 "Feature"` | Create spec from Jira issues |
+| `kspec sync-jira` | Create Jira issue from spec |
+| `kspec sync-jira --update PROJ-123` | Update existing Jira issue |
+| `kspec jira-subtasks` | Create Jira subtasks from tasks.md |
+| `kspec jira-subtasks PROJ-123` | Create subtasks under specific issue |
+
+## Context Management
+
+kspec maintains context that survives AI context compression:
+
+```
+.kspec/CONTEXT.md (auto-generated)
+├── Current Spec: 2026-01-24-user-auth
+├── Task: 3/12 - Implement JWT validation
+├── Requirements Summary (from spec-lite)
+├── Decisions & Learnings
+└── Jira Links (if integrated)
+```
+
+Agents read CONTEXT.md first, automatically restoring state after context compression.
+
+```bash
+kspec context    # View and refresh context manually
+```
 
 ## Agents & Shortcuts
 
 | Agent | Shortcut | Purpose |
 |-------|----------|---------|
-| kspec-analyse | Ctrl+A | Analyse codebase |
-| kspec-spec | Ctrl+S | Create specifications |
-| kspec-tasks | Ctrl+T | Generate tasks |
-| kspec-build | Ctrl+B | Execute with TDD |
-| kspec-verify | Ctrl+V | Verify spec/tasks/impl |
-| kspec-review | Ctrl+R | Code review |
+| kspec-analyse | Ctrl+Shift+A | Analyse codebase |
+| kspec-spec | Ctrl+Shift+S | Create specifications |
+| kspec-tasks | Ctrl+Shift+T | Generate tasks |
+| kspec-build | Ctrl+Shift+B | Execute with TDD |
+| kspec-verify | Ctrl+Shift+V | Verify spec/tasks/impl |
+| kspec-review | Ctrl+Shift+R | Code review |
+| kspec-jira | Ctrl+Shift+J | Jira integration |
+
+Switch agents in kiro-cli: `/agent swap kspec-build` or use keyboard shortcuts.
 
 ## Structure
 
 ```
 .kspec/
 ├── config.json           # User preferences
+├── .current              # Current active spec path
+├── CONTEXT.md            # Auto-generated context for agents
 ├── memory.md             # Project learnings
 └── specs/
     └── 2026-01-22-feature/
         ├── spec.md       # Full specification
         ├── spec-lite.md  # Concise (for context compression)
         ├── tasks.md      # Implementation tasks
-        └── memory.md     # Feature learnings
+        ├── memory.md     # Feature learnings
+        └── jira-links.json # Jira issue links (if integrated)
 
 .kiro/
-└── steering/             # Project rules (Kiro native)
+├── steering/             # Project rules (Kiro native)
+└── agents/               # kspec-generated agents
 ```
 
-## Configuration
-
-Set during `kspec init`:
-
-- **Date format**: YYYY-MM-DD, DD-MM-YYYY, or MM-DD-YYYY
-- **Auto-execute**: ask (default), auto, or dry-run
-
-## Integration with Kiro IDE
-
-kspec and Kiro IDE work seamlessly together, combining structured workflow automation with interactive development assistance.
+## Jira Integration
 
-### Workflow Integration
+Bridge the gap between BAs/PMs and developers by integrating with Jira via Atlassian MCP.
 
-**kspec provides:**
-- Structured spec creation and task generation
-- Automated analysis and verification steps
-- TDD workflow enforcement
-- Project memory harvesting
+### Pull Requirements from Jira
 
-**Kiro IDE provides:**
-- Interactive implementation assistance
-- Real-time code help and debugging
-- Native spec workflow support
-- Advanced AI-powered development tools
-
-### Usage Patterns
-
-#### Pattern 1: kspec-Driven Development
 ```bash
-# Use kspec for structure and planning
-kspec init
-kspec analyse
-kspec spec "User Authentication API"
-kspec tasks
-
-# Switch to Kiro IDE for implementation
-# Reference spec files: #File .kspec/specs/2026-01-22-user-auth/spec.md
-# Implement tasks interactively with AI assistance
-
-# Return to kspec for verification
-kspec verify
-kspec done
+kspec spec --jira PROJ-123,PROJ-456 "User Authentication"
 ```
 
-#### Pattern 2: Kiro-Native with kspec Analysis
-```bash
-# Use Kiro's built-in spec workflow
-# Create specs using Kiro IDE's native tools
+This fetches issue details, extracts acceptance criteria, and creates a unified spec with source attribution.
 
-# Use kspec for analysis and verification
-kspec analyse          # Update steering docs
-kspec review          # Code review
-kspec verify          # Verify implementation
-```
+### Push Specs to Jira
 
-#### Pattern 3: Hybrid Approach
 ```bash
-kspec spec "Feature"   # Create initial spec
-# Edit and refine spec in Kiro IDE
-kspec tasks           # Generate tasks
-# Implement tasks in Kiro IDE with AI assistance
-kspec verify          # Final verification
+kspec sync-jira                      # Create new issue
+kspec sync-jira --update PROJ-789    # Update existing issue
 ```
 
-### File System Integration
+Create or update Jira issues with spec content for BA/PM review.
 
-Both tools share the same file structure:
+### Create Subtasks
 
+```bash
+kspec jira-subtasks PROJ-789
 ```
-.kiro/
-├── steering/         # Shared project context
-│   ├── product.md   # Used by both kspec and Kiro
-│   ├── tech.md      # Technology standards
-│   └── testing.md   # Testing approach
-└── agents/          # kspec-generated agents (usable in Kiro)
 
-.kspec/
-└── specs/           # kspec-generated specs
-    └── feature/
-        ├── spec.md      # Reference in Kiro: #File .kspec/specs/feature/spec.md
-        ├── spec-lite.md # Concise version for context
-        ├── tasks.md     # Task list
-        └── memory.md    # Learnings
+Generate Jira subtasks from tasks.md for progress tracking.
+
+### Prerequisites
+
+Configure Atlassian MCP in `~/.kiro/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "atlassian": {
+      "command": "npx",
+      "args": ["-y", "@anthropic/mcp-atlassian"],
+      "env": {
+        "ATLASSIAN_HOST": "https://your-domain.atlassian.net",
+        "ATLASSIAN_EMAIL": "your-email@example.com",
+        "ATLASSIAN_API_TOKEN": "your-api-token"
+      }
+    }
+  }
+}
 ```
 
-### Kiro IDE Context Usage
+Get your API token: https://id.atlassian.com/manage-profile/security/api-tokens
 
-Reference kspec files in Kiro IDE chat:
-
-```
-#File .kspec/specs/user-auth/spec.md     # Full specification
-#File .kspec/specs/user-auth/tasks.md    # Task list
-#Folder .kspec/specs/user-auth           # Entire spec folder
-#Folder .kiro/steering                   # Project context
-```
+## Configuration
 
-### Agent Integration
+Set during `kspec init`:
 
-kspec creates specialized agents that work in Kiro IDE:
+- **Date format**: YYYY-MM-DD, DD-MM-YYYY, or MM-DD-YYYY
+- **Auto-execute**: ask (default), auto, or dry-run
 
-- **kspec-analyse** (Ctrl+A): Codebase analysis
-- **kspec-spec** (Ctrl+S): Specification creation  
-- **kspec-tasks** (Ctrl+T): Task generation
-- **kspec-build** (Ctrl+B): TDD implementation
-- **kspec-verify** (Ctrl+V): Verification
-- **kspec-review** (Ctrl+R): Code review
+## Auto-Updates
 
-Switch agents in Kiro IDE: `/agent swap` or use keyboard shortcuts.
+kspec checks for updates automatically (cached for 24 hours). Check manually:
 
-### Best Practices
+```bash
+kspec update
+```
 
-1. **Start with kspec** for structured planning and analysis
-2. **Use Kiro IDE** for interactive implementation and debugging
-3. **Reference kspec files** in Kiro chat for context
-4. **Leverage steering docs** updated by kspec analysis
-5. **Use kspec agents** within Kiro for specialized workflows
-6. **Verify with kspec** to ensure completeness
+Or check when viewing version:
 
-This integration gives you the best of both worlds: structured workflow automation and intelligent development assistance.
+```bash
+kspec --version
+```
 
 ## Requirements
 
 - Node.js >= 18
 - Kiro CLI or Amazon Q CLI
-- Kiro IDE (optional, for enhanced integration)
+- Atlassian MCP (optional, for Jira integration)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kspec",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Spec-driven development workflow for Kiro CLI",
   "main": "src/index.js",
   "bin": {

package/src/index.js

@@ -9,6 +9,7 @@ const STEERING_DIR = '.kiro/steering';
 const AGENTS_DIR = '.kiro/agents';
 const CONFIG_FILE = path.join(KSPEC_DIR, 'config.json');
 const UPDATE_CHECK_FILE = path.join(os.homedir(), '.kspec-update-check');
+const KIRO_MCP_CONFIG = path.join(os.homedir(), '.kiro', 'mcp.json');
 
 // Default config
 const defaultConfig = {
@@ -92,6 +93,67 @@ async function checkForUpdates() {
   }
 }
 
+// MCP Integration Detection
+function getMcpConfig() {
+  try {
+    if (fs.existsSync(KIRO_MCP_CONFIG)) {
+      return JSON.parse(fs.readFileSync(KIRO_MCP_CONFIG, 'utf8'));
+    }
+  } catch {}
+  return null;
+}
+
+function hasAtlassianMcp() {
+  const mcpConfig = getMcpConfig();
+  if (!mcpConfig || !mcpConfig.mcpServers) return false;
+
+  // Check for atlassian or jira MCP server
+  const serverNames = Object.keys(mcpConfig.mcpServers);
+  return serverNames.some(name =>
+    name.toLowerCase().includes('atlassian') ||
+    name.toLowerCase().includes('jira')
+  );
+}
+
+function getAtlassianMcpName() {
+  const mcpConfig = getMcpConfig();
+  if (!mcpConfig || !mcpConfig.mcpServers) return null;
+
+  const serverNames = Object.keys(mcpConfig.mcpServers);
+  return serverNames.find(name =>
+    name.toLowerCase().includes('atlassian') ||
+    name.toLowerCase().includes('jira')
+  );
+}
+
+function requireAtlassianMcp() {
+  if (!hasAtlassianMcp()) {
+    die(`Atlassian MCP not configured.
+
+To use Jira integration, you need to:
+1. Install the Atlassian MCP server
+2. Configure it in ~/.kiro/mcp.json
+
+Example ~/.kiro/mcp.json:
+{
+  "mcpServers": {
+    "atlassian": {
+      "command": "npx",
+      "args": ["-y", "@anthropic/mcp-atlassian"],
+      "env": {
+        "ATLASSIAN_HOST": "https://your-domain.atlassian.net",
+        "ATLASSIAN_EMAIL": "your-email@example.com",
+        "ATLASSIAN_API_TOKEN": "your-api-token"
+      }
+    }
+  }
+}
+
+Get your API token: https://id.atlassian.com/manage-profile/security/api-tokens`);
+  }
+  return getAtlassianMcpName();
+}
+
 // Helpers
 function log(msg) { console.log(`[kspec] ${msg}`); }
 function die(msg) { console.error(`Error: ${msg}`); process.exit(1); }
@@ -283,6 +345,15 @@ No active spec. Run: \`kspec spec "Feature Name"\`
     memory = fs.readFileSync(memoryFile, 'utf8');
   }
 
+  // Read Jira links if exists
+  const jiraLinksFile = path.join(current, 'jira-links.json');
+  let jiraLinks = null;
+  if (fs.existsSync(jiraLinksFile)) {
+    try {
+      jiraLinks = JSON.parse(fs.readFileSync(jiraLinksFile, 'utf8'));
+    } catch {}
+  }
+
   // Build context
   let content = `# kspec Context
 > Auto-generated. Always read this first after context compression.
@@ -319,6 +390,24 @@ ${memory}
 `;
   }
 
+  if (jiraLinks) {
+    content += `## Jira Links
+`;
+    if (jiraLinks.sourceIssues && jiraLinks.sourceIssues.length > 0) {
+      content += `- Source Issues: ${jiraLinks.sourceIssues.join(', ')}
+`;
+    }
+    if (jiraLinks.specIssue) {
+      content += `- Spec Issue: ${jiraLinks.specIssue}
+`;
+    }
+    if (jiraLinks.subtasks && jiraLinks.subtasks.length > 0) {
+      content += `- Subtasks: ${jiraLinks.subtasks.join(', ')}
+`;
+    }
+    content += '\n';
+  }
+
   content += `## Quick Commands
 - \`kspec build\` - Continue building tasks
 - \`kspec verify\` - Verify implementation
@@ -567,6 +656,59 @@ Your job:
 Output: APPROVE / REQUEST_CHANGES with specific issues.`,
     keyboardShortcut: 'ctrl+shift+r',
     welcomeMessage: 'Ready to review. What should I look at?'
+  },
+
+  'kspec-jira.json': {
+    name: 'kspec-jira',
+    description: 'Jira integration for specs',
+    model: 'claude-sonnet-4',
+    tools: ['read', 'write', 'mcp'],
+    allowedTools: ['read', 'write', 'mcp'],
+    resources: [
+      'file://.kspec/CONTEXT.md',
+      'file://.kiro/steering/**/*.md',
+      'file://.kspec/**/*.md'
+    ],
+    prompt: `You are the kspec Jira integration agent.
+
+PREREQUISITE: This agent requires Atlassian MCP to be configured.
+If MCP calls fail, inform the user to configure Atlassian MCP first.
+
+CAPABILITIES:
+
+1. PULL FROM JIRA (when user provides issue keys):
+   - Use MCP to fetch Jira issue details
+   - Extract: summary, description, acceptance criteria, comments
+   - For multiple issues, consolidate into unified requirements
+   - Create spec.md with proper attribution to source issues
+   - Include Jira links in spec for traceability
+
+2. SYNC TO JIRA (when user asks to sync/push):
+   - Create new "Technical Specification" issue in Jira
+   - Or update existing issue with spec content
+   - Link to source stories
+   - Add comment requesting BA review
+   - Set appropriate labels (kspec, technical-spec)
+
+3. CREATE SUBTASKS (when user asks after tasks.md exists):
+   - Read tasks.md from current spec
+   - Create Jira sub-tasks for each task
+   - Link to parent spec issue
+   - Include task details and acceptance criteria
+
+WORKFLOW:
+1. Read .kspec/CONTEXT.md for current spec state
+2. Identify what user wants (pull/sync/subtasks)
+3. Use Atlassian MCP for Jira operations
+4. Update .kspec/CONTEXT.md with Jira links
+5. Report what was created/updated
+
+IMPORTANT:
+- Always include Jira issue links in spec.md
+- Add "Source: JIRA-XXX" attribution for pulled requirements
+- Update CONTEXT.md with linked Jira issues`,
+    keyboardShortcut: 'ctrl+shift+j',
+    welcomeMessage: 'Jira integration ready. Provide issue keys to pull, or say "sync" to push spec to Jira.'
   }
 };
 
@@ -635,16 +777,62 @@ Update steering docs as needed.`, 'kspec-analyse');
   },
 
   async spec(args) {
+    // Parse --jira flag
+    const jiraIndex = args.findIndex(a => a === '--jira' || a.startsWith('--jira='));
+    let jiraIssues = null;
+
+    if (jiraIndex !== -1) {
+      // Check prerequisite
+      requireAtlassianMcp();
+
+      if (args[jiraIndex].startsWith('--jira=')) {
+        jiraIssues = args[jiraIndex].split('=')[1];
+        args.splice(jiraIndex, 1);
+      } else if (args[jiraIndex + 1] && !args[jiraIndex + 1].startsWith('-')) {
+        jiraIssues = args[jiraIndex + 1];
+        args.splice(jiraIndex, 2);
+      } else {
+        die('Usage: kspec spec --jira PROJ-123,PROJ-124 "Feature Name"');
+      }
+    }
+
     const feature = args.join(' ');
-    if (!feature) die('Usage: kspec spec "Feature Name"');
+    if (!feature && !jiraIssues) die('Usage: kspec spec "Feature Name" [--jira ISSUE-123,ISSUE-456]');
 
     const date = formatDate(config.dateFormat || 'YYYY-MM-DD');
-    const folder = path.join(getSpecsDir(), `${date}-${slugify(feature)}`);
+    const featureName = feature || `jira-${jiraIssues.split(',')[0].toLowerCase()}`;
+    const folder = path.join(getSpecsDir(), `${date}-${slugify(featureName)}`);
     ensureDir(folder);
     setCurrentSpec(folder);
 
     log(`Spec folder: ${folder}`);
-    await chat(`Create specification for: ${feature}
+
+    if (jiraIssues) {
+      // Jira-driven spec creation
+      log(`Pulling requirements from Jira: ${jiraIssues}`);
+      await chat(`Create specification from Jira issues: ${jiraIssues}
+
+Folder: ${folder}
+
+WORKFLOW:
+1. Use Atlassian MCP to fetch each Jira issue: ${jiraIssues}
+2. Extract from each issue:
+   - Summary and description
+   - Acceptance criteria
+   - Comments (for context)
+   - Linked issues
+3. Consolidate into unified spec.md with:
+   - Problem/Context (from issue descriptions)
+   - Requirements (from acceptance criteria)
+   - Source attribution: "Source: JIRA-XXX" for each requirement
+   - Links to original issues
+4. Create spec-lite.md (<500 words, key requirements only)
+5. Save Jira issue keys to ${folder}/jira-links.json
+
+IMPORTANT: Include Jira links for traceability.`, 'kspec-jira');
+    } else {
+      // Standard spec creation
+      await chat(`Create specification for: ${feature}
 
 Folder: ${folder}
 
@@ -653,6 +841,7 @@ Folder: ${folder}
 3. IMMEDIATELY create ${folder}/spec-lite.md (concise version, <500 words)
 
 spec-lite.md is critical - it's loaded after context compression.`, 'kspec-spec');
+    }
   },
 
   async 'verify-spec'(args) {
@@ -670,6 +859,120 @@ Read the codebase to check implementability.
 Report: PASS/FAIL with specific issues.`, 'kspec-verify');
   },
 
+  async 'sync-jira'(args) {
+    // Check prerequisite
+    requireAtlassianMcp();
+
+    const folder = getOrSelectSpec();
+
+    // Parse flags
+    const createFlag = args.includes('--create');
+    const updateIndex = args.findIndex(a => a === '--update' || a.startsWith('--update='));
+    let updateIssue = null;
+
+    if (updateIndex !== -1) {
+      if (args[updateIndex].startsWith('--update=')) {
+        updateIssue = args[updateIndex].split('=')[1];
+      } else if (args[updateIndex + 1] && !args[updateIndex + 1].startsWith('-')) {
+        updateIssue = args[updateIndex + 1];
+      } else {
+        die('Usage: kspec sync-jira --update PROJ-123');
+      }
+    }
+
+    if (!createFlag && !updateIssue) {
+      // Default to create
+      log('No flag specified, will create new Jira issue');
+    }
+
+    log(`Syncing spec to Jira: ${folder}`);
+
+    if (updateIssue) {
+      await chat(`Update existing Jira issue with specification.
+
+Spec folder: ${folder}
+Target issue: ${updateIssue}
+
+WORKFLOW:
+1. Read ${folder}/spec.md
+2. Use Atlassian MCP to update ${updateIssue}:
+   - Update description with spec content (or add as comment)
+   - Add label: kspec-spec
+   - Add comment: "Technical specification updated via kspec"
+3. Update ${folder}/jira-links.json with the issue key
+4. Update .kspec/CONTEXT.md with Jira link
+
+Report the updated issue URL.`, 'kspec-jira');
+    } else {
+      await chat(`Create new Jira issue from specification.
+
+Spec folder: ${folder}
+
+WORKFLOW:
+1. Read ${folder}/spec.md and ${folder}/spec-lite.md
+2. Check ${folder}/jira-links.json for source issues to link
+3. Use Atlassian MCP to create new issue:
+   - Type: Task or Story (based on project settings)
+   - Summary: Extract from spec title
+   - Description: Include spec-lite.md content
+   - Labels: kspec-spec, technical-specification
+   - Link to source issues if any
+4. Add comment requesting BA/PM review
+5. Save new issue key to ${folder}/jira-links.json
+6. Update .kspec/CONTEXT.md with new Jira link
+
+Report the created issue URL.`, 'kspec-jira');
+    }
+  },
+
+  async 'jira-subtasks'(args) {
+    // Check prerequisite
+    requireAtlassianMcp();
+
+    const folder = getOrSelectSpec();
+    const tasksFile = path.join(folder, 'tasks.md');
+
+    if (!fs.existsSync(tasksFile)) {
+      die(`No tasks.md found in ${folder}. Run 'kspec tasks' first.`);
+    }
+
+    // Check for parent issue
+    const jiraLinksFile = path.join(folder, 'jira-links.json');
+    let parentIssue = args[0];
+
+    if (!parentIssue && fs.existsSync(jiraLinksFile)) {
+      try {
+        const links = JSON.parse(fs.readFileSync(jiraLinksFile, 'utf8'));
+        parentIssue = links.specIssue || links.sourceIssues?.[0];
+      } catch {}
+    }
+
+    if (!parentIssue) {
+      die(`No parent issue specified. Usage: kspec jira-subtasks PROJ-123
+Or run 'kspec sync-jira' first to create a spec issue.`);
+    }
+
+    log(`Creating Jira subtasks from: ${folder}`);
+
+    await chat(`Create Jira subtasks from tasks.md.
+
+Spec folder: ${folder}
+Parent issue: ${parentIssue}
+Tasks file: ${tasksFile}
+
+WORKFLOW:
+1. Read ${tasksFile}
+2. For each uncompleted task (- [ ]):
+   - Use Atlassian MCP to create subtask under ${parentIssue}
+   - Summary: Task description
+   - Description: Include any details, file paths mentioned
+   - Labels: kspec-task
+3. Save created subtask keys to ${folder}/jira-links.json
+4. Update .kspec/CONTEXT.md with subtask links
+
+Report created subtasks with their URLs.`, 'kspec-jira');
+  },
+
   async tasks(args) {
     const folder = getOrSelectSpec(args.join(' '));
     log(`Generating tasks: ${folder}`);
@@ -863,14 +1166,15 @@ Output: APPROVE or REQUEST_CHANGES with specifics.`, 'kspec-review');
     console.log(`
 kspec Agents
 
-Agent           Shortcut  Purpose
-─────────────────────────────────────────────
+Agent           Shortcut        Purpose
+─────────────────────────────────────────────────────────
 kspec-analyse   Ctrl+Shift+A    Analyse codebase, update steering
 kspec-spec      Ctrl+Shift+S    Create specifications
 kspec-tasks     Ctrl+Shift+T    Generate tasks from spec
 kspec-build     Ctrl+Shift+B    Execute tasks with TDD
 kspec-verify    Ctrl+Shift+V    Verify spec/tasks/implementation
 kspec-review    Ctrl+Shift+R    Code review
+kspec-jira      Ctrl+Shift+J    Jira integration (requires Atlassian MCP)
 
 Switch: /agent swap or use keyboard shortcuts
 `);
@@ -930,6 +1234,16 @@ Inside kiro-cli (recommended):
 
   Agents read .kspec/CONTEXT.md automatically for state.
 
+Jira Integration (requires Atlassian MCP):
+  kspec spec --jira PROJ-123,PROJ-456 "Feature"
+                          Create spec from Jira issues
+  kspec sync-jira         Create/update Jira issue from spec
+  kspec sync-jira --update PROJ-123
+                          Update existing Jira issue
+  kspec jira-subtasks     Create Jira subtasks from tasks.md
+  kspec jira-subtasks PROJ-123
+                          Create subtasks under specific issue
+
 Other:
   kspec context           Refresh/view context file
   kspec review [target]   Code review
@@ -942,6 +1256,7 @@ Other:
 Examples:
   kspec init                        # First time setup
   kspec spec "User Auth"            # CLI mode
+  kspec spec --jira PROJ-123 "Auth" # From Jira story
   kiro-cli --agent kspec-spec       # Direct agent mode
 `);
   }
@@ -972,4 +1287,4 @@ async function run(args) {
   }
 }
 
-module.exports = { run, commands, loadConfig, detectCli, requireCli, agentTemplates, getTaskStats, refreshContext, getCurrentTask, checkForUpdates, compareVersions };
+module.exports = { run, commands, loadConfig, detectCli, requireCli, agentTemplates, getTaskStats, refreshContext, getCurrentTask, checkForUpdates, compareVersions, hasAtlassianMcp, getMcpConfig };