aiwf 0.3.7 → 0.3.12

package/claude-code/docker/Dockerfile

@@ -1,117 +0,0 @@
-FROM node:20
-
-ARG TZ
-ENV TZ="$TZ"
-ARG SANDBOX_NAME="ai-code-sandbox"
-ARG CLI_VERSION_ARG
-ENV SANDBOX="$SANDBOX_NAME"
-ENV CLI_VERSION=$CLI_VERSION_ARG
-
-# Install basic development tools and iptables/ipset
-RUN apt update && apt install -y less \
-  git \
-  procps \
-  sudo \
-  fzf \
-  zsh \
-  man-db \
-  unzip \
-  gnupg2 \
-  gh \
-  iptables \
-  ipset \
-  iproute2 \
-  dnsutils \
-  aggregate \
-  jq \
-  ripgrep \
-  nano \
-  python3 \
-  make \
-  g++ \
-  curl \
-  bc \
-  git \
-  rsync \
-  psmisc \
-  lsof \
-  socat \
-  neovim \
-  fasd \
-  ca-certificates \
-  && apt-get clean \
-  && rm -rf /var/lib/apt/lists/*
-
-# Ensure default node user has access to /usr/local/share
-RUN mkdir -p /usr/local/share/npm-global && \
-  chown -R node:node /usr/local/share/npm-global && \
-  chown -R node:node /usr/local/share
-
-ARG USERNAME=node
-
-# Persist bash history.
-RUN SNIPPET="export PROMPT_COMMAND='history -a' && export HISTFILE=/commandhistory/.bash_history" \
-  && mkdir /commandhistory \
-  && touch /commandhistory/.bash_history \
-  && chown -R $USERNAME /commandhistory
-
-# Set `DEVCONTAINER` environment variable to help with orientation
-ENV DEVCONTAINER=true
-
-# Create workspace and config directories and set permissions
-RUN mkdir -p /workspace /home/node/.claude && \
-  chown -R node:node /workspace /home/node/.claude
-
-WORKDIR /workspace
-
-RUN ARCH=$(dpkg --print-architecture) && \
-  wget "https://github.com/dandavison/delta/releases/download/0.18.2/git-delta_0.18.2_${ARCH}.deb" && \
-  sudo dpkg -i "git-delta_0.18.2_${ARCH}.deb" && \
-  rm "git-delta_0.18.2_${ARCH}.deb"
-
-# Set up non-root user
-USER node
-
-# Install global packages
-ENV NPM_CONFIG_PREFIX=/usr/local/share/npm-global
-ENV PATH=$PATH:/usr/local/share/npm-global/bin
-
-# Set the default shell to bash rather than sh
-ENV SHELL /bin/zsh
-
-# Default powerline10k theme
-RUN sh -c "$(wget -O- https://github.com/deluan/zsh-in-docker/releases/download/v1.2.0/zsh-in-docker.sh)" -- \
-  -p git \
-  -p fzf \
-  -p fasd \
-  -p zsh-autosuggestions \
-  -p zsh-syntax-highlighting \
-  -a "source /usr/share/doc/fzf/examples/key-bindings.zsh" \
-  -a "source /usr/share/doc/fzf/examples/completion.zsh" \
-  -a "export PROMPT_COMMAND='history -a' && export HISTFILE=/commandhistory/.bash_history" \
-  -x
-
-# Install Claude
-RUN npm install -g @anthropic-ai/claude-code
-
-# Setup Claude config
-RUN mkdir ~/.claude-code.config && \
-  echo "{}" > ~/.claude-code.config/.claude.json && \
-  ln -sf ~/.claude-code.config/.claude.json ~/.claude.json
-
-# Install Gemini
-RUN npm install -g @google/gemini-cli
-
-# Install Taskmaster
-RUN npm install -g task-master-ai
-
-RUN echo "alias tm='task-master'" >> ~/.zshrc
-RUN echo "export GOOGLE_CLOUD_PROJECT="sellerking"" >> ~/.zshrc
-
-# Copy and set up firewall script
-# COPY init-firewall.sh /usr/local/bin/
-# USER root
-# RUN chmod +x /usr/local/bin/init-firewall.sh && \
-#   echo "node ALL=(root) NOPASSWD: /usr/local/bin/init-firewall.sh" > /etc/sudoers.d/node-firewall && \
-#   chmod 0440 /etc/sudoers.d/node-firewall
-# USER node

package/jest.config.js

@@ -1,23 +0,0 @@
-export default {
-  testEnvironment: 'node',
-  testMatch: ['**/__tests__/**/*.js', '**/?(*.)+(spec|test).js'],
-  collectCoverage: true,
-  coverageDirectory: 'coverage',
-  coverageReporters: ['text', 'html', 'json', 'lcov'],
-  collectCoverageFrom: [
-    'index.js',
-    'language-cli.js',
-    'scripts/**/*.js',
-    '!**/node_modules/**',
-    '!**/coverage/**',
-    '!**/tests/**'
-  ],
-  coverageThreshold: {
-    global: {
-      branches: 80,
-      functions: 80,
-      lines: 80,
-      statements: 80
-    }
-  }
-};

