specweave 0.23.16 → 0.24.0

package/plugins/specweave-jira/commands/import-projects.js

@@ -0,0 +1,183 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { existsSync } from "fs";
+import path from "path";
+import { JiraClient } from "../../../src/integrations/jira/jira-client.js";
+import { FilterProcessor } from "../../../src/integrations/jira/filter-processor.js";
+import { mergeEnvList, getEnvValue } from "../../../src/utils/env-manager.js";
+import { consoleLogger } from "../../../src/utils/logger.js";
+import { credentialsManager } from "../../../src/core/credentials-manager.js";
+async function importProjects(options = {}) {
+  const logger = options.logger ?? consoleLogger;
+  const projectRoot = process.cwd();
+  console.log(chalk.cyan("\n\u{1F4E5} JIRA Project Import\n"));
+  const credentials = credentialsManager.getJiraCredentials();
+  if (!credentials) {
+    console.log(chalk.red("\u274C No JIRA credentials found"));
+    console.log(chalk.gray("   Run: specweave init"));
+    return;
+  }
+  const client = new JiraClient(credentials);
+  const filterProcessor = new FilterProcessor(client, { logger });
+  if (options.resume) {
+    const resumed = await resumeImport(projectRoot, client, filterProcessor, options);
+    if (resumed) {
+      return;
+    }
+    console.log(chalk.yellow("\u26A0\uFE0F  No import state found. Starting fresh import.\n"));
+  }
+  const existing = await loadExistingProjects(projectRoot, logger);
+  console.log(chalk.gray(`Current projects: ${existing.length > 0 ? existing.join(", ") : "none"}
+`));
+  console.log(chalk.cyan("\u{1F4E1} Fetching available JIRA projects...\n"));
+  let allProjects = [];
+  try {
+    const response = await client.searchProjects({ maxResults: 1e3 });
+    allProjects = response.values || [];
+    console.log(chalk.green(`\u2713 Found ${allProjects.length} total projects
+`));
+  } catch (error) {
+    console.log(chalk.red(`\u274C Failed to fetch projects: ${error.message}`));
+    return;
+  }
+  let filteredProjects = allProjects;
+  if (options.preset) {
+    console.log(chalk.cyan(`\u{1F50D} Applying preset: ${options.preset}
+`));
+    try {
+      filteredProjects = await filterProcessor.applyPreset(allProjects, options.preset);
+    } catch (error) {
+      console.log(chalk.red(`\u274C ${error.message}`));
+      return;
+    }
+  } else if (options.filter || options.type || options.lead || options.jql) {
+    const filterOptions = {};
+    if (options.filter === "active") {
+      filterOptions.active = true;
+    } else if (options.filter === "archived") {
+      filterOptions.active = false;
+    }
+    if (options.type) {
+      filterOptions.types = options.type;
+    }
+    if (options.lead) {
+      filterOptions.lead = options.lead;
+    }
+    if (options.jql) {
+      filterOptions.jql = options.jql;
+    }
+    console.log(chalk.cyan("\u{1F50D} Applying filters...\n"));
+    filteredProjects = await filterProcessor.applyFilters(allProjects, filterOptions);
+  }
+  const newProjects = filteredProjects.filter((p) => {
+    return !existing.some((e) => e.toLowerCase() === p.key.toLowerCase());
+  });
+  if (newProjects.length === 0) {
+    console.log(chalk.yellow("\u26A0\uFE0F  No new projects found to import"));
+    console.log(chalk.gray("   All available projects are already imported\n"));
+    return;
+  }
+  console.log(chalk.cyan("\u{1F4CB} Import Preview:\n"));
+  console.log(chalk.white(`   Total available: ${allProjects.length}`));
+  console.log(chalk.white(`   After filtering: ${filteredProjects.length}`));
+  console.log(chalk.white(`   Already imported: ${existing.length}`));
+  console.log(chalk.white(`   New projects: ${chalk.green.bold(newProjects.length)}
+`));
+  if (newProjects.length <= 10) {
+    console.log(chalk.gray("Projects to import:"));
+    newProjects.forEach((p) => {
+      const typeLabel = p.projectTypeKey || "unknown";
+      const leadLabel = p.lead?.displayName || "no lead";
+      console.log(chalk.gray(`   \u2728 ${p.key} - ${p.name} (${typeLabel}, ${leadLabel})`));
+    });
+    console.log("");
+  }
+  if (options.dryRun) {
+    console.log(chalk.yellow("\u{1F50D} Dry-run mode: No changes will be made\n"));
+    console.log(chalk.green(`\u2713 Preview complete: ${newProjects.length} project(s) would be imported
+`));
+    return;
+  }
+  const { confirmed } = await inquirer.prompt([{
+    type: "confirm",
+    name: "confirmed",
+    message: `Import ${newProjects.length} new project(s)?`,
+    default: true
+  }]);
+  if (!confirmed) {
+    console.log(chalk.yellow("\n\u23ED\uFE0F  Import canceled\n"));
+    return;
+  }
+  const projectKeys = newProjects.map((p) => p.key);
+  console.log(chalk.cyan("\n\u{1F4E5} Importing projects...\n"));
+  try {
+    await mergeEnvList({
+      key: "JIRA_PROJECTS",
+      newValues: projectKeys,
+      projectRoot,
+      logger,
+      createBackup: true
+    });
+    console.log(chalk.green(`
+\u2705 Successfully imported ${projectKeys.length} project(s)
+`));
+    console.log(chalk.gray("Updated: .env (JIRA_PROJECTS)"));
+    console.log(chalk.gray("Backup: .env.backup\n"));
+  } catch (error) {
+    console.log(chalk.red(`
+\u274C Import failed: ${error.message}
+`));
+  }
+}
+async function loadExistingProjects(projectRoot, logger) {
+  const value = await getEnvValue(projectRoot, "JIRA_PROJECTS");
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
+}
+async function resumeImport(projectRoot, client, filterProcessor, options) {
+  const stateFile = path.join(projectRoot, ".specweave", "cache", "import-state.json");
+  if (!existsSync(stateFile)) {
+    return false;
+  }
+  console.log(chalk.cyan("\u{1F504} Resuming interrupted import...\n"));
+  return false;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--filter") {
+      options.filter = args[++i];
+    } else if (arg === "--type") {
+      options.type = args[++i].split(",");
+    } else if (arg === "--lead") {
+      options.lead = args[++i];
+    } else if (arg === "--jql") {
+      options.jql = args[++i];
+    } else if (arg === "--preset") {
+      options.preset = args[++i];
+    } else if (arg === "--dry-run") {
+      options.dryRun = true;
+    } else if (arg === "--resume") {
+      options.resume = true;
+    } else if (arg === "--no-progress") {
+      options.noProgress = true;
+    }
+  }
+  await importProjects(options);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error(chalk.red(`
+\u274C Error: ${error.message}
+`));
+    process.exit(1);
+  });
+}
+export {
+  main as default,
+  importProjects
+};

