specweave 0.32.2 → 0.32.3

package/plugins/specweave-jira/commands/status.md

@@ -0,0 +1,215 @@
+---
+name: specweave-jira:status
+description: Check JIRA sync status for SpecWeave increment
+---
+
+# JIRA Status Command
+
+**Usage**: `/specweave-jira:status <increment-id>`
+
+**Purpose**: Display JIRA sync status and issue details for an increment
+
+---
+
+## Command Behavior
+
+When user runs this command, Claude should:
+
+### 1. Read Increment Metadata
+
+```typescript
+// Load increment metadata
+const metadataPath = `.specweave/increments/${incrementId}/metadata.json`;
+const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));
+
+// Check for linked JIRA issue (check both standard and legacy paths)
+const jiraSync = metadata?.external_sync?.jira || metadata?.external_ids?.jira;
+const issueKey = jiraSync?.issueKey || jiraSync?.epic;
+
+if (!issueKey) {
+  console.log(`
+⚠️ No JIRA issue linked
+
+This increment is not linked to a JIRA issue.
+Create one with: /specweave-jira:create ${incrementId}
+`);
+  return;
+}
+```
+
+### 2. Resolve JIRA Profile
+
+```typescript
+// Priority: increment profile > global defaultProfile > activeProfile
+let profileName = jiraSync?.profile;
+if (!profileName) {
+  const config = JSON.parse(await fs.readFile('.specweave/config.json', 'utf-8'));
+  profileName = config?.sync?.defaultProfile ?? config?.sync?.activeProfile;
+}
+
+const profileConfig = config?.sync?.profiles?.[profileName];
+const { domain, projectKey } = profileConfig?.config || {};
+```
+
+### 3. Read Local Task Status
+
+```typescript
+// Check tasks.md for completion
+const tasksPath = `.specweave/increments/${incrementId}/tasks.md`;
+const tasksContent = await fs.readFile(tasksPath, 'utf-8');
+
+const totalTasks = (tasksContent.match(/### T-\d+/g) || []).length;
+const completedTasks = (tasksContent.match(/\[x\] completed/gi) || []).length;
+const completion = totalTasks > 0 ? Math.round((completedTasks / totalTasks) * 100) : 0;
+```
+
+### 4. Invoke JIRA Manager Agent (Optional - For Live Status)
+
+```
+Use Task tool with subagent_type: "specweave-jira:jira-manager:jira-manager"
+
+Prompt: "Check JIRA sync status for increment {increment-id}.
+
+Issue Key: {issueKey}
+Profile: {profileName} (domain: {domain})
+
+Steps:
+1. GET issue from JIRA API: /rest/api/3/issue/{issueKey}
+2. Extract: status, priority, assignee, sprint, story points
+3. Compare local vs JIRA status
+4. Detect any sync issues or drift
+5. Display comprehensive status"
+```
+
+### 5. Display Status
+
+```
+JIRA Sync Status
+================
+Increment: {increment-id}
+Issue: {issueKey}
+URL: https://{domain}/browse/{issueKey}
+Status: {jiraStatus}
+Completion: {completion}% ({completedTasks}/{totalTasks} tasks)
+Last Synced: {lastSyncedAt} ({relativeTime})
+Sync Enabled: ✅
+
+Profile: {profileName}
+  Domain: {domain}
+  Project: {projectKey}
+
+Next Sync: Automatic on task completion
+```
+
+---
+
+## Example Output
+
+### Issue Linked
+
+```
+User: /specweave-jira:status 0005-payment-integration
+
+Claude:
+JIRA Sync Status
+================
+Increment: 0005-payment-integration
+Issue: MYPROJ-123
+URL: https://company.atlassian.net/browse/MYPROJ-123
+Status: In Progress
+Completion: 60% (6/10 tasks)
+Last Synced: 2025-12-07 10:30:00 (5 minutes ago)
+Sync Enabled: ✅
+
+Profile: jira-my-project
+  Domain: company.atlassian.net
+  Project: MYPROJ
+
+Priority: High
+Assignee: john.doe
+Sprint: Sprint 42
+
+Next Sync: Automatic on task completion
+```
+
+### No Issue Linked
+
+```
+User: /specweave-jira:status 0005
+
+Claude:
+JIRA Sync Status
+================
+Increment: 0005-payment-integration
+
+⚠️ No JIRA issue linked
+
+This increment is not linked to a JIRA issue.
+Create one with: /specweave-jira:create 0005-payment-integration
+```
+
+### Sync Issues Detected
+
+```
+User: /specweave-jira:status 0005
+
+Claude:
+JIRA Sync Status
+================
+Increment: 0005-payment-integration
+Issue: MYPROJ-123
+URL: https://company.atlassian.net/browse/MYPROJ-123
+Status: In Progress
+Completion: 60% (6/10 tasks)
+Last Synced: 2025-12-05 10:30:00 (2 days ago)
+Sync Enabled: ✅
+
+⚠️ Sync Issues Detected:
+  - Local status: in_progress, JIRA status: Done
+  - Status drift detected - run /specweave-jira:pull to sync
+
+Profile: jira-my-project
+  Domain: company.atlassian.net
+  Project: MYPROJ
+```
+
+---
+
+## Status Information Displayed
+
+| Field | Source | Description |
+|-------|--------|-------------|
+| Issue | metadata.json | JIRA issue key (e.g., PROJ-123) |
+| URL | Constructed | Direct link to JIRA issue |
+| Status | JIRA API | Current issue status |
+| Completion | tasks.md | Local completion percentage |
+| Last Synced | metadata.json | Timestamp of last sync |
+| Profile | metadata/config | Which JIRA profile is used |
+| Priority | JIRA API | Issue priority |
+| Assignee | JIRA API | Current assignee |
+| Sprint | JIRA API | Current sprint assignment |
+
+---
+
+## Drift Detection
+
+The status command detects common sync issues:
+
+| Issue | Detection | Resolution |
+|-------|-----------|------------|
+| Status drift | Local vs JIRA status mismatch | `/specweave-jira:pull` |
+| Stale sync | Last synced > 24 hours ago | `/specweave-jira:sync` |
+| Missing issue | Issue deleted in JIRA | `/specweave-jira:create` |
+| Permission denied | canUpdateExternalItems=false | Read-only mode note |
+
+---
+
+## Related
+
+| Command | Purpose |
+|---------|---------|
+| `/specweave-jira:pull` | Pull changes from JIRA |
+| `/specweave-jira:push` | Push progress to JIRA |
+| `/specweave-jira:sync` | Two-way sync |
+| `/specweave-jira:create` | Create JIRA issue |
+| `/specweave-jira:close` | Close issue when complete |

