relayax-cli 0.4.34 → 0.4.36

package/dist/commands/package.d.ts

@@ -34,7 +34,13 @@ export declare function computeContentsDiff(contents: ContentEntry[], relayDir:
 /**
  * contents 항목 단위로 from → .relay/ 동기화한다.
  */
-export declare function syncContentsToRelay(contents: ContentEntry[], contentsDiff: ContentDiffEntry[], relayDir: string, projectPath: string): void;
+export declare function syncContentsToRelay(contents: ContentEntry[], contentsDiff: ContentDiffEntry[], relayDir: string, projectPath: string): {
+    removed: string[];
+};
+/**
+ * .relay/ 내에 있지만 contents 매니페스트에 없는 orphan 항목을 찾는다.
+ */
+export declare function findOrphanItems(contents: ContentEntry[], relayDir: string): string[];
 /**
  * 패키지 홈 디렉토리를 결정한다.
  * 1. 프로젝트에 .relay/가 있으면 → projectPath/.relay/

package/dist/commands/package.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (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;
@@ -214,27 +215,60 @@ function discoverNewItems(contents, projectPath) {
  * 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;
-        const content = contents.find((c) => c.name === diffEntry.name && c.type === diffEntry.type);
         if (!content)
             continue;
         const absFrom = resolveFromPath(getFromPath(content), projectPath);
         const relaySubPath = deriveRelaySubPath(content);
         const relayTarget = path_1.default.join(relayDir, relaySubPath);
-        // 단일 파일인 경우 직접 복사 (디렉토리 기반 diff/sync 불필요)
+        // 단일 파일인 경우 직접 복사
         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 기반 동기화
+        // 디렉토리인 경우 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 ───
 /**
@@ -462,20 +496,31 @@ function registerPackage(program) {
         }
         // 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;
-        // --sync: contents 단위 동기화
+        const hasChanges = summary.modified > 0 || summary.source_missing > 0 || summary.orphaned > 0;
+        // --sync: contents 단위 동기화 + orphan 정리
         if (opts.sync && hasChanges) {
-            syncContentsToRelay(contents, contentsDiff, relayDir, projectPath);
+            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,
         };
@@ -499,6 +544,12 @@ function registerPackage(program) {
                     }
                 }
             }
+            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) {
@@ -506,7 +557,7 @@ function registerPackage(program) {
                 }
             }
             console.error('');
-            console.error(`  합계: 변경 ${summary.modified}, 유지 ${summary.unchanged}, 원본 없음 ${summary.source_missing}, 신규 ${summary.new_available}`);
+            console.error(`  합계: 변경 ${summary.modified}, 유지 ${summary.unchanged}, 원본 없음 ${summary.source_missing}, 신규 ${summary.new_available}, 고아 ${summary.orphaned}`);
             if (opts.sync) {
                 console.error('\n✓ .relay/에 반영 완료');
             }

package/dist/commands/publish.js

@@ -16,6 +16,7 @@ const error_report_js_1 = require("../lib/error-report.js");
 const step_tracker_js_1 = require("../lib/step-tracker.js");
 const git_operations_js_1 = require("../lib/git-operations.js");
 const setup_command_js_1 = require("../lib/setup-command.js");
+const requires_suggest_js_1 = require("../lib/requires-suggest.js");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const cliPkg = require('../../package.json');
 const VALID_DIRS = ['skills', 'agents', 'rules', 'commands', 'bin'];
@@ -681,6 +682,28 @@ function registerPublish(program) {
                 console.error(`  → relay.yaml에 visibility: ${config.visibility} 저장됨 (${visLabelMap[config.visibility]})\n`);
             }
         }
+        // ── Requires 자동 감지 + 제안 ──
+        if (isTTY && !json) {
+            const suggestions = (0, requires_suggest_js_1.suggestRequires)(relayDir, config.requires);
+            if (suggestions.length > 0) {
+                console.error('\n\x1b[33m⚡ requires에 빠진 항목이 감지되었습니다:\x1b[0m');
+                for (const line of (0, requires_suggest_js_1.formatSuggestions)(suggestions)) {
+                    console.error(line);
+                }
+                const { confirm } = await import('@inquirer/prompts');
+                const addThem = await confirm({
+                    message: 'requires에 추가할까요?',
+                    default: true,
+                });
+                if (addThem) {
+                    config.requires = (0, requires_suggest_js_1.mergeIntoRequires)(config.requires ?? {}, suggestions);
+                    const yamlData = js_yaml_1.default.load(fs_1.default.readFileSync(relayYamlPath, 'utf-8'));
+                    yamlData.requires = config.requires;
+                    fs_1.default.writeFileSync(relayYamlPath, js_yaml_1.default.dump(yamlData, { lineWidth: 120 }), 'utf-8');
+                    console.error('  → relay.yaml에 requires 업데이트됨\n');
+                }
+            }
+        }
         // Generate setup command BEFORE detectCommands so it's included in metadata
         {
             const commandsDir = path_1.default.join(relayDir, 'commands');

package/dist/lib/requires-suggest.d.ts

@@ -0,0 +1,23 @@
+import type { Requires } from '../commands/publish.js';
+interface Suggestion {
+    category: 'env' | 'cli' | 'pip' | 'runtime';
+    name: string;
+    source: string;
+    description?: string;
+    setup_hint?: string;
+    install?: string;
+    required?: boolean;
+}
+/**
+ * .relay/ 디렉토리를 스캔하여 requires에 빠진 항목을 제안한다.
+ */
+export declare function suggestRequires(relayDir: string, currentRequires?: Requires): Suggestion[];
+/**
+ * 제안 항목을 사람이 읽기 좋은 형태로 포맷한다.
+ */
+export declare function formatSuggestions(suggestions: Suggestion[]): string[];
+/**
+ * 제안 항목을 requires 객체에 병합한다.
+ */
+export declare function mergeIntoRequires(requires: Requires, suggestions: Suggestion[]): Requires;
+export {};

package/dist/lib/requires-suggest.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestRequires = suggestRequires;
+exports.formatSuggestions = formatSuggestions;
+exports.mergeIntoRequires = mergeIntoRequires;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// Python stdlib — 이 목록에 없는 import는 pip 패키지 후보
+const PYTHON_STDLIB = new Set([
+    'abc', 'argparse', 'ast', 'asyncio', 'base64', 'bisect', 'calendar',
+    'cmath', 'codecs', 'collections', 'concurrent', 'contextlib', 'copy',
+    'csv', 'ctypes', 'dataclasses', 'datetime', 'decimal', 'difflib',
+    'email', 'enum', 'errno', 'filecmp', 'fnmatch', 'fractions', 'ftplib',
+    'functools', 'gc', 'gettext', 'glob', 'gzip', 'hashlib', 'heapq',
+    'hmac', 'html', 'http', 'imaplib', 'importlib', 'inspect', 'io',
+    'itertools', 'json', 'keyword', 'linecache', 'locale', 'logging',
+    'lzma', 'math', 'mimetypes', 'multiprocessing', 'numbers', 'operator',
+    'os', 'pathlib', 'pickle', 'platform', 'plistlib', 'pprint',
+    'profile', 'pstats', 'queue', 'random', 're', 'readline',
+    'reprlib', 'resource', 'rlcompleter', 'sched', 'secrets', 'select',
+    'shelve', 'shlex', 'shutil', 'signal', 'site', 'smtplib', 'socket',
+    'socketserver', 'sqlite3', 'ssl', 'stat', 'statistics', 'string',
+    'struct', 'subprocess', 'sys', 'sysconfig', 'syslog', 'tempfile',
+    'textwrap', 'threading', 'time', 'timeit', 'token', 'tokenize',
+    'tomllib', 'trace', 'traceback', 'tracemalloc', 'types', 'typing',
+    'unicodedata', 'unittest', 'urllib', 'uuid', 'venv', 'warnings',
+    'wave', 'weakref', 'webbrowser', 'xml', 'xmlrpc', 'zipfile', 'zipimport', 'zlib',
+    // 자주 쓰이는 서브모듈
+    'os.path', 'collections.abc', 'concurrent.futures', 'urllib.parse',
+    'http.client', 'http.server', 'email.mime',
+]);
+// pip 패키지명 → import 이름 매핑 (다른 경우만)
+const PIP_IMPORT_MAP = {
+    'Pillow': 'PIL',
+    'google-genai': 'google',
+    'scikit-learn': 'sklearn',
+    'python-dotenv': 'dotenv',
+    'beautifulsoup4': 'bs4',
+    'opencv-python': 'cv2',
+    'pyyaml': 'yaml',
+};
+// import 이름 → pip 패키지명 역매핑
+const IMPORT_TO_PIP = {};
+for (const [pip, imp] of Object.entries(PIP_IMPORT_MAP)) {
+    IMPORT_TO_PIP[imp] = pip;
+}
+/**
+ * .relay/ 디렉토리를 스캔하여 requires에 빠진 항목을 제안한다.
+ */
+function suggestRequires(relayDir, currentRequires) {
+    const suggestions = [];
+    const existing = normalizeExisting(currentRequires);
+    // 모든 스크립트 파일 수집
+    const scripts = findScripts(relayDir);
+    for (const scriptPath of scripts) {
+        const content = fs_1.default.readFileSync(scriptPath, 'utf-8');
+        const relName = path_1.default.relative(relayDir, scriptPath);
+        const ext = path_1.default.extname(scriptPath);
+        // Python 스크립트
+        if (ext === '.py') {
+            // 환경변수 감지: os.environ.get("VAR") / os.environ["VAR"] / os.getenv("VAR")
+            const envPattern = /os\.environ\.get\(\s*['"](\w+)['"]/g;
+            const envPattern2 = /os\.environ\[['"](\w+)['"]\]/g;
+            const envPattern3 = /os\.getenv\(\s*['"](\w+)['"]/g;
+            for (const pattern of [envPattern, envPattern2, envPattern3]) {
+                let match;
+                while ((match = pattern.exec(content)) !== null) {
+                    const varName = match[1];
+                    if (!existing.envNames.has(varName)) {
+                        suggestions.push({ category: 'env', name: varName, source: relName });
+                    }
+                }
+            }
+            // pip 패키지 감지: import xxx / from xxx import
+            const importPattern = /^(?:import|from)\s+(\w+)/gm;
+            let match;
+            while ((match = importPattern.exec(content)) !== null) {
+                const moduleName = match[1];
+                if (PYTHON_STDLIB.has(moduleName))
+                    continue;
+                const pipName = IMPORT_TO_PIP[moduleName] ?? moduleName;
+                if (!existing.pipNames.has(pipName) && !existing.pipNames.has(moduleName)) {
+                    suggestions.push({ category: 'pip', name: pipName, source: relName });
+                }
+            }
+            // shebang → python3 런타임
+            if (content.startsWith('#!/') && content.includes('python')) {
+                if (!existing.hasRuntime.python) {
+                    suggestions.push({ category: 'runtime', name: 'python', source: relName });
+                }
+            }
+        }
+        // Node/TS 스크립트
+        if (ext === '.js' || ext === '.ts' || ext === '.mjs') {
+            // 환경변수 감지: process.env.VAR / process.env['VAR']
+            const envPattern = /process\.env\.(\w+)/g;
+            const envPattern2 = /process\.env\[['"](\w+)['"]\]/g;
+            for (const pattern of [envPattern, envPattern2]) {
+                let match;
+                while ((match = pattern.exec(content)) !== null) {
+                    const varName = match[1];
+                    if (['NODE_ENV', 'PATH', 'HOME', 'PWD'].includes(varName))
+                        continue;
+                    if (!existing.envNames.has(varName)) {
+                        suggestions.push({ category: 'env', name: varName, source: relName });
+                    }
+                }
+            }
+        }
+    }
+    // setup-* 스킬 감지: 관련 env가 requires에 없으면 제안
+    const skillsDir = path_1.default.join(relayDir, 'skills');
+    if (fs_1.default.existsSync(skillsDir)) {
+        for (const entry of fs_1.default.readdirSync(skillsDir, { withFileTypes: true })) {
+            if (entry.isDirectory() && entry.name.startsWith('setup-')) {
+                const setupName = entry.name; // e.g., setup-kling
+                const skillMd = path_1.default.join(skillsDir, setupName, 'SKILL.md');
+                if (fs_1.default.existsSync(skillMd)) {
+                    const skillContent = fs_1.default.readFileSync(skillMd, 'utf-8');
+                    // SKILL.md에서 환경변수 참조 찾기
+                    const envRefs = /[A-Z][A-Z0-9_]{2,}/g;
+                    let match;
+                    while ((match = envRefs.exec(skillContent)) !== null) {
+                        const varName = match[0];
+                        if (['SKILL', 'WHEN', 'THEN', 'SHALL', 'MUST', 'TODO', 'NOTE', 'IMPORTANT', 'WARNING', 'ERROR', 'JSON', 'API', 'URL', 'HTTP', 'HTTPS', 'MCP', 'CLI', 'SDK', 'README', 'YAML'].includes(varName))
+                            continue;
+                        if (varName.endsWith('_KEY') || varName.endsWith('_TOKEN') || varName.endsWith('_SECRET') || varName.endsWith('_SESSION')) {
+                            if (!existing.envNames.has(varName)) {
+                                suggestions.push({
+                                    category: 'env',
+                                    name: varName,
+                                    source: `skills/${setupName}/SKILL.md`,
+                                    setup_hint: `/${setupName} 스킬을 실행하세요`,
+                                    required: false,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // CLI 도구 감지: subprocess.run(['cmd', ...]) / execSync('cmd ...')
+    for (const scriptPath of scripts) {
+        const content = fs_1.default.readFileSync(scriptPath, 'utf-8');
+        const relName = path_1.default.relative(relayDir, scriptPath);
+        // Python subprocess
+        const subprocessPattern = /subprocess\.(?:run|Popen|call)\(\s*\[?\s*['"](\w+)['"]/g;
+        let match;
+        while ((match = subprocessPattern.exec(content)) !== null) {
+            const cmd = match[1];
+            if (['python', 'python3', 'node', 'npm', 'npx'].includes(cmd))
+                continue;
+            if (!existing.cliNames.has(cmd)) {
+                suggestions.push({ category: 'cli', name: cmd, source: relName });
+            }
+        }
+        // Node execSync
+        const execPattern = /execSync\(\s*['"`](\w+)/g;
+        while ((match = execPattern.exec(content)) !== null) {
+            const cmd = match[1];
+            if (['node', 'npm', 'npx', 'git'].includes(cmd))
+                continue;
+            if (!existing.cliNames.has(cmd)) {
+                suggestions.push({ category: 'cli', name: cmd, source: relName });
+            }
+        }
+    }
+    // 중복 제거
+    const seen = new Set();
+    return suggestions.filter((s) => {
+        const key = `${s.category}:${s.name}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function normalizeExisting(requires) {
+    const envNames = new Set();
+    const cliNames = new Set();
+    const pipNames = new Set();
+    const npmNames = new Set();
+    const hasRuntime = { node: false, python: false };
+    if (!requires)
+        return { envNames, cliNames, pipNames, npmNames, hasRuntime };
+    for (const e of requires.env ?? [])
+        envNames.add(e.name);
+    for (const c of requires.cli ?? [])
+        cliNames.add(c.name);
+    for (const n of requires.npm ?? [])
+        npmNames.add(typeof n === 'string' ? n : n.name);
+    // pip은 Requires 타입에 없지만 relay.yaml에 존재할 수 있음
+    const raw = requires;
+    if (Array.isArray(raw.pip)) {
+        for (const p of raw.pip)
+            pipNames.add(typeof p === 'string' ? p : p.name);
+    }
+    if (requires.runtime?.node)
+        hasRuntime.node = true;
+    if (requires.runtime?.python)
+        hasRuntime.python = true;
+    return { envNames, cliNames, pipNames, npmNames, hasRuntime };
+}
+function findScripts(dir) {
+    const scripts = [];
+    if (!fs_1.default.existsSync(dir))
+        return scripts;
+    function walk(d) {
+        for (const entry of fs_1.default.readdirSync(d, { withFileTypes: true })) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const full = path_1.default.join(d, entry.name);
+            if (entry.isDirectory()) {
+                walk(full);
+            }
+            else if (/\.(py|js|ts|mjs|sh)$/.test(entry.name)) {
+                scripts.push(full);
+            }
+        }
+    }
+    walk(dir);
+    return scripts;
+}
+/**
+ * 제안 항목을 사람이 읽기 좋은 형태로 포맷한다.
+ */
+function formatSuggestions(suggestions) {
+    const lines = [];
+    const envs = suggestions.filter((s) => s.category === 'env');
+    const clis = suggestions.filter((s) => s.category === 'cli');
+    const pips = suggestions.filter((s) => s.category === 'pip');
+    const runtimes = suggestions.filter((s) => s.category === 'runtime');
+    if (envs.length > 0) {
+        lines.push('  환경변수:');
+        for (const e of envs) {
+            const hint = e.setup_hint ? ` (${e.setup_hint})` : '';
+            lines.push(`    ${e.name}${hint} — ${e.source}에서 감지`);
+        }
+    }
+    if (clis.length > 0) {
+        lines.push('  CLI 도구:');
+        for (const c of clis)
+            lines.push(`    ${c.name} — ${c.source}에서 감지`);
+    }
+    if (pips.length > 0) {
+        lines.push('  pip 패키지:');
+        for (const p of pips)
+            lines.push(`    ${p.name} — ${p.source}에서 감지`);
+    }
+    if (runtimes.length > 0) {
+        lines.push('  런타임:');
+        for (const r of runtimes)
+            lines.push(`    ${r.name} — ${r.source}에서 감지`);
+    }
+    return lines;
+}
+/**
+ * 제안 항목을 requires 객체에 병합한다.
+ */
+function mergeIntoRequires(requires, suggestions) {
+    const result = { ...requires };
+    for (const s of suggestions) {
+        if (s.category === 'env') {
+            if (!result.env)
+                result.env = [];
+            result.env.push({
+                name: s.name,
+                required: s.required ?? true,
+                description: s.description,
+                setup_hint: s.setup_hint,
+            });
+        }
+        else if (s.category === 'cli') {
+            if (!result.cli)
+                result.cli = [];
+            result.cli.push({
+                name: s.name,
+                install: s.install,
+            });
+        }
+        else if (s.category === 'runtime') {
+            if (!result.runtime)
+                result.runtime = {};
+            if (s.name === 'python')
+                result.runtime.python = '>=3.8';
+            if (s.name === 'node')
+                result.runtime.node = '>=18';
+        }
+    }
+    return result;
+}

package/package.json

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