package/plugins/specweave-jira/commands/import-projects.md

@@ -0,0 +1,97 @@
+---
+name: specweave-jira:import-projects
+description: Import additional JIRA projects post-init with smart filtering, resume, and dry-run support
+---
+
+# JIRA Project Import Command
+
+Import additional JIRA projects after initial setup with advanced filtering and merge capabilities.
+
+## Usage
+
+```bash
+# Import all active projects
+/specweave-jira:import-projects --filter active
+
+# Import with preset filter
+/specweave-jira:import-projects --preset production
+
+# Import with custom JQL
+/specweave-jira:import-projects --jql "project NOT IN (TEST, SANDBOX)"
+
+# Dry-run preview (no changes)
+/specweave-jira:import-projects --dry-run
+
+# Resume interrupted import
+/specweave-jira:import-projects --resume
+```
+
+## Options
+
+- `--filter <type>` - Filter by status (active, archived, all)
+- `--type <types>` - Filter by project type (software, business, service_desk)
+- `--lead <email>` - Filter by project lead
+- `--jql <query>` - Custom JQL filter
+- `--preset <name>` - Use saved filter preset
+- `--dry-run` - Preview without making changes
+- `--resume` - Resume interrupted import
+- `--no-progress` - Disable progress tracking
+
+## Examples
+
+### Import Active Projects Only
+
+```bash
+/specweave-jira:import-projects --filter active
+```
+
+Filters out archived projects, shows preview, prompts for confirmation, merges with existing.
+
+### Import with Production Preset
+
+```bash
+/specweave-jira:import-projects --preset production
+```
+
+Uses the "production" preset filter (active + software + excludes TEST/SANDBOX).
+
+### Custom JQL Filter
+
+```bash
+/specweave-jira:import-projects --jql "lead = currentUser() AND status != Archived"
+```
+
+Imports projects where you are the lead and not archived.
+
+### Dry-Run Preview
+
+```bash
+/specweave-jira:import-projects --filter active --dry-run
+```
+
+Shows which projects would be imported without making any changes.
+
+## Features
+
+- **Smart Filtering**: Filter by status, type, lead, or custom JQL
+- **Merge with Existing**: Automatically merges with existing projects (no duplicates)
+- **Progress Tracking**: Real-time progress with ETA and cancelation support
+- **Resume Support**: Resume interrupted imports with `--resume`
+- **Dry-Run Mode**: Preview changes before applying
+- **Filter Presets**: Use saved filter combinations
+
+## Implementation
+
+This command:
+
+1. Reads existing projects from `.env` (JIRA_PROJECTS)
+2. Fetches available projects from JIRA API
+3. Applies selected filters using FilterProcessor
+4. Shows preview with project count and reduction percentage
+5. Prompts for confirmation
+6. Batch imports with AsyncProjectLoader (50-project limit)
+7. Shows progress with ETA
+8. Merges with existing projects (no duplicates)
+9. Updates `.env` file atomically
+
+Handles Ctrl+C gracefully with import state saving for resume.

