@team-semicolon/semo-cli 3.1.0 → 3.3.0

package/dist/index.js

@@ -131,11 +131,12 @@ async function getRemotePackageVersion(packagePath) {
     }
 }
 /**
- * semo-core/semo-skills 원격 버전 가져오기
+ * semo-core/semo-skills 원격 버전 가져오기 (semo-system/ 하위 경로)
  */
 async function getRemoteCoreVersion(type) {
     try {
-        const url = `https://raw.githubusercontent.com/semicolon-devteam/semo/main/${type}/VERSION`;
+        // v5.0: semo-system/ 하위에 Standard 패키지가 위치
+        const url = `https://raw.githubusercontent.com/semicolon-devteam/semo/main/semo-system/${type}/VERSION`;
         const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
         if (!response.ok)
             return null;
@@ -168,12 +169,24 @@ async function showVersionComparison(cwd) {
             needsUpdate: latestCliVersion ? isVersionLower(currentCliVersion, latestCliVersion) : false,
             level: 0,
         });
-        // semo-core (루트 또는 semo-system 내부)
-        const corePathRoot = path.join(cwd, "semo-core", "VERSION");
+        // 레거시 환경 경고 (루트에 semo-core/semo-skills가 있는 경우)
+        const hasLegacyCore = fs.existsSync(path.join(cwd, "semo-core"));
+        const hasLegacySkills = fs.existsSync(path.join(cwd, "semo-skills"));
+        if (hasLegacyCore || hasLegacySkills) {
+            spinner.warn("레거시 환경 감지됨");
+            console.log(chalk_1.default.yellow("\n  ⚠️  구버전 SEMO 구조가 감지되었습니다."));
+            console.log(chalk_1.default.gray("     루트에 semo-core/ 또는 semo-skills/가 있습니다."));
+            console.log(chalk_1.default.cyan("\n  💡 마이그레이션 방법:"));
+            console.log(chalk_1.default.gray("     1. 기존 semo-core/, semo-skills/ 폴더 삭제"));
+            console.log(chalk_1.default.gray("     2. .claude/ 폴더 삭제"));
+            console.log(chalk_1.default.gray("     3. semo init 다시 실행\n"));
+            console.log(chalk_1.default.gray("     또는: semo migrate --force\n"));
+            return;
+        }
+        // semo-core (semo-system/ 내부만 확인)
         const corePathSystem = path.join(semoSystemDir, "semo-core", "VERSION");
-        const corePath = fs.existsSync(corePathRoot) ? corePathRoot : corePathSystem;
-        if (fs.existsSync(corePath)) {
-            const localCore = fs.readFileSync(corePath, "utf-8").trim();
+        if (fs.existsSync(corePathSystem)) {
+            const localCore = fs.readFileSync(corePathSystem, "utf-8").trim();
             const remoteCore = await getRemoteCoreVersion("semo-core");
             versionInfos.push({
                 name: "semo-core",
@@ -183,12 +196,10 @@ async function showVersionComparison(cwd) {
                 level: 0,
             });
         }
-        // semo-skills (루트 또는 semo-system 내부)
-        const skillsPathRoot = path.join(cwd, "semo-skills", "VERSION");
+        // semo-skills (semo-system/ 내부만 확인)
         const skillsPathSystem = path.join(semoSystemDir, "semo-skills", "VERSION");
-        const skillsPath = fs.existsSync(skillsPathRoot) ? skillsPathRoot : skillsPathSystem;
-        if (fs.existsSync(skillsPath)) {
-            const localSkills = fs.readFileSync(skillsPath, "utf-8").trim();
+        if (fs.existsSync(skillsPathSystem)) {
+            const localSkills = fs.readFileSync(skillsPathSystem, "utf-8").trim();
             const remoteSkills = await getRemoteCoreVersion("semo-skills");
             versionInfos.push({
                 name: "semo-skills",
@@ -198,6 +209,32 @@ async function showVersionComparison(cwd) {
                 level: 0,
             });
         }
+        // semo-agents (semo-system/ 내부)
+        const agentsPathSystem = path.join(semoSystemDir, "semo-agents", "VERSION");
+        if (fs.existsSync(agentsPathSystem)) {
+            const localAgents = fs.readFileSync(agentsPathSystem, "utf-8").trim();
+            const remoteAgents = await getRemoteCoreVersion("semo-agents");
+            versionInfos.push({
+                name: "semo-agents",
+                local: localAgents,
+                remote: remoteAgents,
+                needsUpdate: remoteAgents ? isVersionLower(localAgents, remoteAgents) : false,
+                level: 0,
+            });
+        }
+        // semo-scripts (semo-system/ 내부)
+        const scriptsPathSystem = path.join(semoSystemDir, "semo-scripts", "VERSION");
+        if (fs.existsSync(scriptsPathSystem)) {
+            const localScripts = fs.readFileSync(scriptsPathSystem, "utf-8").trim();
+            const remoteScripts = await getRemoteCoreVersion("semo-scripts");
+            versionInfos.push({
+                name: "semo-scripts",
+                local: localScripts,
+                remote: remoteScripts,
+                needsUpdate: remoteScripts ? isVersionLower(localScripts, remoteScripts) : false,
+                level: 0,
+            });
+        }
         // 그룹 패키지 (eng, biz, ops) 및 하위 Extension - semo-system 내부
         // 그룹별로 묶어서 계층 구조로 출력
         if (hasSemoSystem) {
@@ -380,12 +417,27 @@ function createSymlinkOrJunction(targetPath, linkPath) {
     if (isWindows) {
         // Windows: Junction 사용 (절대 경로 필요)
         const absoluteTarget = path.resolve(targetPath);
-        try {
-            (0, child_process_1.execSync)(`cmd /c "mklink /J "${linkPath}" "${absoluteTarget}""`, { stdio: "pipe" });
+        // 재시도 메커니즘 (최대 3회)
+        let success = false;
+        let lastError = null;
+        for (let attempt = 1; attempt <= 3 && !success; attempt++) {
+            try {
+                (0, child_process_1.execSync)(`cmd /c "mklink /J "${linkPath}" "${absoluteTarget}""`, { stdio: "pipe" });
+                success = true;
+            }
+            catch (err) {
+                lastError = err;
+                if (attempt < 3) {
+                    // 잠시 대기 후 재시도
+                    (0, child_process_1.execSync)("timeout /t 1 /nobreak >nul 2>&1", { stdio: "pipe" });
+                }
+            }
         }
-        catch {
-            // fallback: 디렉토리 복사
-            console.log(chalk_1.default.yellow(`  ⚠ Junction 생성 실패, 복사로 대체: ${path.basename(linkPath)}`));
+        if (!success) {
+            // fallback: 디렉토리 복사 (경고 표시)
+            console.log(chalk_1.default.yellow(`  ⚠ Junction 생성 실패 (3회 시도), 복사로 대체: ${path.basename(linkPath)}`));
+            console.log(chalk_1.default.gray(`     원인: ${lastError}`));
+            console.log(chalk_1.default.gray(`     💡 관리자 권한으로 실행하거나 개발자 모드를 활성화하세요.`));
             (0, child_process_1.execSync)(`xcopy /E /I /Q "${absoluteTarget}" "${linkPath}"`, { stdio: "pipe" });
         }
     }
@@ -395,6 +447,137 @@ function createSymlinkOrJunction(targetPath, linkPath) {
         fs.symlinkSync(relativeTarget, linkPath);
     }
 }
+/**
+ * 심볼릭 링크가 유효한지 확인 (타겟 존재 여부)
+ */
+function isSymlinkValid(linkPath) {
+    try {
+        const stats = fs.lstatSync(linkPath);
+        if (!stats.isSymbolicLink())
+            return true; // 일반 파일/디렉토리
+        // 심볼릭 링크인 경우 타겟 존재 확인
+        const target = fs.readlinkSync(linkPath);
+        const absoluteTarget = path.isAbsolute(target)
+            ? target
+            : path.resolve(path.dirname(linkPath), target);
+        return fs.existsSync(absoluteTarget);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 레거시 SEMO 환경을 감지합니다.
+ * 레거시: 프로젝트 루트에 semo-core/, semo-skills/ 가 직접 있는 경우
+ * 신규: semo-system/ 하위에 있는 경우
+ */
+function detectLegacyEnvironment(cwd) {
+    const legacyPaths = [];
+    // 루트에 직접 있는 레거시 디렉토리 확인
+    const legacyDirs = ["semo-core", "semo-skills", "sax-core", "sax-skills"];
+    for (const dir of legacyDirs) {
+        const dirPath = path.join(cwd, dir);
+        if (fs.existsSync(dirPath) && !fs.lstatSync(dirPath).isSymbolicLink()) {
+            legacyPaths.push(dir);
+        }
+    }
+    // .claude/ 내부의 레거시 구조 확인
+    const claudeDir = path.join(cwd, ".claude");
+    if (fs.existsSync(claudeDir)) {
+        // 심볼릭 링크가 레거시 경로를 가리키는지 확인
+        const checkLegacyLink = (linkName) => {
+            const linkPath = path.join(claudeDir, linkName);
+            if (fs.existsSync(linkPath) && fs.lstatSync(linkPath).isSymbolicLink()) {
+                try {
+                    const target = fs.readlinkSync(linkPath);
+                    // 레거시 경로 패턴: ../semo-core, ../sax-core 등
+                    if (target.match(/^\.\.\/(semo|sax)-(core|skills)/)) {
+                        legacyPaths.push(`.claude/${linkName} → ${target}`);
+                    }
+                }
+                catch {
+                    // 읽기 실패 무시
+                }
+            }
+        };
+        checkLegacyLink("agents");
+        checkLegacyLink("skills");
+        checkLegacyLink("commands");
+    }
+    return {
+        hasLegacy: legacyPaths.length > 0,
+        legacyPaths,
+        hasSemoSystem: fs.existsSync(path.join(cwd, "semo-system")),
+    };
+}
+/**
+ * 레거시 환경을 새 환경으로 마이그레이션합니다.
+ */
+async function migrateLegacyEnvironment(cwd) {
+    const detection = detectLegacyEnvironment(cwd);
+    if (!detection.hasLegacy) {
+        return true; // 마이그레이션 불필요
+    }
+    console.log(chalk_1.default.yellow("\n⚠️  레거시 SEMO 환경이 감지되었습니다.\n"));
+    console.log(chalk_1.default.gray("   감지된 레거시 경로:"));
+    detection.legacyPaths.forEach(p => {
+        console.log(chalk_1.default.gray(`     - ${p}`));
+    });
+    console.log();
+    // 사용자 확인
+    const { shouldMigrate } = await inquirer_1.default.prompt([
+        {
+            type: "confirm",
+            name: "shouldMigrate",
+            message: "레거시 환경을 새 구조(semo-system/)로 마이그레이션하시겠습니까?",
+            default: true,
+        },
+    ]);
+    if (!shouldMigrate) {
+        console.log(chalk_1.default.yellow("\n마이그레이션이 취소되었습니다."));
+        console.log(chalk_1.default.gray("💡 수동 마이그레이션 방법:"));
+        console.log(chalk_1.default.gray("   1. 기존 semo-core/, semo-skills/ 폴더 삭제"));
+        console.log(chalk_1.default.gray("   2. .claude/ 폴더 삭제"));
+        console.log(chalk_1.default.gray("   3. semo init 다시 실행\n"));
+        return false;
+    }
+    const spinner = (0, ora_1.default)("레거시 환경 마이그레이션 중...").start();
+    try {
+        // 1. 루트의 레거시 디렉토리 삭제
+        const legacyDirs = ["semo-core", "semo-skills", "sax-core", "sax-skills"];
+        for (const dir of legacyDirs) {
+            const dirPath = path.join(cwd, dir);
+            if (fs.existsSync(dirPath) && !fs.lstatSync(dirPath).isSymbolicLink()) {
+                removeRecursive(dirPath);
+                console.log(chalk_1.default.gray(`     ✓ ${dir}/ 삭제됨`));
+            }
+        }
+        // 2. .claude/ 내부의 레거시 심볼릭 링크 삭제
+        const claudeDir = path.join(cwd, ".claude");
+        if (fs.existsSync(claudeDir)) {
+            const linksToCheck = ["agents", "skills", "commands"];
+            for (const linkName of linksToCheck) {
+                const linkPath = path.join(claudeDir, linkName);
+                if (fs.existsSync(linkPath)) {
+                    removeRecursive(linkPath);
+                }
+            }
+        }
+        // 3. 기존 semo-system이 있으면 삭제 (새로 설치)
+        const semoSystemDir = path.join(cwd, "semo-system");
+        if (fs.existsSync(semoSystemDir)) {
+            removeRecursive(semoSystemDir);
+        }
+        spinner.succeed("레거시 환경 정리 완료");
+        console.log(chalk_1.default.green("   → 새 환경으로 설치를 진행합니다.\n"));
+        return true;
+    }
+    catch (error) {
+        spinner.fail("마이그레이션 실패");
+        console.error(chalk_1.default.red(`   ${error}`));
+        return false;
+    }
+}
 /**
  * 플랫폼에 맞는 rm -rf 실행
  */
@@ -887,19 +1070,28 @@ program
     .option("--skip-mcp", "MCP 설정 생략")
     .option("--no-gitignore", ".gitignore 수정 생략")
     .option("--with <packages>", "추가 설치할 패키지 (쉼표 구분: next,backend)")
+    .option("--migrate", "레거시 환경 강제 마이그레이션")
     .action(async (options) => {
     console.log(chalk_1.default.cyan.bold("\n🚀 SEMO 설치 시작\n"));
     console.log(chalk_1.default.gray("Gemini 하이브리드 전략: White Box + Black Box\n"));
     const cwd = process.cwd();
     // 0. 버전 비교
     await showVersionComparison(cwd);
+    // 0.5. 레거시 환경 감지 및 마이그레이션
+    const legacyCheck = detectLegacyEnvironment(cwd);
+    if (legacyCheck.hasLegacy || options.migrate) {
+        const migrationSuccess = await migrateLegacyEnvironment(cwd);
+        if (!migrationSuccess) {
+            process.exit(0);
+        }
+    }
     // 1. 필수 도구 확인
     const shouldContinue = await showToolsStatus();
     if (!shouldContinue) {
         console.log(chalk_1.default.yellow("\n설치가 취소되었습니다. 필수 도구 설치 후 다시 시도하세요.\n"));
         process.exit(0);
     }
-    // 1. Git 레포지토리 확인
+    // 1.5. Git 레포지토리 확인
     const spinner = (0, ora_1.default)("Git 레포지토리 확인 중...").start();
     try {
         (0, child_process_1.execSync)("git rev-parse --git-dir", { cwd, stdio: "pipe" });
@@ -1003,6 +1195,8 @@ program
     console.log(chalk_1.default.gray("  [Standard]"));
     console.log(chalk_1.default.gray("    ✓ semo-core (원칙, 오케스트레이터)"));
     console.log(chalk_1.default.gray("    ✓ semo-skills (13개 통합 스킬)"));
+    console.log(chalk_1.default.gray("    ✓ semo-agents (14개 페르소나 Agent)"));
+    console.log(chalk_1.default.gray("    ✓ semo-scripts (자동화 스크립트)"));
     if (extensionsToInstall.length > 0) {
         console.log(chalk_1.default.gray("  [Extensions]"));
         extensionsToInstall.forEach(pkg => {
@@ -1023,7 +1217,9 @@ async function setupStandard(cwd, force) {
     const semoSystemDir = path.join(cwd, "semo-system");
     console.log(chalk_1.default.cyan("\n📚 Standard 설치 (White Box)"));
     console.log(chalk_1.default.gray("   semo-core: 원칙, 오케스트레이터"));
-    console.log(chalk_1.default.gray("   semo-skills: 13개 통합 스킬\n"));
+    console.log(chalk_1.default.gray("   semo-skills: 13개 통합 스킬"));
+    console.log(chalk_1.default.gray("   semo-agents: 14개 페르소나 Agent"));
+    console.log(chalk_1.default.gray("   semo-scripts: 자동화 스크립트\n"));
     // 기존 디렉토리 확인
     if (fs.existsSync(semoSystemDir) && !force) {
         const shouldOverwrite = await confirmOverwrite("semo-system/", semoSystemDir);
@@ -1034,19 +1230,20 @@ async function setupStandard(cwd, force) {
         removeRecursive(semoSystemDir);
         console.log(chalk_1.default.green("  ✓ 기존 semo-system/ 삭제됨"));
     }
-    const spinner = (0, ora_1.default)("semo-core, semo-skills 다운로드 중...").start();
+    const spinner = (0, ora_1.default)("semo-core, semo-skills, semo-agents, semo-scripts 다운로드 중...").start();
     try {
         const tempDir = path.join(cwd, ".semo-temp");
         removeRecursive(tempDir);
         (0, child_process_1.execSync)(`git clone --depth 1 ${SEMO_REPO} "${tempDir}"`, { stdio: "pipe" });
         fs.mkdirSync(semoSystemDir, { recursive: true });
-        // semo-core 복사
-        if (fs.existsSync(path.join(tempDir, "semo-core"))) {
-            copyRecursive(path.join(tempDir, "semo-core"), path.join(semoSystemDir, "semo-core"));
-        }
-        // semo-skills 복사
-        if (fs.existsSync(path.join(tempDir, "semo-skills"))) {
-            copyRecursive(path.join(tempDir, "semo-skills"), path.join(semoSystemDir, "semo-skills"));
+        // Standard 패키지 목록 (semo-system/ 하위에 있는 것들)
+        const standardPackages = ["semo-core", "semo-skills", "semo-agents", "semo-scripts"];
+        for (const pkg of standardPackages) {
+            const srcPath = path.join(tempDir, "semo-system", pkg);
+            const destPath = path.join(semoSystemDir, pkg);
+            if (fs.existsSync(srcPath)) {
+                copyRecursive(srcPath, destPath);
+            }
         }
         removeRecursive(tempDir);
         spinner.succeed("Standard 설치 완료");
@@ -1152,7 +1349,7 @@ function verifyInstallation(cwd, installedExtensions = []) {
         result.errors.push("semo-skills가 설치되지 않았습니다");
         result.success = false;
     }
-    // 2. agents 링크 검증
+    // 2. agents 링크 검증 (isSymlinkValid 사용)
     const claudeAgentsDir = path.join(claudeDir, "agents");
     const coreAgentsDir = path.join(coreDir, "agents");
     if (fs.existsSync(coreAgentsDir)) {
@@ -1161,31 +1358,19 @@ function verifyInstallation(cwd, installedExtensions = []) {
         if (fs.existsSync(claudeAgentsDir)) {
             for (const agent of expectedAgents) {
                 const linkPath = path.join(claudeAgentsDir, agent);
-                if (fs.existsSync(linkPath)) {
-                    if (fs.lstatSync(linkPath).isSymbolicLink()) {
-                        try {
-                            fs.readlinkSync(linkPath);
-                            const targetExists = fs.existsSync(linkPath);
-                            if (targetExists) {
-                                result.stats.agents.linked++;
-                            }
-                            else {
-                                result.stats.agents.broken++;
-                                result.warnings.push(`깨진 링크: .claude/agents/${agent}`);
-                            }
-                        }
-                        catch {
-                            result.stats.agents.broken++;
-                        }
+                if (fs.existsSync(linkPath) || fs.lstatSync(linkPath).isSymbolicLink()) {
+                    if (isSymlinkValid(linkPath)) {
+                        result.stats.agents.linked++;
                     }
                     else {
-                        result.stats.agents.linked++; // 디렉토리로 복사된 경우
+                        result.stats.agents.broken++;
+                        result.warnings.push(`깨진 링크: .claude/agents/${agent}`);
                     }
                 }
             }
         }
     }
-    // 3. skills 링크 검증
+    // 3. skills 링크 검증 (isSymlinkValid 사용)
     if (fs.existsSync(skillsDir)) {
         const expectedSkills = fs.readdirSync(skillsDir).filter(f => fs.statSync(path.join(skillsDir, f)).isDirectory());
         result.stats.skills.expected = expectedSkills.length;
@@ -1193,43 +1378,38 @@ function verifyInstallation(cwd, installedExtensions = []) {
         if (fs.existsSync(claudeSkillsDir)) {
             for (const skill of expectedSkills) {
                 const linkPath = path.join(claudeSkillsDir, skill);
-                if (fs.existsSync(linkPath)) {
-                    if (fs.lstatSync(linkPath).isSymbolicLink()) {
-                        try {
-                            fs.readlinkSync(linkPath);
-                            const targetExists = fs.existsSync(linkPath);
-                            if (targetExists) {
-                                result.stats.skills.linked++;
-                            }
-                            else {
-                                result.stats.skills.broken++;
-                                result.warnings.push(`깨진 링크: .claude/skills/${skill}`);
-                            }
+                try {
+                    if (fs.existsSync(linkPath) || fs.lstatSync(linkPath).isSymbolicLink()) {
+                        if (isSymlinkValid(linkPath)) {
+                            result.stats.skills.linked++;
                         }
-                        catch {
+                        else {
                             result.stats.skills.broken++;
+                            result.warnings.push(`깨진 링크: .claude/skills/${skill}`);
                         }
                     }
-                    else {
-                        result.stats.skills.linked++;
-                    }
+                }
+                catch {
+                    // 링크가 존재하지 않음
                 }
             }
         }
     }
-    // 4. commands 검증
+    // 4. commands 검증 (isSymlinkValid 사용)
     const semoCommandsLink = path.join(claudeDir, "commands", "SEMO");
-    result.stats.commands.exists = fs.existsSync(semoCommandsLink);
-    if (result.stats.commands.exists) {
-        if (fs.lstatSync(semoCommandsLink).isSymbolicLink()) {
-            result.stats.commands.valid = fs.existsSync(semoCommandsLink);
+    try {
+        const linkExists = fs.existsSync(semoCommandsLink) || fs.lstatSync(semoCommandsLink).isSymbolicLink();
+        result.stats.commands.exists = linkExists;
+        if (linkExists) {
+            result.stats.commands.valid = isSymlinkValid(semoCommandsLink);
             if (!result.stats.commands.valid) {
                 result.warnings.push("깨진 링크: .claude/commands/SEMO");
             }
         }
-        else {
-            result.stats.commands.valid = true;
-        }
+    }
+    catch {
+        result.stats.commands.exists = false;
+        result.stats.commands.valid = false;
     }
     // 5. Extensions 검증
     for (const ext of installedExtensions) {
@@ -2721,6 +2901,8 @@ program
     // 업데이트 대상 결정
     const updateSemoCore = !isSelectiveUpdate || onlyPackages.includes("semo-core");
     const updateSemoSkills = !isSelectiveUpdate || onlyPackages.includes("semo-skills");
+    const updateSemoAgents = !isSelectiveUpdate || onlyPackages.includes("semo-agents");
+    const updateSemoScripts = !isSelectiveUpdate || onlyPackages.includes("semo-scripts");
     const extensionsToUpdate = isSelectiveUpdate
         ? installedExtensions.filter(ext => onlyPackages.includes(ext))
         : installedExtensions;
@@ -2730,12 +2912,16 @@ program
         console.log(chalk_1.default.gray("    - semo-core"));
     if (updateSemoSkills)
         console.log(chalk_1.default.gray("    - semo-skills"));
+    if (updateSemoAgents)
+        console.log(chalk_1.default.gray("    - semo-agents"));
+    if (updateSemoScripts)
+        console.log(chalk_1.default.gray("    - semo-scripts"));
     extensionsToUpdate.forEach(pkg => {
         console.log(chalk_1.default.gray(`    - ${pkg}`));
     });
-    if (!updateSemoCore && !updateSemoSkills && extensionsToUpdate.length === 0) {
+    if (!updateSemoCore && !updateSemoSkills && !updateSemoAgents && !updateSemoScripts && extensionsToUpdate.length === 0) {
         console.log(chalk_1.default.yellow("\n  ⚠️ 업데이트할 패키지가 없습니다."));
-        console.log(chalk_1.default.gray("     설치된 패키지: semo-core, semo-skills" +
+        console.log(chalk_1.default.gray("     설치된 패키지: semo-core, semo-skills, semo-agents, semo-scripts" +
             (installedExtensions.length > 0 ? ", " + installedExtensions.join(", ") : "")));
         return;
     }
@@ -2744,14 +2930,22 @@ program
         const tempDir = path.join(cwd, ".semo-temp");
         removeRecursive(tempDir);
         (0, child_process_1.execSync)(`git clone --depth 1 ${SEMO_REPO} "${tempDir}"`, { stdio: "pipe" });
-        // Standard 업데이트 (선택적)
-        if (updateSemoCore) {
-            removeRecursive(path.join(semoSystemDir, "semo-core"));
-            copyRecursive(path.join(tempDir, "semo-core"), path.join(semoSystemDir, "semo-core"));
-        }
-        if (updateSemoSkills) {
-            removeRecursive(path.join(semoSystemDir, "semo-skills"));
-            copyRecursive(path.join(tempDir, "semo-skills"), path.join(semoSystemDir, "semo-skills"));
+        // Standard 업데이트 (선택적) - semo-system/ 하위에서 복사
+        const standardUpdates = [
+            { flag: updateSemoCore, name: "semo-core" },
+            { flag: updateSemoSkills, name: "semo-skills" },
+            { flag: updateSemoAgents, name: "semo-agents" },
+            { flag: updateSemoScripts, name: "semo-scripts" },
+        ];
+        for (const { flag, name } of standardUpdates) {
+            if (flag) {
+                const srcPath = path.join(tempDir, "semo-system", name);
+                const destPath = path.join(semoSystemDir, name);
+                if (fs.existsSync(srcPath)) {
+                    removeRecursive(destPath);
+                    copyRecursive(srcPath, destPath);
+                }
+            }
         }
         // Extensions 업데이트 (선택적)
         for (const pkg of extensionsToUpdate) {
@@ -2873,6 +3067,143 @@ program
         console.log(chalk_1.default.yellow.bold("\n⚠️ SEMO 업데이트 완료 (일부 문제 발견)\n"));
     }
 });
+// === migrate 명령어 ===
+program
+    .command("migrate")
+    .description("레거시 SEMO 환경을 새 구조(semo-system/)로 마이그레이션")
+    .option("-f, --force", "확인 없이 강제 마이그레이션")
+    .action(async (options) => {
+    console.log(chalk_1.default.cyan.bold("\n🔄 SEMO 마이그레이션\n"));
+    const cwd = process.cwd();
+    const detection = detectLegacyEnvironment(cwd);
+    if (!detection.hasLegacy) {
+        console.log(chalk_1.default.green("✅ 레거시 환경이 감지되지 않았습니다."));
+        if (detection.hasSemoSystem) {
+            console.log(chalk_1.default.gray("   현재 환경: semo-system/ (정상)"));
+        }
+        else {
+            console.log(chalk_1.default.gray("   SEMO가 설치되지 않았습니다. 'semo init'을 실행하세요."));
+        }
+        console.log();
+        return;
+    }
+    console.log(chalk_1.default.yellow("⚠️  레거시 SEMO 환경이 감지되었습니다.\n"));
+    console.log(chalk_1.default.gray("   감지된 레거시 경로:"));
+    detection.legacyPaths.forEach(p => {
+        console.log(chalk_1.default.gray(`     - ${p}`));
+    });
+    console.log();
+    if (!options.force) {
+        const { confirm } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "레거시 환경을 삭제하고 새 구조로 마이그레이션하시겠습니까?",
+                default: true,
+            },
+        ]);
+        if (!confirm) {
+            console.log(chalk_1.default.yellow("\n마이그레이션이 취소되었습니다.\n"));
+            return;
+        }
+    }
+    const migrationSuccess = await migrateLegacyEnvironment(cwd);
+    if (migrationSuccess) {
+        console.log(chalk_1.default.cyan("\n새 환경 설치를 위해 'semo init'을 실행하세요.\n"));
+    }
+});
+// === doctor 명령어 (설치 상태 진단) ===
+program
+    .command("doctor")
+    .description("SEMO 설치 상태를 진단하고 문제를 리포트")
+    .action(async () => {
+    console.log(chalk_1.default.cyan.bold("\n🩺 SEMO 진단\n"));
+    const cwd = process.cwd();
+    const semoSystemDir = path.join(cwd, "semo-system");
+    const claudeDir = path.join(cwd, ".claude");
+    // 1. 레거시 환경 확인
+    console.log(chalk_1.default.cyan("1. 레거시 환경 확인"));
+    const legacyCheck = detectLegacyEnvironment(cwd);
+    if (legacyCheck.hasLegacy) {
+        console.log(chalk_1.default.yellow("   ⚠️ 레거시 환경 감지됨"));
+        legacyCheck.legacyPaths.forEach(p => {
+            console.log(chalk_1.default.gray(`      - ${p}`));
+        });
+        console.log(chalk_1.default.gray("   💡 해결: semo migrate 실행"));
+    }
+    else {
+        console.log(chalk_1.default.green("   ✅ 레거시 환경 없음"));
+    }
+    // 2. semo-system 확인
+    console.log(chalk_1.default.cyan("\n2. semo-system 구조 확인"));
+    if (!fs.existsSync(semoSystemDir)) {
+        console.log(chalk_1.default.red("   ❌ semo-system/ 없음"));
+        console.log(chalk_1.default.gray("   💡 해결: semo init 실행"));
+    }
+    else {
+        const packages = ["semo-core", "semo-skills", "semo-agents", "semo-scripts"];
+        for (const pkg of packages) {
+            const pkgPath = path.join(semoSystemDir, pkg);
+            if (fs.existsSync(pkgPath)) {
+                const versionPath = path.join(pkgPath, "VERSION");
+                const version = fs.existsSync(versionPath)
+                    ? fs.readFileSync(versionPath, "utf-8").trim()
+                    : "?";
+                console.log(chalk_1.default.green(`   ✅ ${pkg} v${version}`));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`   ⚠️ ${pkg} 없음`));
+            }
+        }
+    }
+    // 3. 심볼릭 링크 확인
+    console.log(chalk_1.default.cyan("\n3. 심볼릭 링크 상태"));
+    if (fs.existsSync(claudeDir)) {
+        const linksToCheck = [
+            { name: "agents", dir: path.join(claudeDir, "agents") },
+            { name: "skills", dir: path.join(claudeDir, "skills") },
+            { name: "commands/SEMO", dir: path.join(claudeDir, "commands", "SEMO") },
+        ];
+        for (const { name, dir } of linksToCheck) {
+            if (fs.existsSync(dir)) {
+                if (fs.lstatSync(dir).isSymbolicLink()) {
+                    if (isSymlinkValid(dir)) {
+                        console.log(chalk_1.default.green(`   ✅ .claude/${name} (심볼릭 링크)`));
+                    }
+                    else {
+                        console.log(chalk_1.default.red(`   ❌ .claude/${name} (깨진 링크)`));
+                        console.log(chalk_1.default.gray("      💡 해결: semo update 실행"));
+                    }
+                }
+                else {
+                    console.log(chalk_1.default.green(`   ✅ .claude/${name} (복사본)`));
+                }
+            }
+            else {
+                console.log(chalk_1.default.yellow(`   ⚠️ .claude/${name} 없음`));
+            }
+        }
+    }
+    else {
+        console.log(chalk_1.default.red("   ❌ .claude/ 디렉토리 없음"));
+    }
+    // 4. 설치 검증
+    console.log(chalk_1.default.cyan("\n4. 전체 설치 검증"));
+    const verificationResult = verifyInstallation(cwd, []);
+    if (verificationResult.success) {
+        console.log(chalk_1.default.green("   ✅ 설치 상태 정상"));
+    }
+    else {
+        console.log(chalk_1.default.yellow("   ⚠️ 문제 발견"));
+        verificationResult.errors.forEach(err => {
+            console.log(chalk_1.default.red(`      ❌ ${err}`));
+        });
+        verificationResult.warnings.forEach(warn => {
+            console.log(chalk_1.default.yellow(`      ⚠️ ${warn}`));
+        });
+    }
+    console.log();
+});
 // === -v 옵션 처리 (program.parse 전에 직접 처리) ===
 async function main() {
     const args = process.argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-semicolon/semo-cli",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "SEMO CLI - AI Agent Orchestration Framework Installer",
   "main": "dist/index.js",
   "bin": {