package/scripts/update-feature-status.js

@@ -1,70 +0,0 @@
-#!/usr/bin/env node
-
-import { promises as fs } from 'fs';
-import path from 'path';
-import { parseYamlFrontmatter, updateYamlFrontmatter, getFeaturePath } from '../src/utils/git-integration.js';
-
-// Feature 상태 업데이트 함수
-async function updateFeatureStatus(featureId, newStatus) {
-    const featurePath = await getFeaturePath(featureId);
-    if (!featurePath) {
-        console.error(`Feature ${featureId} not found`);
-        return false;
-    }
-
-    try {
-        const content = await fs.readFile(featurePath, 'utf-8');
-        const metadata = parseYamlFrontmatter(content);
-        
-        if (!metadata) {
-            console.error(`Invalid feature file format: ${featurePath}`);
-            return false;
-        }
-
-        // 상태 업데이트
-        const oldStatus = metadata.status;
-        metadata.status = newStatus;
-        
-        // 완료 시간 기록
-        if (newStatus === 'completed' && !metadata.actual_completion) {
-            metadata.actual_completion = new Date().toISOString().split('T')[0];
-        }
-        
-        // 파일 업데이트
-        const updatedContent = updateYamlFrontmatter(content, metadata);
-        await fs.writeFile(featurePath, updatedContent, 'utf-8');
-        
-        console.log(`✅ Feature ${featureId} status updated: ${oldStatus} → ${newStatus}`);
-        return true;
-        
-    } catch (error) {
-        console.error(`Error updating feature ${featureId}:`, error.message);
-        return false;
-    }
-}
-
-// CLI 실행
-if (process.argv.length < 4) {
-    console.log('Usage: node update-feature-status.js <featureId> <newStatus>');
-    console.log('Status: planning | active | completed | archived');
-    process.exit(1);
-}
-
-const featureId = process.argv[2];
-const newStatus = process.argv[3];
-
-const validStatuses = ['planning', 'active', 'completed', 'archived'];
-if (!validStatuses.includes(newStatus)) {
-    console.error(`Invalid status: ${newStatus}`);
-    console.log(`Valid statuses: ${validStatuses.join(', ')}`);
-    process.exit(1);
-}
-
-updateFeatureStatus(featureId, newStatus)
-    .then(success => process.exit(success ? 0 : 1))
-    .catch(error => {
-        console.error('Unexpected error:', error);
-        process.exit(1);
-    });
-
-export { updateFeatureStatus };

package/tests/application.test.js

