relayax-cli 0.2.40 → 0.2.41

package/dist/commands/package.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerPackage(program: Command): void;

package/dist/commands/package.js

@@ -0,0 +1,287 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPackage = registerPackage;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const ai_tools_js_1 = require("../lib/ai-tools.js");
+const SYNC_DIRS = ['skills', 'commands', 'agents', 'rules'];
+const EXCLUDE_SUBDIRS = ['relay']; // relay CLI 전용 하위 디렉토리 제외
+// ─── Helpers ───
+function fileHash(filePath) {
+    const content = fs_1.default.readFileSync(filePath);
+    return crypto_1.default.createHash('md5').update(content).digest('hex');
+}
+/**
+ * 디렉토리를 재귀 탐색하여 파일 목록을 반환한다.
+ * baseDir 기준 상대 경로 + 해시.
+ */
+function scanDir(baseDir, subDir) {
+    const fullDir = path_1.default.join(baseDir, subDir);
+    if (!fs_1.default.existsSync(fullDir))
+        return [];
+    const entries = [];
+    function walk(dir) {
+        for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            }
+            else {
+                const relPath = path_1.default.relative(baseDir, fullPath);
+                entries.push({ relPath, hash: fileHash(fullPath) });
+            }
+        }
+    }
+    walk(fullDir);
+    return entries;
+}
+/**
+ * 소스 디렉토리(예: .claude/)에서 배포 가능한 콘텐츠를 스캔한다.
+ * relay/ 하위 디렉토리는 제외.
+ */
+function scanSource(projectPath, tool) {
+    const sourceBase = path_1.default.join(projectPath, tool.skillsDir);
+    const files = [];
+    const summary = {};
+    for (const dir of SYNC_DIRS) {
+        const fullDir = path_1.default.join(sourceBase, dir);
+        if (!fs_1.default.existsSync(fullDir))
+            continue;
+        // 제외 대상 필터링 (예: commands/relay/)
+        const dirEntries = fs_1.default.readdirSync(fullDir, { withFileTypes: true });
+        let count = 0;
+        for (const entry of dirEntries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.isDirectory() && EXCLUDE_SUBDIRS.includes(entry.name))
+                continue;
+            const entryPath = path_1.default.join(fullDir, entry.name);
+            if (entry.isDirectory()) {
+                // 하위 파일 재귀 탐색
+                const subFiles = scanDir(sourceBase, path_1.default.join(dir, entry.name));
+                // relPath를 sourceBase 기준 → SYNC_DIRS 기준으로 유지
+                files.push(...subFiles);
+                count += subFiles.length > 0 ? 1 : 0; // 디렉토리 단위로 카운트
+            }
+            else {
+                const relPath = path_1.default.relative(sourceBase, entryPath);
+                files.push({ relPath, hash: fileHash(entryPath) });
+                count++;
+            }
+        }
+        if (count > 0)
+            summary[dir] = count;
+    }
+    return { tool, files, summary };
+}
+/**
+ * .relay/ 디렉토리의 현재 콘텐츠를 스캔한다.
+ */
+function scanRelay(relayDir) {
+    const files = [];
+    for (const dir of SYNC_DIRS) {
+        files.push(...scanDir(relayDir, dir));
+    }
+    return files;
+}
+/**
+ * 소스와 .relay/를 비교하여 diff를 생성한다.
+ */
+function computeDiff(sourceFiles, relayFiles) {
+    const relayMap = new Map(relayFiles.map((f) => [f.relPath, f.hash]));
+    const sourceMap = new Map(sourceFiles.map((f) => [f.relPath, f.hash]));
+    const diff = [];
+    // 소스에 있는 파일
+    for (const [relPath, hash] of sourceMap) {
+        const relayHash = relayMap.get(relPath);
+        if (!relayHash) {
+            diff.push({ relPath, status: 'added' });
+        }
+        else if (relayHash !== hash) {
+            diff.push({ relPath, status: 'modified' });
+        }
+        else {
+            diff.push({ relPath, status: 'unchanged' });
+        }
+    }
+    // .relay/에만 있는 파일 (소스에서 삭제됨)
+    for (const [relPath] of relayMap) {
+        if (!sourceMap.has(relPath)) {
+            diff.push({ relPath, status: 'deleted' });
+        }
+    }
+    return diff.sort((a, b) => a.relPath.localeCompare(b.relPath));
+}
+/**
+ * 소스에서 .relay/로 파일을 동기화한다.
+ */
+function syncToRelay(sourceBase, relayDir, diff) {
+    for (const entry of diff) {
+        const sourcePath = path_1.default.join(sourceBase, entry.relPath);
+        const relayPath = path_1.default.join(relayDir, entry.relPath);
+        if (entry.status === 'added' || entry.status === 'modified') {
+            fs_1.default.mkdirSync(path_1.default.dirname(relayPath), { recursive: true });
+            fs_1.default.copyFileSync(sourcePath, relayPath);
+        }
+        else if (entry.status === 'deleted') {
+            if (fs_1.default.existsSync(relayPath)) {
+                fs_1.default.unlinkSync(relayPath);
+                // 빈 디렉토리 정리
+                const parentDir = path_1.default.dirname(relayPath);
+                try {
+                    const remaining = fs_1.default.readdirSync(parentDir).filter((f) => !f.startsWith('.'));
+                    if (remaining.length === 0)
+                        fs_1.default.rmdirSync(parentDir);
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+}
+// ─── Command ───
+function registerPackage(program) {
+    program
+        .command('package')
+        .description('소스 디렉토리에서 .relay/로 콘텐츠를 동기화합니다')
+        .option('--source <dir>', '소스 디렉토리 지정 (예: .claude)')
+        .option('--sync', '변경사항을 .relay/에 즉시 반영', false)
+        .option('--init', '최초 패키징: 소스 감지 → .relay/ 초기화', false)
+        .action(async (opts) => {
+        const json = program.opts().json ?? false;
+        const projectPath = process.cwd();
+        const relayDir = path_1.default.join(projectPath, '.relay');
+        const relayYamlPath = path_1.default.join(relayDir, 'relay.yaml');
+        // ─── 최초 패키징 (--init) ───
+        if (opts.init || !fs_1.default.existsSync(relayYamlPath)) {
+            const detected = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+            // 각 도구의 콘텐츠 스캔
+            const scans = detected
+                .map((tool) => scanSource(projectPath, tool))
+                .filter((s) => s.files.length > 0);
+            if (json) {
+                console.log(JSON.stringify({
+                    status: 'init_required',
+                    detected: scans.map((s) => ({
+                        source: s.tool.skillsDir,
+                        name: s.tool.name,
+                        summary: s.summary,
+                        fileCount: s.files.length,
+                    })),
+                }));
+            }
+            else {
+                if (scans.length === 0) {
+                    console.error('배포 가능한 에이전트 콘텐츠를 찾지 못했습니다.');
+                    console.error('skills/, commands/, agents/, rules/ 중 하나를 만들어주세요.');
+                    process.exit(1);
+                }
+                console.error('\n프로젝트에서 발견된 에이전트 콘텐츠:\n');
+                for (const scan of scans) {
+                    const parts = Object.entries(scan.summary)
+                        .map(([dir, count]) => `${dir} ${count}개`)
+                        .join(', ');
+                    console.error(`  📁 ${scan.tool.skillsDir}/ — ${parts}`);
+                }
+                console.error('');
+            }
+            return;
+        }
+        // ─── 재패키징 (source 기반 동기화) ───
+        const yamlContent = fs_1.default.readFileSync(relayYamlPath, 'utf-8');
+        const config = js_yaml_1.default.load(yamlContent);
+        const source = opts.source ?? config.source;
+        if (!source) {
+            if (json) {
+                console.log(JSON.stringify({
+                    status: 'no_source',
+                    message: 'relay.yaml에 source 필드가 없습니다. --source 옵션으로 지정하거나 relay.yaml에 source를 추가하세요.',
+                }));
+            }
+            else {
+                console.error('relay.yaml에 source 필드가 없습니다.');
+                console.error('--source <dir> 옵션으로 지정하거나 relay.yaml에 source를 추가하세요.');
+            }
+            process.exit(1);
+        }
+        // 소스 디렉토리 존재 확인
+        const sourceBase = path_1.default.join(projectPath, source);
+        if (!fs_1.default.existsSync(sourceBase)) {
+            const msg = `소스 디렉토리 '${source}'를 찾을 수 없습니다.`;
+            if (json) {
+                console.log(JSON.stringify({ error: 'SOURCE_NOT_FOUND', message: msg }));
+            }
+            else {
+                console.error(msg);
+            }
+            process.exit(1);
+        }
+        // 소스에서 해당 도구 찾기
+        const allTools = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+        const tool = allTools.find((t) => t.skillsDir === source);
+        const toolName = tool?.name ?? source;
+        // diff 계산
+        const sourceScan = tool
+            ? scanSource(projectPath, tool)
+            : { tool: { name: source, value: source, skillsDir: source }, files: [], summary: {} };
+        // tool이 없으면 직접 스캔
+        if (!tool) {
+            for (const dir of SYNC_DIRS) {
+                const files = scanDir(sourceBase, dir);
+                sourceScan.files.push(...files);
+                if (files.length > 0)
+                    sourceScan.summary[dir] = files.length;
+            }
+        }
+        const relayFiles = scanRelay(relayDir);
+        const diff = computeDiff(sourceScan.files, relayFiles);
+        const summary = {
+            added: diff.filter((d) => d.status === 'added').length,
+            modified: diff.filter((d) => d.status === 'modified').length,
+            deleted: diff.filter((d) => d.status === 'deleted').length,
+            unchanged: diff.filter((d) => d.status === 'unchanged').length,
+        };
+        const hasChanges = summary.added + summary.modified + summary.deleted > 0;
+        // --sync: 즉시 동기화
+        if (opts.sync && hasChanges) {
+            syncToRelay(sourceBase, relayDir, diff);
+        }
+        const result = {
+            source,
+            sourceName: toolName,
+            synced: opts.sync === true && hasChanges,
+            diff: diff.filter((d) => d.status !== 'unchanged'),
+            summary,
+        };
+        if (json) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            if (!hasChanges) {
+                console.error(`✓ 소스(${source})와 .relay/가 동기화 상태입니다.`);
+                return;
+            }
+            console.error(`\n📦 소스 동기화 (${source}/ → .relay/)\n`);
+            for (const entry of diff) {
+                if (entry.status === 'unchanged')
+                    continue;
+                const icon = entry.status === 'added' ? '  신규' : entry.status === 'modified' ? '  변경' : '  삭제';
+                console.error(`${icon}: ${entry.relPath}`);
+            }
+            console.error('');
+            console.error(`  합계: 신규 ${summary.added}, 변경 ${summary.modified}, 삭제 ${summary.deleted}, 유지 ${summary.unchanged}`);
+            if (opts.sync) {
+                console.error(`\n✓ .relay/에 반영 완료`);
+            }
+            else {
+                console.error(`\n반영하려면: relay package --sync`);
+            }
+        }
+    });
+}

package/dist/commands/publish.js

@@ -43,6 +43,7 @@ function parseRelayYaml(content) {
         requires,
         visibility,
         type,
+        source: raw.source ? String(raw.source) : undefined,
     };
 }
 function detectCommands(teamDir) {
@@ -245,7 +246,7 @@ async function createTarball(teamDir) {
     const dirsToInclude = VALID_DIRS.filter((d) => fs_1.default.existsSync(path_1.default.join(teamDir, d)));
     // Include root-level files if they exist
     const entries = [...dirsToInclude];
-    const rootFiles = ['relay.yaml', 'SKILL.md'];
+    const rootFiles = ['relay.yaml', 'SKILL.md', 'guide.md'];
     for (const file of rootFiles) {
         if (fs_1.default.existsSync(path_1.default.join(teamDir, file))) {
             entries.push(file);
@@ -648,6 +649,10 @@ function registerPublish(program) {
             console.error('\x1b[33m⚠ GUIDE.html은 더 이상 지원되지 않습니다. 상세페이지가 가이드 역할을 합니다.\x1b[0m');
             console.error('  long_description을 활용하거나 relayax.com에서 팀 정보를 편집하세요.\n');
         }
+        // Generate guide.md (consumer install guide)
+        const { generateGuide } = await import('../lib/guide.js');
+        const guideContent = generateGuide(config, detectedCommands, config.requires);
+        fs_1.default.writeFileSync(path_1.default.join(relayDir, 'guide.md'), guideContent);
         // Generate bin/relay-preamble.sh (self-contained tracking + update check)
         (0, preamble_js_1.generatePreambleBin)(relayDir, config.slug, config_js_1.API_URL);
         // Generate entry command (commands/{author}-{name}.md)
@@ -720,6 +725,12 @@ function registerPublish(program) {
                     console.log('```');
                     console.log(`\n  \x1b[90mCLI 설치된 사용자용 (짧은 버전):\x1b[0m`);
                     console.log(`  /relay:relay-install ${result.slug}`);
+                    if (config.visibility !== 'private') {
+                        console.log(`\n  \x1b[90m유료 판매하려면:\x1b[0m`);
+                        console.log(`  1. 가시성을 "링크 공유"로 변경: \x1b[36mrelayax.com/dashboard\x1b[0m`);
+                        console.log(`  2. API 키 발급: \x1b[36mrelayax.com/dashboard/keys\x1b[0m`);
+                        console.log(`  3. 웹훅 연동 가이드: \x1b[36mrelayax.com/docs/webhook-guide.md\x1b[0m`);
+                    }
                     console.log(`\n  \x1b[90m상세페이지: \x1b[36mrelayax.com/@${detailSlug}\x1b[0m`);
                 }
             }

package/dist/commands/spaces.d.ts

@@ -4,7 +4,6 @@ export interface SpaceInfo {
     slug: string;
     name: string;
     description: string | null;
-    space_type?: string;
     join_policy?: string;
     role: string;
 }

package/dist/index.js

@@ -9,6 +9,7 @@ const search_js_1 = require("./commands/search.js");
 const install_js_1 = require("./commands/install.js");
 const list_js_1 = require("./commands/list.js");
 const uninstall_js_1 = require("./commands/uninstall.js");
+const package_js_1 = require("./commands/package.js");
 const publish_js_1 = require("./commands/publish.js");
 const login_js_1 = require("./commands/login.js");
 const update_js_1 = require("./commands/update.js");
@@ -36,6 +37,7 @@ program
 (0, install_js_1.registerInstall)(program);
 (0, list_js_1.registerList)(program);
 (0, uninstall_js_1.registerUninstall)(program);
+(0, package_js_1.registerPackage)(program);
 (0, publish_js_1.registerPublish)(program);
 (0, login_js_1.registerLogin)(program);
 (0, update_js_1.registerUpdate)(program);

package/dist/lib/command-adapter.js

@@ -506,58 +506,154 @@ ${ERROR_HANDLING_GUIDE}
         description: '현재 팀 패키지를 relay Space에 배포합니다',
         body: `현재 디렉토리의 에이전트 팀(.relay/)을 분석하고, 보안 점검 및 requirements를 구성한 뒤, 사용가이드를 생성하고 relay Space에 배포합니다.
 
-## 사전 준비 (자동)
+## 사전 준비
 
-### 0-1. 팀 프로젝트 확인 & 초기화
+### 0-1. 인증 확인
 
-.relay/relay.yaml이 있는지 확인합니다.
+- \`relay status --json\` 명령어를 실행하여 로그인 상태를 확인합니다.
+- 인증되어 있으면 다음 단계로 진행합니다.
+- 미인증이면 바로 로그인을 진행합니다:
+  1. \`relay login\` 실행 (timeout 300초)
+     - 브라우저가 자동으로 열리고, 사용자가 로그인을 완료하면 토큰이 자동 저장됩니다.
+  2. 완료 후 \`relay status --json\`으로 로그인 성공을 확인합니다.
+
+### 0-2. 소스 패키징 (source → .relay/)
+
+\`relay package\` CLI 명령을 사용하여 소스 디렉토리의 콘텐츠를 .relay/로 동기화합니다.
+소스 탐색과 파일 비교는 CLI가 결정적으로 처리하고, 에이전트는 결과를 사용자에게 보여주고 흐름을 조율합니다.
+
+#### A. 최초 배포 (.relay/relay.yaml이 없음)
 
-**있으면** → 바로 0-2로 진행합니다.
+##### 1단계: 소스 탐색
 
-**없으면** → 팀 프로젝트를 인라인으로 초기화합니다:
+\`relay package --init --json\` 실행
+- CLI가 프로젝트에서 에이전트 CLI 디렉토리(.claude/, .codex/, .gemini/ 등)를 자동 탐색합니다.
+- JSON 결과의 \`detected\` 배열에 각 디렉토리별 콘텐츠 요약이 포함됩니다:
+  \`\`\`json
+  {
+    "status": "init_required",
+    "detected": [
+      { "source": ".claude", "name": "Claude Code", "summary": { "skills": 2, "commands": 3 }, "fileCount": 8 },
+      { "source": ".codex", "name": "Codex", "summary": { "agents": 1 }, "fileCount": 2 }
+    ]
+  }
+  \`\`\`
 
-1. "이 프로젝트를 relay 팀으로 배포하겠습니다. 먼저 팀 정보를 입력해주세요." 안내
+- **detected가 0개** → "배포 가능한 에이전트 콘텐츠가 없습니다. skills/이나 commands/를 먼저 만들어주세요." 안내 후 중단
 
-2. **AskUserQuestion 호출:**
-   - question: "팀 이름을 입력해주세요"
-   - 기본값으로 현재 디렉토리명을 제안합니다.
+##### 2단계: 콘텐츠 분석 & 팀 포지셔닝
 
-3. **AskUserQuestion 호출:**
-   - question: "팀을 한 줄로 설명해주세요 (Space에 표시됩니다)"
-   - 기본값으로 적절한 값을 만들어줍니다.
+detected된 소스 디렉토리의 skills/, commands/, agents/, rules/ 파일 **내용을 직접 읽어** 팀의 정체성을 파악합니다.
 
-4. 자동 처리:
-   - \`mkdir -p .relay/skills .relay/commands .relay/agents .relay/rules\` 실행
-   - \`.relay/relay.yaml\` 생성:
-     \`\`\`yaml
-     name: <입력된 이름>
-     slug: <이름에서 자동 생성 — 소문자, 특수문자→하이픈>
-     description: <입력된 설명>
-     version: 1.0.0
-     tags: []
+**분석 관점:**
+- 이 팀이 **무엇을 하는 팀**인지 (코드 리뷰? QA? 문서 생성? 데이터 분석?)
+- 어떤 **기술 스택/도메인**에 특화되어 있는지 (Supabase? React? Python?)
+- 설치자에게 **어떤 가치**를 제공하는지
+
+이 분석을 기반으로 팀을 하나의 "제품"으로 포지셔닝합니다.
+
+**중요: 소스 디렉토리 이름(.claude 등)은 인프라 디테일이므로 사용자에게 노출하지 않습니다.**
+사용자에게는 팀의 기능과 정체성 중심으로 질문합니다.
+
+##### 3단계: 배포 제안
+
+분석 결과를 바탕으로 팀 배포를 제안합니다.
+
+**detected가 1개일 때:**
+
+**AskUserQuestion 호출:**
+- question: 콘텐츠 분석 기반의 포지셔닝 질문
+- 예시:
+  - "Supabase 웹 개발팀으로 배포할까요? (skills 2개, commands 3개)"
+  - "코드 리뷰 자동화 팀으로 배포할까요? (skills 1개, agents 2개)"
+  - "Next.js QA 테스트팀으로 배포할까요? (commands 5개)"
+- options: \`["배포", "취소"]\`
+
+**detected가 여러 개일 때:**
+각 소스의 콘텐츠를 분석하여 서로 다른 팀으로 포지셔닝합니다.
+
+**AskUserQuestion 호출:**
+- question: "어떤 팀으로 배포할까요?"
+- options: 콘텐츠 기반 설명 (예: \`["Supabase 웹 개발팀 (skills 2개, commands 3개)", "QA 자동화 에이전트 (agents 1개)"]\`)
+- 디렉토리 이름은 내부적으로만 매핑하고, 사용자에게는 팀의 기능으로 보여줍니다.
+
+##### 4단계: 팀 정보 확정
+
+포지셔닝 분석을 기반으로 팀 이름과 설명을 제안합니다.
+
+**AskUserQuestion 호출:**
+- question: "팀 이름을 확인해주세요"
+- 분석된 포지셔닝에서 자연스러운 팀 이름을 제안합니다 (예: "supabase-web-dev", "code-reviewer")
+- 현재 디렉토리명이 아닌, **콘텐츠 기반** 이름을 기본값으로 제시합니다.
+
+**AskUserQuestion 호출:**
+- question: "팀 설명을 확인해주세요 (Space에 표시됩니다)"
+- 분석한 콘텐츠를 기반으로 설치자 관점의 설명을 제안합니다.
+- 좋은 예: "Supabase 기반 웹앱의 DB 마이그레이션, API 개발, 테스트를 자동화합니다"
+- 나쁜 예: ".claude 디렉토리의 skills와 commands를 패키징한 팀"
+
+##### 5단계: 초기화 & 패키징
+
+자동 처리:
+- \`.relay/relay.yaml\` 생성:
+  \`\`\`yaml
+  name: <확정된 이름>
+  slug: <이름에서 자동 생성 — 소문자, 특수문자→하이픈>
+  description: <확정된 설명>
+  source: <선택된 소스 디렉토리> # 예: .claude (내부용)
+  version: 1.0.0
+  tags: []
+  \`\`\`
+- \`relay package --source <선택된 소스> --sync --json\` 실행하여 콘텐츠를 .relay/로 복사
+- \`relay init --auto\` 실행하여 글로벌 커맨드 설치 보장
+- 결과를 사용자에게 표시
+
+#### B. 재배포 (.relay/relay.yaml이 있음)
+
+1. \`relay package --json\` 실행
+   - CLI가 relay.yaml의 \`source\` 필드를 읽고, 소스 디렉토리와 .relay/를 파일 해시로 비교합니다.
+   - JSON 결과 예시:
+     \`\`\`json
+     {
+       "source": ".claude",
+       "sourceName": "Claude Code",
+       "synced": false,
+       "diff": [
+         { "relPath": "skills/code-review/SKILL.md", "status": "modified" },
+         { "relPath": "commands/deploy.md", "status": "added" },
+         { "relPath": "commands/old-cmd.md", "status": "deleted" }
+       ],
+       "summary": { "added": 1, "modified": 1, "deleted": 1, "unchanged": 5 }
+     }
      \`\`\`
-   - \`relay init --update\` 실행하여 글로벌 커맨드 설치 보장
 
-5. "✓ 팀 프로젝트가 초기화되었습니다. 배포를 계속 진행합니다." 안내
+2. **변경이 있으면** (added + modified + deleted > 0) → diff를 사용자에게 보여줍니다:
+   \`\`\`
+   📦 소스 동기화 (.claude/ → .relay/)
+     변경: skills/code-review/SKILL.md
+     신규: commands/deploy.md
+     삭제: commands/old-cmd.md
+     유지: 5개 파일
+   \`\`\`
 
-### 0-2. 인증 확인
+   **AskUserQuestion 호출:**
+   - question: "소스 변경사항을 .relay/에 반영할까요?"
+   - options: \`["반영", "변경 확인", "건너뛰기"]\`
 
-- \`relay status --json\` 명령어를 실행하여 로그인 상태를 확인합니다.
-- 인증되어 있으면 다음 단계로 진행합니다.
-- 미인증이면 바로 로그인을 진행합니다:
-  1. \`relay login\` 실행 (timeout 300초)
-     - 브라우저가 자동으로 열리고, 사용자가 로그인을 완료하면 토큰이 자동 저장됩니다.
-  2. 완료 후 \`relay status --json\`으로 로그인 성공을 확인합니다.
+   **응답 처리:**
+   - "반영" → \`relay package --sync --json\` 실행하여 동기화
+   - "변경 확인" → 변경된 파일의 내용을 직접 읽어 diff를 상세히 보여준 후 다시 AskUserQuestion
+   - "건너뛰기" → 현재 .relay/ 그대로 배포
+
+3. **변경이 없으면** → "✓ 소스와 동기화 상태입니다." 표시 후 다음 단계로
 
-### 0-3. 팀 구조 분석
-- .relay/ 디렉토리의 skills/, agents/, rules/, commands/를 탐색합니다.
-- 각 파일의 이름과 description을 추출합니다.
+4. \`source\` 필드가 없으면 → .relay/ 내 콘텐츠를 직접 편집하는 모드로 간주하고 동기화를 건너뜁니다.
 
 ## 인터랙션 플로우
 
-이 커맨드는 5단계 인터랙션으로 진행됩니다. 각 단계에서 반드시 AskUserQuestion 도구를 사용하세요.
+이 커맨드는 4단계 인터랙션으로 진행됩니다. 각 단계에서 반드시 AskUserQuestion 도구를 사용하세요.
 
-### Step 0. 버전 범프
+### Step 1. 버전 범프
 
 relay.yaml의 현재 \`version\`을 읽고 semver 범프를 제안합니다.
 
@@ -741,5 +837,5 @@ ${ERROR_HANDLING_GUIDE}`,
 ];
 // ─── Builder Commands (로컬 설치) ───
 // relay-publish가 글로벌로 승격되어 현재 비어있음.
-// relay init --update만 실행하면 모든 커맨드가 한번에 업데이트됨.
+// relay init --auto만 실행하면 모든 커맨드가 한번에 업데이트됨.
 exports.BUILDER_COMMANDS = [];

package/dist/lib/guide.d.ts

@@ -1,5 +1,13 @@
-/**
- * GUIDE.html 생성 프롬프트 템플릿.
- * publish slash command에서 Claude Code가 이 프롬프트를 읽고 GUIDE.html을 생성한다.
- */
-export declare const GUIDE_HTML_PROMPT: string;
+import type { Requires } from '../commands/publish.js';
+interface CommandEntry {
+    name: string;
+    description: string;
+}
+export declare function generateGuide(config: {
+    slug: string;
+    name: string;
+    description: string;
+    version: string;
+    visibility?: string;
+}, commands: CommandEntry[], requires?: Requires): string;
+export {};

package/dist/lib/guide.js

@@ -1,52 +1,144 @@
 "use strict";
-/**
- * GUIDE.html 생성 프롬프트 템플릿.
- * publish slash command에서 Claude Code가 이 프롬프트를 읽고 GUIDE.html을 생성한다.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GUIDE_HTML_PROMPT = void 0;
-exports.GUIDE_HTML_PROMPT = `
-당신은 에이전트 팀의 사용가이드(GUIDE.html)를 생성하는 에이전트입니다.
-팀의 skills/, agents/, commands/ 파일을 분석한 결과를 바탕으로, 설치자가 읽을 수 있는 standalone HTML 파일을 생성하세요.
-
-## 콘텐츠 구조 (순서대로)
-
-1. **헤더**: 팀 이름 + 한 줄 소개
-2. **설치 방법 (준비하기)**:
-   - Step 1: CLI 설치 — \`npm install -g relayax-cli\`
-   - Step 2: 팀 설치 — \`relay install @owner/slug\` (실제 팀의 scoped slug 사용)
-   - Step 3: 에이전트에 복사붙여넣기 — "사용하시는 AI 에이전트(Claude Code, Codex 등)의 채팅창에 아래 명령어를 붙여넣기 하세요!"
-3. **안내 Callout**: 노란 배경 박스로 시작 방법 강조 — "채팅창에 '○○○'라고 입력하세요."
-4. **워크플로우 요약**: 전체 흐름을 한 줄로 — \`[0 온보딩 → 1 분석 → 1.5 선택 → 2 추천 → 3 생성]\`
-5. **파이프라인 다이어그램**: 2-column 세로 플로우차트
-   - 왼쪽 컬럼: 파이프라인 단계 (노드 + 연결선, 세로 흐름)
-   - 오른쪽 컬럼: 해당 단계에서 사용하는 skill 카드 (skill명 + 한 줄 설명)
-   - 색상 구분: 유저 개입 단계 = 베이지/주황 톤, AI 자동 단계 = 연두/초록 톤
-   - 상단에 범례: ■ 유저 개입 / ■ 자동 실행
-   - 선택적 단계(optional)는 점선 테두리 그룹으로 묶기
-6. **단계별 상세 테이블**: 4-column 테이블
-   - 컬럼: 단계 | skill명 | 액션 | 상세
-   - 각 행에 역할 뱃지: "AI가 알아서 해줘요" (초록 배경) / "직접 아래 액션을 수행해주세요!" (주황 배경, 볼드)
-   - 상세 컬럼에 bullet list로 구체적 동작 설명
-   - 주의사항은 빨간 이탤릭 (*주의: ...)
-7. **사전 준비사항**: 필요한 환경변수, 접근 권한, 데이터 등
-8. **Q&A**: 접이식 토글(details/summary)로 자주 묻는 질문
-   - 커스터마이징 방법 (개수 변경, 타입 고정 등)
-   - 중단/재시작 방법
-   - 데이터 형식 요구사항
-
-파이프라인이 없는 단순한 팀은 시작 방법 + 기능 설명 + Q&A만 포함합니다.
-
-## 디자인 규칙 (Notion 스타일)
-
-- **라이트 모드**: 배경 #ffffff / 부배경 #fafaf8, 텍스트 다크 #1a1a18
-- **레이아웃**: max-width 900px, padding 40px, Notion 문서형 넓은 여백
-- **타이포그래피**: system-ui, -apple-system, sans-serif. 본문 15px, line-height 1.7
-- **Callout 박스**: 노란 배경 #fffbeb + 좌측 보더 4px solid #fcd34d (중요 안내), 파란 배경 #eff6ff + 보더 #93c5fd (참고)
-- **역할 뱃지**: 둥근 모서리 pill, 초록 배경 #e0f5ea + 텍스트 #0d6b2e (AI) / 주황 배경 #fff0e0 + 텍스트 #b85a00 (유저)
-- **테이블**: 깔끔한 border #e8e8e4, hover 시 행 하이라이트 #f5f5f3, 헤더 회색 배경 #f5f5f3
-- **색상**: 유저 단계 = 베이지/주황 (#fff8f0, #f0c090), AI 단계 = 연두 (#f0faf4, #90d4a8)
-- **톤**: 따뜻하고 친근한 한국어, 이모지 적절히 활용
-- **반응형**: 600px 이하에서 테이블 가로스크롤, 다이어그램 단일 컬럼
-- **기술 제약**: standalone HTML, CSS는 style 태그 내, 외부 CDN/폰트 없음, JS 최소화 (details/summary만)
-`.trim();
+exports.generateGuide = generateGuide;
+function buildSetupSection(needsLogin) {
+    const installStep = `## Step 1. Relay CLI 설치
+
+relay CLI가 설치되어 있지 않다면:
+
+\`\`\`bash
+npm install -g relayax-cli
+\`\`\`
+
+Node.js가 없는 경우:
+- macOS: \`brew install node\`
+- Windows: \`winget install OpenJS.NodeJS.LTS\`
+- Linux: \`curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash && source ~/.bashrc && nvm install --lts\`
+
+npm 권한 오류 시:
+\`\`\`bash
+mkdir -p ~/.npm-global && npm config set prefix '~/.npm-global'
+echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.zshrc && source ~/.zshrc
+npm install -g relayax-cli
+\`\`\``;
+    if (!needsLogin)
+        return installStep;
+    return `${installStep}
+
+## Step 2. 로그인
+
+\`\`\`bash
+relay login
+\`\`\`
+
+브라우저가 열리면 GitHub 또는 카카오 계정으로 로그인하세요.`;
+}
+function buildRequiresSection(requires) {
+    const sections = [];
+    if (requires.cli && requires.cli.length > 0) {
+        sections.push('### CLI 도구 설치\n');
+        for (const cli of requires.cli) {
+            const label = cli.required === false ? '(선택)' : '(필수)';
+            if (cli.install) {
+                sections.push(`- **${cli.name}** ${label}: \`${cli.install}\``);
+            }
+            else {
+                sections.push(`- **${cli.name}** ${label}: 설치 후 \`which ${cli.name}\`으로 확인`);
+            }
+        }
+        sections.push('');
+    }
+    if (requires.npm && requires.npm.length > 0) {
+        sections.push('### npm 패키지 설치\n');
+        sections.push('```bash');
+        const pkgNames = requires.npm.map((p) => typeof p === 'string' ? p : p.name);
+        sections.push(`npm install ${pkgNames.join(' ')}`);
+        sections.push('```\n');
+    }
+    if (requires.env && requires.env.length > 0) {
+        sections.push('### 환경변수 설정\n');
+        sections.push('```bash');
+        for (const env of requires.env) {
+            const label = env.required === false ? '# (선택)' : '# (필수)';
+            const desc = env.description ? ` — ${env.description}` : '';
+            sections.push(`${env.name}=your_value_here  ${label}${desc}`);
+        }
+        sections.push('```\n');
+    }
+    if (requires.mcp && requires.mcp.length > 0) {
+        sections.push('### MCP 서버 설정\n');
+        for (const mcp of requires.mcp) {
+            sections.push(`**${mcp.name}:**`);
+            if (mcp.package)
+                sections.push(`- 패키지: \`${mcp.package}\``);
+            if (mcp.config) {
+                sections.push(`- 실행: \`${mcp.config.command}${mcp.config.args ? ' ' + mcp.config.args.join(' ') : ''}\``);
+            }
+            if (mcp.env && mcp.env.length > 0) {
+                sections.push(`- 필요한 환경변수: ${mcp.env.map((e) => `\`${e}\``).join(', ')}`);
+            }
+            sections.push('');
+        }
+    }
+    if (requires.teams && requires.teams.length > 0) {
+        sections.push('### 의존 팀 설치\n');
+        sections.push('```bash');
+        for (const team of requires.teams) {
+            sections.push(`relay install ${team}`);
+        }
+        sections.push('```\n');
+    }
+    if (requires.permissions && requires.permissions.length > 0) {
+        sections.push('### 권한 설정\n');
+        sections.push('아래 도구 사용을 허용해야 합니다:\n');
+        for (const perm of requires.permissions) {
+            sections.push(`- \`${perm}\``);
+        }
+        sections.push('');
+    }
+    if (sections.length === 0)
+        return '';
+    return '## Step 4. 환경 구성\n\n' + sections.join('\n');
+}
+function generateGuide(config, commands, requires) {
+    const scopedSlug = config.slug.startsWith('@') ? config.slug : `@${config.slug}`;
+    const needsLogin = config.visibility === 'private' || config.visibility === 'gated';
+    const setupSection = buildSetupSection(needsLogin);
+    const installStepNum = needsLogin ? 3 : 2;
+    const requiresSection = requires ? buildRequiresSection(requires) : '';
+    const requiresSectionFinal = requiresSection
+        ? requiresSection.replace('## Step 4.', `## Step ${installStepNum + 1}.`)
+        : '';
+    let usageHint = '';
+    if (commands.length > 0) {
+        usageHint = `## 사용법
+
+설치가 완료되면 아래 커맨드를 사용할 수 있습니다:
+
+${commands.map((cmd) => `- \`/${cmd.name}\`: ${cmd.description}`).join('\n')}
+
+원하는 작업을 말하거나 위 커맨드를 직접 실행하세요.
+`;
+    }
+    return `# ${config.name} — 설치 가이드
+
+> ${config.description}
+
+이 가이드는 [RelayAX](https://relayax.com)에서 자동 생성되었습니다.
+아래 단계를 순서대로 실행하면 Agent 팀이 설치됩니다.
+
+${setupSection}
+
+## Step ${installStepNum}. 팀 설치
+
+\`\`\`bash
+relay install ${scopedSlug}
+\`\`\`
+
+설치 후 Agent가 자동으로 의존성을 확인하고 환경을 구성합니다.
+
+${requiresSectionFinal}${usageHint}---
+*출처: https://relayax.com — Agent Team Marketplace*
+*설치: \`relay install ${scopedSlug}\`*
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relayax-cli",
-  "version": "0.2.40",
+  "version": "0.2.41",
   "description": "RelayAX Agent Team Marketplace CLI - Install and manage agent teams",
   "main": "dist/index.js",
   "bin": {