package/plugins/specweave-jira/lib/jira-duplicate-detector.js

@@ -0,0 +1,296 @@
+import { consoleLogger } from "../../../src/utils/logger.js";
+class JiraDuplicateDetector {
+  constructor(options = {}) {
+    this.domain = options.domain || process.env.JIRA_DOMAIN || "";
+    const email = options.email || process.env.JIRA_EMAIL || "";
+    const token = options.token || process.env.JIRA_API_TOKEN || "";
+    this.auth = Buffer.from(`${email}:${token}`).toString("base64");
+    this.logger = options.logger || consoleLogger;
+  }
+  /**
+   * Phase 1: Check if issue exists before creating
+   */
+  async checkBeforeCreate(summaryPattern, incrementId) {
+    try {
+      const issues = await this.searchIssues(summaryPattern);
+      if (issues.length > 0) {
+        return {
+          found: true,
+          existingIssue: issues[0],
+          count: issues.length
+        };
+      }
+      return { found: false, count: 0 };
+    } catch (error) {
+      this.logger.log(`\u26A0\uFE0F  Detection check failed: ${error.message}`);
+      return { found: false, count: 0 };
+    }
+  }
+  /**
+   * Phase 2: Verify count after creation
+   */
+  async verifyAfterCreate(summaryPattern, expectedCount = 1) {
+    try {
+      const issues = await this.searchIssues(summaryPattern);
+      if (issues.length > expectedCount) {
+        const sorted = issues.sort(
+          (a, b) => new Date(a.created).getTime() - new Date(b.created).getTime()
+        );
+        return {
+          success: false,
+          expectedCount,
+          actualCount: issues.length,
+          duplicates: sorted.slice(expectedCount)
+          // All issues after expected count
+        };
+      }
+      return {
+        success: true,
+        expectedCount,
+        actualCount: issues.length,
+        duplicates: []
+      };
+    } catch (error) {
+      this.logger.log(`\u26A0\uFE0F  Verification check failed: ${error.message}`);
+      return {
+        success: true,
+        // Assume success on error
+        expectedCount,
+        actualCount: expectedCount,
+        duplicates: []
+      };
+    }
+  }
+  /**
+   * Phase 3: Auto-close duplicates
+   */
+  async closeDuplicates(duplicates, keepIssueKey) {
+    const result = {
+      closedCount: 0,
+      keptCount: 1,
+      errors: []
+    };
+    for (const issue of duplicates) {
+      try {
+        await this.closeIssue(issue.key, keepIssueKey);
+        result.closedCount++;
+        this.logger.log(`  \u2705 Closed ${issue.key} (duplicate of ${keepIssueKey})`);
+      } catch (error) {
+        result.errors.push(`${issue.key}: ${error.message}`);
+        this.logger.log(`  \u274C Failed to close ${issue.key}: ${error.message}`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Full cleanup: Find and close all duplicates for a feature
+   */
+  async cleanupFeatureDuplicates(featureId, dryRun = false) {
+    const searchPattern = `[${featureId}]`;
+    const issues = await this.searchIssues(searchPattern);
+    this.logger.log(`
+\u{1F50D} Scanning for duplicates in Feature ${featureId}...`);
+    this.logger.log(`   Found ${issues.length} total issues`);
+    const groups = this.groupBySummary(issues);
+    const duplicateGroups = groups.filter((g) => g.duplicates.length > 0);
+    if (duplicateGroups.length === 0) {
+      this.logger.log(`   \u2705 No duplicates found!`);
+      return {
+        groups: [],
+        totalIssues: issues.length,
+        duplicateCount: 0,
+        closedCount: 0
+      };
+    }
+    this.logger.log(`   Detected ${duplicateGroups.length} duplicate groups:
+`);
+    for (let i = 0; i < duplicateGroups.length; i++) {
+      const group = duplicateGroups[i];
+      this.logger.log(`   \u{1F4CB} Group ${i + 1}: "${group.summary.substring(0, 50)}..."`);
+      this.logger.log(`      - ${group.keepIssue.key} (KEEP) - Created ${group.keepIssue.created.split("T")[0]}`);
+      for (const dup of group.duplicates) {
+        this.logger.log(`      - ${dup.key} (CLOSE) - Created ${dup.created.split("T")[0]} - DUPLICATE`);
+      }
+      this.logger.log("");
+    }
+    const totalDuplicates = duplicateGroups.reduce((sum, g) => sum + g.duplicates.length, 0);
+    if (dryRun) {
+      this.logger.log(`
+\u2705 Dry run complete!`);
+      this.logger.log(`   Total issues: ${issues.length}`);
+      this.logger.log(`   Duplicate groups: ${duplicateGroups.length}`);
+      this.logger.log(`   Issues to close: ${totalDuplicates}`);
+      this.logger.log(`
+\u26A0\uFE0F  This was a DRY RUN - no changes made.`);
+      return {
+        groups: duplicateGroups,
+        totalIssues: issues.length,
+        duplicateCount: totalDuplicates,
+        closedCount: 0
+      };
+    }
+    let closedCount = 0;
+    this.logger.log(`\u{1F5D1}\uFE0F  Closing duplicates...`);
+    for (const group of duplicateGroups) {
+      const result = await this.closeDuplicates(group.duplicates, group.keepIssue.key);
+      closedCount += result.closedCount;
+    }
+    this.logger.log(`
+\u2705 Cleanup complete!`);
+    this.logger.log(`   Closed: ${closedCount} duplicates`);
+    this.logger.log(`   Kept: ${duplicateGroups.length} original issues`);
+    return {
+      groups: duplicateGroups,
+      totalIssues: issues.length,
+      duplicateCount: totalDuplicates,
+      closedCount
+    };
+  }
+  /**
+   * Group issues by summary
+   */
+  groupBySummary(issues) {
+    const summaryMap = /* @__PURE__ */ new Map();
+    for (const issue of issues) {
+      const existing = summaryMap.get(issue.summary) || [];
+      existing.push(issue);
+      summaryMap.set(issue.summary, existing);
+    }
+    const groups = [];
+    for (const [summary, groupIssues] of summaryMap) {
+      const sorted = groupIssues.sort(
+        (a, b) => new Date(a.created).getTime() - new Date(b.created).getTime()
+      );
+      groups.push({
+        summary,
+        issues: sorted,
+        keepIssue: sorted[0],
+        duplicates: sorted.slice(1)
+      });
+    }
+    return groups;
+  }
+  /**
+   * Search for issues using JQL
+   */
+  async searchIssues(summaryPattern) {
+    if (!this.domain || !this.auth) {
+      throw new Error("JIRA credentials not configured");
+    }
+    const jql = encodeURIComponent(`summary ~ "${summaryPattern}" ORDER BY created ASC`);
+    const url = `https://${this.domain}/rest/api/3/search?jql=${jql}&fields=summary,status,created`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Basic ${this.auth}`,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`JQL search failed: ${response.status}`);
+    }
+    const data = await response.json();
+    return (data.issues || []).map((issue) => ({
+      key: issue.key,
+      summary: issue.fields.summary,
+      status: issue.fields.status?.name,
+      created: issue.fields.created,
+      url: `https://${this.domain}/browse/${issue.key}`
+    }));
+  }
+  /**
+   * Close an issue with duplicate comment
+   */
+  async closeIssue(issueKey, originalKey) {
+    await this.addComment(issueKey, originalKey);
+    const transitions = await this.getTransitions(issueKey);
+    const closeTransition = transitions.find(
+      (t) => t.name === "Won't Do" || t.name === "Done" || t.name === "Closed" || t.to?.name === "Won't Do" || t.to?.name === "Done"
+    );
+    if (!closeTransition) {
+      throw new Error(`No close transition found. Available: ${transitions.map((t) => t.name).join(", ")}`);
+    }
+    const url = `https://${this.domain}/rest/api/3/issue/${issueKey}/transitions`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${this.auth}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        transition: { id: closeTransition.id }
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to transition issue: ${response.status} - ${error}`);
+    }
+  }
+  /**
+   * Get available transitions for an issue
+   */
+  async getTransitions(issueKey) {
+    const url = `https://${this.domain}/rest/api/3/issue/${issueKey}/transitions`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Basic ${this.auth}`,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get transitions: ${response.status}`);
+    }
+    const data = await response.json();
+    return data.transitions || [];
+  }
+  /**
+   * Add duplicate comment to issue
+   */
+  async addComment(issueKey, originalKey) {
+    const url = `https://${this.domain}/rest/api/3/issue/${issueKey}/comment`;
+    const comment = `h2. Duplicate of ${originalKey}
+
+This issue was automatically closed by SpecWeave cleanup because it is a duplicate.
+
+The original issue (${originalKey}) contains the same content and should be used for tracking instead.
+
+----
+\u{1F916} Auto-closed by SpecWeave Duplicate Cleanup`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${this.auth}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        body: {
+          type: "doc",
+          version: 1,
+          content: [
+            {
+              type: "paragraph",
+              content: [
+                {
+                  type: "text",
+                  text: comment
+                }
+              ]
+            }
+          ]
+        }
+      })
+    });
+    if (!response.ok) {
+      this.logger.log(`     \u26A0\uFE0F  Failed to add comment to ${issueKey}`);
+    }
+  }
+}
+async function cleanupJiraDuplicates(featureId, dryRun = false) {
+  const detector = new JiraDuplicateDetector();
+  return detector.cleanupFeatureDuplicates(featureId, dryRun);
+}
+var jira_duplicate_detector_default = JiraDuplicateDetector;
+export {
+  JiraDuplicateDetector,
+  cleanupJiraDuplicates,
+  jira_duplicate_detector_default as default
+};