@dusky-bluehour/agent-service 0.6.5 → 0.6.7

package/scripts/validate.mjs

@@ -51,6 +51,18 @@ function parseFrontmatter(content) {
   return result;
 }
 
+function normalizeCommandBasename(commandId) {
+  const normalized = String(commandId ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  if (!normalized) {
+    throw new Error(`invalid command id: ${commandId}`);
+  }
+  return normalized;
+}
+
 async function validateCatalog() {
   const catalogPath = path.join(rootDir, 'catalog', 'tool-catalog.ko.json');
   if (!(await exists(catalogPath))) {
@@ -188,6 +200,214 @@ async function validateCatalog() {
   }
 }
 
+async function validateCommonSources() {
+  const requiredJsonFiles = [
+    'common/commands/command-catalog.json',
+    'common/workflows/workflow-catalog.json',
+    'common/skills/skill-catalog.json',
+    'common/settings/security-policy.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}`);
+          }
+        }
+      }
+    }
+  }
+
+  const securityPolicy = commonData['common/settings/security-policy.json'];
+  if (securityPolicy) {
+    if (!securityPolicy.policy_id || !securityPolicy.shared_permissions) {
+      fail('[common/settings] policy_id/shared_permissions 누락');
+    }
+    const shared = securityPolicy.shared_permissions ?? {};
+    for (const field of [
+      'allow_bash',
+      'ask_bash',
+      'deny_bash',
+      'deny_read',
+      'deny_edit'
+    ]) {
+      if (!Array.isArray(shared[field])) {
+        fail(`[common/settings] 배열 누락: ${field}`);
+      }
+    }
+
+    const claude = securityPolicy.claude_code ?? {};
+    if (!claude.default_mode || !claude.disable_bypass_permissions_mode) {
+      fail('[common/settings] claude_code default_mode/disable_bypass_permissions_mode 누락');
+    }
+  }
+}
+
 async function validatePackageJson() {
   const packagePath = path.join(rootDir, 'package.json');
   if (!(await exists(packagePath))) {
@@ -203,7 +423,14 @@ 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}`);
@@ -215,11 +442,13 @@ async function validatePackageJson() {
   }
 
   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) {
@@ -282,10 +511,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}`);
+          }
+        }
       }
     }
   }
@@ -295,7 +543,7 @@ 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() };
+    return { commandIds: new Set(), commandFileBases: new Set() };
   }
 
   let data;
