specweave 0.9.0 → 0.10.0

package/plugins/specweave-jira/lib/jira-hierarchical-sync.ts

@@ -0,0 +1,283 @@
+/**
+ * Jira Hierarchical Sync Implementation
+ *
+ * Supports three sync strategies:
+ * 1. Simple: One project, all boards (backward compatible)
+ * 2. Filtered: Multiple projects + specific boards + filters
+ * 3. Custom: Raw JQL query
+ */
+
+import {
+  SyncProfile,
+  SyncContainer,
+  JiraConfig,
+  isSimpleStrategy,
+  isFilteredStrategy,
+  isCustomStrategy,
+} from '../../../src/core/types/sync-profile.js';
+import { JiraClient, JiraIssue } from '../../../src/integrations/jira/jira-client.js';
+import { getBoardIds } from './jira-board-resolver.js';
+
+/**
+ * Build hierarchical JQL query from containers
+ *
+ * Example output:
+ * (project=PROJECT-A AND board IN (123, 456) AND labels IN (feature))
+ * OR
+ * (project=PROJECT-B AND board IN (789))
+ *
+ * @param client JiraClient instance
+ * @param containers Array of containers with projects + boards + filters
+ * @returns JQL query string
+ */
+export async function buildHierarchicalJQL(
+  client: JiraClient,
+  containers: SyncContainer[]
+): Promise<string> {
+  const clauses: string[] = [];
+
+  for (const container of containers) {
+    const parts: string[] = [];
+
+    // Project clause
+    parts.push(`project=${container.id}`);
+
+    // Board filtering (if sub-organizations specified)
+    if (container.subOrganizations && container.subOrganizations.length > 0) {
+      try {
+        const boardIds = await getBoardIds(
+          client,
+          container.id,
+          container.subOrganizations
+        );
+
+        if (boardIds.length > 0) {
+          parts.push(`board IN (${boardIds.join(',')})`);
+        } else {
+          console.warn(
+            `⚠️  No valid boards found for project ${container.id}, syncing all boards`
+          );
+        }
+      } catch (error) {
+        console.warn(
+          `⚠️  Failed to resolve boards for ${container.id}, syncing all boards:`,
+          (error as Error).message
+        );
+      }
+    }
+
+    // Filters
+    if (container.filters) {
+      const filterClauses = buildFilterClauses(container.filters);
+      parts.push(...filterClauses);
+    }
+
+    // Combine parts with AND
+    clauses.push(`(${parts.join(' AND ')})`);
+  }
+
+  // Combine clauses with OR
+  return clauses.join(' OR ');
+}
+
+/**
+ * Build filter clauses from container filters
+ *
+ * @param filters Container filters
+ * @returns Array of JQL filter clauses
+ */
+function buildFilterClauses(filters: any): string[] {
+  const clauses: string[] = [];
+
+  // Include labels
+  if (filters.includeLabels && filters.includeLabels.length > 0) {
+    const labels = filters.includeLabels.map((l: string) => `"${l}"`).join(', ');
+    clauses.push(`labels IN (${labels})`);
+  }
+
+  // Exclude labels
+  if (filters.excludeLabels && filters.excludeLabels.length > 0) {
+    const labels = filters.excludeLabels.map((l: string) => `"${l}"`).join(', ');
+    clauses.push(`labels NOT IN (${labels})`);
+  }
+
+  // Assignees
+  if (filters.assignees && filters.assignees.length > 0) {
+    const assignees = filters.assignees.map((a: string) => `"${a}"`).join(', ');
+    clauses.push(`assignee IN (${assignees})`);
+  }
+
+  // Status categories
+  if (filters.statusCategories && filters.statusCategories.length > 0) {
+    const statuses = filters.statusCategories.map((s: string) => `"${s}"`).join(', ');
+    clauses.push(`status IN (${statuses})`);
+  }
+
+  // Components (Jira-specific)
+  if (filters.components && filters.components.length > 0) {
+    const components = filters.components.map((c: string) => `"${c}"`).join(', ');
+    clauses.push(`component IN (${components})`);
+  }
+
+  // Sprints (Jira-specific)
+  if (filters.sprints && filters.sprints.length > 0) {
+    const sprints = filters.sprints.map((s: string) => `"${s}"`).join(', ');
+    clauses.push(`sprint IN (${sprints})`);
+  }
+
+  // Issue types (Jira-specific)
+  if (filters.issueTypes && filters.issueTypes.length > 0) {
+    const types = filters.issueTypes.map((t: string) => `"${t}"`).join(', ');
+    clauses.push(`issuetype IN (${types})`);
+  }
+
+  return clauses;
+}
+
+/**
+ * Add time range filter to JQL query
+ *
+ * @param jql Base JQL query
+ * @param timeRange Time range preset (1W, 1M, 3M, 6M, ALL)
+ * @returns JQL with time range filter
+ */
+function addTimeRangeFilter(jql: string, timeRange: string): string {
+  if (timeRange === 'ALL') {
+    return jql; // No time filter
+  }
+
+  // Convert time range to Jira format
+  const timeMap: Record<string, string> = {
+    '1W': '-1w',
+    '2W': '-2w',
+    '1M': '-1M',
+    '3M': '-3M',
+    '6M': '-6M',
+    '1Y': '-1y',
+  };
+
+  const jiraTime = timeMap[timeRange] || '-1M';
+
+  return `${jql} AND created >= ${jiraTime}`;
+}
+
+/**
+ * Fetch issues hierarchically based on sync strategy
+ *
+ * @param client JiraClient instance
+ * @param profile Sync profile with strategy
+ * @param timeRange Time range preset
+ * @returns Array of Jira issues
+ */
+export async function fetchIssuesHierarchical(
+  client: JiraClient,
+  profile: SyncProfile,
+  timeRange: string = '1M'
+): Promise<JiraIssue[]> {
+  const config = profile.config as JiraConfig;
+
+  // Strategy 1: SIMPLE (backward compatible)
+  if (isSimpleStrategy(profile)) {
+    return fetchIssuesSimple(client, config, timeRange);
+  }
+
+  // Strategy 2: CUSTOM (raw JQL)
+  if (isCustomStrategy(profile)) {
+    return fetchIssuesCustom(client, config, timeRange);
+  }
+
+  // Strategy 3: FILTERED (hierarchical)
+  if (isFilteredStrategy(profile)) {
+    return fetchIssuesFiltered(client, config, timeRange);
+  }
+
+  // Default to simple if strategy not recognized
+  console.warn('⚠️  Unknown strategy, defaulting to simple');
+  return fetchIssuesSimple(client, config, timeRange);
+}
+
+/**
+ * Fetch issues using SIMPLE strategy (one project, all boards)
+ *
+ * @param client JiraClient instance
+ * @param config Jira configuration
+ * @param timeRange Time range preset
+ * @returns Array of Jira issues
+ */
+async function fetchIssuesSimple(
+  client: JiraClient,
+  config: JiraConfig,
+  timeRange: string
+): Promise<JiraIssue[]> {
+  const projectKey = config.projectKey;
+
+  if (!projectKey) {
+    throw new Error('Simple strategy requires projectKey in config');
+  }
+
+  let jql = `project=${projectKey}`;
+
+  // Add time range
+  jql = addTimeRangeFilter(jql, timeRange);
+
+  console.log('🔍 Fetching issues (SIMPLE strategy):', jql);
+
+  return client.searchIssues({ jql });
+}
+
+/**
+ * Fetch issues using CUSTOM strategy (raw JQL)
+ *
+ * @param client JiraClient instance
+ * @param config Jira configuration
+ * @param timeRange Time range preset
+ * @returns Array of Jira issues
+ */
+async function fetchIssuesCustom(
+  client: JiraClient,
+  config: JiraConfig,
+  timeRange: string
+): Promise<JiraIssue[]> {
+  const customQuery = config.customQuery;
+
+  if (!customQuery) {
+    throw new Error('Custom strategy requires customQuery in config');
+  }
+
+  // Add time range to custom query
+  const jql = addTimeRangeFilter(customQuery, timeRange);
+
+  console.log('🔍 Fetching issues (CUSTOM strategy):', jql);
+
+  return client.searchIssues({ jql });
+}
+
+/**
+ * Fetch issues using FILTERED strategy (multiple projects + boards + filters)
+ *
+ * @param client JiraClient instance
+ * @param config Jira configuration
+ * @param timeRange Time range preset
+ * @returns Array of Jira issues
+ */
+async function fetchIssuesFiltered(
+  client: JiraClient,
+  config: JiraConfig,
+  timeRange: string
+): Promise<JiraIssue[]> {
+  const containers = config.containers;
+
+  if (!containers || containers.length === 0) {
+    throw new Error('Filtered strategy requires containers array in config');
+  }
+
+  // Build hierarchical JQL
+  const baseJql = await buildHierarchicalJQL(client, containers);
+
+  // Add time range
+  const jql = addTimeRangeFilter(baseJql, timeRange);
+
+  console.log('🔍 Fetching issues (FILTERED strategy):', jql);
+
+  return client.searchIssues({ jql });
+}

package/plugins/specweave-jira/plugin.json

@@ -0,0 +1,20 @@
+{
+  "name": "specweave-jira",
+  "description": "JIRA integration for SpecWeave increments. Bidirectional sync between SpecWeave increments and JIRA epics/stories. Automatically creates JIRA issues from increments, tracks progress, and updates status.",
+  "version": "1.0.0",
+  "author": {
+    "name": "SpecWeave Team",
+    "url": "https://spec-weave.com"
+  },
+  "homepage": "https://spec-weave.com",
+  "repository": "https://github.com/anton-abyzov/specweave",
+  "license": "MIT",
+  "keywords": [
+    "jira",
+    "atlassian",
+    "integration",
+    "sync",
+    "specweave",
+    "project-management"
+  ]
+}