aiwf 0.3.22 → 0.4.0

package/src/commands/persona.js

@@ -1,309 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * AI 페르소나 명령어
- * AI 행동 페르소나 관리 및 전환
- */
-
-import { AIPersonaManager } from '../lib/ai-persona-manager.js';
-import { ResourceLoader } from '../lib/resource-loader.js';
-import path from 'path';
-import chalk from 'chalk';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-class PersonaCommand {
-  constructor() {
-    this.personaManager = null;
-    this.resourceLoader = new ResourceLoader();
-  }
-
-  /**
-   * 페르소나 매니저 초기화
-   */
-  async initPersonaManager() {
-    if (!this.personaManager) {
-      // 사용자 디렉토리 초기화
-      await this.resourceLoader.initUserDirectory();
-      
-      this.personaManager = new AIPersonaManager({
-        personaConfigPath: path.join(process.cwd(), '.aiwf', 'personas'),
-        metricsPath: path.join(process.cwd(), '.aiwf', 'metrics'),
-        metricsEnabled: true,
-        autoDetectionEnabled: true,
-        resourceLoader: this.resourceLoader
-      });
-      
-      await this.personaManager.init();
-    }
-    
-    return this.personaManager;
-  }
-
-  /**
-   * 페르소나 상태 표시
-   */
-  async showStatus() {
-    try {
-      // 파일에서 현재 페르소나 읽기
-      const fs = await import('fs/promises');
-      const path = await import('path');
-      const personaFile = path.join(process.cwd(), '.aiwf', 'personas', 'current.json');
-      
-      try {
-        const content = await fs.readFile(personaFile, 'utf-8');
-        const currentPersona = JSON.parse(content);
-        
-        console.log(chalk.cyan('🎭 현재 AI 페르소나 상태'));
-        console.log(chalk.gray('-'.repeat(50)));
-        console.log(`현재 페르소나: ${chalk.yellow(currentPersona.name)}`);
-        console.log(`설명: ${currentPersona.description}`);
-        console.log(`활성화 시간: ${new Date(currentPersona.activatedAt).toLocaleString('ko-KR')}`);
-        
-        const behaviors = this.getKoreanBehaviors(currentPersona.name);
-        if (behaviors.length > 0) {
-          console.log('\n주요 동작:');
-          behaviors.forEach(behavior => {
-            console.log(`  • ${behavior}`);
-          });
-        }
-
-        console.log(chalk.gray('\n' + '-'.repeat(50)));
-        console.log(chalk.green('✅ 페르소나가 활성화되어 있습니다.'));
-        
-      } catch (fileError) {
-        console.log(chalk.yellow('⚠️  현재 활성화된 페르소나가 없습니다.'));
-        console.log(chalk.gray('사용 가능한 페르소나 목록을 보려면: aiwf persona list'));
-        console.log(chalk.gray('페르소나를 설정하려면: aiwf persona set <페르소나명>'));
-      }
-      
-    } catch (error) {
-      console.error(chalk.red('❌ 페르소나 상태 확인 중 오류가 발생했습니다:'), error.message);
-      console.error(error.stack);
-    }
-  }
-
-  /**
-   * 페르소나 목록 표시
-   */
-  async listPersonas() {
-    try {
-      console.log(chalk.cyan('🎭 사용 가능한 AI 페르소나'));
-      console.log(chalk.gray('-'.repeat(50)));
-      
-      // ResourceLoader를 사용하여 페르소나 목록 가져오기
-      try {
-        const personas = await this.resourceLoader.listPersonas();
-        
-        for (const personaName of personas) {
-          try {
-            const persona = await this.resourceLoader.loadPersona(personaName);
-            const displayName = chalk.yellow(personaName);
-            const description = persona.description || '설명 없음';
-            console.log(`  ${displayName} - ${description}`);
-          } catch (error) {
-            // 개별 페르소나 로드 실패 시 건너뛰기
-            console.log(`  ${chalk.yellow(personaName)} - ${chalk.gray('(로드 실패)')}`);
-          }
-        }
-      } catch (error) {
-        // 페르소나 목록 가져오기 실패 시 기본 목록 표시
-        const defaultPersonas = [
-          { name: 'architect', description: '시스템 설계 및 아키텍처 전문가' },
-          { name: 'developer', description: '일반 개발자 (기본값)' },
-          { name: 'reviewer', description: '코드 리뷰 및 품질 관리 전문가' },
-          { name: 'analyst', description: '비즈니스 분석가' },
-          { name: 'tester', description: '테스트 엔지니어' }
-        ];
-        
-        defaultPersonas.forEach(persona => {
-          const displayName = chalk.yellow(persona.name);
-          console.log(`  ${displayName} - ${persona.description}`);
-        });
-      }
-      
-      console.log(chalk.gray('\n' + '-'.repeat(50)));
-      console.log(chalk.gray('사용법: aiwf persona set <페르소나명>'));
-      
-    } catch (error) {
-      console.error(chalk.red('❌ 페르소나 목록 조회 중 오류가 발생했습니다:'), error.message);
-      console.error(error.stack);
-    }
-  }
-
-  /**
-   * 페르소나 전환
-   */
-  async setPersona(personaName) {
-    if (!personaName) {
-      console.error(chalk.red('❌ 페르소나 이름을 지정해주세요.'));
-      console.log(chalk.gray('사용법: aiwf persona set <페르소나명>'));
-      console.log(chalk.gray('사용 가능한 페르소나: aiwf persona list'));
-      return;
-    }
-
-    try {
-      // 유효한 페르소나인지 확인
-      const validPersonas = ['architect', 'developer', 'reviewer', 'debugger', 'optimizer', 'security', 'documenter'];
-      
-      if (!validPersonas.includes(personaName)) {
-        console.error(chalk.red(`❌ 페르소나 '${personaName}'를 찾을 수 없습니다.`));
-        console.log(chalk.gray('사용 가능한 페르소나: aiwf persona list'));
-        return;
-      }
-
-      // 간단한 페르소나 설정 (파일 기반)
-      const fs = await import('fs/promises');
-      const path = await import('path');
-      const personaDir = path.join(process.cwd(), '.aiwf', 'personas');
-      
-      // 디렉토리 생성
-      await fs.mkdir(personaDir, { recursive: true });
-      
-      // 현재 페르소나 저장
-      const personaConfig = {
-        name: personaName,
-        description: this.getKoreanDescription(personaName),
-        activatedAt: new Date().toISOString()
-      };
-      
-      await fs.writeFile(
-        path.join(personaDir, 'current.json'),
-        JSON.stringify(personaConfig, null, 2)
-      );
-      
-      console.log(chalk.green('🎭 AI 페르소나 활성화 완료'));
-      console.log(chalk.gray('-'.repeat(50)));
-      console.log(`현재 페르소나: ${chalk.yellow(personaName)}`);
-      console.log(`전문 분야: ${this.getKoreanDescription(personaName)}`);
-      console.log(chalk.gray('-'.repeat(50)));
-      console.log(chalk.green('✅ 페르소나가 성공적으로 활성화되었습니다.'));
-      
-    } catch (error) {
-      console.error(chalk.red('❌ 페르소나 전환 중 오류가 발생했습니다:'), error.message);
-      console.error(error.stack);
-    }
-  }
-
-  /**
-   * 페르소나 리셋
-   */
-  async resetPersona() {
-    try {
-      // 기본 페르소나(developer)로 리셋
-      await this.setPersona('developer');
-      console.log(chalk.green('🔄 페르소나가 기본값(developer)으로 리셋되었습니다.'));
-      
-    } catch (error) {
-      console.error(chalk.red('❌ 페르소나 리셋 중 오류가 발생했습니다:'), error.message);
-      console.error(error.stack);
-    }
-  }
-
-  /**
-   * 명령어 실행
-   */
-  async execute(args) {
-    const [subcommand, ...restArgs] = args;
-
-    switch (subcommand) {
-      case 'status':
-        await this.showStatus();
-        break;
-      case 'list':
-        await this.listPersonas();
-        break;
-      case 'set':
-        await this.setPersona(restArgs[0]);
-        break;
-      case 'reset':
-        await this.resetPersona();
-        break;
-      default:
-        this.showHelp();
-        break;
-    }
-  }
-
-  /**
-   * 도움말 표시
-   */
-  showHelp() {
-    console.log(chalk.cyan('🎭 AIWF 페르소나 관리'));
-    console.log(chalk.gray('-'.repeat(50)));
-    console.log('사용법: aiwf persona <명령어> [옵션]');
-    console.log('');
-    console.log('명령어:');
-    console.log('  status              현재 페르소나 상태 표시');
-    console.log('  list                사용 가능한 페르소나 목록');
-    console.log('  set <페르소나명>     특정 페르소나로 전환');
-    console.log('  reset               기본 페르소나로 리셋');
-    console.log('');
-    console.log('예시:');
-    console.log('  aiwf persona status');
-    console.log('  aiwf persona list');
-    console.log('  aiwf persona set architect');
-    console.log('  aiwf persona reset');
-  }
-
-  /**
-   * 한국어 설명 가져오기
-   */
-  getKoreanDescription(persona) {
-    const descriptions = {
-      architect: '시스템 설계 및 아키텍처 전문가',
-      developer: '일반 개발자 (기본값)',
-      reviewer: '코드 리뷰 및 품질 관리 전문가',
-      debugger: '디버깅 및 문제 해결 전문가',
-      optimizer: '성능 최적화 전문가',
-      security: '보안 및 취약점 분석 전문가',
-      devops: 'DevOps 및 인프라 관리 전문가',
-      tester: '테스트 및 QA 전문가',
-      documenter: '문서화 및 기술 작성 전문가',
-      mentor: '멘토링 및 교육 전문가'
-    };
-    
-    return descriptions[persona] || '설명 없음';
-  }
-
-  /**
-   * 한국어 동작 설명 가져오기
-   */
-  getKoreanBehaviors(persona) {
-    const behaviors = {
-      architect: [
-        '큰 그림과 전체 시스템 구조에 집중',
-        '확장성과 유지보수성 우선시',
-        '디자인 패턴과 아키텍처 원칙 적용',
-        '통합 지점과 인터페이스 고려'
-      ],
-      developer: [
-        '실용적이고 효율적인 코드 작성',
-        '베스트 프랙티스 적용',
-        '가독성과 유지보수성 중시'
-      ],
-      reviewer: [
-        '코드 품질과 표준 준수 확인',
-        '잠재적 버그와 개선점 식별',
-        '성능과 보안 측면 검토'
-      ],
-      debugger: [
-        '문제의 근본 원인 분석',
-        '체계적인 디버깅 접근',
-        '재현 가능한 테스트 케이스 생성'
-      ],
-      optimizer: [
-        '성능 병목 지점 식별',
-        '메모리 사용량 최적화',
-        '알고리즘 효율성 개선'
-      ]
-    };
-    
-    return behaviors[persona] || ['기본 동작'];
-  }
-}
-
-export default PersonaCommand;

