relayax-cli 0.2.41 → 0.3.42

package/dist/commands/package.js

@@ -3,94 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelayDir = resolveRelayDir;
+exports.initGlobalAgentHome = initGlobalAgentHome;
 exports.registerPackage = registerPackage;
 const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
 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를 생성한다.
  */
@@ -145,6 +72,186 @@ function syncToRelay(sourceBase, relayDir, diff) {
         }
     }
 }
+// ─── Contents-based Helpers ───
+/**
+ * from 경로를 절대 경로로 해석한다.
+ * ~/로 시작하면 홈 디렉토리, 그 외는 projectPath 기준 상대 경로.
+ */
+function resolveFromPath(fromPath, projectPath) {
+    if (fromPath.startsWith('~/')) {
+        return path_1.default.join(os_1.default.homedir(), fromPath.slice(2));
+    }
+    return path_1.default.join(projectPath, fromPath);
+}
+/**
+ * 파일 또는 디렉토리의 모든 파일을 재귀 스캔하여 FileEntry[]를 반환한다.
+ * relPath는 baseDir 기준.
+ */
+function scanPath(absPath) {
+    if (!fs_1.default.existsSync(absPath))
+        return [];
+    const stat = fs_1.default.statSync(absPath);
+    if (stat.isFile()) {
+        return [{ relPath: path_1.default.basename(absPath), hash: fileHash(absPath) }];
+    }
+    // 디렉토리
+    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 {
+                entries.push({ relPath: path_1.default.relative(absPath, fullPath), hash: fileHash(fullPath) });
+            }
+        }
+    }
+    walk(absPath);
+    return entries;
+}
+/**
+ * contents 매니페스트 기반으로 각 항목의 원본과 .relay/ 복사본을 비교한다.
+ */
+function computeContentsDiff(contents, relayDir, projectPath) {
+    const diff = [];
+    for (const entry of contents) {
+        const absFrom = resolveFromPath(entry.from, projectPath);
+        if (!fs_1.default.existsSync(absFrom)) {
+            diff.push({ name: entry.name, type: entry.type, status: 'source_missing' });
+            continue;
+        }
+        // from 경로에서 .relay/ 내 대응 위치 결정
+        // from: .claude/skills/code-review → .relay/skills/code-review
+        // from: ~/.claude/skills/code-review → .relay/skills/code-review
+        const relaySubPath = deriveRelaySubPath(entry);
+        const relayItemDir = path_1.default.join(relayDir, relaySubPath);
+        const sourceFiles = scanPath(absFrom);
+        const relayFiles = scanPath(relayItemDir);
+        const fileDiff = computeDiff(sourceFiles, relayFiles);
+        const hasChanges = fileDiff.some((d) => d.status !== 'unchanged');
+        diff.push({
+            name: entry.name,
+            type: entry.type,
+            status: hasChanges ? 'modified' : 'unchanged',
+            files: hasChanges ? fileDiff.filter((d) => d.status !== 'unchanged') : undefined,
+        });
+    }
+    // 소스 디렉토리를 다시 스캔하여 contents에 없는 새 항목 탐지
+    const newItems = discoverNewItems(contents, projectPath);
+    return { diff, newItems };
+}
+/**
+ * contents 항목의 from 경로에서 .relay/ 내 서브경로를 유도한다.
+ * 예: .claude/skills/code-review → skills/code-review
+ *     ~/.claude/agents/dev-lead.md → agents/dev-lead.md
+ */
+function deriveRelaySubPath(entry) {
+    const from = entry.from.startsWith('~/') ? entry.from.slice(2) : entry.from;
+    // skills/xxx, agents/xxx 등의 패턴을 추출
+    for (const dir of SYNC_DIRS) {
+        const idx = from.indexOf(`/${dir}/`);
+        if (idx !== -1) {
+            return from.slice(idx + 1); // /skills/code-review → skills/code-review
+        }
+    }
+    // fallback: type + name
+    return `${entry.type}s/${entry.name}`;
+}
+/**
+ * contents에 등록되지 않은 새 항목을 소스 디렉토리에서 찾는다.
+ */
+function discoverNewItems(contents, projectPath) {
+    const existingNames = new Set(contents.map((c) => `${c.type}:${c.name}`));
+    const newItems = [];
+    // 로컬 소스 스캔
+    const localTools = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+    for (const tool of localTools) {
+        const items = (0, ai_tools_js_1.scanLocalItems)(projectPath, tool);
+        for (const item of items) {
+            if (!existingNames.has(`${item.type}:${item.name}`)) {
+                newItems.push({
+                    name: item.name,
+                    type: item.type,
+                    source: tool.skillsDir,
+                    relativePath: item.relativePath,
+                });
+            }
+        }
+    }
+    // 글로벌 소스 스캔
+    const globalTools = (0, ai_tools_js_1.detectGlobalCLIs)();
+    for (const tool of globalTools) {
+        const items = (0, ai_tools_js_1.scanGlobalItems)(tool);
+        for (const item of items) {
+            if (!existingNames.has(`${item.type}:${item.name}`)) {
+                newItems.push({
+                    name: item.name,
+                    type: item.type,
+                    source: `~/${tool.skillsDir}`,
+                    relativePath: item.relativePath,
+                });
+            }
+        }
+    }
+    return newItems;
+}
+/**
+ * contents 항목 단위로 from → .relay/ 동기화한다.
+ */
+function syncContentsToRelay(contents, contentsDiff, relayDir, projectPath) {
+    for (const diffEntry of contentsDiff) {
+        if (diffEntry.status !== 'modified')
+            continue;
+        const content = contents.find((c) => c.name === diffEntry.name && c.type === diffEntry.type);
+        if (!content)
+            continue;
+        const absFrom = resolveFromPath(content.from, projectPath);
+        const relaySubPath = deriveRelaySubPath(content);
+        const relayItemDir = path_1.default.join(relayDir, relaySubPath);
+        // 소스 파일을 .relay/로 복사
+        const sourceFiles = scanPath(absFrom);
+        const relayFiles = scanPath(relayItemDir);
+        const fileDiff = computeDiff(sourceFiles, relayFiles);
+        syncToRelay(absFrom, relayItemDir, fileDiff);
+    }
+}
+// ─── Global Agent Home ───
+/**
+ * 패키지 홈 디렉토리를 결정한다.
+ * 1. 프로젝트에 .relay/가 있으면 → projectPath/.relay/
+ * 2. 없으면 → ~/.relay/agents/<slug>/ (slug 필요)
+ *
+ * slug가 없고 프로젝트에도 .relay/가 없으면 null 반환.
+ */
+function resolveRelayDir(projectPath, slug) {
+    const projectRelay = path_1.default.join(projectPath, '.relay');
+    if (fs_1.default.existsSync(path_1.default.join(projectRelay, 'relay.yaml'))) {
+        return projectRelay;
+    }
+    // .relay/ 디렉토리는 있지만 relay.yaml이 없는 경우도 프로젝트 모드
+    if (fs_1.default.existsSync(projectRelay)) {
+        return projectRelay;
+    }
+    // 글로벌 에이전트 홈
+    if (slug) {
+        return path_1.default.join(os_1.default.homedir(), '.relay', 'agents', slug);
+    }
+    return null;
+}
+/**
+ * 글로벌 에이전트 홈에 패키지 구조를 초기화한다.
+ */
+function initGlobalAgentHome(slug, yamlData) {
+    const agentDir = path_1.default.join(os_1.default.homedir(), '.relay', 'agents', slug);
+    fs_1.default.mkdirSync(agentDir, { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(agentDir, 'skills'), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(agentDir, 'agents'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(agentDir, 'relay.yaml'), js_yaml_1.default.dump(yamlData, { lineWidth: 120 }), 'utf-8');
+    return agentDir;
+}
 // ─── Command ───
 function registerPackage(program) {
     program
@@ -153,6 +260,7 @@ function registerPackage(program) {
         .option('--source <dir>', '소스 디렉토리 지정 (예: .claude)')
         .option('--sync', '변경사항을 .relay/에 즉시 반영', false)
         .option('--init', '최초 패키징: 소스 감지 → .relay/ 초기화', false)
+        .option('--migrate', '기존 source 필드를 contents로 마이그레이션', false)
         .action(async (opts) => {
         const json = program.opts().json ?? false;
         const projectPath = process.cwd();
@@ -160,127 +268,228 @@ function registerPackage(program) {
         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);
+            // 로컬 + 글로벌 소스를 모두 스캔하여 개별 항목 목록 생성
+            const localTools = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+            const globalTools = (0, ai_tools_js_1.detectGlobalCLIs)();
+            const sources = [];
+            for (const tool of localTools) {
+                const items = (0, ai_tools_js_1.scanLocalItems)(projectPath, tool);
+                if (items.length > 0) {
+                    sources.push({
+                        path: tool.skillsDir,
+                        location: 'local',
+                        name: tool.name,
+                        items,
+                    });
+                }
+            }
+            for (const tool of globalTools) {
+                const items = (0, ai_tools_js_1.scanGlobalItems)(tool);
+                if (items.length > 0) {
+                    sources.push({
+                        path: `~/${tool.skillsDir}`,
+                        location: 'global',
+                        name: `${tool.name} (global)`,
+                        items,
+                    });
+                }
+            }
+            // ~/.relay/agents/ 에 기존 에이전트 패키지가 있는지 스캔
+            const globalAgentsDir = path_1.default.join(os_1.default.homedir(), '.relay', 'agents');
+            const existingAgents = [];
+            if (fs_1.default.existsSync(globalAgentsDir)) {
+                for (const entry of fs_1.default.readdirSync(globalAgentsDir, { withFileTypes: true })) {
+                    if (!entry.isDirectory() || entry.name.startsWith('.'))
+                        continue;
+                    const agentYaml = path_1.default.join(globalAgentsDir, entry.name, 'relay.yaml');
+                    if (fs_1.default.existsSync(agentYaml)) {
+                        try {
+                            const cfg = js_yaml_1.default.load(fs_1.default.readFileSync(agentYaml, 'utf-8'));
+                            existingAgents.push({
+                                slug: cfg.slug ?? entry.name,
+                                name: cfg.name ?? entry.name,
+                                version: cfg.version ?? '0.0.0',
+                                path: `~/.relay/agents/${entry.name}`,
+                            });
+                        }
+                        catch { /* skip invalid yaml */ }
+                    }
+                }
+            }
             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,
-                    })),
+                    sources,
+                    existing_agents: existingAgents,
                 }));
             }
             else {
-                if (scans.length === 0) {
+                if (sources.length === 0 && existingAgents.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}`);
+                if (sources.length > 0) {
+                    console.error('\n발견된 에이전트 콘텐츠:\n');
+                    for (const src of sources) {
+                        const typeCounts = new Map();
+                        for (const item of src.items) {
+                            typeCounts.set(item.type, (typeCounts.get(item.type) ?? 0) + 1);
+                        }
+                        const parts = Array.from(typeCounts.entries())
+                            .map(([t, c]) => `${t} ${c}개`)
+                            .join(', ');
+                        const label = src.location === 'global' ? '🌐' : '📁';
+                        console.error(`  ${label} ${src.path}/ — ${parts}`);
+                    }
+                }
+                if (existingAgents.length > 0) {
+                    console.error('\n기존 글로벌 에이전트:\n');
+                    for (const agent of existingAgents) {
+                        console.error(`  📦 ${agent.name} (v${agent.version}) — ${agent.path}`);
+                    }
                 }
                 console.error('');
             }
             return;
         }
-        // ─── 재패키징 (source 기반 동기화) ───
+        // ─── 마이그레이션 (--migrate) ───
+        if (opts.migrate) {
+            const yamlMigrate = fs_1.default.readFileSync(relayYamlPath, 'utf-8');
+            const cfgMigrate = js_yaml_1.default.load(yamlMigrate);
+            if (cfgMigrate.contents) {
+                if (json) {
+                    console.log(JSON.stringify({ status: 'already_migrated', message: '이미 contents 형식입니다.' }));
+                }
+                else {
+                    console.error('✓ 이미 contents 형식입니다.');
+                }
+                return;
+            }
+            const legacySource = cfgMigrate.source;
+            if (!legacySource) {
+                if (json) {
+                    console.log(JSON.stringify({ status: 'no_source', message: 'source 필드가 없습니다.' }));
+                }
+                else {
+                    console.error('source 필드가 없습니다. relay package --init으로 초기화하세요.');
+                }
+                process.exit(1);
+            }
+            // source 디렉토리를 스캔하여 모든 항목을 contents[]로 변환
+            const sourceBase = path_1.default.join(projectPath, legacySource);
+            const migratedContents = [];
+            if (fs_1.default.existsSync(sourceBase)) {
+                const localTools = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+                const tool = localTools.find((t) => t.skillsDir === legacySource);
+                if (tool) {
+                    const items = (0, ai_tools_js_1.scanLocalItems)(projectPath, tool);
+                    for (const item of items) {
+                        migratedContents.push({
+                            name: item.name,
+                            type: item.type,
+                            from: `${legacySource}/${item.relativePath}`,
+                        });
+                    }
+                }
+            }
+            // relay.yaml에서 source 제거, contents 저장
+            delete cfgMigrate.source;
+            cfgMigrate.contents = migratedContents;
+            fs_1.default.writeFileSync(relayYamlPath, js_yaml_1.default.dump(cfgMigrate, { lineWidth: 120 }), 'utf-8');
+            if (json) {
+                console.log(JSON.stringify({ status: 'migrated', contents: migratedContents }));
+            }
+            else {
+                console.error(`✓ source(${legacySource}) → contents(${migratedContents.length}개 항목)로 마이그레이션 완료`);
+            }
+            return;
+        }
+        // ─── 재패키징 (contents 매니페스트 기반 동기화) ───
         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) {
+        const contents = config.contents ?? [];
+        // 기존 source 필드 → contents 마이그레이션 안내
+        if (!config.contents && config.source) {
+            const legacySource = config.source;
             if (json) {
                 console.log(JSON.stringify({
-                    status: 'no_source',
-                    message: 'relay.yaml에 source 필드가 없습니다. --source 옵션으로 지정하거나 relay.yaml에 source를 추가하세요.',
+                    status: 'migration_required',
+                    message: `relay.yaml의 source 필드를 contents로 마이그레이션해야 합니다.`,
+                    legacy_source: legacySource,
                 }));
             }
             else {
-                console.error('relay.yaml에 source 필드가 없습니다.');
-                console.error('--source <dir> 옵션으로 지정하거나 relay.yaml에 source를 추가하세요.');
+                console.error(`relay.yaml에 기존 source 필드(${legacySource})가 있습니다.`);
+                console.error(`contents 형식으로 마이그레이션하려면: relay package --migrate`);
             }
             process.exit(1);
         }
-        // 소스 디렉토리 존재 확인
-        const sourceBase = path_1.default.join(projectPath, source);
-        if (!fs_1.default.existsSync(sourceBase)) {
-            const msg = `소스 디렉토리 '${source}'를 찾을 수 없습니다.`;
+        if (contents.length === 0) {
             if (json) {
-                console.log(JSON.stringify({ error: 'SOURCE_NOT_FOUND', message: msg }));
+                console.log(JSON.stringify({
+                    status: 'no_contents',
+                    message: 'relay.yaml에 contents가 없습니다. relay package --init으로 패키지를 초기화하세요.',
+                }));
             }
             else {
-                console.error(msg);
+                console.error('relay.yaml에 contents가 없습니다.');
+                console.error('relay package --init으로 패키지를 초기화하세요.');
             }
             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);
+        // contents 기반 diff 계산
+        const { diff: contentsDiff, newItems } = computeContentsDiff(contents, relayDir, projectPath);
         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,
+            modified: contentsDiff.filter((d) => d.status === 'modified').length,
+            unchanged: contentsDiff.filter((d) => d.status === 'unchanged').length,
+            source_missing: contentsDiff.filter((d) => d.status === 'source_missing').length,
+            new_available: newItems.length,
         };
-        const hasChanges = summary.added + summary.modified + summary.deleted > 0;
-        // --sync: 즉시 동기화
+        const hasChanges = summary.modified > 0;
+        // --sync: contents 단위 동기화
         if (opts.sync && hasChanges) {
-            syncToRelay(sourceBase, relayDir, diff);
+            syncContentsToRelay(contents, contentsDiff, relayDir, projectPath);
         }
         const result = {
-            source,
-            sourceName: toolName,
+            diff: contentsDiff.filter((d) => d.status !== 'unchanged'),
+            new_items: newItems,
             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/가 동기화 상태입니다.`);
+            if (!hasChanges && newItems.length === 0 && summary.source_missing === 0) {
+                console.error('✓ 모든 콘텐츠가 동기화 상태입니다.');
                 return;
             }
-            console.error(`\n📦 소스 동기화 (${source}/ → .relay/)\n`);
-            for (const entry of diff) {
+            console.error('\n📦 콘텐츠 동기화 상태\n');
+            for (const entry of contentsDiff) {
                 if (entry.status === 'unchanged')
                     continue;
-                const icon = entry.status === 'added' ? '  신규' : entry.status === 'modified' ? '  변경' : '  삭제';
-                console.error(`${icon}: ${entry.relPath}`);
+                const icon = entry.status === 'modified' ? '  변경' : '  ⚠ 원본 없음';
+                console.error(`${icon}: ${entry.name} (${entry.type})`);
+                if (entry.files) {
+                    for (const f of entry.files) {
+                        console.error(`    ${f.status}: ${f.relPath}`);
+                    }
+                }
+            }
+            if (newItems.length > 0) {
+                console.error('\n  새로 발견된 콘텐츠:');
+                for (const item of newItems) {
+                    console.error(`    + ${item.name} (${item.type}) — ${item.source}`);
+                }
             }
             console.error('');
-            console.error(`  합계: 신규 ${summary.added}, 변경 ${summary.modified}, 삭제 ${summary.deleted}, 유지 ${summary.unchanged}`);
+            console.error(`  합계: 변경 ${summary.modified}, 유지 ${summary.unchanged}, 원본 없음 ${summary.source_missing}, 신규 ${summary.new_available}`);
             if (opts.sync) {
-                console.error(`\n✓ .relay/에 반영 완료`);
+                console.error('\n✓ .relay/에 반영 완료');
             }
-            else {
-                console.error(`\n반영하려면: relay package --sync`);
+            else if (hasChanges) {
+                console.error('\n반영하려면: relay package --sync');
             }
         }
     });

