@dusky-bluehour/agent-service 0.6.4 → 0.6.6

package/scripts/validate.mjs

@@ -188,6 +188,189 @@ async function validateCatalog() {
   }
 }
 
+async function validateCommonSources() {
+  const requiredJsonFiles = [
+    'common/commands/command-catalog.json',
+    'common/workflows/workflow-catalog.json',
+    'common/skills/skill-catalog.json',
+    'common/claude/subagent-catalog.json',
+    'common/claude/team-catalog.json',
+    'common/antigravity/agent-catalog.json',
+    'common/antigravity/artifact-catalog.json'
+  ];
+
+  const commonData = {};
+  for (const relPath of requiredJsonFiles) {
+    const fullPath = path.join(rootDir, relPath);
+    if (!(await exists(fullPath))) {
+      fail(`[common] 파일 누락: ${relPath}`);
+      continue;
+    }
+    try {
+      commonData[relPath] = await readJson(fullPath);
+    } catch (error) {
+      fail(`[common] JSON 파싱 실패: ${relPath} (${error.message})`);
+    }
+  }
+
+  const workflowCatalog = commonData['common/workflows/workflow-catalog.json'];
+  if (workflowCatalog) {
+    if (!Array.isArray(workflowCatalog.tools) || workflowCatalog.tools.length === 0) {
+      fail('[common/workflows] tools 배열 누락 또는 비어 있음');
+    }
+
+    const toolSet = new Set(Array.isArray(workflowCatalog.tools) ? workflowCatalog.tools : []);
+    for (const toolId of toolDirs) {
+      if (!toolSet.has(toolId)) {
+        fail(`[common/workflows] tools에 필수 tool 누락: ${toolId}`);
+      }
+    }
+
+    if (!workflowCatalog.workflow_policy || typeof workflowCatalog.workflow_policy !== 'object') {
+      fail('[common/workflows] workflow_policy 누락');
+    } else {
+      for (const toolId of toolSet) {
+        if (!(toolId in workflowCatalog.workflow_policy)) {
+          fail(`[common/workflows] workflow_policy 누락: ${toolId}`);
+        }
+      }
+    }
+
+    if (!Array.isArray(workflowCatalog.workflows) || workflowCatalog.workflows.length === 0) {
+      fail('[common/workflows] workflows 배열 누락 또는 비어 있음');
+    } else {
+      const workflowIds = new Set();
+      const workflowMap = new Map();
+      for (const workflow of workflowCatalog.workflows) {
+        if (!workflow?.id) {
+          fail('[common/workflows] workflow id 누락');
+          continue;
+        }
+        if (workflowIds.has(workflow.id)) {
+          fail(`[common/workflows] 중복 workflow id: ${workflow.id}`);
+        }
+        workflowIds.add(workflow.id);
+        workflowMap.set(workflow.id, workflow);
+
+        if (!workflow.profiles || typeof workflow.profiles !== 'object') {
+          fail(`[common/workflows] profiles 누락: ${workflow.id}`);
+          continue;
+        }
+
+        const profileTools = Object.keys(workflow.profiles);
+        if (profileTools.length === 0) {
+          fail(`[common/workflows] profile 비어 있음: ${workflow.id}`);
+        }
+
+        for (const toolId of profileTools) {
+          if (!toolSet.has(toolId)) {
+            fail(`[common/workflows] 알 수 없는 tool profile: ${workflow.id}/${toolId}`);
+            continue;
+          }
+          const profile = workflow.profiles[toolId];
+          if (!profile || typeof profile !== 'object') {
+            fail(`[common/workflows] profile 형식 오류: ${workflow.id}/${toolId}`);
+            continue;
+          }
+          if (!profile.name || !profile.summary || !profile.when_to_use) {
+            fail(`[common/workflows] profile 필수 필드 누락: ${workflow.id}/${toolId}`);
+          }
+          if (!Array.isArray(profile.stages) || profile.stages.length === 0) {
+            fail(`[common/workflows] profile stages 누락: ${workflow.id}/${toolId}`);
+          }
+        }
+      }
+
+      if (!workflowCatalog.workflow_order || typeof workflowCatalog.workflow_order !== 'object') {
+        fail('[common/workflows] workflow_order 누락');
+      } else {
+        for (const toolId of toolSet) {
+          const order = workflowCatalog.workflow_order[toolId];
+          if (!Array.isArray(order)) {
+            fail(`[common/workflows] workflow_order 형식 오류: ${toolId}`);
+            continue;
+          }
+          const seen = new Set();
+          for (const workflowId of order) {
+            if (!workflowIds.has(workflowId)) {
+              fail(`[common/workflows] workflow_order가 없는 id 참조: ${toolId}/${workflowId}`);
+              continue;
+            }
+            const workflow = workflowMap.get(workflowId);
+            if (!workflow?.profiles?.[toolId]) {
+              fail(`[common/workflows] workflow_order와 profile 불일치: ${toolId}/${workflowId}`);
+            }
+            if (seen.has(workflowId)) {
+              fail(`[common/workflows] workflow_order 중복: ${toolId}/${workflowId}`);
+            }
+            seen.add(workflowId);
+          }
+        }
+      }
+    }
+  }
+
+  const skillCatalog = commonData['common/skills/skill-catalog.json'];
+  if (skillCatalog) {
+    if (!Array.isArray(skillCatalog.skills) || skillCatalog.skills.length === 0) {
+      fail('[common/skills] skills 배열 누락 또는 비어 있음');
+    } else {
+      const toolSet = new Set(Array.isArray(skillCatalog.tools) ? skillCatalog.tools : []);
+      for (const toolId of toolDirs) {
+        if (!toolSet.has(toolId)) {
+          fail(`[common/skills] tools 누락: ${toolId}`);
+        }
+      }
+
+      const skillIds = new Set();
+      for (const skill of skillCatalog.skills) {
+        if (!skill?.id) {
+          fail('[common/skills] skill id 누락');
+          continue;
+        }
+        if (skillIds.has(skill.id)) {
+          fail(`[common/skills] 중복 skill id: ${skill.id}`);
+        }
+        skillIds.add(skill.id);
+
+        for (const toolId of toolSet) {
+          if (!skill.names?.[toolId] || !skill.descriptions?.[toolId]) {
+            fail(`[common/skills] 이름/설명 누락: ${skill.id}/${toolId}`);
+          }
+          if (!Array.isArray(skill.procedures?.[toolId]) || skill.procedures[toolId].length === 0) {
+            fail(`[common/skills] 실행 절차 누락: ${skill.id}/${toolId}`);
+          }
+          if (
+            !Array.isArray(skill.quality_rules?.[toolId]) ||
+            skill.quality_rules[toolId].length === 0
+          ) {
+            fail(`[common/skills] 품질 규칙 누락: ${skill.id}/${toolId}`);
+          }
+        }
+
+        if (!Array.isArray(skill.input_checklist) || skill.input_checklist.length === 0) {
+          fail(`[common/skills] 시작 전 체크리스트 누락: ${skill.id}`);
+        }
+        if (!Array.isArray(skill.report_format) || skill.report_format.length === 0) {
+          fail(`[common/skills] 결과 보고 형식 누락: ${skill.id}`);
+        }
+        if (!Array.isArray(skill.stop_conditions) || skill.stop_conditions.length === 0) {
+          fail(`[common/skills] 중단 조건 누락: ${skill.id}`);
+        }
+
+        if (!skill.codex_openai) {
+          fail(`[common/skills] codex_openai 누락: ${skill.id}`);
+        } else {
+          const ui = skill.codex_openai;
+          if (!ui.display_name || !ui.short_description || !ui.default_prompt) {
+            fail(`[common/skills] codex_openai 필수 필드 누락: ${skill.id}`);
+          }
+        }
+      }
+    }
+  }
+}
+
 async function validatePackageJson() {
   const packagePath = path.join(rootDir, 'package.json');
   if (!(await exists(packagePath))) {
@@ -203,19 +386,32 @@ async function validatePackageJson() {
     return;
   }
 
-  const requiredScripts = ['validate', 'pack:dry-run', 'prepublish:check', 'prepublishOnly'];
+  const requiredScripts = [
+    'generate',
+    'generate:check',
+    'validate',
+    'pack:dry-run',
+    'prepublish:check',
+    'prepublishOnly'
+  ];
   for (const scriptName of requiredScripts) {
     if (!pkg.scripts || !(scriptName in pkg.scripts)) {
       fail(`[package] scripts 누락: ${scriptName}`);
     }
   }
 
+  if (!pkg.bin || pkg.bin['tri-agent-manager'] !== 'scripts/init.mjs') {
+    fail('[package] bin 설정 오류: tri-agent-manager -> scripts/init.mjs 가 필요합니다.');
+  }
+
   const requiredFiles = [
+    'common',
     'claude-code',
     'antigravity',
     'codex',
     'catalog/tool-catalog.ko.json',
     'scripts/init.mjs',
+    'scripts/generate-from-common.mjs',
     'scripts/validate.mjs'
   ];
   for (const fileEntry of requiredFiles) {
@@ -228,7 +424,8 @@ async function validatePackageJson() {
     'docs/COMPOSITION.ko.md',
     'docs/DEPLOYMENT-GUIDE.ko.md',
     'docs/UPDATE-GUIDE.ko.md',
-    'docs/UX-FLOW.ko.md'
+    'docs/UX-FLOW.ko.md',
+    'docs/NPM-PUBLISH-REPO-ONLY.ko.md'
   ];
   for (const fileEntry of excludedFromPublish) {
     if (Array.isArray(pkg.files) && pkg.files.includes(fileEntry)) {
@@ -277,10 +474,29 @@ async function validateSkillDirectory(toolName) {
       fail(`[${toolName}] frontmatter name/description 누락: ${skillFile}`);
     }
 
+    for (const heading of [
+      '# 시작 전 체크리스트',
+      '# 실행 절차',
+      '# 결과 보고 형식',
+      '# 중단 조건',
+      '# 품질 규칙'
+    ]) {
+      if (!content.includes(heading)) {
+        fail(`[${toolName}] SKILL 섹션 누락: ${skillName}/${heading}`);
+      }
+    }
+
     if (toolName === 'codex') {
       const openaiYaml = path.join(skillsPath, skillName, 'agents', 'openai.yaml');
       if (!(await exists(openaiYaml))) {
         fail(`[codex] openai.yaml 누락: ${skillName}`);
+      } else {
+        const raw = await fs.readFile(openaiYaml, 'utf8');
+        for (const key of ['display_name', 'short_description', 'default_prompt']) {
+          if (!new RegExp(`\\b${key}:\\s+\".+\"`).test(raw)) {
+            fail(`[codex] openai.yaml 필수 필드 누락: ${skillName}/${key}`);
+          }
+        }
       }
     }
   }
@@ -447,6 +663,36 @@ async function validateAntigravityExtras() {
       fail(`[antigravity] JSON 파싱 실패: ${path.relative(rootDir, f)} (${error.message})`);
     }
   }
+
+  const workflowCatalogPath = path.join(rootDir, 'antigravity', 'workflows', 'workflow-catalog.json');
+  const workflowDefsDir = path.join(rootDir, 'antigravity', 'workflows', 'definitions');
+
+  if (!(await exists(workflowDefsDir))) {
+    fail('[antigravity] workflow definitions 디렉터리 누락');
+    return;
+  }
+
+  let workflowCatalog;
+  try {
+    workflowCatalog = await readJson(workflowCatalogPath);
+  } catch (error) {
+    fail(`[antigravity] workflow-catalog.json 파싱 실패: ${error.message}`);
+    return;
+  }
+
+  const workflowIds = new Set(
+    Array.isArray(workflowCatalog.workflows) ? workflowCatalog.workflows.map((wf) => wf.id) : []
+  );
+  const definitionFiles = (await fs.readdir(workflowDefsDir))
+    .filter((file) => file.endsWith('.workflow.yaml'))
+    .sort();
+
+  for (const workflowId of workflowIds) {
+    const expected = `${workflowId}.workflow.yaml`;
+    if (!definitionFiles.includes(expected)) {
+      fail(`[antigravity] workflow definition 누락: ${expected}`);
+    }
+  }
 }
 
 async function validateReadmes() {
@@ -621,6 +867,7 @@ async function runCliSmokeTests() {
 
 async function main() {
   await validatePackageJson();
+  await validateCommonSources();
   await validateCatalog();
   await validateReadmes();