anpm-io 1.0.0

package/dist/commands/package.js

@@ -0,0 +1,569 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeContentsDiff = computeContentsDiff;
+exports.syncContentsToRelay = syncContentsToRelay;
+exports.findOrphanItems = findOrphanItems;
+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 paths_js_1 = require("../lib/paths.js");
+const SYNC_DIRS = ['skills', 'commands', 'agents', 'rules'];
+/** from 또는 path 중 존재하는 값을 반환 */
+function getFromPath(entry) {
+    const val = entry.from ?? entry.path;
+    if (!val) {
+        throw new Error(`contents 항목 "${entry.name}"에 from 또는 path가 필요합니다.`);
+    }
+    return val;
+}
+// ─── Helpers ───
+function fileHash(filePath) {
+    const content = fs_1.default.readFileSync(filePath);
+    return crypto_1.default.createHash('md5').update(content).digest('hex');
+}
+/**
+ * 소스와 .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 */ }
+            }
+        }
+    }
+}
+// ─── 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(getFromPath(entry), 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 fromPath = getFromPath(entry);
+    const from = fromPath.startsWith('~/') ? fromPath.slice(2) : fromPath;
+    // 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) {
+    const removed = [];
+    for (const diffEntry of contentsDiff) {
+        const content = contents.find((c) => c.name === diffEntry.name && c.type === diffEntry.type);
+        // source_missing: 소스에서 삭제됨 → .relay/에서도 제거
+        if (diffEntry.status === 'source_missing') {
+            const relaySubPath = content ? deriveRelaySubPath(content) : `${diffEntry.type}s/${diffEntry.name}`;
+            const relayTarget = path_1.default.join(relayDir, relaySubPath);
+            if (fs_1.default.existsSync(relayTarget)) {
+                fs_1.default.rmSync(relayTarget, { recursive: true, force: true });
+                removed.push(relaySubPath);
+            }
+            continue;
+        }
+        if (diffEntry.status !== 'modified')
+            continue;
+        if (!content)
+            continue;
+        const absFrom = resolveFromPath(getFromPath(content), projectPath);
+        const relaySubPath = deriveRelaySubPath(content);
+        const relayTarget = path_1.default.join(relayDir, relaySubPath);
+        // 단일 파일인 경우 직접 복사
+        if (fs_1.default.existsSync(absFrom) && fs_1.default.statSync(absFrom).isFile()) {
+            fs_1.default.mkdirSync(path_1.default.dirname(relayTarget), { recursive: true });
+            fs_1.default.copyFileSync(absFrom, relayTarget);
+            continue;
+        }
+        // 디렉토리인 경우 diff 기반 동기화 (deleted 포함)
+        const sourceFiles = scanPath(absFrom);
+        const relayFiles = scanPath(relayTarget);
+        const fileDiff = computeDiff(sourceFiles, relayFiles);
+        syncToRelay(absFrom, relayTarget, fileDiff);
+    }
+    return { removed };
+}
+/**
+ * .relay/ 내에 있지만 contents 매니페스트에 없는 orphan 항목을 찾는다.
+ */
+function findOrphanItems(contents, relayDir) {
+    const contentPaths = new Set(contents.map((c) => deriveRelaySubPath(c)));
+    const orphans = [];
+    for (const dir of SYNC_DIRS) {
+        const fullDir = path_1.default.join(relayDir, dir);
+        if (!fs_1.default.existsSync(fullDir))
+            continue;
+        for (const entry of fs_1.default.readdirSync(fullDir, { withFileTypes: true })) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const relPath = `${dir}/${entry.name}`;
+            if (!contentPaths.has(relPath)) {
+                orphans.push(relPath);
+            }
+        }
+    }
+    return orphans;
+}
+// ─── 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
+        .command('package')
+        .description('소스 디렉토리에서 .relay/로 콘텐츠를 동기화합니다')
+        .option('--source <dir>', '소스 디렉토리 지정 (예: .claude)')
+        .option('--sync', '변경사항을 .relay/에 즉시 반영', false)
+        .option('--init', '최초 패키징: 소스 감지 → .relay/ 초기화', false)
+        .option('--migrate', '기존 source 필드를 contents로 마이그레이션', false)
+        .option('--project <dir>', '프로젝트 루트 경로 (기본: cwd, 환경변수: RELAY_PROJECT_PATH)')
+        .option('--home <dir>', '홈 디렉토리 경로 (기본: os.homedir(), 환경변수: RELAY_HOME)')
+        .action(async (opts) => {
+        const json = program.opts().json ?? false;
+        const projectPath = (0, paths_js_1.resolveProjectPath)(opts.project);
+        const homeDir = (0, paths_js_1.resolveHome)(opts.home);
+        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 localTools = (0, ai_tools_js_1.detectAgentCLIs)(projectPath);
+            const globalTools = (0, ai_tools_js_1.detectGlobalCLIs)(homeDir);
+            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, homeDir);
+                if (items.length > 0) {
+                    sources.push({
+                        path: `~/${tool.skillsDir}`,
+                        location: 'global',
+                        name: `${tool.name} (global)`,
+                        items,
+                    });
+                }
+            }
+            // ~/.relay/agents/ 에 기존 에이전트 패키지가 있는지 스캔
+            const globalAgentsDir = path_1.default.join(homeDir ?? 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',
+                    sources,
+                    existing_agents: existingAgents,
+                }));
+            }
+            else {
+                if (sources.length === 0 && existingAgents.length === 0) {
+                    console.error('배포 가능한 에이전트 콘텐츠를 찾지 못했습니다.');
+                    console.error('skills/, commands/, agents/, rules/ 중 하나를 만들어주세요.');
+                    process.exit(1);
+                }
+                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;
+        }
+        // ─── 마이그레이션 (--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 필드가 없습니다. anpm 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 rawContents = config.contents;
+        const contents = Array.isArray(rawContents) ? rawContents : [];
+        // 기존 source 필드 → contents 마이그레이션 안내
+        if (!config.contents && config.source) {
+            const legacySource = config.source;
+            if (json) {
+                console.log(JSON.stringify({
+                    status: 'migration_required',
+                    message: `relay.yaml의 source 필드를 contents로 마이그레이션해야 합니다.`,
+                    legacy_source: legacySource,
+                }));
+            }
+            else {
+                console.error(`relay.yaml에 기존 source 필드(${legacySource})가 있습니다.`);
+                console.error(`contents 형식으로 마이그레이션하려면: anpm package --migrate`);
+            }
+            process.exit(1);
+        }
+        if (contents.length === 0) {
+            if (json) {
+                console.log(JSON.stringify({
+                    status: 'no_contents',
+                    message: 'relay.yaml에 contents가 없습니다. anpm package --init으로 패키지를 초기화하세요.',
+                }));
+            }
+            else {
+                console.error('relay.yaml에 contents가 없습니다.');
+                console.error('anpm package --init으로 패키지를 초기화하세요.');
+            }
+            process.exit(1);
+        }
+        // contents 기반 diff 계산
+        const { diff: contentsDiff, newItems } = computeContentsDiff(contents, relayDir, projectPath);
+        const orphans = findOrphanItems(contents, relayDir);
+        const summary = {
+            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,
+            orphaned: orphans.length,
+        };
+        const hasChanges = summary.modified > 0 || summary.source_missing > 0 || summary.orphaned > 0;
+        // --sync: contents 단위 동기화 + orphan 정리
+        if (opts.sync && hasChanges) {
+            const { removed } = syncContentsToRelay(contents, contentsDiff, relayDir, projectPath);
+            // orphan 항목 삭제
+            for (const orphan of orphans) {
+                const orphanPath = path_1.default.join(relayDir, orphan);
+                if (fs_1.default.existsSync(orphanPath)) {
+                    fs_1.default.rmSync(orphanPath, { recursive: true, force: true });
+                    removed.push(orphan);
+                }
+            }
+        }
+        const result = {
+            diff: contentsDiff.filter((d) => d.status !== 'unchanged'),
+            new_items: newItems,
+            orphans,
+            synced: opts.sync === true && hasChanges,
+            summary,
+        };
+        if (json) {
+            console.log(JSON.stringify(result));
+        }
+        else {
+            if (!hasChanges && newItems.length === 0 && summary.source_missing === 0) {
+                console.error('✓ 모든 콘텐츠가 동기화 상태입니다.');
+                return;
+            }
+            console.error('\n📦 콘텐츠 동기화 상태\n');
+            for (const entry of contentsDiff) {
+                if (entry.status === 'unchanged')
+                    continue;
+                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 (orphans.length > 0) {
+                console.error('\n  \x1b[33m.relay/에만 존재 (소스에서 삭제됨):\x1b[0m');
+                for (const orphan of orphans) {
+                    console.error(`    \x1b[31m✗ ${orphan}\x1b[0m`);
+                }
+            }
+            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.modified}, 유지 ${summary.unchanged}, 원본 없음 ${summary.source_missing}, 신규 ${summary.new_available}, 고아 ${summary.orphaned}`);
+            if (opts.sync) {
+                console.error('\n✓ .relay/에 반영 완료');
+            }
+            else if (hasChanges) {
+                console.error('\n반영하려면: anpm package --sync');
+            }
+        }
+    });
+}

package/dist/commands/ping.d.ts

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

package/dist/commands/ping.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPing = registerPing;
+const api_js_1 = require("../lib/api.js");
+const config_js_1 = require("../lib/config.js");
+const slug_js_1 = require("../lib/slug.js");
+function registerPing(program) {
+    program
+        .command('ping <slug>')
+        .description('사용 현황을 기록합니다 (preamble용 경량 명령)')
+        .option('--quiet', '출력 없이 실행')
+        .action(async (slugInput, opts) => {
+        // Resolve slug
+        let slug;
+        if ((0, slug_js_1.isScopedSlug)(slugInput)) {
+            slug = slugInput;
+        }
+        else {
+            const localRegistry = (0, config_js_1.loadInstalled)();
+            const globalRegistry = (0, config_js_1.loadGlobalInstalled)();
+            const allKeys = [...Object.keys(localRegistry), ...Object.keys(globalRegistry)];
+            const match = allKeys.find((key) => {
+                const parsed = (0, slug_js_1.parseSlug)(key);
+                return parsed && parsed.name === slugInput;
+            });
+            slug = match ?? slugInput;
+        }
+        // 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 agentId = entry?.agent_id;
+        // Fire-and-forget ping (agent_id 없어도 slug fallback으로 전송)
+        await (0, api_js_1.sendUsagePing)(agentId ?? null, slug, version);
+        if (!opts.quiet) {
+            console.log(`RELAY_READY: ${slug}`);
+        }
+    });
+}