create-ai-project 1.11.2

package/scripts/set-language.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const SUPPORTED_LANGUAGES = ['ja', 'en'];
+const CONFIG_FILE = '.claudelang';
+
+// Language configuration file path definitions
+const LANGUAGE_PATHS = {
+  claude: {
+    source: (lang) => `CLAUDE.${lang}.md`,
+    target: 'CLAUDE.md'
+  },
+  rules: {
+    source: (lang) => `docs/rules-${lang}`,
+    target: 'docs/rules'
+  },
+  guides: {
+    source: (lang) => `docs/guides/${lang}`,
+    target: 'docs/guides/sub-agents.md',
+    sourceFile: (lang) => `docs/guides/${lang}/sub-agents.md`
+  },
+  commands: {
+    source: (lang) => `.claude/commands-${lang}`,
+    target: '.claude/commands'
+  },
+  agents: {
+    source: (lang) => `.claude/agents-${lang}`,
+    target: '.claude/agents'
+  }
+};
+
+/**
+ * Load configuration file
+ */
+function loadConfig() {
+  try {
+    const content = fs.readFileSync(CONFIG_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    // Default configuration if config file doesn't exist
+    return {
+      current: 'ja',
+      method: 'copy',
+      lastUpdated: null
+    };
+  }
+}
+
+/**
+ * Save configuration file
+ */
+function saveConfig(config) {
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Recursively copy directory
+ */
+function copyDirectory(source, target) {
+  if (!fs.existsSync(source)) {
+    return false;
+  }
+
+  // Create target directory
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(target, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(source, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const sourcePath = path.join(source, entry.name);
+    const targetPath = path.join(target, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectory(sourcePath, targetPath);
+    } else {
+      fs.copyFileSync(sourcePath, targetPath);
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Remove directory
+ */
+function removeDirectory(dirPath) {
+  if (fs.existsSync(dirPath)) {
+    fs.rmSync(dirPath, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Copy file
+ */
+function copyFile(source, target) {
+  if (!fs.existsSync(source)) {
+    return false;
+  }
+
+  // Create target directory
+  const targetDir = path.dirname(target);
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  fs.copyFileSync(source, target);
+  return true;
+}
+
+/**
+ * Detect current language
+ */
+function detectCurrentLanguage() {
+  const config = loadConfig();
+  return config.current;
+}
+
+/**
+ * Switch language
+ */
+function switchLanguage(targetLang) {
+  if (!SUPPORTED_LANGUAGES.includes(targetLang)) {
+    console.error(`❌ Unsupported language: ${targetLang}`);
+    console.error(`   Supported languages: ${SUPPORTED_LANGUAGES.join(', ')}`);
+    process.exit(1);
+  }
+
+  console.log(`🌐 Switching language to ${targetLang}...`);
+
+  let hasErrors = false;
+
+  // 1. Switch CLAUDE.md
+  const claudeSource = LANGUAGE_PATHS.claude.source(targetLang);
+  const claudeTarget = LANGUAGE_PATHS.claude.target;
+  
+  if (fs.existsSync(claudeSource)) {
+    if (fs.existsSync(claudeTarget)) {
+      fs.unlinkSync(claudeTarget);
+    }
+    copyFile(claudeSource, claudeTarget);
+    console.log(`✅ Updated ${claudeTarget}`);
+  } else {
+    console.warn(`⚠️  ${claudeSource} does not exist`);
+    hasErrors = true;
+  }
+
+  // 2. Switch docs/rules
+  const rulesSource = LANGUAGE_PATHS.rules.source(targetLang);
+  const rulesTarget = LANGUAGE_PATHS.rules.target;
+  
+  if (fs.existsSync(rulesSource)) {
+    removeDirectory(rulesTarget);
+    copyDirectory(rulesSource, rulesTarget);
+    console.log(`✅ Updated ${rulesTarget}`);
+  } else {
+    console.warn(`⚠️  ${rulesSource} does not exist`);
+    hasErrors = true;
+  }
+
+
+  // 3. Switch docs/guides/sub-agents.md
+  const guideSource = LANGUAGE_PATHS.guides.sourceFile(targetLang);
+  const guideTarget = LANGUAGE_PATHS.guides.target;
+  
+  if (fs.existsSync(guideSource)) {
+    if (fs.existsSync(guideTarget)) {
+      fs.unlinkSync(guideTarget);
+    }
+    copyFile(guideSource, guideTarget);
+    console.log(`✅ Updated ${guideTarget}`);
+  } else {
+    console.warn(`⚠️  ${guideSource} does not exist`);
+  }
+
+  // 4. Switch .claude/commands (only if exists)
+  const commandsSource = LANGUAGE_PATHS.commands.source(targetLang);
+  const commandsTarget = LANGUAGE_PATHS.commands.target;
+  
+  if (fs.existsSync(commandsSource)) {
+    removeDirectory(commandsTarget);
+    copyDirectory(commandsSource, commandsTarget);
+    console.log(`✅ Updated ${commandsTarget}`);
+  }
+
+  // 5. Switch .claude/agents (only if exists)
+  const agentsSource = LANGUAGE_PATHS.agents.source(targetLang);
+  const agentsTarget = LANGUAGE_PATHS.agents.target;
+  
+  if (fs.existsSync(agentsSource)) {
+    removeDirectory(agentsTarget);
+    copyDirectory(agentsSource, agentsTarget);
+    console.log(`✅ Updated ${agentsTarget}`);
+  }
+
+  // Save configuration
+  const config = {
+    current: targetLang,
+    method: 'copy',
+    lastUpdated: new Date().toISOString()
+  };
+  saveConfig(config);
+
+  if (hasErrors) {
+    console.log(`⚠️  Language switched to ${targetLang}, but some files are missing`);
+  } else {
+    console.log(`🎉 Successfully switched language to ${targetLang}`);
+  }
+}
+
+/**
+ * Show current status
+ */
+function showStatus() {
+  const config = loadConfig();
+  
+  console.log('📊 Multi-language configuration status:');
+  console.log(`   Current language: ${config.current}`);
+  console.log(`   Switch method: ${config.method}`);
+  console.log(`   Last updated: ${config.lastUpdated || 'Not set'}`);
+  console.log();
+  
+  console.log('📁 File existence check:');
+  for (const lang of SUPPORTED_LANGUAGES) {
+    console.log(`\n  ${lang.toUpperCase()} language files:`);
+    
+    // CLAUDE.md
+    const claudeFile = LANGUAGE_PATHS.claude.source(lang);
+    console.log(`    ${claudeFile}: ${fs.existsSync(claudeFile) ? '✅' : '❌'}`);
+    
+    // docs/rules
+    const rulesDir = LANGUAGE_PATHS.rules.source(lang);
+    console.log(`    ${rulesDir}: ${fs.existsSync(rulesDir) ? '✅' : '❌'}`);
+    
+    // docs/guides
+    const guideFile = LANGUAGE_PATHS.guides.sourceFile(lang);
+    console.log(`    ${guideFile}: ${fs.existsSync(guideFile) ? '✅' : '❌'}`);
+    
+  }
+  
+  console.log('\n📝 Currently active files:');
+  console.log(`   CLAUDE.md: ${fs.existsSync('CLAUDE.md') ? '✅' : '❌'}`);
+  console.log(`   docs/rules: ${fs.existsSync('docs/rules') ? '✅' : '❌'}`);
+  console.log(`   docs/guides/sub-agents.md: ${fs.existsSync('docs/guides/sub-agents.md') ? '✅' : '❌'}`);
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log('🌐 Multi-language script');
+  console.log();
+  console.log('Usage:');
+  console.log('  node scripts/set-language.js <language>');
+  console.log('  node scripts/set-language.js --status');
+  console.log('  node scripts/set-language.js --help');
+  console.log();
+  console.log('Available languages:');
+  console.log(`  ${SUPPORTED_LANGUAGES.join(', ')}`);
+  console.log();
+  console.log('Examples:');
+  console.log('  node scripts/set-language.js ja    # Switch to Japanese');
+  console.log('  node scripts/set-language.js en    # Switch to English');
+  console.log('  node scripts/set-language.js --status  # Check current status');
+}
+
+// Main processing
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    showHelp();
+    return;
+  }
+
+  const command = args[0];
+
+  switch (command) {
+    case '--status':
+      showStatus();
+      break;
+    case '--help':
+    case '-h':
+      showHelp();
+      break;
+    default:
+      if (SUPPORTED_LANGUAGES.includes(command)) {
+        switchLanguage(command);
+      } else {
+        console.error(`❌ Unknown command or language: ${command}`);
+        showHelp();
+        process.exit(1);
+      }
+      break;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  switchLanguage,
+  detectCurrentLanguage,
+  showStatus,
+  SUPPORTED_LANGUAGES
+};

package/scripts/setup-project.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Get command line arguments
+const projectName = process.argv[2];
+const language = process.argv[3] || 'en';
+
+if (!projectName) {
+  console.error('❌ Project name is required');
+  process.exit(1);
+}
+
+const sourceRoot = path.join(__dirname, '..');
+const targetRoot = path.resolve(process.cwd(), projectName);
+
+// Files and directories to exclude from copying
+const excludeList = [
+  'node_modules',
+  '.git',
+  'dist',
+  'coverage',
+  '.vitest-cache',
+  'tmp',
+  '.claudelang',
+  'CLAUDE.md',
+  'docs/rules',
+  'docs/guides/sub-agents.md',
+  '.claude/commands',
+  '.claude/agents',
+  'bin', // Exclude bin directory for production use
+  'templates' // Exclude templates directory for production use
+];
+
+// Files to process with template replacements
+const templateFiles = [
+  'package.json',
+  'README.md',
+  'README.ja.md'
+];
+
+/**
+ * Recursively copy directory with exclusions
+ */
+function copyDirectory(source, target, projectName, rootSource = source) {
+  if (!fs.existsSync(source)) {
+    return;
+  }
+
+  // Create target directory
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(target, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(source, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const sourcePath = path.join(source, entry.name);
+    const targetPath = path.join(target, entry.name);
+    const relativePath = path.relative(rootSource, sourcePath);
+
+    // Check if should exclude
+    const shouldExclude = excludeList.some(exclude => {
+      const excludePath = path.normalize(exclude);
+      const relativeNormalized = path.normalize(relativePath);
+      return relativeNormalized === excludePath || relativeNormalized.startsWith(excludePath + path.sep);
+    });
+
+    if (shouldExclude) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      copyDirectory(sourcePath, targetPath, projectName, rootSource);
+    } else {
+      // Check if it's a template file that needs processing
+      if (templateFiles.includes(entry.name)) {
+        processTemplateFile(sourcePath, targetPath, projectName);
+      } else {
+        fs.copyFileSync(sourcePath, targetPath);
+      }
+    }
+  }
+}
+
+/**
+ * Process template files with replacements
+ */
+function processTemplateFile(source, target, projectName) {
+  let content = fs.readFileSync(source, 'utf8');
+
+  // Replace placeholders based on file
+  const fileName = path.basename(source);
+  
+  if (fileName === 'package.json') {
+    const packageJson = JSON.parse(content);
+    packageJson.name = projectName;
+    packageJson.version = '0.1.0';
+    packageJson.description = `${projectName} - AI-powered TypeScript project`;
+    
+    // Remove bin field for user projects
+    delete packageJson.bin;
+    
+    // Remove scripts related to package maintenance
+    delete packageJson.scripts['lang:status'];
+    delete packageJson.scripts.postinstall;
+    
+    content = JSON.stringify(packageJson, null, 2);
+  } else if (fileName === 'README.md' || fileName === 'README.ja.md') {
+    // Replace project name in README
+    content = content.replace(/ai-coding-project-boilerplate/g, projectName);
+    content = content.replace(/AI Coding Project Boilerplate/g, projectName);
+  }
+
+  fs.writeFileSync(target, content);
+}
+
+/**
+ * Create .gitignore with language-specific exclusions
+ */
+function createGitignore(projectPath) {
+  const gitignorePath = path.join(projectPath, '.gitignore');
+  const templatePath = path.join(sourceRoot, 'templates', '.gitignore.template');
+  
+  // Use template if exists, otherwise use current .gitignore
+  const sourcePath = fs.existsSync(templatePath) ? templatePath : path.join(sourceRoot, '.gitignore');
+  let content = fs.readFileSync(sourcePath, 'utf8');
+  
+  // Add language-specific exclusions
+  const languageExclusions = `
+# Language-specific files (excluded from version control)
+CLAUDE.*.md
+docs/rules-*/
+docs/guides/ja/
+docs/guides/en/
+.claude/commands-*/
+.claude/agents-*/
+`;
+
+  // Remove current language-related exclusions and add new ones
+  const lines = content.split('\n');
+  const filteredLines = lines.filter(line => {
+    const trimmed = line.trim();
+    return !trimmed.startsWith('CLAUDE.md') &&
+           !trimmed.startsWith('docs/rules/') &&
+           !trimmed.startsWith('docs/guides/sub-agents.md') &&
+           !trimmed.startsWith('.claude/commands/') &&
+           !trimmed.startsWith('.claude/agents/');
+  });
+
+  content = filteredLines.join('\n') + languageExclusions;
+  fs.writeFileSync(gitignorePath, content);
+}
+
+/**
+ * Main setup process
+ */
+async function setupProject() {
+  try {
+    console.log('📁 Creating project directory...');
+    fs.mkdirSync(targetRoot, { recursive: true });
+
+    console.log('📋 Copying project files...');
+    copyDirectory(sourceRoot, targetRoot, projectName);
+
+    console.log('🔧 Setting up language configuration...');
+    // Change to project directory and run language setup
+    process.chdir(targetRoot);
+
+    // Run language setup
+    execSync(`node scripts/set-language.js ${language}`, { stdio: 'inherit' });
+
+    console.log('📝 Creating .gitignore with language-specific exclusions...');
+    createGitignore(targetRoot);
+
+    console.log('🔧 Running post-setup tasks...');
+    const postSetupScript = path.join(sourceRoot, 'scripts', 'post-setup.js');
+    if (fs.existsSync(postSetupScript)) {
+      execSync(`node ${postSetupScript}`, { stdio: 'inherit', cwd: targetRoot });
+    }
+
+    console.log('✅ Project setup completed!');
+  } catch (error) {
+    console.error(`❌ Setup failed: ${error.message}`);
+    
+    // Cleanup on failure
+    if (fs.existsSync(targetRoot)) {
+      console.log('🧹 Cleaning up...');
+      fs.rmSync(targetRoot, { recursive: true, force: true });
+    }
+    
+    process.exit(1);
+  }
+}
+
+// Run setup
+setupProject();

package/scripts/show-coverage.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+
+const coverageFile = path.join(__dirname, '..', 'coverage', 'coverage-final.json')
+
+if (!fs.existsSync(coverageFile)) {
+  console.error('❌ Coverage report not found.')
+  console.error('   Please run npm run test:coverage first.')
+  process.exit(1)
+}
+
+try {
+  const coverage = JSON.parse(fs.readFileSync(coverageFile, 'utf8'))
+  
+  let totalStatements = 0
+  let coveredStatements = 0
+  let totalBranches = 0
+  let coveredBranches = 0
+  let totalFunctions = 0
+  let coveredFunctions = 0
+  let totalLines = 0
+  let coveredLines = 0
+
+  Object.values(coverage).forEach(file => {
+    totalStatements += file.s ? Object.keys(file.s).length : 0
+    coveredStatements += file.s ? Object.values(file.s).filter(count => count > 0).length : 0
+    
+    totalBranches += file.b ? Object.values(file.b).flat().length : 0
+    coveredBranches += file.b ? Object.values(file.b).flat().filter(count => count > 0).length : 0
+    
+    totalFunctions += file.f ? Object.keys(file.f).length : 0
+    coveredFunctions += file.f ? Object.values(file.f).filter(count => count > 0).length : 0
+    
+    totalLines += file.l ? Object.keys(file.l).length : 0
+    coveredLines += file.l ? Object.values(file.l).filter(count => count > 0).length : 0
+  })
+
+  const statementsCoverage = totalStatements > 0 ? ((coveredStatements / totalStatements) * 100).toFixed(2) : '0.00'
+  const branchesCoverage = totalBranches > 0 ? ((coveredBranches / totalBranches) * 100).toFixed(2) : '0.00'
+  const functionsCoverage = totalFunctions > 0 ? ((coveredFunctions / totalFunctions) * 100).toFixed(2) : '0.00'
+  const linesCoverage = totalLines > 0 ? ((coveredLines / totalLines) * 100).toFixed(2) : '0.00'
+
+  console.log('\n📊 Test Coverage Summary')
+  console.log('═══════════════════════════════════════')
+  console.log(`  Statements : ${statementsCoverage.padStart(6)}% (${coveredStatements}/${totalStatements})`)
+  console.log(`  Branches   : ${branchesCoverage.padStart(6)}% (${coveredBranches}/${totalBranches})`)
+  console.log(`  Functions  : ${functionsCoverage.padStart(6)}% (${coveredFunctions}/${totalFunctions})`)
+  console.log(`  Lines      : ${linesCoverage.padStart(6)}% (${coveredLines}/${totalLines})`)
+  console.log('═══════════════════════════════════════')
+
+  // Assessment against 80% target
+  const allMetrics = [
+    parseFloat(statementsCoverage),
+    parseFloat(branchesCoverage),
+    parseFloat(functionsCoverage),
+    parseFloat(linesCoverage)
+  ]
+  
+  const failedMetrics = allMetrics.filter(metric => metric < 80).length
+
+  if (failedMetrics === 0) {
+    console.log('\n✅ All metrics achieved the 80% target!')
+  } else {
+    console.log('\n⚠️  Some metrics have not reached the 80% target.')
+    console.log('   Please check coverage/index.html for details.')
+  }
+  console.log()
+
+} catch (error) {
+  console.error('❌ Failed to read coverage report:', error.message)
+  process.exit(1)
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Application entry point
+ *
+ * This file serves as a usage example for the boilerplate.
+ * In actual projects, implement your application-specific logic here.
+ */
+
+console.log('Hello from TypeScript boilerplate!')
+
+// Add your project-specific implementation here
+export {}

package/templates/.gitignore.template

@@ -0,0 +1,52 @@
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Build artifacts
+dist/
+build/
+*.tsbuildinfo
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Log files
+logs
+*.log
+
+# Runtime data
+.nyc_output
+coverage
+test-output.json
+
+# IDE and editor specific files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS specific files
+.DS_Store
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp
+tmp/
+
+# Work plans (excluded from commits)
+docs/plans/*
+!docs/plans/template-*.md
+
+# Work plan tasks (auto-generated)
+docs/plans/tasks/
+
+# Multi-language related (dynamically generated by npm scripts)
+.claudelang

package/tsconfig.json

@@ -0,0 +1,50 @@
+{
+  "compilerOptions": {
+    // Basic configuration
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "types": ["node"],
+    "baseUrl": ".",  // Use project root as reference
+    "paths": {
+      "src/*": ["src/*"]
+    },
+    
+    // Output configuration
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    
+    // Strict type checking (this is important!)
+    "strict": true,                          // Enable all strict checks
+    "noImplicitAny": true,                   // Prohibit implicit any
+    "strictNullChecks": true,                // Strict null/undefined checks
+    "strictFunctionTypes": true,             // Strict function type checks
+    "strictBindCallApply": true,             // Strict bind/call/apply checks
+    "strictPropertyInitialization": true,    // Strict property initialization checks
+    "noImplicitThis": true,                  // Prohibit implicit this
+    "alwaysStrict": true,                    // Always enable strict mode
+    
+    // Additional safety checks (currently disabled in this PR)
+    "noUncheckedIndexedAccess": true,       // Safety checks for index access
+    "exactOptionalPropertyTypes": true,      // Strict type checking for optional properties
+    "noPropertyAccessFromIndexSignature": true, // Prohibit property access from index signature
+    
+    // Error detection
+    "noFallthroughCasesInSwitch": true,     // Prohibit fallthrough in switch statements
+    "noImplicitReturns": true,              // Prohibit implicit returns
+    "noImplicitOverride": true,             // Require override keyword
+    "noUnusedLocals": true,                 // Detect unused local variables
+    "noUnusedParameters": true,             // Detect unused parameters
+    
+    // Module resolution
+    "esModuleInterop": true,
+    "skipLibCheck": true,                    // Skip type checking of declaration files (build optimization)
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.spec.ts", "**/*.test.ts"]
+}