Remove project type inference from scanner

- Set type to undefined in RepositoryInfo (AI will analyze)
- Made type field optional in types.ts
- Removed type display from init.ts repository list and selection
- Added project type to "To be analyzed by AI" list in SETUP_GUIDE

All analysis (type, stack, description) now done by AI during setup phase.
No more inaccurate inference during init.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: YAYLABS-Snoo

src/commands/init.ts

@@ -96,11 +96,7 @@ export async function initCommand(options: InitOptions) {
   // Display found repositories
   console.log(chalk.bold(`\n${lang === 'ko' ? '📁 발견된 레포지토리:' : '📁 Discovered Repositories:'}\n`));
   foundRepos.forEach((repo) => {
-    const typeLabel = lang === 'ko'
-      ? { frontend: '프론트엔드', backend: '백엔드', mobile: '모바일', fullstack: '풀스택' }[repo.type]
-      : repo.type;
-
-    console.log(`  ${chalk.cyan('●')} ${chalk.bold(repo.name)} ${chalk.gray(`(${typeLabel})`)}`);
+    console.log(`  ${chalk.cyan('●')} ${chalk.bold(repo.name)}`);
   });
   console.log();
 
@@ -113,12 +109,8 @@ export async function initCommand(options: InitOptions) {
         ? '포함할 레포지토리를 선택하세요:'
         : 'Select repositories to include:',
       choices: foundRepos.map(repo => {
-        const typeLabel = lang === 'ko'
-          ? { frontend: '프론트엔드', backend: '백엔드', mobile: '모바일', fullstack: '풀스택' }[repo.type]
-          : repo.type;
-
         return {
-          name: `${repo.name} (${typeLabel})`,
+          name: repo.name,
           value: repo.name,
           checked: true, // 기본적으로 모두 선택
         };
@@ -149,13 +141,10 @@ export async function initCommand(options: InitOptions) {
 
   // Generate repository list for SETUP_GUIDE (only selected repos)
   const repoListText = includedRepos.map(repo => {
-    const typeLabel = lang === 'ko'
-      ? { frontend: '프론트엔드', backend: '백엔드', mobile: '모바일', fullstack: '풀스택' }[repo.type]
-      : repo.type;
-
-    return `- **${repo.name}** (${typeLabel})
+    return `- **${repo.name}**
   - Path: \`./${repo.name}\`
   - ${lang === 'ko' ? 'AI가 분석할 내용' : 'To be analyzed by AI'}:
+    - ${lang === 'ko' ? '프로젝트 유형 (프론트엔드/백엔드/모바일/풀스택)' : 'Project type (frontend/backend/mobile/fullstack)'}
     - ${lang === 'ko' ? '기술 스택' : 'Tech stack'}
     - ${lang === 'ko' ? '프로젝트 설명' : 'Project description'}
     - ${lang === 'ko' ? '주요 기능' : 'Main features'}`;

src/types.ts

@@ -36,7 +36,7 @@ export interface ProjectConfig {
 export interface RepositoryInfo {
   name: string;
   path: string;
-  type: ProjectType;
+  type?: ProjectType;    // AI will analyze during setup
   description?: string;  // AI will analyze during setup
   techStack?: string[];   // AI will analyze during setup
   hasCodeSyncer: boolean;

src/utils/scanner.ts

@@ -24,13 +24,12 @@ export async function scanForRepositories(rootPath: string): Promise<RepositoryI
       const isRepo = await isValidRepository(folderPath);
 
       if (isRepo) {
-        const type = await detectProjectType(folderPath, entry.name);
         const hasCodeSyncer = await hasCodeSyncerSetup(folderPath);
 
         repos.push({
           name: entry.name,
           path: folderPath,
-          type,
+          type: undefined, // AI will analyze
           description: undefined, // AI will analyze
           techStack: undefined, // AI will analyze
           hasCodeSyncer,
@@ -83,130 +82,10 @@ async function isValidRepository(folderPath: string): Promise<boolean> {
   }
 }
 
-/**
- * Detect project type based on folder structure, files, and repository name
- */
-async function detectProjectType(folderPath: string, repoName: string): Promise<'frontend' | 'backend' | 'mobile' | 'fullstack'> {
-  try {
-    // Analyze repository name for hints
-    const nameLower = repoName.toLowerCase();
-    const nameHints = {
-      backend: ['server', 'api', 'backend', 'service', 'socket', 'gateway', 'middleware'],
-      frontend: ['client', 'frontend', 'web', 'app', 'ui', 'admin', 'dashboard'],
-      mobile: ['mobile', 'ios', 'android', 'app'],
-    };
-
-    // Check for Java projects (Spring Boot)
-    const hasPomXml = await fs.pathExists(path.join(folderPath, 'pom.xml'));
-    const hasGradle = await fs.pathExists(path.join(folderPath, 'build.gradle'));
-    if (hasPomXml || hasGradle) {
-      // Check if it's Android (mobile) or Spring (backend)
-      const hasAndroid = await fs.pathExists(path.join(folderPath, 'app', 'src', 'main', 'AndroidManifest.xml'));
-      if (hasAndroid) {
-        return 'mobile';
-      }
-      return 'backend'; // Java Spring Boot
-    }
-
-    // Check for Python projects (Django, FastAPI)
-    const hasRequirements = await fs.pathExists(path.join(folderPath, 'requirements.txt'));
-    const hasPipfile = await fs.pathExists(path.join(folderPath, 'Pipfile'));
-    if (hasRequirements || hasPipfile) {
-      try {
-        let content = '';
-        if (hasRequirements) {
-          content = await fs.readFile(path.join(folderPath, 'requirements.txt'), 'utf-8');
-        }
-        // Check for web frameworks
-        if (content.includes('django') || content.includes('fastapi') || content.includes('flask')) {
-          return 'backend';
-        }
-      } catch {
-        // If can't read file, default to backend
-      }
-      return 'backend'; // Python backend
-    }
-
-    // Check for Node.js projects
-    const packageJsonPath = path.join(folderPath, 'package.json');
-    if (await fs.pathExists(packageJsonPath)) {
-      const packageJson = await fs.readJson(packageJsonPath);
-      const deps = {
-        ...packageJson.dependencies,
-        ...packageJson.devDependencies,
-      };
-
-      // Check for mobile
-      if (deps['react-native'] || deps['expo'] || deps['@react-native']) {
-        return 'mobile';
-      }
-
-      // Strong hint from repo name (socket server, api server, etc.)
-      if (nameHints.backend.some(keyword => nameLower.includes(keyword))) {
-        // If it has socket.io or backend keywords in name, prioritize backend
-        if (deps['socket.io'] || deps['express'] || deps['fastify'] || deps['@nestjs/core']) {
-          return 'backend';
-        }
-      }
-
-      // Check for frontend (React, Vue, etc.)
-      if (deps['react'] || deps['vue'] || deps['angular'] || deps['svelte']) {
-        // Check repo name hints
-        if (nameHints.frontend.some(keyword => nameLower.includes(keyword))) {
-          return 'frontend';
-        }
-
-        // Check if it's Next.js (could be fullstack)
-        if (deps['next']) {
-          // If has database or backend hints in name, it's fullstack
-          if (deps['prisma'] || deps['mongoose'] || deps['@prisma/client'] ||
-              nameLower.includes('fullstack') || nameLower.includes('full-stack')) {
-            return 'fullstack';
-          }
-          // If name suggests frontend only, return frontend
-          if (nameHints.frontend.some(keyword => nameLower.includes(keyword))) {
-            return 'frontend';
-          }
-          // Next.js with no DB is usually frontend
-          return 'frontend';
-        }
-        return 'frontend';
-      }
-
-      // Check for backend (Express, Fastify, NestJS, Socket.IO)
-      if (deps['express'] || deps['fastify'] || deps['koa'] || deps['@nestjs/core'] ||
-          deps['socket.io'] || deps['ws']) {
-        return 'backend';
-      }
-    }
-
-    // Check for mobile-specific files
-    const hasPodfile = await fs.pathExists(path.join(folderPath, 'ios', 'Podfile'));
-    const hasAndroidGradle = await fs.pathExists(path.join(folderPath, 'android', 'build.gradle'));
-    if (hasPodfile || hasAndroidGradle) {
-      return 'mobile';
-    }
-
-    // Use repo name as fallback
-    if (nameHints.backend.some(keyword => nameLower.includes(keyword))) {
-      return 'backend';
-    }
-    if (nameHints.frontend.some(keyword => nameLower.includes(keyword))) {
-      return 'frontend';
-    }
-    if (nameHints.mobile.some(keyword => nameLower.includes(keyword))) {
-      return 'mobile';
-    }
-
-    // Default to fullstack if can't determine
-    return 'fullstack';
-  } catch {
-    return 'fullstack';
-  }
-}
-
-// Tech stack and description detection removed
-// AI will analyze these accurately during setup phase
+// All project analysis removed - AI will analyze during setup phase
+// - Project type (frontend/backend/mobile/fullstack)
+// - Tech stack
+// - Description
 
 /**
  * Check if CodeSyncer is already set up in the repository