@dusky-bluehour/agent-service 0.6.6 → 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))) {
@@ -193,6 +205,7 @@ async function validateCommonSources() {
     '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',
@@ -369,6 +382,30 @@ async function validateCommonSources() {
       }
     }
   }
+
+  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() {
@@ -506,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;
@@ -514,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 = [
@@ -536,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)) {
@@ -552,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 = [
@@ -566,7 +609,7 @@ async function validateCommandCatalog(toolName) {
     }
   }
 
-  return { commandIds };
+  return { commandIds, commandFileBases };
 }
 
 async function validateWorkflowCatalog(toolName, commandIds) {
@@ -620,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 디렉터리 누락');
@@ -645,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 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() {
+async function validateAntigravityExtras(commandFileBases) {
   const agentCatalog = path.join(rootDir, 'antigravity', 'agents', 'agent-catalog.json');
   const artifactCatalog = path.join(rootDir, 'antigravity', 'artifacts', 'artifact-catalog.json');
 
@@ -693,6 +764,22 @@ async function validateAntigravityExtras() {
       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() {
@@ -704,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');
@@ -802,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,
@@ -870,15 +1064,20 @@ async function main() {
   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) {