package/src/commands/sprint-independent.js

@@ -1,393 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * 독립 스프린트 생성 명령어
- * 마일스톤 없이 독립적으로 실행 가능한 스프린트를 생성
- * YOLO 모드의 핵심 기능
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import chalk from 'chalk';
-import ora from 'ora';
-import prompts from 'prompts';
-import { execSync } from 'child_process';
-
-// 프로젝트 루트에서 .aiwf 디렉토리 찾기
-async function findProjectRoot(startDir = process.cwd()) {
-  let currentDir = startDir;
-  
-  while (currentDir !== path.parse(currentDir).root) {
-    try {
-      const aiwfPath = path.join(currentDir, '.aiwf');
-      await fs.access(aiwfPath);
-      return currentDir;
-    } catch {
-      currentDir = path.dirname(currentDir);
-    }
-  }
-  
-  throw new Error('.aiwf 디렉토리를 찾을 수 없습니다. AIWF 프로젝트 내에서 실행해주세요.');
-}
-
-// 다음 스프린트 ID 생성
-async function getNextSprintId(projectRoot) {
-  const sprintsDir = path.join(projectRoot, '.aiwf', '03_SPRINTS');
-  
-  try {
-    await fs.access(sprintsDir);
-  } catch {
-    await fs.mkdir(sprintsDir, { recursive: true });
-    return 'S01';
-  }
-  
-  const entries = await fs.readdir(sprintsDir);
-  const sprintDirs = entries.filter(entry => entry.match(/^S\d+_/));
-  
-  if (sprintDirs.length === 0) {
-    return 'S01';
-  }
-  
-  const numbers = sprintDirs.map(dir => {
-    const match = dir.match(/^S(\d+)_/);
-    return match ? parseInt(match[1]) : 0;
-  });
-  
-  const maxNumber = Math.max(...numbers);
-  return `S${String(maxNumber + 1).padStart(2, '0')}`;
-}
-
-// README에서 TODO 추출
-async function extractTodosFromReadme(projectRoot) {
-  const readmePaths = [
-    path.join(projectRoot, 'README.md'),
-    path.join(projectRoot, 'readme.md'),
-    path.join(projectRoot, 'README.ko.md')
-  ];
-  
-  for (const readmePath of readmePaths) {
-    try {
-      const content = await fs.readFile(readmePath, 'utf-8');
-      
-      // TODO, Features, 기능, 할 일 등의 섹션 찾기
-      const todoPatterns = [
-        /## (?:TODO|To Do|할 일|Tasks?)[\s\S]*?(?=##|$)/gi,
-        /## (?:Features?|기능)[\s\S]*?(?=##|$)/gi,
-        /- \[ \] .+/g
-      ];
-      
-      const todos = [];
-      for (const pattern of todoPatterns) {
-        const matches = content.match(pattern);
-        if (matches) {
-          matches.forEach(match => {
-            const todoItems = match.match(/- \[ \] (.+)/g);
-            if (todoItems) {
-              todoItems.forEach(item => {
-                const task = item.replace(/- \[ \] /, '').trim();
-                todos.push(task);
-              });
-            }
-          });
-        }
-      }
-      
-      if (todos.length > 0) {
-        return todos;
-      }
-    } catch {
-      // 파일이 없으면 다음 경로 시도
-      continue;
-    }
-  }
-  
-  return [];
-}
-
-// GitHub 이슈에서 정보 추출
-async function extractFromGitHubIssue(issueNumber) {
-  try {
-    // gh CLI 사용
-    const issueData = execSync(`gh issue view ${issueNumber} --json title,body`, { encoding: 'utf8' });
-    const issue = JSON.parse(issueData);
-    
-    const tasks = [];
-    const title = issue.title;
-    
-    // 이슈 본문에서 체크리스트 추출
-    if (issue.body) {
-      const checklistItems = issue.body.match(/- \[ \] (.+)/g);
-      if (checklistItems) {
-        checklistItems.forEach(item => {
-          const task = item.replace(/- \[ \] /, '').trim();
-          tasks.push(task);
-        });
-      }
-    }
-    
-    return { title, tasks };
-  } catch (error) {
-    throw new Error(`GitHub 이슈 #${issueNumber}를 가져올 수 없습니다: ${error.message}`);
-  }
-}
-
-// 스프린트 디렉토리 생성
-async function createSprintDirectory(projectRoot, sprintId, sprintName) {
-  const dirName = `${sprintId}_${sprintName.toLowerCase().replace(/\s+/g, '_').replace(/[^a-z0-9_가-힣]/g, '')}`;
-  const sprintPath = path.join(projectRoot, '.aiwf', '03_SPRINTS', dirName);
-  
-  await fs.mkdir(sprintPath, { recursive: true });
-  return { sprintPath, dirName };
-}
-
-// 스프린트 메타 파일 생성
-async function createSprintMeta(sprintPath, sprintId, sprintName, options) {
-  const timestamp = new Date().toISOString().slice(0, 10);
-  
-  const content = `# ${sprintId} - ${sprintName}
-
-**타입**: 독립 스프린트
-**생성일**: ${timestamp}
-**상태**: active
-**마일스톤**: ${options.milestone || 'N/A (독립 스프린트)'}
-
-## 개요
-
-${options.description || '이 스프린트는 마일스톤과 독립적으로 실행되는 작업 단위입니다.'}
-
-## 목표
-
-${options.goals ? options.goals.map(g => `- ${g}`).join('\n') : '- 요구사항 충족\n- 최소 기능 구현\n- 빠른 완성'}
-
-## 범위
-
-${options.scope || '이 스프린트의 범위는 명시된 태스크로 제한됩니다. 오버엔지니어링을 피하고 핵심 기능에 집중합니다.'}
-
-## YOLO 설정
-
-\`\`\`yaml
-engineering_level: ${options.engineeringLevel || 'minimal'}
-focus_rules:
-  - requirement_first
-  - simple_solution
-  - no_gold_plating
-  - stay_on_track
-\`\`\`
-
-## 태스크 목록
-
-${options.tasks ? options.tasks.map((t, i) => `- [ ] T${String(i + 1).padStart(2, '0')}: ${t} - 상태: pending`).join('\n') : '(태스크가 자동으로 추가됩니다)'}
-
-## 진행 상황
-
-- **계획됨**: ${options.tasks ? options.tasks.length : 0}
-- **진행 중**: 0
-- **완료됨**: 0
-- **전체 진행률**: 0%
-
-## 노트
-
-- 이 스프린트는 YOLO 모드로 실행하기에 최적화되어 있습니다.
-- \`/project:aiwf:yolo ${sprintId}\`로 전체 스프린트를 자동 실행할 수 있습니다.
-`;
-  
-  const metaPath = path.join(sprintPath, `${sprintId}_sprint_meta.md`);
-  await fs.writeFile(metaPath, content);
-  return metaPath;
-}
-
-// 태스크 파일들 생성
-async function createTaskFiles(sprintPath, sprintId, tasks) {
-  const createdTasks = [];
-  
-  for (let i = 0; i < tasks.length; i++) {
-    const taskNumber = `T${String(i + 1).padStart(2, '0')}`;
-    const taskTitle = tasks[i];
-    const fileName = `${taskNumber}_${sprintId}_${taskTitle.toLowerCase().replace(/\s+/g, '_').replace(/[^a-z0-9_가-힣]/g, '')}.md`;
-    const filePath = path.join(sprintPath, fileName);
-    
-    const content = `# ${taskNumber}: ${taskTitle}
-
-**스프린트**: ${sprintId}
-**생성일**: ${new Date().toISOString().slice(0, 16).replace('T', ' ')}
-**상태**: pending
-**우선순위**: high
-**예상 시간**: TBD
-
-## 개요
-
-${taskTitle}를 구현합니다.
-
-## 요구사항
-
-- [ ] 핵심 기능 구현
-- [ ] 기본적인 테스트
-- [ ] 필수 문서화
-
-## 승인 기준
-
-- [ ] 요구사항 충족
-- [ ] 정상 작동 확인
-- [ ] 코드 품질 기준 충족
-
-## 구현 노트
-
-- 가장 간단한 해결책 우선
-- 기존 코드 재사용
-- 오버엔지니어링 방지
-`;
-    
-    await fs.writeFile(filePath, content);
-    createdTasks.push({ taskNumber, fileName, taskTitle });
-  }
-  
-  return createdTasks;
-}
-
-// 메인 함수: 독립 스프린트 생성
-export async function createIndependentSprint(options = {}) {
-  const spinner = ora('독립 스프린트 생성 중...').start();
-  
-  try {
-    const projectRoot = await findProjectRoot();
-    const sprintId = await getNextSprintId(projectRoot);
-    
-    let sprintName = options.name;
-    let tasks = options.tasks || [];
-    let description = options.description;
-    let engineeringLevel = options.minimal ? 'minimal' : options.engineeringLevel || 'minimal';
-    
-    // README에서 TODO 추출
-    if (options.fromReadme) {
-      spinner.text = 'README에서 TODO 추출 중...';
-      const todos = await extractTodosFromReadme(projectRoot);
-      if (todos.length > 0) {
-        tasks = todos;
-        sprintName = sprintName || 'README TODO 구현';
-        description = 'README에서 추출한 TODO 항목들을 구현합니다.';
-      } else {
-        spinner.warn('README에서 TODO를 찾을 수 없습니다.');
-      }
-    }
-    
-    // GitHub 이슈에서 추출
-    if (options.fromIssue) {
-      spinner.text = `GitHub 이슈 #${options.fromIssue} 로딩 중...`;
-      const issueData = await extractFromGitHubIssue(options.fromIssue);
-      sprintName = sprintName || issueData.title;
-      tasks = issueData.tasks.length > 0 ? issueData.tasks : [`이슈 #${options.fromIssue} 구현`];
-      description = `GitHub 이슈 #${options.fromIssue}: ${issueData.title}`;
-    }
-    
-    // 대화형 입력
-    if (!sprintName || tasks.length === 0) {
-      spinner.stop();
-      
-      const response = await prompts([
-        {
-          type: !sprintName ? 'text' : null,
-          name: 'name',
-          message: '스프린트 이름:',
-          initial: '빠른 프로토타입'
-        },
-        {
-          type: tasks.length === 0 ? 'text' : null,
-          name: 'goal',
-          message: '주요 목표 (한 줄로):',
-          initial: '핵심 기능 구현'
-        }
-      ]);
-      
-      sprintName = sprintName || response.name;
-      if (response.goal && tasks.length === 0) {
-        tasks = [response.goal];
-      }
-      
-      spinner.start();
-    }
-    
-    // 스프린트 디렉토리 생성
-    spinner.text = '스프린트 디렉토리 생성 중...';
-    const { sprintPath, dirName } = await createSprintDirectory(projectRoot, sprintId, sprintName);
-    
-    // 스프린트 메타 파일 생성
-    spinner.text = '스프린트 메타 파일 생성 중...';
-    await createSprintMeta(sprintPath, sprintId, sprintName, {
-      description,
-      goals: options.goals || [`${sprintName} 완성`],
-      scope: options.scope,
-      engineeringLevel,
-      tasks,
-      milestone: null
-    });
-    
-    // 태스크 파일 생성
-    if (tasks.length > 0) {
-      spinner.text = '태스크 파일 생성 중...';
-      await createTaskFiles(sprintPath, sprintId, tasks);
-    }
-    
-    spinner.succeed('독립 스프린트 생성 완료!');
-    
-    // 성공 메시지
-    console.log('\n' + chalk.green('✅ 독립 스프린트 생성 완료!'));
-    console.log('\n📁 스프린트: ' + chalk.cyan(dirName));
-    console.log('🆔 ID: ' + chalk.yellow(sprintId));
-    console.log('📝 이름: ' + chalk.yellow(sprintName));
-    console.log('🎯 태스크: ' + chalk.blue(`${tasks.length}개`));
-    console.log('🔧 엔지니어링 레벨: ' + chalk.magenta(engineeringLevel));
-    
-    console.log('\n' + chalk.bold('🚀 다음 단계:'));
-    console.log(`1. ${chalk.cyan(`/project:aiwf:yolo ${sprintId}`)}로 전체 스프린트 실행`);
-    console.log(`2. ${chalk.cyan(`/project:aiwf:yolo ${sprintId} --minimal`)}로 최소 구현 모드 실행`);
-    console.log(`3. ${chalk.cyan(`aiwf sprint-task ${sprintId} "새 태스크"`)}로 태스크 추가`);
-    
-    console.log('\n💡 팁: 이 스프린트는 마일스톤과 독립적으로 실행됩니다!');
-    
-    return { success: true, sprintId, sprintPath, tasks: tasks.length };
-    
-  } catch (error) {
-    spinner.fail(`독립 스프린트 생성 실패: ${error.message}`);
-    throw error;
-  }
-}
-
-// CLI 실행
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const args = process.argv.slice(2);
-  
-  const options = {
-    name: null,
-    fromReadme: false,
-    fromIssue: null,
-    minimal: false,
-    engineeringLevel: 'minimal'
-  };
-  
-  // 인자 파싱
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    
-    if (arg === '--from-readme') {
-      options.fromReadme = true;
-    } else if (arg === '--from-issue' && args[i + 1]) {
-      options.fromIssue = args[++i];
-    } else if (arg === '--minimal') {
-      options.minimal = true;
-      options.engineeringLevel = 'minimal';
-    } else if (arg === '--balanced') {
-      options.engineeringLevel = 'balanced';
-    } else if (arg === '--complete') {
-      options.engineeringLevel = 'complete';
-    } else if (!options.name) {
-      options.name = arg;
-    }
-  }
-  
-  createIndependentSprint(options).catch(error => {
-    console.error(chalk.red(`오류: ${error.message}`));
-    process.exit(1);
-  });
-}
-
-export default createIndependentSprint;