@@ -303,12 +551,12 @@ async function validateCommandCatalog(toolName) {
     data = await readJson(filePath);
   } catch (error) {
     fail(`[${toolName}] command-catalog.json 파싱 실패: ${error.message}`);
-    return { commandIds: new Set() };
+    return { commandIds: new Set(), commandFileBases: new Set() };
   }
 
   if (!Array.isArray(data.commands) || data.commands.length === 0) {
     fail(`[${toolName}] commands 배열 누락 또는 비어 있음`);
-    return { commandIds: new Set() };
+    return { commandIds: new Set(), commandFileBases: new Set() };
   }
 
   const requiredFields = [
@@ -325,6 +573,7 @@ async function validateCommandCatalog(toolName) {
   ];
 
   const commandIds = new Set();
+  const commandFileBases = new Set();
   for (const cmd of data.commands) {
     for (const field of requiredFields) {
       if (!(field in cmd)) {
@@ -341,6 +590,11 @@ async function validateCommandCatalog(toolName) {
       fail(`[${toolName}] 중복 명령 ID: ${cmd.id}`);
     }
     commandIds.add(cmd.id);
+    try {
+      commandFileBases.add(normalizeCommandBasename(cmd.id));
+    } catch (error) {
+      fail(`[${toolName}] 명령 ID 형식 오류: ${cmd.id} (${error.message})`);
+    }
   }
 
   const repeatedIds = [
@@ -355,7 +609,7 @@ async function validateCommandCatalog(toolName) {
     }
   }
 
-  return { commandIds };
+  return { commandIds, commandFileBases };
 }
 
 async function validateWorkflowCatalog(toolName, commandIds) {
@@ -409,7 +663,7 @@ async function validateWorkflowCatalog(toolName, commandIds) {
   }
 }
 
-async function validateClaudeExtras() {
+async function validateClaudeExtras(commandFileBases) {
   const subagentsPath = path.join(rootDir, 'claude-code', 'subagents');
   if (!(await exists(subagentsPath))) {
     fail('[claude-code] subagents 디렉터리 누락');
@@ -434,9 +688,37 @@ async function validateClaudeExtras() {
   if (!(await exists(teamCatalog))) {
     fail('[claude-code] team-catalog.json 누락');
   }
+
+  const commandDir = path.join(rootDir, 'claude-code', 'commands', 'native');
+  if (!(await exists(commandDir))) {
+    fail('[claude-code] commands/native 디렉터리 누락');
+    return;
+  }
+
+  const commandFiles = new Set((await fs.readdir(commandDir)).filter((file) => file.endsWith('.md')));
+  for (const base of commandFileBases) {
+    const expected = `${base}.md`;
+    if (!commandFiles.has(expected)) {
+      fail(`[claude-code] native command 누락: commands/native/${expected}`);
+    }
+  }
 }
 
-async function validateAntigravityExtras() {
+async function validateCodexExtras(commandFileBases) {
+  const codexSkillDir = path.join(rootDir, 'codex', 'skills');
+  for (const base of commandFileBases) {
+    const skillFile = path.join(codexSkillDir, base, 'SKILL.md');
+    const openAiYaml = path.join(codexSkillDir, base, 'agents', 'openai.yaml');
+    if (!(await exists(skillFile))) {
+      fail(`[codex] 명령 스킬 누락: skills/${base}/SKILL.md`);
+    }
+    if (!(await exists(openAiYaml))) {
+      fail(`[codex] 명령 스킬 openai.yaml 누락: skills/${base}/agents/openai.yaml`);
+    }
+  }
+}
+
+async function validateAntigravityExtras(commandFileBases) {
   const agentCatalog = path.join(rootDir, 'antigravity', 'agents', 'agent-catalog.json');
   const artifactCatalog = path.join(rootDir, 'antigravity', 'artifacts', 'artifact-catalog.json');
 
@@ -452,6 +734,52 @@ 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}`);
+    }
+  }
+
+  const commandDefinitionsDir = path.join(rootDir, 'antigravity', 'commands', 'definitions');
+  if (!(await exists(commandDefinitionsDir))) {
+    fail('[antigravity] commands/definitions 디렉터리 누락');
+    return;
+  }
+
+  const commandDefinitionFiles = new Set(
+    (await fs.readdir(commandDefinitionsDir)).filter((file) => file.endsWith('.md'))
+  );
+  for (const base of commandFileBases) {
+    const expected = `${base}.md`;
+    if (!commandDefinitionFiles.has(expected)) {
+      fail(`[antigravity] command definition 누락: commands/definitions/${expected}`);
+    }
+  }
 }
 
 async function validateReadmes() {
@@ -463,6 +791,89 @@ async function validateReadmes() {
   }
 }
 
+async function validateSettingsOutputs() {
+  const settingsFiles = [
+    'claude-code/settings/settings.json',
+    'claude-code/settings/settings.local.json',
+    'antigravity/settings/editor-policy.json',
+    'codex/settings/runtime-policy.json'
+  ];
+
+  for (const relPath of settingsFiles) {
+    const fullPath = path.join(rootDir, relPath);
+    if (!(await exists(fullPath))) {
+      fail(`[settings] 파일 누락: ${relPath}`);
+      continue;
+    }
+    try {
+      await readJson(fullPath);
+    } catch (error) {
+      fail(`[settings] JSON 파싱 실패: ${relPath} (${error.message})`);
+    }
+  }
+
+  const claudeProjectPath = path.join(
+    rootDir,
+    'claude-code',
+    'settings',
+    'settings.json'
+  );
+  if (await exists(claudeProjectPath)) {
+    try {
+      const claude = await readJson(claudeProjectPath);
+      const permissions = claude.permissions ?? {};
+      const validModes = new Set([
+        'default',
+        'acceptEdits',
+        'plan',
+        'dontAsk',
+        'bypassPermissions'
+      ]);
+      if (!validModes.has(permissions.defaultMode)) {
+        fail(`[settings] Claude defaultMode 값 오류: ${permissions.defaultMode}`);
+      }
+      for (const key of ['allow', 'ask', 'deny']) {
+        if (!Array.isArray(permissions[key])) {
+          fail(`[settings] Claude permissions.${key} 누락`);
+        }
+      }
+    } catch (error) {
+      fail(`[settings] Claude 설정 검증 실패: ${error.message}`);
+    }
+  }
+
+  const codexAgentsPermissionPath = path.join(
+    rootDir,
+    'codex',
+    'instructions',
+    'AGENTS.permissions.generated.md'
+  );
+  if (!(await exists(codexAgentsPermissionPath))) {
+    fail('[settings] Codex AGENTS.permissions.generated.md 누락');
+  }
+}
+
+async function validateProjectRuleTemplates() {
+  const requiredFiles = [
+    'claude-code/instructions/CLAUDE.template.md',
+    'codex/instructions/AGENTS.template.md',
+    'antigravity/instructions/WORKSPACE-RULES.template.md'
+  ];
+
+  for (const relPath of requiredFiles) {
+    const fullPath = path.join(rootDir, relPath);
+    if (!(await exists(fullPath))) {
+      fail(`[project-rules] 템플릿 누락: ${relPath}`);
+      continue;
+    }
+
+    const content = await fs.readFile(fullPath, 'utf8');
+    if (!content.trim()) {
+      fail(`[project-rules] 템플릿 비어 있음: ${relPath}`);
+    }
+  }
+}
+
 async function runCliSmokeTests() {
   const nodeBin = process.execPath;
   const cliPath = path.join(rootDir, 'scripts', 'init.mjs');
@@ -561,6 +972,30 @@ async function runCliSmokeTests() {
     fail(`[cli] install --install-root dry-run 실행 실패: ${error.message}`);
   }
 
+  try {
+    await execFileAsync(
+      nodeBin,
+      [
+        cliPath,
+        'install',
+        '--tool',
+        'antigravity',
+        '--components',
+        'skills',
+        '--project-rules',
+        'if-instructions',
+        '--target',
+        '/tmp/tri-agent-manager-validate',
+        '--dry-run',
+        '--yes',
+        '--non-interactive'
+      ],
+      { cwd: rootDir }
+    );
+  } catch (error) {
+    fail(`[cli] install --project-rules dry-run 실행 실패: ${error.message}`);
+  }
+
   try {
     await execFileAsync(
       nodeBin,
@@ -626,17 +1061,23 @@ async function runCliSmokeTests() {
 
 async function main() {
   await validatePackageJson();
+  await validateCommonSources();
   await validateCatalog();
   await validateReadmes();
+  await validateSettingsOutputs();
+  await validateProjectRuleTemplates();
 
+  const commandFileBaseByTool = {};
   for (const toolName of toolDirs) {
     await validateSkillDirectory(toolName);
-    const { commandIds } = await validateCommandCatalog(toolName);
+    const { commandIds, commandFileBases } = await validateCommandCatalog(toolName);
+    commandFileBaseByTool[toolName] = commandFileBases;
     await validateWorkflowCatalog(toolName, commandIds);
   }
 
-  await validateClaudeExtras();
-  await validateAntigravityExtras();
+  await validateClaudeExtras(commandFileBaseByTool['claude-code'] ?? new Set());
+  await validateCodexExtras(commandFileBaseByTool.codex ?? new Set());
+  await validateAntigravityExtras(commandFileBaseByTool.antigravity ?? new Set());
   await runCliSmokeTests();
 
   if (errors.length > 0) {