package/plugins/specweave-jira/commands/import-projects.ts

@@ -0,0 +1,288 @@
+/**
+ * JIRA Project Import Command (Post-Init)
+ *
+ * Import additional JIRA projects after initial setup with smart filtering,
+ * resume support, and merge capabilities.
+ *
+ * Features:
+ * - Smart filtering (active, type, lead, JQL)
+ * - Filter presets (production, active-only, agile-only)
+ * - Dry-run preview mode
+ * - Resume interrupted imports
+ * - Progress tracking with ETA
+ * - Merge with existing projects (no duplicates)
+ *
+ * NEW (v0.24.0): Post-init flexibility for project management
+ *
+ * @module plugins/specweave-jira/commands/import-projects
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { existsSync } from 'fs';
+import path from 'path';
+import { JiraClient } from '../../../src/integrations/jira/jira-client.js';
+import { FilterProcessor, type FilterOptions } from '../../../src/integrations/jira/filter-processor.js';
+import { AsyncProjectLoader } from '../../../src/cli/helpers/async-project-loader.js';
+import { mergeEnvList, getEnvValue } from '../../../src/utils/env-manager.js';
+import { consoleLogger, type Logger } from '../../../src/utils/logger.js';
+import { credentialsManager } from '../../../src/core/credentials-manager.js';
+
+export interface ImportProjectsOptions {
+  filter?: 'active' | 'archived' | 'all';
+  type?: string[];
+  lead?: string;
+  jql?: string;
+  preset?: string;
+  dryRun?: boolean;
+  resume?: boolean;
+  noProgress?: boolean;
+  logger?: Logger;
+}
+
+export interface ImportState {
+  total: number;
+  completed: string[];
+  remaining: string[];
+  timestamp: number;
+}
+
+/**
+ * Import JIRA projects command
+ *
+ * TC-063: Post-Init Import (Merge with Existing)
+ * TC-064: Filter Active Projects Only
+ * TC-068: Resume Interrupted Import
+ * TC-069: Dry-Run Preview
+ * TC-070: Progress During Import
+ *
+ * @param options - Import options
+ */
+export async function importProjects(options: ImportProjectsOptions = {}): Promise<void> {
+  const logger = options.logger ?? consoleLogger;
+  const projectRoot = process.cwd();
+
+  // Step 1: Load credentials
+  console.log(chalk.cyan('\n📥 JIRA Project Import\n'));
+
+  const credentials = credentialsManager.getJiraCredentials();
+  if (!credentials) {
+    console.log(chalk.red('❌ No JIRA credentials found'));
+    console.log(chalk.gray('   Run: specweave init'));
+    return;
+  }
+
+  const client = new JiraClient(credentials);
+  const filterProcessor = new FilterProcessor(client, { logger });
+
+  // Step 2: Check for resume state
+  if (options.resume) {
+    const resumed = await resumeImport(projectRoot, client, filterProcessor, options);
+    if (resumed) {
+      return;
+    }
+    console.log(chalk.yellow('⚠️  No import state found. Starting fresh import.\n'));
+  }
+
+  // Step 3: Read existing projects from .env
+  const existing = await loadExistingProjects(projectRoot, logger);
+  console.log(chalk.gray(`Current projects: ${existing.length > 0 ? existing.join(', ') : 'none'}\n`));
+
+  // Step 4: Fetch available projects from JIRA
+  console.log(chalk.cyan('📡 Fetching available JIRA projects...\n'));
+
+  let allProjects: any[] = [];
+  try {
+    const response = await client.searchProjects({ maxResults: 1000 });
+    allProjects = response.values || [];
+    console.log(chalk.green(`✓ Found ${allProjects.length} total projects\n`));
+  } catch (error: any) {
+    console.log(chalk.red(`❌ Failed to fetch projects: ${error.message}`));
+    return;
+  }
+
+  // Step 5: Apply filters
+  let filteredProjects = allProjects;
+
+  if (options.preset) {
+    // Use filter preset
+    console.log(chalk.cyan(`🔍 Applying preset: ${options.preset}\n`));
+    try {
+      filteredProjects = await filterProcessor.applyPreset(allProjects, options.preset);
+    } catch (error: any) {
+      console.log(chalk.red(`❌ ${error.message}`));
+      return;
+    }
+  } else if (options.filter || options.type || options.lead || options.jql) {
+    // Build filter options
+    const filterOptions: FilterOptions = {};
+
+    if (options.filter === 'active') {
+      filterOptions.active = true;
+    } else if (options.filter === 'archived') {
+      filterOptions.active = false;
+    }
+
+    if (options.type) {
+      filterOptions.types = options.type;
+    }
+
+    if (options.lead) {
+      filterOptions.lead = options.lead;
+    }
+
+    if (options.jql) {
+      filterOptions.jql = options.jql;
+    }
+
+    console.log(chalk.cyan('🔍 Applying filters...\n'));
+    filteredProjects = await filterProcessor.applyFilters(allProjects, filterOptions);
+  }
+
+  // Step 6: Exclude existing projects
+  const newProjects = filteredProjects.filter(p => {
+    return !existing.some(e => e.toLowerCase() === p.key.toLowerCase());
+  });
+
+  if (newProjects.length === 0) {
+    console.log(chalk.yellow('⚠️  No new projects found to import'));
+    console.log(chalk.gray('   All available projects are already imported\n'));
+    return;
+  }
+
+  // Step 7: Show preview
+  console.log(chalk.cyan('📋 Import Preview:\n'));
+  console.log(chalk.white(`   Total available: ${allProjects.length}`));
+  console.log(chalk.white(`   After filtering: ${filteredProjects.length}`));
+  console.log(chalk.white(`   Already imported: ${existing.length}`));
+  console.log(chalk.white(`   New projects: ${chalk.green.bold(newProjects.length)}\n`));
+
+  if (newProjects.length <= 10) {
+    console.log(chalk.gray('Projects to import:'));
+    newProjects.forEach(p => {
+      const typeLabel = p.projectTypeKey || 'unknown';
+      const leadLabel = p.lead?.displayName || 'no lead';
+      console.log(chalk.gray(`   ✨ ${p.key} - ${p.name} (${typeLabel}, ${leadLabel})`));
+    });
+    console.log('');
+  }
+
+  // Step 8: Dry-run mode (exit without changes)
+  if (options.dryRun) {
+    console.log(chalk.yellow('🔍 Dry-run mode: No changes will be made\n'));
+    console.log(chalk.green(`✓ Preview complete: ${newProjects.length} project(s) would be imported\n`));
+    return;
+  }
+
+  // Step 9: Confirm import
+  const { confirmed } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirmed',
+    message: `Import ${newProjects.length} new project(s)?`,
+    default: true
+  }]);
+
+  if (!confirmed) {
+    console.log(chalk.yellow('\n⏭️  Import canceled\n'));
+    return;
+  }
+
+  // Step 10: Extract project keys
+  const projectKeys = newProjects.map(p => p.key);
+
+  // Step 11: Merge with existing
+  console.log(chalk.cyan('\n📥 Importing projects...\n'));
+
+  try {
+    await mergeEnvList({
+      key: 'JIRA_PROJECTS',
+      newValues: projectKeys,
+      projectRoot,
+      logger,
+      createBackup: true
+    });
+
+    console.log(chalk.green(`\n✅ Successfully imported ${projectKeys.length} project(s)\n`));
+    console.log(chalk.gray('Updated: .env (JIRA_PROJECTS)'));
+    console.log(chalk.gray('Backup: .env.backup\n'));
+
+  } catch (error: any) {
+    console.log(chalk.red(`\n❌ Import failed: ${error.message}\n`));
+  }
+}
+
+/**
+ * Load existing JIRA projects from .env
+ */
+async function loadExistingProjects(projectRoot: string, logger: Logger): Promise<string[]> {
+  const value = await getEnvValue(projectRoot, 'JIRA_PROJECTS');
+  if (!value) {
+    return [];
+  }
+
+  return value.split(',').map(v => v.trim()).filter(v => v.length > 0);
+}
+
+/**
+ * Resume interrupted import
+ */
+async function resumeImport(
+  projectRoot: string,
+  client: JiraClient,
+  filterProcessor: FilterProcessor,
+  options: ImportProjectsOptions
+): Promise<boolean> {
+  const stateFile = path.join(projectRoot, '.specweave', 'cache', 'import-state.json');
+
+  if (!existsSync(stateFile)) {
+    return false;
+  }
+
+  console.log(chalk.cyan('🔄 Resuming interrupted import...\n'));
+
+  // Load state and continue
+  // (Implementation would load state, skip completed, import remaining)
+
+  return false; // Placeholder - full implementation would handle resume
+}
+
+/**
+ * Command entry point (called by CLI)
+ */
+export default async function main(): Promise<void> {
+  // Parse CLI arguments
+  const args = process.argv.slice(2);
+  const options: ImportProjectsOptions = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--filter') {
+      options.filter = args[++i] as 'active' | 'archived' | 'all';
+    } else if (arg === '--type') {
+      options.type = args[++i].split(',');
+    } else if (arg === '--lead') {
+      options.lead = args[++i];
+    } else if (arg === '--jql') {
+      options.jql = args[++i];
+    } else if (arg === '--preset') {
+      options.preset = args[++i];
+    } else if (arg === '--dry-run') {
+      options.dryRun = true;
+    } else if (arg === '--resume') {
+      options.resume = true;
+    } else if (arg === '--no-progress') {
+      options.noProgress = true;
+    }
+  }
+
+  await importProjects(options);
+}
+
+// Run command if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(error => {
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  });
+}