@@ -1,260 +0,0 @@
-/**
- * 애플리케이션 메인 코드 테스트
- */
-
-import { spawn } from 'child_process';
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 애플리케이션 실행 헬퍼
-async function runApp(args = [], timeout = 10000) {
-  return new Promise((resolve, reject) => {
-    const appPath = path.join(__dirname, '..', 'src', 'cli', 'index.js');
-    const child = spawn('node', [appPath, ...args], {
-      stdio: 'pipe',
-      timeout: timeout
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      resolve({ code, stdout, stderr });
-    });
-
-    child.on('error', reject);
-
-    // 타임아웃 처리
-    setTimeout(() => {
-      child.kill();
-      reject(new Error('Process timeout'));
-    }, timeout);
-  });
-}
-
-describe('AIWF 애플리케이션 테스트', () => {
-  test('애플리케이션이 정상적으로 시작됨', async () => {
-    const result = await runApp(['--version']);
-    expect(result.code).toBe(0);
-  });
-
-  test('도움말 메시지가 표시됨', async () => {
-    const result = await runApp(['--help']);
-    expect(result.stdout).toContain('AIWF');
-    expect(result.stdout).toContain('설치');
-  });
-
-  test('버전 정보가 표시됨', async () => {
-    const result = await runApp(['--version']);
-    expect(result.stdout).toMatch(/\d+\.\d+\.\d+/);
-  });
-
-  test('잘못된 명령어에 대한 오류 처리', async () => {
-    const result = await runApp(['--invalid-option']);
-    expect(result.code).not.toBe(0);
-  });
-});
-
-describe('Language CLI 테스트', () => {
-  async function runLanguageCli(args = [], timeout = 5000) {
-    return new Promise((resolve, reject) => {
-      const cliPath = path.join(__dirname, '..', 'src', 'cli', 'language-cli.js');
-      const child = spawn('node', [cliPath, ...args], {
-        stdio: 'pipe',
-        timeout: timeout
-      });
-
-      let stdout = '';
-      let stderr = '';
-
-      child.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      child.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      child.on('close', (code) => {
-        resolve({ code, stdout, stderr });
-      });
-
-      child.on('error', reject);
-
-      setTimeout(() => {
-        child.kill();
-        reject(new Error('Process timeout'));
-      }, timeout);
-    });
-  }
-
-  test('언어 상태 확인', async () => {
-    const result = await runLanguageCli(['status']);
-    expect(result.code).toBe(0);
-    expect(result.stdout).toContain('언어 설정');
-  });
-
-  test('언어 CLI 도움말', async () => {
-    const result = await runLanguageCli(['--help']);
-    expect(result.stdout).toContain('언어 설정');
-  });
-});
-
-describe('설치 프로세스 테스트', () => {
-  let tempDir;
-
-  beforeEach(async () => {
-    tempDir = path.join(__dirname, 'temp_install_test');
-    await fs.mkdir(tempDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  test('임시 디렉토리에서 설치 시뮬레이션', async () => {
-    // 패키지 설치 시뮬레이션
-    const packageJsonPath = path.join(tempDir, 'package.json');
-    await fs.writeFile(packageJsonPath, JSON.stringify({
-      name: 'test-project',
-      version: '1.0.0',
-      scripts: {
-        test: 'echo "test"'
-      }
-    }, null, 2));
-
-    // 설치 프로세스 시뮬레이션
-    const result = await runApp(['--target', tempDir, '--dry-run']);
-    
-    // 드라이런 모드에서는 실제 설치하지 않고 계획만 보여줌
-    expect(result.code).toBe(0);
-  });
-
-  test('기존 프로젝트 감지', async () => {
-    // 기존 AIWF 프로젝트 시뮬레이션
-    const aiwfDir = path.join(tempDir, '.aiwf');
-    await fs.mkdir(aiwfDir, { recursive: true });
-    await fs.writeFile(path.join(aiwfDir, '00_PROJECT_MANIFEST.md'), '# Test Project');
-
-    const result = await runApp(['--target', tempDir, '--check']);
-    expect(result.code).toBe(0);
-  });
-});
-
-describe('명령어 유효성 검증 테스트', () => {
-  test('명령어 파일 구조 검증', async () => {
-    const koCommandsDir = path.join(__dirname, '..', 'claude-code', 'aiwf', 'ko', '.claude', 'commands', 'aiwf');
-    const enCommandsDir = path.join(__dirname, '..', 'claude-code', 'aiwf', 'en', '.claude', 'commands', 'aiwf');
-
-    // 한국어 명령어 파일 존재 확인
-    const koFiles = await fs.readdir(koCommandsDir);
-    expect(koFiles.length).toBeGreaterThan(0);
-
-    // 영어 명령어 파일 존재 확인
-    const enFiles = await fs.readdir(enCommandsDir);
-    expect(enFiles.length).toBeGreaterThan(0);
-
-    // 필수 명령어 파일 확인
-    const requiredCommands = ['aiwf_initialize.md', 'aiwf_test.md', 'aiwf_prime.md'];
-    
-    for (const command of requiredCommands) {
-      expect(koFiles).toContain(command);
-      expect(enFiles).toContain(command);
-    }
-  });
-
-  test('명령어 파일 내용 검증', async () => {
-    const koCommandsDir = path.join(__dirname, '..', 'claude-code', 'aiwf', 'ko', '.claude', 'commands', 'aiwf');
-    const testFile = path.join(koCommandsDir, 'aiwf_test.md');
-    
-    const content = await fs.readFile(testFile, 'utf8');
-    
-    // 마크다운 헤더 확인
-    expect(content).toMatch(/^#\s+.+/m);
-    
-    // 한국어 내용 확인
-    expect(content).toContain('테스트');
-  });
-});
-
-describe('설정 파일 관리 테스트', () => {
-  test('언어 설정 파일 읽기', async () => {
-    const configDir = path.join(__dirname, '..', '.aiwf', 'config');
-    
-    try {
-      await fs.access(configDir);
-      const files = await fs.readdir(configDir);
-      
-      if (files.includes('language.json')) {
-        const configPath = path.join(configDir, 'language.json');
-        const config = JSON.parse(await fs.readFile(configPath, 'utf8'));
-        
-        expect(config).toHaveProperty('language');
-        expect(['ko', 'en']).toContain(config.language);
-      }
-    } catch (error) {
-      // 설정 파일이 없는 경우는 정상 (기본값 사용)
-      expect(error.code).toBe('ENOENT');
-    }
-  });
-
-  test('기본 설정 생성', async () => {
-    const tempConfigDir = path.join(__dirname, 'temp_config');
-    await fs.mkdir(tempConfigDir, { recursive: true });
-    
-    const defaultConfig = {
-      language: 'ko',
-      version: '0.3.1',
-      created_at: new Date().toISOString()
-    };
-    
-    const configPath = path.join(tempConfigDir, 'language.json');
-    await fs.writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
-    
-    const savedConfig = JSON.parse(await fs.readFile(configPath, 'utf8'));
-    expect(savedConfig.language).toBe('ko');
-    expect(savedConfig.version).toBe('0.3.1');
-    
-    await fs.rm(tempConfigDir, { recursive: true, force: true });
-  });
-});
-
-describe('오류 처리 테스트', () => {
-  test('존재하지 않는 디렉토리에 대한 오류 처리', async () => {
-    const result = await runApp(['--target', '/nonexistent/directory']);
-    expect(result.code).not.toBe(0);
-  });
-
-  test('권한 없는 디렉토리에 대한 오류 처리', async () => {
-    // 권한 테스트는 시스템에 따라 다르므로 간단히 처리
-    const result = await runApp(['--target', '/root']);
-    // 권한 오류가 발생하거나 정상 처리되어야 함
-    expect(typeof result.code).toBe('number');
-  });
-
-  test('잘못된 JSON 파일 처리', async () => {
-    const tempDir = path.join(__dirname, 'temp_invalid_json');
-    await fs.mkdir(tempDir, { recursive: true });
-    
-    const invalidJsonPath = path.join(tempDir, 'invalid.json');
-    await fs.writeFile(invalidJsonPath, '{ invalid json }');
-    
-    // 애플리케이션이 잘못된 JSON 파일을 만나도 크래시하지 않아야 함
-    const result = await runApp(['--target', tempDir]);
-    expect(typeof result.code).toBe('number');
-    
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-});

package/tests/basic.test.js

@@ -1,62 +0,0 @@
-/**
- * 기본 프로젝트 구조 테스트
- */
-
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-describe('프로젝트 기본 구조', () => {
-  test('package.json 파일이 존재한다', () => {
-    const packagePath = path.join(__dirname, '../package.json');
-    expect(fs.existsSync(packagePath)).toBe(true);
-  });
-
-  test('메인 실행 파일 index.js가 존재한다', () => {
-    const indexPath = path.join(__dirname, '../index.js');
-    expect(fs.existsSync(indexPath)).toBe(true);
-  });
-
-  test('AIWF 프레임워크 디렉토리가 존재한다', () => {
-    const aiwfPath = path.join(__dirname, '../claude-code/aiwf');
-    expect(fs.existsSync(aiwfPath)).toBe(true);
-  });
-
-  test('한국어 버전 디렉토리가 존재한다', () => {
-    const koPath = path.join(__dirname, '../claude-code/aiwf/ko');
-    expect(fs.existsSync(koPath)).toBe(true);
-  });
-
-  test('영어 버전 디렉토리가 존재한다', () => {
-    const enPath = path.join(__dirname, '../claude-code/aiwf/en');
-    expect(fs.existsSync(enPath)).toBe(true);
-  });
-});
-
-describe('패키지 구성 검증', () => {
-  let packageJson;
-
-  beforeAll(() => {
-    const packagePath = path.join(__dirname, '../package.json');
-    packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-  });
-
-  test('패키지 이름이 올바르다', () => {
-    expect(packageJson.name).toBe('aiwf');
-  });
-
-  test('필수 의존성이 설치되어 있다', () => {
-    expect(packageJson.dependencies).toHaveProperty('commander');
-    expect(packageJson.dependencies).toHaveProperty('chalk');
-    expect(packageJson.dependencies).toHaveProperty('ora');
-    expect(packageJson.dependencies).toHaveProperty('prompts');
-  });
-
-  test('bin 명령어가 설정되어 있다', () => {
-    expect(packageJson.bin).toHaveProperty('aiwf');
-    expect(packageJson.bin.aiwf).toBe('./.aiwf/bin/aiwf.js');
-  });
-});

package/tests/commands.test.js

@@ -1,127 +0,0 @@
-/**
- * AIWF 명령어 파일 테스트
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-describe('AIWF 명령어 검증', () => {
-  test('명령어 디렉토리 구조가 올바르다', async () => {
-    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
-    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
-    
-    const koFiles = await fs.readdir(koDir);
-    const enFiles = await fs.readdir(enDir);
-    
-    expect(koFiles.length).toBeGreaterThan(20);
-    expect(enFiles.length).toBeGreaterThan(20);
-    
-    // 한국어가 영어보다 파일이 많을 수 있음 (한국어 전용 명령어)
-    expect(koFiles.length).toBeGreaterThanOrEqual(enFiles.length);
-  });
-
-  test('한국어 명령어 디렉토리가 존재한다', async () => {
-    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
-    const stats = await fs.stat(koDir);
-    expect(stats.isDirectory()).toBe(true);
-  });
-
-  test('영어 명령어 디렉토리가 존재한다', async () => {
-    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
-    const stats = await fs.stat(enDir);
-    expect(stats.isDirectory()).toBe(true);
-  });
-
-  test('필수 명령어 파일들이 존재한다', async () => {
-    const requiredCommands = [
-      'aiwf_initialize.md',
-      'aiwf_test.md',
-      'aiwf_prime.md',
-      'aiwf_do_task.md'
-    ];
-
-    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
-    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
-
-    for (const command of requiredCommands) {
-      const koPath = path.join(koDir, command);
-      const enPath = path.join(enDir, command);
-      
-      const koExists = await fs.access(koPath).then(() => true).catch(() => false);
-      const enExists = await fs.access(enPath).then(() => true).catch(() => false);
-      
-      expect(koExists).toBe(true);
-      expect(enExists).toBe(true);
-    }
-  });
-
-  test('명령어 파일들이 유효한 마크다운 구조를 가진다', async () => {
-    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
-    const files = await fs.readdir(koDir);
-    const mdFiles = files.filter(file => file.endsWith('.md'));
-    
-    expect(mdFiles.length).toBeGreaterThan(0);
-    
-    // 첫 번째 파일만 샘플 테스트
-    const sampleFile = path.join(koDir, mdFiles[0]);
-    const content = await fs.readFile(sampleFile, 'utf-8');
-    
-    // 마크다운 파일은 최소한 하나의 헤더를 가져야 함
-    expect(content).toMatch(/^#\s+.+/m);
-  });
-
-  test('한국어 전용 명령어 파일 존재 검증', async () => {
-    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
-    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
-    
-    const koFiles = await fs.readdir(koDir);
-    const enFiles = await fs.readdir(enDir);
-    
-    // aiwf_update_docs_kr.md는 한국어 전용이어야 함
-    const krSpecificFile = 'aiwf_update_docs_kr.md';
-    expect(koFiles).toContain(krSpecificFile);
-    
-    // 영어 버전에는 없어야 함 - 이 테스트는 실패할 것임
-    expect(enFiles).not.toContain(krSpecificFile);
-  });
-
-  test('한국어 명령어가 영어 명령어보다 많거나 같아야 함', async () => {
-    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
-    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
-    
-    const koFiles = await fs.readdir(koDir);
-    const enFiles = await fs.readdir(enDir);
-    
-    // 한국어 버전이 영어보다 더 많은 명령어를 가질 수 있음 (한국어 전용 명령어)
-    expect(koFiles.length).toBeGreaterThanOrEqual(enFiles.length);
-  });
-
-  test('핵심 명령어들이 존재하는지 검증', async () => {
-    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
-    const coreCommands = ['aiwf_initialize.md', 'aiwf_prime.md', 'aiwf_test.md', 'aiwf_do_task.md'];
-    
-    const koFiles = await fs.readdir(koDir);
-    
-    coreCommands.forEach(command => {
-      expect(koFiles).toContain(command);
-    });
-  });
-
-  test('존재하지 않는 명령어 파일 테스트', async () => {
-    const nonExistentPath = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf/non_existent_command.md');
-    
-    const exists = await fs.access(nonExistentPath).then(() => true).catch(() => false);
-    expect(exists).toBe(false);
-  });
-
-  test('잘못된 디렉토리 경로 테스트', async () => {
-    const invalidDir = path.join(__dirname, '../invalid/directory/path');
-    
-    const dirExists = await fs.access(invalidDir).then(() => true).catch(() => false);
-    expect(dirExists).toBe(false);
-  });
-});