@dusky-bluehour/agent-service 0.6.2

package/scripts/validate.mjs

@@ -0,0 +1,591 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+
+const execFileAsync = promisify(execFile);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, '..');
+
+const toolDirs = ['claude-code', 'codex', 'antigravity'];
+const errors = [];
+
+function fail(message) {
+  errors.push(message);
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(filePath) {
+  const raw = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(raw);
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    return null;
+  }
+
+  const yaml = match[1];
+  const result = {};
+  for (const line of yaml.split('\n')) {
+    const idx = line.indexOf(':');
+    if (idx <= 0) continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    result[key] = value;
+  }
+  return result;
+}
+
+async function validateCatalog() {
+  const catalogPath = path.join(rootDir, 'catalog', 'tool-catalog.ko.json');
+  if (!(await exists(catalogPath))) {
+    fail('[catalog] tool-catalog.ko.json 누락');
+    return;
+  }
+
+  let catalog;
+  try {
+    catalog = await readJson(catalogPath);
+  } catch (error) {
+    fail(`[catalog] JSON 파싱 실패: ${error.message}`);
+    return;
+  }
+
+  if (!Array.isArray(catalog.tools) || catalog.tools.length === 0) {
+    fail('[catalog] tools 배열 누락 또는 비어 있음');
+    return;
+  }
+
+  const toolIdSet = new Set();
+  const toolComponentIdMap = new Map();
+  for (const tool of catalog.tools) {
+    if (!tool.id || !tool.root || !tool.readme || !Array.isArray(tool.components)) {
+      fail(`[catalog] tool 필수 필드 누락: ${JSON.stringify(tool)}`);
+      continue;
+    }
+
+    if (toolIdSet.has(tool.id)) {
+      fail(`[catalog] 중복 tool id: ${tool.id}`);
+    }
+    toolIdSet.add(tool.id);
+
+    const toolRootPath = path.join(rootDir, tool.root);
+    if (!(await exists(toolRootPath))) {
+      fail(`[catalog] tool root 누락: ${tool.root}`);
+    }
+
+    const readmePath = path.join(rootDir, tool.root, tool.readme);
+    if (!(await exists(readmePath))) {
+      fail(`[catalog] tool readme 누락: ${tool.root}/${tool.readme}`);
+    }
+
+    const componentIds = new Set();
+    for (const component of tool.components) {
+      if (!component.id || !component.path) {
+        fail(`[catalog] component 필수 필드 누락: ${tool.id}`);
+        continue;
+      }
+
+      if (componentIds.has(component.id)) {
+        fail(`[catalog] 중복 component id: ${tool.id}/${component.id}`);
+      }
+      componentIds.add(component.id);
+
+      const compPath = path.join(rootDir, tool.root, component.path);
+      if (!(await exists(compPath))) {
+        fail(`[catalog] component 경로 누락: ${tool.id}/${component.path}`);
+      }
+    }
+    toolComponentIdMap.set(tool.id, componentIds);
+  }
+
+  if (!Array.isArray(catalog.presets) || catalog.presets.length === 0) {
+    fail('[catalog] presets 배열 누락 또는 비어 있음');
+  } else {
+    const presetIdSet = new Set();
+    for (const preset of catalog.presets) {
+      if (!preset.id || !preset.title || !Array.isArray(preset.tools) || !preset.components) {
+        fail(`[catalog] preset 필수 필드 누락: ${JSON.stringify(preset)}`);
+        continue;
+      }
+
+      if (presetIdSet.has(preset.id)) {
+        fail(`[catalog] 중복 preset id: ${preset.id}`);
+      }
+      presetIdSet.add(preset.id);
+
+      for (const toolId of preset.tools) {
+        if (!toolIdSet.has(toolId)) {
+          fail(`[catalog] preset(${preset.id})의 tool이 유효하지 않음: ${toolId}`);
+          continue;
+        }
+
+        const requested = preset.components[toolId];
+        if (!Array.isArray(requested) || requested.length === 0) {
+          fail(`[catalog] preset(${preset.id})의 구성요소 누락: ${toolId}`);
+          continue;
+        }
+
+        const availableIds = toolComponentIdMap.get(toolId) ?? new Set();
+        for (const componentId of requested) {
+          if (!availableIds.has(componentId)) {
+            fail(`[catalog] preset(${preset.id})의 구성요소가 유효하지 않음: ${toolId}/${componentId}`);
+          }
+        }
+      }
+    }
+  }
+
+  for (const toolId of toolDirs) {
+    if (!toolIdSet.has(toolId)) {
+      fail(`[catalog] toolDirs 대비 누락된 tool id: ${toolId}`);
+    }
+  }
+}
+
+async function validatePackageJson() {
+  const packagePath = path.join(rootDir, 'package.json');
+  if (!(await exists(packagePath))) {
+    fail('[package] package.json 누락');
+    return;
+  }
+
+  let pkg;
+  try {
+    pkg = await readJson(packagePath);
+  } catch (error) {
+    fail(`[package] package.json 파싱 실패: ${error.message}`);
+    return;
+  }
+
+  const requiredScripts = ['validate', 'pack:dry-run', 'prepublish:check', 'prepublishOnly'];
+  for (const scriptName of requiredScripts) {
+    if (!pkg.scripts || !(scriptName in pkg.scripts)) {
+      fail(`[package] scripts 누락: ${scriptName}`);
+    }
+  }
+
+  const requiredFiles = [
+    'claude-code',
+    'antigravity',
+    'codex',
+    'catalog/tool-catalog.ko.json',
+    'scripts/init.mjs',
+    'scripts/validate.mjs'
+  ];
+  for (const fileEntry of requiredFiles) {
+    if (!Array.isArray(pkg.files) || !pkg.files.includes(fileEntry)) {
+      fail(`[package] files 누락: ${fileEntry}`);
+    }
+  }
+
+  const excludedFromPublish = [
+    'docs/COMPOSITION.ko.md',
+    'docs/DEPLOYMENT-GUIDE.ko.md',
+    'docs/UPDATE-GUIDE.ko.md',
+    'docs/UX-FLOW.ko.md'
+  ];
+  for (const fileEntry of excludedFromPublish) {
+    if (Array.isArray(pkg.files) && pkg.files.includes(fileEntry)) {
+      fail(`[package] files에서 제외 필요: ${fileEntry}`);
+    }
+  }
+
+  for (const docFile of excludedFromPublish) {
+    const docPath = path.join(rootDir, docFile);
+    if (!(await exists(docPath))) {
+      fail(`[docs] 문서 누락: ${docFile}`);
+    }
+  }
+}
+
+async function validateSkillDirectory(toolName) {
+  const skillsPath = path.join(rootDir, toolName, 'skills');
+  if (!(await exists(skillsPath))) {
+    fail(`[${toolName}] skills 디렉터리 없음`);
+    return;
+  }
+
+  const skillEntries = await fs.readdir(skillsPath, { withFileTypes: true });
+  const skillDirs = skillEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+
+  if (skillDirs.length === 0) {
+    fail(`[${toolName}] skills 디렉터리가 비어 있음`);
+    return;
+  }
+
+  for (const skillName of skillDirs) {
+    const skillFile = path.join(skillsPath, skillName, 'SKILL.md');
+    if (!(await exists(skillFile))) {
+      fail(`[${toolName}] SKILL.md 누락: ${skillName}`);
+      continue;
+    }
+
+    const content = await fs.readFile(skillFile, 'utf8');
+    const fm = parseFrontmatter(content);
+    if (!fm) {
+      fail(`[${toolName}] frontmatter 누락: ${skillFile}`);
+      continue;
+    }
+
+    if (!fm.name || !fm.description) {
+      fail(`[${toolName}] frontmatter name/description 누락: ${skillFile}`);
+    }
+
+    if (toolName === 'codex') {
+      const openaiYaml = path.join(skillsPath, skillName, 'agents', 'openai.yaml');
+      if (!(await exists(openaiYaml))) {
+        fail(`[codex] openai.yaml 누락: ${skillName}`);
+      }
+    }
+  }
+}
+
+async function validateCommandCatalog(toolName) {
+  const filePath = path.join(rootDir, toolName, 'commands', 'command-catalog.json');
+  if (!(await exists(filePath))) {
+    fail(`[${toolName}] command-catalog.json 누락`);
+    return { commandIds: new Set() };
+  }
+
+  let data;
+  try {
+    data = await readJson(filePath);
+  } catch (error) {
+    fail(`[${toolName}] command-catalog.json 파싱 실패: ${error.message}`);
+    return { commandIds: new Set() };
+  }
+
+  if (!Array.isArray(data.commands) || data.commands.length === 0) {
+    fail(`[${toolName}] commands 배열 누락 또는 비어 있음`);
+    return { commandIds: new Set() };
+  }
+
+  const requiredFields = [
+    'id',
+    'name',
+    'phase',
+    'owner_role',
+    'purpose',
+    'input_contract',
+    'execution_contract',
+    'quality_gates',
+    'output_contract',
+    'handoff'
+  ];
+
+  const commandIds = new Set();
+  for (const cmd of data.commands) {
+    for (const field of requiredFields) {
+      if (!(field in cmd)) {
+        fail(`[${toolName}] 명령 필드 누락 (${cmd.id ?? 'unknown'}): ${field}`);
+      }
+    }
+
+    if (!cmd.id) {
+      fail(`[${toolName}] 명령 ID 누락`);
+      continue;
+    }
+
+    if (commandIds.has(cmd.id)) {
+      fail(`[${toolName}] 중복 명령 ID: ${cmd.id}`);
+    }
+    commandIds.add(cmd.id);
+  }
+
+  const repeatedIds = [
+    'CMD-DEV-FE-UI-COMPONENTIZE',
+    'CMD-DEV-FE-HOOK-SEPARATE',
+    'CMD-DEV-PERF-OPTIMIZE'
+  ];
+
+  for (const rid of repeatedIds) {
+    if (!commandIds.has(rid)) {
+      fail(`[${toolName}] 반복 작업 명령 누락: ${rid}`);
+    }
+  }
+
+  return { commandIds };
+}
+
+async function validateWorkflowCatalog(toolName, commandIds) {
+  const filePath = path.join(rootDir, toolName, 'workflows', 'workflow-catalog.json');
+  if (!(await exists(filePath))) {
+    fail(`[${toolName}] workflow-catalog.json 누락`);
+    return;
+  }
+
+  let data;
+  try {
+    data = await readJson(filePath);
+  } catch (error) {
+    fail(`[${toolName}] workflow-catalog.json 파싱 실패: ${error.message}`);
+    return;
+  }
+
+  if (!Array.isArray(data.workflows) || data.workflows.length === 0) {
+    fail(`[${toolName}] workflows 배열 누락 또는 비어 있음`);
+    return;
+  }
+
+  for (const wf of data.workflows) {
+    if (!wf.id || !wf.name) {
+      fail(`[${toolName}] workflow id/name 누락`);
+    }
+
+    if (!Array.isArray(wf.stages) || wf.stages.length === 0) {
+      fail(`[${toolName}] stage 누락: ${wf.id ?? 'unknown'}`);
+      continue;
+    }
+
+    for (const stage of wf.stages) {
+      if (!Array.isArray(stage.commands)) {
+        fail(`[${toolName}] stage commands 누락: ${wf.id}/${stage.stage_id ?? 'unknown'}`);
+        continue;
+      }
+
+      for (const cmdId of stage.commands) {
+        if (!commandIds.has(cmdId)) {
+          fail(`[${toolName}] workflow가 존재하지 않는 명령 참조: ${wf.id} -> ${cmdId}`);
+        }
+      }
+    }
+  }
+}
+
+async function validateClaudeExtras() {
+  const subagentsPath = path.join(rootDir, 'claude-code', 'subagents');
+  if (!(await exists(subagentsPath))) {
+    fail('[claude-code] subagents 디렉터리 누락');
+    return;
+  }
+
+  const files = (await fs.readdir(subagentsPath)).filter((file) => file.endsWith('.md'));
+  if (files.length === 0) {
+    fail('[claude-code] subagents 파일 없음');
+    return;
+  }
+
+  for (const file of files) {
+    const content = await fs.readFile(path.join(subagentsPath, file), 'utf8');
+    const fm = parseFrontmatter(content);
+    if (!fm || !fm.name || !fm.description) {
+      fail(`[claude-code] subagent frontmatter 누락: ${file}`);
+    }
+  }
+
+  const teamCatalog = path.join(rootDir, 'claude-code', 'agent-teams', 'team-catalog.json');
+  if (!(await exists(teamCatalog))) {
+    fail('[claude-code] team-catalog.json 누락');
+  }
+}
+
+async function validateAntigravityExtras() {
+  const agentCatalog = path.join(rootDir, 'antigravity', 'agents', 'agent-catalog.json');
+  const artifactCatalog = path.join(rootDir, 'antigravity', 'artifacts', 'artifact-catalog.json');
+
+  for (const f of [agentCatalog, artifactCatalog]) {
+    if (!(await exists(f))) {
+      fail(`[antigravity] 누락: ${path.relative(rootDir, f)}`);
+      continue;
+    }
+
+    try {
+      await readJson(f);
+    } catch (error) {
+      fail(`[antigravity] JSON 파싱 실패: ${path.relative(rootDir, f)} (${error.message})`);
+    }
+  }
+}
+
+async function validateReadmes() {
+  for (const tool of toolDirs) {
+    const filePath = path.join(rootDir, tool, 'README.md');
+    if (!(await exists(filePath))) {
+      fail(`[${tool}] README.md 누락`);
+    }
+  }
+}
+
+async function runCliSmokeTests() {
+  const nodeBin = process.execPath;
+  const cliPath = path.join(rootDir, 'scripts', 'init.mjs');
+
+  try {
+    await execFileAsync(nodeBin, [cliPath, 'list'], { cwd: rootDir });
+  } catch (error) {
+    fail(`[cli] list 실행 실패: ${error.message}`);
+  }
+
+  try {
+    await execFileAsync(
+      nodeBin,
+      [
+        cliPath,
+        'setup',
+        '--tool',
+        'codex',
+        '--components',
+        'skills,workflows,commands',
+        '--target',
+        '/tmp/tri-agent-manager-validate',
+        '--dry-run',
+        '--yes',
+        '--non-interactive'
+      ],
+      { cwd: rootDir }
+    );
+  } catch (error) {
+    fail(`[cli] setup dry-run 실행 실패: ${error.message}`);
+  }
+
+  try {
+    await execFileAsync(
+      nodeBin,
+      [
+        cliPath,
+        'install',
+        '--preset',
+        'balanced-core',
+        '--target',
+        '/tmp/tri-agent-manager-validate',
+        '--dry-run',
+        '--yes',
+        '--non-interactive'
+      ],
+      { cwd: rootDir }
+    );
+  } catch (error) {
+    fail(`[cli] install preset dry-run 실행 실패: ${error.message}`);
+  }
+
+  try {
+    await execFileAsync(
+      nodeBin,
+      [
+        cliPath,
+        'install',
+        '--tool',
+        'codex',
+        '--components',
+        'skills,workflows,commands',
+        '--target',
+        '/tmp/tri-agent-manager-validate',
+        '--dry-run',
+        '--yes',
+        '--non-interactive'
+      ],
+      { cwd: rootDir }
+    );
+  } catch (error) {
+    fail(`[cli] install dry-run 실행 실패: ${error.message}`);
+  }
+
+  try {
+    await execFileAsync(
+      nodeBin,
+      [
+        cliPath,
+        'update',
+        '--preset',
+        'frontend-refactor',
+        '--target',
+        '/tmp/tri-agent-manager-validate',
+        '--dry-run',
+        '--yes',
+        '--non-interactive'
+      ],
+      { cwd: rootDir }
+    );
+  } catch (error) {
+    fail(`[cli] update preset dry-run 실행 실패: ${error.message}`);
+  }
+
+  try {
+    await execFileAsync(
+      nodeBin,
+      [
+        cliPath,
+        'install',
+        '--preset',
+        'prd-to-production',
+        '--target',
+        '/tmp/tri-agent-manager-validate',
+        '--dry-run',
+        '--yes',
+        '--non-interactive'
+      ],
+      { cwd: rootDir }
+    );
+  } catch (error) {
+    fail(`[cli] install prd-to-production preset dry-run 실행 실패: ${error.message}`);
+  }
+
+  try {
+    await execFileAsync(
+      nodeBin,
+      [
+        cliPath,
+        'update',
+        '--tool',
+        'codex',
+        '--components',
+        'skills,workflows,commands',
+        '--target',
+        '/tmp/tri-agent-manager-validate',
+        '--dry-run',
+        '--yes',
+        '--non-interactive'
+      ],
+      { cwd: rootDir }
+    );
+  } catch (error) {
+    fail(`[cli] update dry-run 실행 실패: ${error.message}`);
+  }
+}
+
+async function main() {
+  await validatePackageJson();
+  await validateCatalog();
+  await validateReadmes();
+
+  for (const toolName of toolDirs) {
+    await validateSkillDirectory(toolName);
+    const { commandIds } = await validateCommandCatalog(toolName);
+    await validateWorkflowCatalog(toolName, commandIds);
+  }
+
+  await validateClaudeExtras();
+  await validateAntigravityExtras();
+  await runCliSmokeTests();
+
+  if (errors.length > 0) {
+    console.error('검증 실패:');
+    for (const error of errors) {
+      console.error(`- ${error}`);
+    }
+    process.exit(1);
+  }
+
+  console.log('검증 통과: 구조/계약/CLI 동작이 모두 유효합니다.');
+}
+
+main().catch((error) => {
+  console.error(`검증 스크립트 오류: ${error.message}`);
+  process.exit(1);
+});