package/dist/commands/ping.js

@@ -25,15 +25,15 @@ function registerPing(program) {
             });
             slug = match ?? slugInput;
         }
-        // Resolve version and team_id from installed registry
+        // Resolve version and agent_id from installed registry
         const local = (0, config_js_1.loadInstalled)();
         const global = (0, config_js_1.loadGlobalInstalled)();
         const entry = local[slug] ?? global[slug];
         const version = entry?.version;
-        const teamId = entry?.team_id;
-        // Fire-and-forget ping (team_id 기반, 없으면 skip)
-        if (teamId) {
-            await (0, api_js_1.sendUsagePing)(teamId, slug, version);
+        const agentId = entry?.agent_id;
+        // Fire-and-forget ping (agent_id 기반, 없으면 skip)
+        if (agentId) {
+            await (0, api_js_1.sendUsagePing)(agentId, slug, version);
         }
         if (!opts.quiet) {
             console.log(`RELAY_READY: ${slug}`);

package/dist/commands/publish.d.ts

@@ -28,7 +28,7 @@ export interface Requires {
     mcp?: RequiresMcp[];
     npm?: (string | RequiresNpm)[];
     env?: RequiresEnv[];
-    teams?: string[];
+    agents?: string[];
     runtime?: {
         node?: string;
         python?: string;